{"id":4595,"date":"2022-11-10T17:47:33","date_gmt":"2022-11-11T01:47:33","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=4595"},"modified":"2025-04-24T17:16:41","modified_gmt":"2025-04-24T17:16:41","slug":"4-techniques-to-tackle-overfitting-in-deep-neural-networks","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/","title":{"rendered":"4 Techniques To Tackle Overfitting In Deep Neural Networks"},"content":{"rendered":"\n
\"\"\/<\/figure>\n\n\n\n

Image Created By Author Using Canva<\/strong><\/a><\/p>\n\n\n\n

\n

A neural network is a combination of different neurons, layers, weights, and biases. The first neural network was created in 1957 and named perceptron<\/em><\/strong><\/a>. It is similar to modern-day neural networks but it only had one layer. Since then, neural networks have become widely used for making predictions and business decisions.<\/p>\n

Neural networks became famous because of their ability to beat any traditional machine learning algorithm by a long margin in terms of performance. After the first neural network, they have evolved so much that nowadays there are networks with tons of layers and billions of parameters.<\/p>\n

With the involvement of APIs like Keras, Tensorflow, and Pytorch it has become very easy to design a neural network to achieve good accuracy on any kind and size of data. Being so powerful in terms of architecture, neural networks, if not created properly, can fall into the problem of overfitting.<\/p>\n

Overfitting is a condition that occurs when a model performs significantly better for training data than it does for new data. In this blog, we will see some of the techniques that are helpful for tackling overfitting in neural networks.<\/p>\n

Data Augmentation<\/h1>\n

The simplest way to eliminate overfitting is data augmentation<\/a>. Data augmentation is the process of reproducing new training instances from existing ones. It is commonly used in computer vision to regenerate images for convolutional neural networks.<\/p>\n

Image augmentation<\/a> is a type of data augmentation technique in which we apply certain transformations to our images to produce multiple copies of the original image that are totally different in terms of size and colors from the original image.<\/p>\n

Position and Color are the two most common transformation techniques that are used to reproduce data. Position augmentation changes the pixel position of an image. Some famous techniques to do so are \u2014 scaling, cropping, flipping, padding, rotation, and translation at different positional values.<\/p>\n

from PIL import Image\nimport matplotlib.pyplot as plt<\/span>img = Image.open(\"\/content\/drive\/MyDrive\/cat.jpg\")\nflipped_img = img.transpose(Image.FLIP_LEFT_RIGHT) ###flipping\nroated_img = img.transpose(Image.ROTATE_90) ## rotating\nscaled_img = img.resize((400, 400))  ### scaling<\/span>##left, upper, right, lower\ncropped_img = img.crop((100,50,400,200))<\/span>width, height = img.size\npad_pixel = 20\ncanvas = Image.new(img.mode, (width+pad_pixel, height+pad_pixel), 'blue')\ncanvas.paste(img, (pad_pixel\/\/2,pad_pixel\/\/2))<\/span><\/pre>\n
\n
\n
\"\"<\/figure>
Position Augmentation<\/picture><\/div>\n<\/div>\n<\/figure>\n
Color Augmentation deals with altering the color properties of an image by changing its pixel values. Some of the most common techniques of it are changing brightness, contrast, saturation, hue, grayscale, dilation, etc.<\/p>\n
from PIL import Image, ImageEnhance\nimport matplotlib.pyplot as plt\nimg = Image.open(\"\/content\/drive\/MyDrive\/cat.jpg\")<\/span>enhancer = ImageEnhance.Brightness(img)\nimg2 = enhancer.enhance(1.5)  ## brightens image\nimg3 = enhancer.enhance(0.5)  ## darkens image<\/span>enhancer = ImageEnhance.Contrast(img)\nimg4 = enhancer.enhance(1.5) ## increase contrast\nimg5 = enhancer.enhance(0.5) ## decrease contrast<\/span>enhancer = ImageEnhance.Sharpness(img)\nimg6 = enhancer.enhance(5) ## increase sharpness<\/span><\/pre>\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>\n<\/figure>\n
Although it is possible to perform image augmentation manually by using image processing libraries like pillow and OpenCV, the much simpler and less time-consuming way is to do it by using the Keras<\/a> API.<\/p>\n
Keras is a deep learning API written in Python, running on top of the machine learning platform Tensorflow. Keras has many inbuild methods and classes that increase the experimentation speed. In Keras, inside the image class, we have a method ImageDataGenerator<\/a> that provides multiple options for Image Augmentation.<\/p>\n
keras.preprocessing.image.ImageDataGenerator<\/strong>()<\/span><\/pre>\n
arguments<\/strong><\/a>:
\n1. featurewise_center<\/code>: Truth value. Average the inputs to 0 for the entire dataset.
\n2. samplewise_center<\/code>: Truth value. Set the average of each sample to 0.
\n3. featurewise_std_normalization<\/code>: Truth value. Normalizes the input with the standard deviation of the dataset.
\n4. samplewise_std_normalization<\/code>: Truth value. Normalize each input with its standard deviation.
\n5. zca_epsilon<\/code>: ZCA whitening epsilon. The default is 1e-6.
\n6. zca_whitening<\/code>: Truth value. Apply ZCA whitening.
\n7. rotation_range<\/code>: Integer. A rotation range that randomly rotates the image.
\n8. width_shift_range<\/code>: Floating point number (ratio to width). Random horizontal shift range.
\n9. height_shift_range<\/code>: Floating point number (ratio to vertical width). Random vertical shift range.
\n10. shear_range<\/code>: Floating point number. Shear strength (counterclockwise shear angle).
\n11. zoom_range<\/code>: Floating point number or [lower, upper]. Random zoom range. Given a floating point number [lower, upper] = [1-zoom_range, 1+zoom_range]<\/code>:
\n12. channel_shift_range<\/code>: Floating point number. The range in which the channel is randomly shifted.
\n13. horizontal_flip<\/code>: Truth value. Randomly inverts the input horizontally.
\n14. vertical_flip<\/code>: Truth value. Randomly inverts the input in the vertical direction.
\n15. <\/strong>rescale<\/code>: Pixel value rescale factor. The default is None. If None or 0, it does not apply.
\n16. preprocessing_function<\/code>: Function applied to each input. This function will be executed before any other changes are made.
\n17. validation_split<\/code>: <\/strong>Floating point number. Percentage of images reserved for verification (strictly between 0 and 1).
\n18. fill_mode<\/code>: {\u201cconstant\u201d, \u201cnearest\u201d, \u201creflect\u201d, \u201cwrap\u201d} The default is \u2018nearest\u2019. Fills around the boundaries of the input image according to the specified mode.
\n19. cval<\/code>: Floating point number or integer. fill_mode = \"constant\"<\/code>The value used around the boundary at.<\/p>\n
Performing Data Augmentation using Tensorflow<\/h2>\n
from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n\ndatagen = ImageDataGenerator(\n        rotation_range=40,\n        width_shift_range=0.2,\n        height_shift_range=0.2,\n        brightness_range= [0.5, 1.5],\n        rescale=1.\/255,\n        shear_range=0.2,\n        zoom_range=0.4,\n        horizontal_flip=True,\n        fill_mode='nearest',\n        zca_epsilon=True)\n\npath = '\/content\/drive\/MyDrive\/cat.jpg' ## Image Path\nimg = load_img(f\"{path}\")\nx = img_to_array(img)\nx = x.reshape((1,) + x.shape)\ni = 0\n\n### Create 25 Augmentated Images and Save Them In `aug_img` directory\nfor batch in datagen.flow(x, batch_size=1,\n                      save_to_dir=\"\/content\/drive\/MyDrive\/aug_imgs\", save_prefix='img', save_format='jpeg'):\n    i += 1\n    if i > 25:   ## Total 25 Augmented Images\n        break<\/pre>\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>\n<\/figure>\n
There are many advanced methods as well that make use of Generative Adversarial Networks (GANs)<\/a> to perform data augmentation. You can read about these methods by reading these research papers:<\/p>\n
1. Data augmentation using Generative Adversarial Networks (GANs) for GAN-based detection of Pneumonia and COVID-19 in chest X-ray images<\/em><\/a>\n2. Data Augmentation Generative Adversarial Networks<\/em><\/a><\/span><\/pre>\n<\/div>\n\n\n\n
<\/div>\n\n\n\n
\n
Adding Dropout Layers<\/h1>\n
Dropout layers are the most common method to tackle overfitting in deep neural networks. It reduces the chances of overfitting by modifying the network.<\/p>\n
Dropout layers randomly<\/strong> set input units to 0 with a frequency of rate<\/em> at each step during the training phase. These inputs with 0 frequency are dropped for the same training epoch. Inputs not set to 0 are scaled up by 1\/(1 \u2014 rate) such that the sum over all inputs is unchanged.<\/p>\n
Rate <\/strong>is the main parameter that ranges from 0 to 1. It specifies the fraction of the input units to drop. For example, the rate of 0.5 means 50% of units (neurons) are dropped randomly from the network.<\/p>\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>\n<\/figure>\n
tf.keras.layers..Dropout(rate<\/strong>, noise_shape=None, seed=None)<\/span><\/pre>\n
arguments<\/strong><\/a>
\n1. <\/strong>rate<\/strong><\/code> : <\/strong>Float between 0 and 1. Fraction of the input units to drop.
\n2. noise_shape<\/code> :1D integer tensor representing the shape of the binary dropout mask that will be multiplied with the input.
\n3. seed<\/code> : Integer to use as a random seed.<\/p>\n
Adding Dropout Layers Using Tensorflow<\/h2>\n
import tensorflow as tf\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense,Reshape\nfrom tensorflow.keras.layers import Dropout\n\ndef create_model():\n  model = Sequential()\n  model.add(Dense(60, input_shape=(60,), activation='relu'))\n  model.add(Dropout(0.2))\n  model.add(Dense(30, activation='relu'))\n  model.add(Dropout(0.2))\n  model.add(Dense(1, activation='sigmoid'))\n  return model\n\nadam = tf.keras.optimizers.Adam()\nmodel.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy'])\n\nmodel = create_model()\nmodel.summary()<\/pre>\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/figure>\n
There are certain tips that you should consider while adding dropout layers to your neural network:<\/p>\n
1. Use a small dropout value of 20%-50% of neurons. Specifying a larger dropout value might decrease the model performance also choosing a very small value will not affect the network much.<\/p>\n
2. Try to dropout layer only in a large network to get maximum performance.<\/p>\n
3. You can use dropout on incoming (visible) and hidden layers both. It performs well in both cases.<\/p>\n<\/div>\n\n\n\n
<\/div>\n\n\n\n
\n
Want to get the most up-to-date news on all things Deep Learning? Subscribe to Deep Learning Weekly<\/a> for the latest research, resources, and industry news, delivered to your inbox.<\/p><\/blockquote>\n<\/div>\n\n\n\n
<\/div>\n\n\n\n
\n
L1 and L2 Regularization<\/h1>\n
Regularization is a technique to reduce the complexity of the network by penalizing the loss function. It adds an extra element to the loss function, which punishes our model for being too complex or, in simple words, for using high values in the weight matrix.<\/p>\n
L1 Regularization reduces the weight values for less important features to zero so that only important features take part in the training and validation process. It works as an automatic feature selector for neural networks. It is also referred to as Least Absolute Deviations, <\/em>and minimizes the absolute difference between target and estimated(predicted) values.<\/p>\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>\n<\/figure>\n
L2 Regularization forces the weights towards zero but never makes them exactly zero. It removes a small percentage of weight at each iteration to reduce the complexity of the network and make it simple so that it does not overfit on the data. It minimizes the square of the sum of the difference between target values and estimated values.<\/p>\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>\n<\/figure>\n
Performing Regularization Using Tensorflow<\/h2>\n
import tensorflow as tf\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense,Reshape\nfrom tensorflow.keras.layers import Dropout\n\ndef create_model():\n  # create model\n  model = Sequential()\n  model.add(Dense(60, input_shape=(60,), activation='relu',  kernel_regularizer=keras.regularizers.l1(0.01)))\n  model.add(Dropout(0.2))\n  model.add(Dense(30, activation='relu',  kernel_regularizer=keras.regularizers.l2(0.001)))\n  model.add(Dropout(0.2))\n  model.add(Dense(1, activation='sigmoid'))\n  return model\n\n\nadam = tf.keras.optimizers.Adam()\nmodel.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy'])\n\nmodel = create_model()\nmodel.summary()<\/pre>\n
You can learn about L1 and L2 Regularization more deeply by reading the below research papers:<\/p>\n
1. Feature selection, L1 vs. L2 regularization, and rotational invariance<\/em><\/a>\n2. Regularization Methods in Neural Networks<\/em><\/a>\n3. A Comparison of Regularization Techniques in Deep Neural Networks<\/em><\/a><\/span><\/pre>\n<\/div>\n\n\n\n
<\/div>\n\n\n\n
\n
Early Stopping<\/h1>\n
One epoch is one complete pass of training data through the neural network. During each epoch, each neuron has the opportunity to update its weights, so the more epochs you choose, the longer your training will be. Additionally, choosing too many epochs can lead to overfitting. On the other hand, choosing too few epochs can cause underfitting.<\/p>\n
Early stopping is a form of regularization that stops the training process once model performance stops improving on the validation set as it significantly decreases the likelihood of overfitting the model.<\/p>\n
\n
\n
\"\"<\/figure>
Early Stopping [<\/picture>Must Read<\/strong> ]\u2014 <\/picture>SOURCE<\/a><\/div>\n<\/div>\n<\/figure>\n
Keras has a callback function designed to stop training early once it has detected that the model is no longer making significant improvements.<\/p>\n
from tensorflow.keras.callbacks import EarlyStopping\nearly_stopping = EarlyStopping(\n    monitor='val_loss',\n    min_delta=0,\n    patience=0,\n    verbose=0,\n    mode='auto',\n    baseline=None,\n    restore_best_weights=False\n)<\/span><\/pre>\n
Arguments<\/strong><\/a>
\nmonitor<\/strong>: metric to be used as a measure for terminating the training.
\nmin_delta<\/strong>: <\/strong>change in the monitored quantity to qualify as an improvement. less min_delta will count as no improvement.
\npatience<\/strong>: number of epochs with no improvement after which training gets terminated.
\nverbose<\/strong>: Verbosity mode, 0 or 1. Mode 0 is silent, and mode 1 displays callback messages.
\nmode<\/strong>:{\u201cauto\u201d, \u201cmin\u201d, \u201cmax\u201d}, in min<\/code>mode training, will stop when performance stops decreasing, in max<\/code> <\/strong>mode training will stop when performance stops increasing, in \"auto\"<\/code> mode, the direction is automatically inferred from the name of the monitored quantity.
\nbaseline<\/strong>: baseline value for the monitored quality.
\nrestore_best_weights<\/strong>: Whether to restore model weights from the epoch with the best value of the monitored quantity or not.<\/p>\n
from tensorflow.keras.callbacks import EarlyStopping<\/span>early_stopping = EarlyStopping(monitor='loss', patience=2)history = model.fit(\n    X_train,\n    y_train,\n    epochs= 100,\n    validation_split= 0.20,\n    batch_size= 50,\n    verbose= \"auto\",\n    callbacks= [early_stopping]\n)<\/span><\/pre>\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>\n<\/figure>\n
Early stopping will stop the neural network when it stops improving for the specified number of epochs, thus reducing the training time taken by the network.<\/p>\n
These methods only work when you apply them correctly. Not every network requires each technique to be applied, some networks can be improved by applying just one method.<\/p>\n
Conclusion<\/h2>\n
As a quick recap of different techniques, data augmentation will increase the size of data by applying different transformations to images and dropout layers will reduce the network complexity by randomly dropping some neurons. Regularization techniques will penalize the network for producing large errors and, at the end, early stopping methods will stop the training of the network once it stops improving.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Image Created By Author Using Canva A neural network is a combination of different neurons, layers, weights, and biases. The first neural network was created in 1957 and named perceptron. It is similar to modern-day neural networks but it only had one layer. Since then, neural networks have become widely used for making predictions and business […]<\/p>\n","protected":false},"author":8,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"customer_name":"","customer_description":"","customer_industry":"","customer_technologies":"","customer_logo":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[6,7],"tags":[],"coauthors":[140],"class_list":["post-4595","post","type-post","status-publish","format-standard","hentry","category-machine-learning","category-tutorials"],"yoast_head":"\n4 Techniques To Tackle Overfitting In Deep Neural Networks - Comet<\/title>\n<meta name=\"description\" content=\"Overfitting is a condition that occurs when a model performs significantly better for training data than it does for new data. In this blog, we will see some of the techniques that are helpful for tackling overfitting in neural networks.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"4 Techniques To Tackle Overfitting In Deep Neural Networks\" \/>\n<meta property=\"og:description\" content=\"Overfitting is a condition that occurs when a model performs significantly better for training data than it does for new data. In this blog, we will see some of the techniques that are helpful for tackling overfitting in neural networks.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/\" \/>\n<meta property=\"og:site_name\" content=\"Comet\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/cometdotml\" \/>\n<meta property=\"article:published_time\" content=\"2022-11-11T01:47:33+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-24T17:16:41+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/miro.medium.com\/max\/700\/1*JTZZjEAQin8fNEDxyYK2Jg.png\" \/>\n<meta name=\"author\" content=\"Abhay Parashar\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Cometml\" \/>\n<meta name=\"twitter:site\" content=\"@Cometml\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Abhay Parashar\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"4 Techniques To Tackle Overfitting In Deep Neural Networks - Comet","description":"Overfitting is a condition that occurs when a model performs significantly better for training data than it does for new data. In this blog, we will see some of the techniques that are helpful for tackling overfitting in neural networks.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/","og_locale":"en_US","og_type":"article","og_title":"4 Techniques To Tackle Overfitting In Deep Neural Networks","og_description":"Overfitting is a condition that occurs when a model performs significantly better for training data than it does for new data. In this blog, we will see some of the techniques that are helpful for tackling overfitting in neural networks.","og_url":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/","og_site_name":"Comet","article_publisher":"https:\/\/www.facebook.com\/cometdotml","article_published_time":"2022-11-11T01:47:33+00:00","article_modified_time":"2025-04-24T17:16:41+00:00","og_image":[{"url":"https:\/\/miro.medium.com\/max\/700\/1*JTZZjEAQin8fNEDxyYK2Jg.png","type":"","width":"","height":""}],"author":"Abhay Parashar","twitter_card":"summary_large_image","twitter_creator":"@Cometml","twitter_site":"@Cometml","twitter_misc":{"Written by":"Abhay Parashar","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#article","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/"},"author":{"name":"Team Comet Digital","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/6266601170c60a7a82b3e0043fbe8ddf"},"headline":"4 Techniques To Tackle Overfitting In Deep Neural Networks","datePublished":"2022-11-11T01:47:33+00:00","dateModified":"2025-04-24T17:16:41+00:00","mainEntityOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/"},"wordCount":1534,"publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/max\/700\/1*JTZZjEAQin8fNEDxyYK2Jg.png","articleSection":["Machine Learning","Tutorials"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/","url":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/","name":"4 Techniques To Tackle Overfitting In Deep Neural Networks - Comet","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#primaryimage"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/max\/700\/1*JTZZjEAQin8fNEDxyYK2Jg.png","datePublished":"2022-11-11T01:47:33+00:00","dateModified":"2025-04-24T17:16:41+00:00","description":"Overfitting is a condition that occurs when a model performs significantly better for training data than it does for new data. In this blog, we will see some of the techniques that are helpful for tackling overfitting in neural networks.","breadcrumb":{"@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#primaryimage","url":"https:\/\/miro.medium.com\/max\/700\/1*JTZZjEAQin8fNEDxyYK2Jg.png","contentUrl":"https:\/\/miro.medium.com\/max\/700\/1*JTZZjEAQin8fNEDxyYK2Jg.png"},{"@type":"BreadcrumbList","@id":"https:\/\/www.comet.com\/site\/blog\/4-techniques-to-tackle-overfitting-in-deep-neural-networks\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.comet.com\/site\/"},{"@type":"ListItem","position":2,"name":"4 Techniques To Tackle Overfitting In Deep Neural Networks"}]},{"@type":"WebSite","@id":"https:\/\/www.comet.com\/site\/#website","url":"https:\/\/www.comet.com\/site\/","name":"Comet","description":"Build Better Models Faster","publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.comet.com\/site\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.comet.com\/site\/#organization","name":"Comet ML, Inc.","alternateName":"Comet","url":"https:\/\/www.comet.com\/site\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","width":310,"height":310,"caption":"Comet ML, Inc."},"image":{"@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/cometdotml","https:\/\/x.com\/Cometml","https:\/\/www.youtube.com\/channel\/UCmN63HKvfXSCS-UwVwmK8Hw"]},{"@type":"Person","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/6266601170c60a7a82b3e0043fbe8ddf","name":"Team Comet Digital","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/image\/4f0c0a8cc7c0e87c636ff6a420a6647c","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2023\/08\/Screen-Shot-2023-08-12-at-8.58.50-AM-96x96.png","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2023\/08\/Screen-Shot-2023-08-12-at-8.58.50-AM-96x96.png","caption":"Team Comet Digital"},"sameAs":["https:\/\/www.comet.ml\/"],"url":"https:\/\/www.comet.com\/site\/blog\/author\/teamcometdigital\/"}]}},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/4595","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/users\/8"}],"replies":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/comments?post=4595"}],"version-history":[{"count":1,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/4595\/revisions"}],"predecessor-version":[{"id":15656,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/4595\/revisions\/15656"}],"wp:attachment":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/media?parent=4595"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/categories?post=4595"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/tags?post=4595"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/coauthors?post=4595"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}