तिथि को रक्षित करें! Google I / O 18-20 मई को पंजीकृत करता है
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

ओवरफिट और अंडरफिट

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

हमेशा की तरह, इस उदाहरण में कोड tf.keras API का उपयोग करेगा, जिसे आप TensorFlow Keras गाइड के बारे में अधिक जान सकते हैं।

पिछले उदाहरणों में- पाठ को वर्गीकृत करना और ईंधन दक्षता की भविष्यवाणी करना - हमने देखा कि सत्यापन डेटा पर हमारे मॉडल की सटीकता कई युगों के लिए प्रशिक्षण के बाद चरम पर होगी, और फिर स्थिर हो जाएगी या कम होने लगेगी।

दूसरे शब्दों में, हमारा मॉडल प्रशिक्षण डेटा से आगे निकल जाएगा। ओवरफिटिंग से कैसे निपटना है, यह सीखना महत्वपूर्ण है। यद्यपि प्रशिक्षण सेट पर उच्च सटीकता प्राप्त करना अक्सर संभव होता है, हम वास्तव में क्या चाहते हैं कि वे मॉडल विकसित करें जो एक परीक्षण सेट (या डेटा जो उन्होंने पहले नहीं देखा है) के लिए सामान्यीकृत करें।

ओवरफिटिंग के विपरीत है। अंडरफ़िटिंग तब होती है जब ट्रेन डेटा में सुधार के लिए अभी भी जगह है। यह कई कारणों से हो सकता है: यदि मॉडल पर्याप्त रूप से शक्तिशाली नहीं है, अधिक नियमित है, या बस लंबे समय तक प्रशिक्षित नहीं किया गया है। इसका मतलब है कि नेटवर्क ने प्रशिक्षण डेटा में प्रासंगिक पैटर्न नहीं सीखा है।

यदि आप बहुत लंबे समय तक प्रशिक्षण लेते हैं, तो मॉडल प्रशिक्षण डेटा से पैटर्न को ओवरफिट और सीखना शुरू कर देगा जो परीक्षण डेटा को सामान्य नहीं करते हैं। हमें एक संतुलन बनाने की जरूरत है। समझ में कैसे उचित युग के लिए प्रशिक्षित करने के लिए नीचे हम एक उपयोगी कौशल है।

ओवरफिटिंग को रोकने के लिए, सबसे अच्छा समाधान अधिक पूर्ण प्रशिक्षण डेटा का उपयोग करना है। डेटासेट की पूरी श्रृंखला को कवर किया जाना चाहिए जिसे मॉडल को संभालने की उम्मीद है। अतिरिक्त डेटा केवल तभी उपयोगी हो सकता है जब यह नए और दिलचस्प मामलों को कवर करता है।

अधिक पूर्ण डेटा पर प्रशिक्षित एक मॉडल स्वाभाविक रूप से बेहतर सामान्यीकरण करेगा। जब यह संभव नहीं रह जाता है, तो अगला सबसे अच्छा उपाय नियमितीकरण जैसी तकनीकों का उपयोग करना है। ये स्थान आपके मॉडल को संग्रहीत करने वाली जानकारी की मात्रा और प्रकार पर बाधा डाल सकते हैं। यदि कोई नेटवर्क केवल बहुत कम पैटर्न याद कर सकता है, तो अनुकूलन प्रक्रिया उसे सबसे प्रमुख पैटर्न पर ध्यान केंद्रित करने के लिए मजबूर करेगी, जिसके पास अच्छी तरह से सामान्यीकरण करने का एक बेहतर मौका है।

इस नोटबुक में, हम कई सामान्य नियमितीकरण तकनीकों का पता लगाएंगे, और उनका उपयोग वर्गीकरण मॉडल में सुधार करने के लिए करेंगे।

सेट अप

आरंभ करने से पहले, आवश्यक पैकेज आयात करें:

import tensorflow as tf

from tensorflow.keras import layers
from tensorflow.keras import regularizers

print(tf.__version__)
2.4.0
!pip install -q git+https://github.com/tensorflow/docs

import tensorflow_docs as tfdocs
import tensorflow_docs.modeling
import tensorflow_docs.plots
from  IPython import display
from matplotlib import pyplot as plt

import numpy as np

import pathlib
import shutil
import tempfile
logdir = pathlib.Path(tempfile.mkdtemp())/"tensorboard_logs"
shutil.rmtree(logdir, ignore_errors=True)

हिग्स दगासेट

इस ट्यूटोरियल का लक्ष्य कण भौतिकी करना नहीं है, इसलिए डेटासेट के विवरण पर ध्यान न दें। इसमें 11 000 000 उदाहरण हैं, प्रत्येक में 28 विशेषताएं हैं, और एक बाइनरी क्लास लेबल है।

gz = tf.keras.utils.get_file('HIGGS.csv.gz', 'http://mlphysics.ics.uci.edu/data/higgs/HIGGS.csv.gz')
Downloading data from http://mlphysics.ics.uci.edu/data/higgs/HIGGS.csv.gz
2816409600/2816407858 [==============================] - 120s 0us/step
FEATURES = 28

tf.data.experimental.CsvDataset वर्ग को बिना किसी मध्यवर्ती विघटन के चरण वाली gzip फ़ाइल से सीधे csv रिकॉर्ड पढ़ने के लिए इस्तेमाल किया जा सकता है।

ds = tf.data.experimental.CsvDataset(gz,[float(),]*(FEATURES+1), compression_type="GZIP")

वह csv रीडर क्लास प्रत्येक रिकॉर्ड के लिए स्केलर्स की एक सूची देता है। निम्न फ़ंक्शन एक (फीचर_वेक्टर, लेबल) जोड़ी में स्केलर की सूची को दोहराता है।

def pack_row(*row):
  label = row[0]
  features = tf.stack(row[1:],1)
  return features, label

डेटा के बड़े बैचों पर काम करते समय TensorFlow सबसे कुशल है।

इसलिए प्रत्येक पंक्ति को अलग-अलग pack_row बजाय एक नया Dataset बनाएं जो 10000-उदाहरणों के बैचों को लेता है, प्रत्येक बैच के लिए pack_row फ़ंक्शन को लागू करता है, और फिर बैचों को अलग-अलग रिकॉर्ड में वापस विभाजित करता है:

packed_ds = ds.batch(10000).map(pack_row).unbatch()

इस नए packed_ds से रिकॉर्ड में से कुछ पर एक नज़र है।

सुविधाएँ पूरी तरह से सामान्यीकृत नहीं हैं, लेकिन यह इस ट्यूटोरियल के लिए पर्याप्त है।

for features,label in packed_ds.batch(1000).take(1):
  print(features[0])
  plt.hist(features.numpy().flatten(), bins = 101)
tf.Tensor(
[ 0.8692932  -0.6350818   0.22569026  0.32747006 -0.6899932   0.75420225
 -0.24857314 -1.0920639   0.          1.3749921  -0.6536742   0.9303491
  1.1074361   1.1389043  -1.5781983  -1.0469854   0.          0.65792954
 -0.01045457 -0.04576717  3.1019614   1.35376     0.9795631   0.97807616
  0.92000484  0.72165745  0.98875093  0.87667835], shape=(28,), dtype=float32)

पींग

इस ट्यूटोरियल को अपेक्षाकृत कम उपयोग करने के लिए सत्यापन के लिए सिर्फ पहले 1000 नमूने, और प्रशिक्षण के लिए अगले 10 000:

N_VALIDATION = int(1e3)
N_TRAIN = int(1e4)
BUFFER_SIZE = int(1e4)
BATCH_SIZE = 500
STEPS_PER_EPOCH = N_TRAIN//BATCH_SIZE

Dataset.skip और Dataset.take विधियाँ इसे आसान बनाती हैं।

उसी समय, यह सुनिश्चित करने के लिए Dataset.cache विधि का उपयोग करें कि लोडर को प्रत्येक एपोक पर फ़ाइल से डेटा को फिर से पढ़ने की आवश्यकता नहीं है:

validate_ds = packed_ds.take(N_VALIDATION).cache()
train_ds = packed_ds.skip(N_VALIDATION).take(N_TRAIN).cache()
train_ds
<CacheDataset shapes: ((28,), ()), types: (tf.float32, tf.float32)>

ये डेटासेट व्यक्तिगत उदाहरण लौटाते हैं। प्रशिक्षण के लिए उचित आकार के बैच बनाने के लिए .batch विधि का उपयोग करें। बैचिंग से पहले .shuffle और .repeat प्रशिक्षण सेट को भी याद रखें।

validate_ds = validate_ds.batch(BATCH_SIZE)
train_ds = train_ds.shuffle(BUFFER_SIZE).repeat().batch(BATCH_SIZE)

ओवरफिटिंग का प्रदर्शन

ओवरफिटिंग को रोकने का सबसे सरल तरीका एक छोटे मॉडल के साथ शुरू करना है: एक मॉडल जिसमें सीखने योग्य पैरामीटर (जो परतों की संख्या और प्रति परत इकाइयों की संख्या) से निर्धारित होता है। गहन सीखने में, एक मॉडल में सीखने योग्य मापदंडों की संख्या को अक्सर मॉडल की "क्षमता" के रूप में संदर्भित किया जाता है।

सहज रूप से, अधिक मापदंडों वाले एक मॉडल में अधिक "मेमोराइजेशन क्षमता" होगी और इसलिए आसानी से प्रशिक्षण के नमूनों और उनके लक्ष्यों के बीच एक सही शब्दकोश जैसी मानचित्रण सीखने में सक्षम होगा, बिना किसी सामान्यीकरण शक्ति के एक मैपिंग, लेकिन यह भविष्यवाणियां करने के लिए बेकार होगा पहले अनदेखी डेटा पर।

इसे हमेशा ध्यान में रखें: डीप लर्निंग मॉडल्स ट्रेनिंग डेटा की फिटिंग के लिए अच्छे होते हैं, लेकिन असली चुनौती सामान्यीकरण की होती है, न कि फिटिंग की।

दूसरी ओर, यदि नेटवर्क में सीमित संस्मरण संसाधन हैं, तो यह आसानी से मैपिंग सीखने में सक्षम नहीं होगा। अपने नुकसान को कम करने के लिए, इसे संपीड़ित अभ्यावेदन सीखना होगा, जिसमें अधिक भविष्य कहनेवाला शक्ति है। उसी समय, यदि आप अपने मॉडल को बहुत छोटा बनाते हैं, तो प्रशिक्षण डेटा के लिए फिटिंग में कठिनाई होगी। "बहुत अधिक क्षमता" और "पर्याप्त क्षमता नहीं" के बीच एक संतुलन है।

दुर्भाग्य से, आपके मॉडल के सही आकार या वास्तुकला (परतों की संख्या, या प्रत्येक परत के लिए सही आकार) के निर्धारण के लिए कोई जादुई सूत्र नहीं है। आपको विभिन्न आर्किटेक्चर की एक श्रृंखला का उपयोग करके प्रयोग करना होगा।

एक उपयुक्त मॉडल आकार खोजने के लिए, अपेक्षाकृत कुछ परतों और मापदंडों के साथ शुरू करना सबसे अच्छा है, फिर परतों के आकार को बढ़ाना या नई परतों को जोड़ना शुरू करें जब तक कि आप सत्यापन नुकसान पर कम नहीं देखते।

केवल layers.Dense का उपयोग करके एक साधारण मॉडल के साथ शुरू करें। एक आधार रेखा के रूप में layers.Dense , फिर बड़े संस्करण बनाएं, और उनकी तुलना करें।

प्रशिक्षण प्रक्रिया

कई मॉडल बेहतर प्रशिक्षण देते हैं यदि आप प्रशिक्षण के दौरान धीरे-धीरे सीखने की दर कम करते हैं। समय के साथ सीखने की दर को कम करने के लिए optimizers.schedules का उपयोग करें:

lr_schedule = tf.keras.optimizers.schedules.InverseTimeDecay(
  0.001,
  decay_steps=STEPS_PER_EPOCH*1000,
  decay_rate=1,
  staircase=False)

def get_optimizer():
  return tf.keras.optimizers.Adam(lr_schedule)

ऊपर दिया गया कोड एकschedules.InverseTimeDecay करता है। InverseTimeDecay, अधिगम दर को १००० युगों के आधार दर के १/२ करने के लिए कम करता है, २००० युगों पर १/३ और इसी तरह।

step = np.linspace(0,100000)
lr = lr_schedule(step)
plt.figure(figsize = (8,6))
plt.plot(step/STEPS_PER_EPOCH, lr)
plt.ylim([0,max(plt.ylim())])
plt.xlabel('Epoch')
_ = plt.ylabel('Learning Rate')

पींग

इस ट्यूटोरियल में प्रत्येक मॉडल समान प्रशिक्षण कॉन्फ़िगरेशन का उपयोग करेगा। इसलिए कॉलबैक की सूची से शुरू करते हुए, इन्हें पुन: प्रयोज्य तरीके से सेट करें।

इस ट्यूटोरियल का प्रशिक्षण कई लघु युगों के लिए चलता है। लॉगिंग के शोर को कम करने के लिए tfdocs.EpochDots उपयोग करें जो केवल एक प्रिंट करता है . प्रत्येक युग के लिए, और हर 100 युग में मीट्रिक का एक पूरा सेट।

अगला callbacks.EarlyStopping शामिल करें। लंबे और अनावश्यक प्रशिक्षण समय से बचने के लिए। ध्यान दें कि यह कॉलबैक नजर रखने के लिए सेट कर दिया जाता है कि val_binary_crossentropy , नहीं val_loss । यह अंतर बाद में महत्वपूर्ण होगा।

प्रशिक्षण के लिए TensorBoard लॉग जेनरेट करने के लिए callbacks.TensorBoard का उपयोग करें।

def get_callbacks(name):
  return [
    tfdocs.modeling.EpochDots(),
    tf.keras.callbacks.EarlyStopping(monitor='val_binary_crossentropy', patience=200),
    tf.keras.callbacks.TensorBoard(logdir/name),
  ]

इसी प्रकार प्रत्येक मॉडल एक ही Model.compile और Model.fit सेटिंग्स का उपयोग करेगा:

def compile_and_fit(model, name, optimizer=None, max_epochs=10000):
  if optimizer is None:
    optimizer = get_optimizer()
  model.compile(optimizer=optimizer,
                loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
                metrics=[
                  tf.keras.losses.BinaryCrossentropy(
                      from_logits=True, name='binary_crossentropy'),
                  'accuracy'])

  model.summary()

  history = model.fit(
    train_ds,
    steps_per_epoch = STEPS_PER_EPOCH,
    epochs=max_epochs,
    validation_data=validate_ds,
    callbacks=get_callbacks(name),
    verbose=0)
  return history

छोटे मॉडल

एक मॉडल को प्रशिक्षित करके शुरू करें:

tiny_model = tf.keras.Sequential([
    layers.Dense(16, activation='elu', input_shape=(FEATURES,)),
    layers.Dense(1)
])
size_histories = {}
size_histories['Tiny'] = compile_and_fit(tiny_model, 'sizes/Tiny')
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense (Dense)                (None, 16)                464       
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 17        
=================================================================
Total params: 481
Trainable params: 481
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0027s vs `on_train_batch_end` time: 0.0064s). Check your callbacks.

Epoch: 0, accuracy:0.5142,  binary_crossentropy:0.7823,  loss:0.7823,  val_accuracy:0.5230,  val_binary_crossentropy:0.7322,  val_loss:0.7322,  
....................................................................................................
Epoch: 100, accuracy:0.5933,  binary_crossentropy:0.6284,  loss:0.6284,  val_accuracy:0.5730,  val_binary_crossentropy:0.6271,  val_loss:0.6271,  
....................................................................................................
Epoch: 200, accuracy:0.6176,  binary_crossentropy:0.6135,  loss:0.6135,  val_accuracy:0.5950,  val_binary_crossentropy:0.6167,  val_loss:0.6167,  
....................................................................................................
Epoch: 300, accuracy:0.6411,  binary_crossentropy:0.6011,  loss:0.6011,  val_accuracy:0.6230,  val_binary_crossentropy:0.6052,  val_loss:0.6052,  
....................................................................................................
Epoch: 400, accuracy:0.6542,  binary_crossentropy:0.5943,  loss:0.5943,  val_accuracy:0.6300,  val_binary_crossentropy:0.6003,  val_loss:0.6003,  
....................................................................................................
Epoch: 500, accuracy:0.6569,  binary_crossentropy:0.5903,  loss:0.5903,  val_accuracy:0.6470,  val_binary_crossentropy:0.5949,  val_loss:0.5949,  
....................................................................................................
Epoch: 600, accuracy:0.6631,  binary_crossentropy:0.5872,  loss:0.5872,  val_accuracy:0.6550,  val_binary_crossentropy:0.5927,  val_loss:0.5927,  
....................................................................................................
Epoch: 700, accuracy:0.6673,  binary_crossentropy:0.5846,  loss:0.5846,  val_accuracy:0.6690,  val_binary_crossentropy:0.5905,  val_loss:0.5905,  
....................................................................................................
Epoch: 800, accuracy:0.6743,  binary_crossentropy:0.5824,  loss:0.5824,  val_accuracy:0.6710,  val_binary_crossentropy:0.5890,  val_loss:0.5890,  
....................................................................................................
Epoch: 900, accuracy:0.6739,  binary_crossentropy:0.5815,  loss:0.5815,  val_accuracy:0.6630,  val_binary_crossentropy:0.5888,  val_loss:0.5888,  
....................................................................................................
Epoch: 1000, accuracy:0.6748,  binary_crossentropy:0.5791,  loss:0.5791,  val_accuracy:0.6610,  val_binary_crossentropy:0.5881,  val_loss:0.5881,  
....................................................................................................
Epoch: 1100, accuracy:0.6763,  binary_crossentropy:0.5774,  loss:0.5774,  val_accuracy:0.6710,  val_binary_crossentropy:0.5875,  val_loss:0.5875,  
....................................................................................................
Epoch: 1200, accuracy:0.6767,  binary_crossentropy:0.5763,  loss:0.5763,  val_accuracy:0.6630,  val_binary_crossentropy:0.5869,  val_loss:0.5869,  
....................................................................................................
Epoch: 1300, accuracy:0.6833,  binary_crossentropy:0.5750,  loss:0.5750,  val_accuracy:0.6550,  val_binary_crossentropy:0.5878,  val_loss:0.5878,  
....................................................................................................
Epoch: 1400, accuracy:0.6766,  binary_crossentropy:0.5737,  loss:0.5737,  val_accuracy:0.6710,  val_binary_crossentropy:0.5865,  val_loss:0.5865,  
....................................................................................................
Epoch: 1500, accuracy:0.6806,  binary_crossentropy:0.5727,  loss:0.5727,  val_accuracy:0.6630,  val_binary_crossentropy:0.5864,  val_loss:0.5864,  
....................................................................................................
Epoch: 1600, accuracy:0.6807,  binary_crossentropy:0.5717,  loss:0.5717,  val_accuracy:0.6720,  val_binary_crossentropy:0.5859,  val_loss:0.5859,  
....................................................................................................
Epoch: 1700, accuracy:0.6823,  binary_crossentropy:0.5707,  loss:0.5707,  val_accuracy:0.6570,  val_binary_crossentropy:0.5872,  val_loss:0.5872,  
..........

अब जाँचें कि मॉडल ने कैसे किया:

plotter = tfdocs.plots.HistoryPlotter(metric = 'binary_crossentropy', smoothing_std=10)
plotter.plot(size_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

पींग

छोटा मॉडल

यह देखने के लिए कि क्या आप छोटे मॉडल के प्रदर्शन को हरा सकते हैं, उत्तरोत्तर कुछ बड़े मॉडलों को प्रशिक्षित कर सकते हैं।

16 इकाइयों के साथ दो छिपी हुई परतों की कोशिश करें:

small_model = tf.keras.Sequential([
    # `input_shape` is only required here so that `.summary` works.
    layers.Dense(16, activation='elu', input_shape=(FEATURES,)),
    layers.Dense(16, activation='elu'),
    layers.Dense(1)
])
size_histories['Small'] = compile_and_fit(small_model, 'sizes/Small')
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_2 (Dense)              (None, 16)                464       
_________________________________________________________________
dense_3 (Dense)              (None, 16)                272       
_________________________________________________________________
dense_4 (Dense)              (None, 1)                 17        
=================================================================
Total params: 753
Trainable params: 753
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0028s vs `on_train_batch_end` time: 0.0112s). Check your callbacks.

Epoch: 0, accuracy:0.5037,  binary_crossentropy:0.9699,  loss:0.9699,  val_accuracy:0.4950,  val_binary_crossentropy:0.7648,  val_loss:0.7648,  
....................................................................................................
Epoch: 100, accuracy:0.6141,  binary_crossentropy:0.6173,  loss:0.6173,  val_accuracy:0.6000,  val_binary_crossentropy:0.6165,  val_loss:0.6165,  
....................................................................................................
Epoch: 200, accuracy:0.6532,  binary_crossentropy:0.5935,  loss:0.5935,  val_accuracy:0.6430,  val_binary_crossentropy:0.6023,  val_loss:0.6023,  
....................................................................................................
Epoch: 300, accuracy:0.6762,  binary_crossentropy:0.5797,  loss:0.5797,  val_accuracy:0.6540,  val_binary_crossentropy:0.5987,  val_loss:0.5987,  
....................................................................................................
Epoch: 400, accuracy:0.6843,  binary_crossentropy:0.5725,  loss:0.5725,  val_accuracy:0.6570,  val_binary_crossentropy:0.6005,  val_loss:0.6005,  
.............................................................................

मध्यम मॉडल

अब 64 इकाइयों के साथ 3 छिपी हुई परतों की कोशिश करें:

medium_model = tf.keras.Sequential([
    layers.Dense(64, activation='elu', input_shape=(FEATURES,)),
    layers.Dense(64, activation='elu'),
    layers.Dense(64, activation='elu'),
    layers.Dense(1)
])

और उसी डेटा का उपयोग करके मॉडल को प्रशिक्षित करें:

size_histories['Medium']  = compile_and_fit(medium_model, "sizes/Medium")
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_5 (Dense)              (None, 64)                1856      
_________________________________________________________________
dense_6 (Dense)              (None, 64)                4160      
_________________________________________________________________
dense_7 (Dense)              (None, 64)                4160      
_________________________________________________________________
dense_8 (Dense)              (None, 1)                 65        
=================================================================
Total params: 10,241
Trainable params: 10,241
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0026s vs `on_train_batch_end` time: 0.0107s). Check your callbacks.

Epoch: 0, accuracy:0.4897,  binary_crossentropy:0.7502,  loss:0.7502,  val_accuracy:0.4590,  val_binary_crossentropy:0.7012,  val_loss:0.7012,  
....................................................................................................
Epoch: 100, accuracy:0.7040,  binary_crossentropy:0.5396,  loss:0.5396,  val_accuracy:0.6760,  val_binary_crossentropy:0.5956,  val_loss:0.5956,  
....................................................................................................
Epoch: 200, accuracy:0.7784,  binary_crossentropy:0.4380,  loss:0.4380,  val_accuracy:0.6560,  val_binary_crossentropy:0.6714,  val_loss:0.6714,  
.......................................................................

बड़ा मॉडल

एक अभ्यास के रूप में, आप एक भी बड़ा मॉडल बना सकते हैं, और देख सकते हैं कि यह कितनी जल्दी ओवरफिट करना शुरू कर देता है। इसके बाद, आइए इस बेंचमार्क में एक नेटवर्क जोड़ें, जिसमें क्षमता अधिक है, समस्या की तुलना में कहीं अधिक है।

large_model = tf.keras.Sequential([
    layers.Dense(512, activation='elu', input_shape=(FEATURES,)),
    layers.Dense(512, activation='elu'),
    layers.Dense(512, activation='elu'),
    layers.Dense(512, activation='elu'),
    layers.Dense(1)
])

और, फिर से, उसी डेटा का उपयोग करके मॉडल को प्रशिक्षित करें:

size_histories['large'] = compile_and_fit(large_model, "sizes/large")
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_9 (Dense)              (None, 512)               14848     
_________________________________________________________________
dense_10 (Dense)             (None, 512)               262656    
_________________________________________________________________
dense_11 (Dense)             (None, 512)               262656    
_________________________________________________________________
dense_12 (Dense)             (None, 512)               262656    
_________________________________________________________________
dense_13 (Dense)             (None, 1)                 513       
=================================================================
Total params: 803,329
Trainable params: 803,329
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0035s vs `on_train_batch_end` time: 0.0129s). Check your callbacks.

Epoch: 0, accuracy:0.4901,  binary_crossentropy:0.8508,  loss:0.8508,  val_accuracy:0.5540,  val_binary_crossentropy:0.6800,  val_loss:0.6800,  
....................................................................................................
Epoch: 100, accuracy:1.0000,  binary_crossentropy:0.0025,  loss:0.0025,  val_accuracy:0.6480,  val_binary_crossentropy:1.7541,  val_loss:1.7541,  
....................................................................................................
Epoch: 200, accuracy:1.0000,  binary_crossentropy:0.0002,  loss:0.0002,  val_accuracy:0.6530,  val_binary_crossentropy:2.4090,  val_loss:2.4090,  
....................

प्रशिक्षण और सत्यापन नुकसान प्लॉट करें

ठोस लाइनें प्रशिक्षण हानि दिखाती हैं, और धराशायी लाइनें सत्यापन हानि दिखाती हैं (याद रखें: एक कम सत्यापन हानि एक बेहतर मॉडल इंगित करता है)।

बड़े मॉडल का निर्माण करते समय इसे अधिक शक्ति मिलती है, अगर यह शक्ति किसी तरह से बाधित नहीं होती है तो यह आसानी से प्रशिक्षण सेट पर पहुंच सकता है।

इस उदाहरण में, आमतौर पर, केवल "Tiny" मॉडल पूरी तरह से ओवरफिटिंग से बचने का प्रबंधन करता है, और प्रत्येक बड़े मॉडल डेटा को अधिक तेज़ी से ओवरफिट करता है। यह "large" मॉडल के लिए इतना गंभीर हो जाता है कि आपको वास्तव में क्या हो रहा है यह देखने के लिए प्लॉट को लॉग-स्केल पर स्विच करना होगा।

यह स्पष्ट है कि यदि आप प्रशिक्षण मीट्रिक के सत्यापन मैट्रिक्स की साजिश रचते हैं और तुलना करते हैं।

  • वहाँ एक छोटा सा अंतर होना सामान्य है।
  • यदि दोनों मीट्रिक समान दिशा में आगे बढ़ रहे हैं, तो सब कुछ ठीक है।
  • यदि सत्यापन मीट्रिक स्थिर होना शुरू हो जाता है जबकि प्रशिक्षण मीट्रिक में सुधार जारी है, तो आप संभवतः ओवरफिटिंग के करीब हैं।
  • यदि सत्यापन मीट्रिक गलत दिशा में जा रहा है, तो मॉडल स्पष्ट रूप से ओवरफिटिंग है।
plotter.plot(size_histories)
a = plt.xscale('log')
plt.xlim([5, max(plt.xlim())])
plt.ylim([0.5, 0.7])
plt.xlabel("Epochs [Log Scale]")
Text(0.5, 0, 'Epochs [Log Scale]')

पींग

TensorBoard में देखें

इन मॉडलों में सभी ने प्रशिक्षण के दौरान टेन्सरबोर्ड लॉग लिखे।

नोटबुक के अंदर एक एम्बेडेड TensorBoard दर्शक खोलें:


# Load the TensorBoard notebook extension
%load_ext tensorboard

# Open an embedded TensorBoard viewer
%tensorboard --logdir {logdir}/sizes

आप TensorBoard.dev पर इस नोटबुक के पिछले रन के परिणाम देख सकते हैं।

TensorBoard.dev होस्टिंग, ट्रैकिंग और सभी के साथ एमएल प्रयोगों को साझा करने के लिए एक प्रबंधित अनुभव है।

यह सुविधा के लिए एक <iframe> में भी शामिल है:

display.IFrame(
    src="https://tensorboard.dev/experiment/vW7jmmF9TmKmy3rbheMQpw/#scalars&_smoothingWeight=0.97",
    width="100%", height="800px")

यदि आप TensorBoard परिणाम साझा करना चाहते हैं, तो आप निम्न को कोड-सेल में कॉपी करके TensorBoard.dev पर लॉग अपलोड कर सकते हैं।

tensorboard dev upload --logdir  {logdir}/sizes

ओवरफिटिंग को रोकने के लिए रणनीतियाँ

तुलना करने के लिए आधार रेखा के रूप में उपयोग करने के लिए इस खंड की सामग्री में आने से पहले, "Tiny" मॉडल से प्रशिक्षण लॉग की प्रतिलिपि बनाएं।

shutil.rmtree(logdir/'regularizers/Tiny', ignore_errors=True)
shutil.copytree(logdir/'sizes/Tiny', logdir/'regularizers/Tiny')
PosixPath('/tmp/tmpr1cbfjvl/tensorboard_logs/regularizers/Tiny')
regularizer_histories = {}
regularizer_histories['Tiny'] = size_histories['Tiny']

वजन नियमितीकरण जोड़ें

आप ओकाम के रेजर सिद्धांत से परिचित हो सकते हैं: किसी चीज के लिए दो स्पष्टीकरण दिए गए, स्पष्टीकरण के सही होने की सबसे अधिक संभावना "सरलतम" है, वह जो कम से कम मान्यताओं को बनाता है। यह तंत्रिका नेटवर्क द्वारा सीखे गए मॉडल पर भी लागू होता है: कुछ प्रशिक्षण डेटा और एक नेटवर्क आर्किटेक्चर को देखते हुए, वज़न मानों (एकाधिक मॉडल) के कई सेट होते हैं जो डेटा को समझा सकते हैं, और सरल मॉडल जटिल लोगों की तुलना में कम होने की संभावना है।

इस संदर्भ में एक "सरल मॉडल" एक ऐसा मॉडल है जहां पैरामीटर मानों का वितरण कम एन्ट्रॉपी (या पूरी तरह से कम मापदंडों वाला मॉडल है, जैसा कि हमने ऊपर अनुभाग में देखा था)। इस प्रकार ओवरफिटिंग को कम करने का एक सामान्य तरीका है कि किसी नेटवर्क की जटिलता पर अड़चनें डालकर केवल छोटे मूल्यों को लेने के लिए उसके भार को मजबूर किया जाए, जिससे वजन मानों का वितरण अधिक "नियमित" हो जाता है। इसे "वेट रेग्युलराइजेशन" कहा जाता है, और यह नेटवर्क के नुकसान फ़ंक्शन को जोड़कर किया जाता है, जो कि बड़े वजन के साथ जुड़ा हुआ है। यह लागत दो स्वादों में आती है:

  • एल 1 नियमितीकरण , जहां लागत को जोड़ा गया, वजन गुणांक के पूर्ण मूल्य के लिए आनुपातिक है (यानी जिसे वजन का "एल 1 मानक" कहा जाता है)।

  • एल 2 नियमितीकरण , जहां लागत को जोड़ा गया, वजन गुणांक के मूल्य के वर्ग के लिए आनुपातिक है (यानी जिसे वजन का वर्ग "एल 2 मानक" कहा जाता है)। एल 2 नियमितीकरण को तंत्रिका नेटवर्क के संदर्भ में वजन क्षय भी कहा जाता है। अलग-अलग नाम आपको भ्रमित न करें: वजन क्षय गणितीय रूप से L2 नियमितीकरण के समान ही है।

L1 नियमितीकरण एक विरल मॉडल को प्रोत्साहित करने वाले शून्य को वज़न की ओर धकेलता है। L2 नियमितीकरण भार मापदण्डों को दंडित करेगा, क्योंकि उन्हें विरल बनाने के लिए दंड छोटे भार-शून्य के कारण शून्य हो जाता है-एक कारण है कि L2 अधिक सामान्य है।

tf.keras , वेट tf.keras इंस्टेंस को लेयर्स तर्कों के रूप में ले कर वज़न नियमितीकरण जोड़ा जाता है। आइए अब L2 वजन नियमितीकरण जोड़ें।

l2_model = tf.keras.Sequential([
    layers.Dense(512, activation='elu',
                 kernel_regularizer=regularizers.l2(0.001),
                 input_shape=(FEATURES,)),
    layers.Dense(512, activation='elu',
                 kernel_regularizer=regularizers.l2(0.001)),
    layers.Dense(512, activation='elu',
                 kernel_regularizer=regularizers.l2(0.001)),
    layers.Dense(512, activation='elu',
                 kernel_regularizer=regularizers.l2(0.001)),
    layers.Dense(1)
])

regularizer_histories['l2'] = compile_and_fit(l2_model, "regularizers/l2")
Model: "sequential_4"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_14 (Dense)             (None, 512)               14848     
_________________________________________________________________
dense_15 (Dense)             (None, 512)               262656    
_________________________________________________________________
dense_16 (Dense)             (None, 512)               262656    
_________________________________________________________________
dense_17 (Dense)             (None, 512)               262656    
_________________________________________________________________
dense_18 (Dense)             (None, 1)                 513       
=================================================================
Total params: 803,329
Trainable params: 803,329
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0034s vs `on_train_batch_end` time: 0.0134s). Check your callbacks.

Epoch: 0, accuracy:0.5162,  binary_crossentropy:0.7512,  loss:2.2423,  val_accuracy:0.4830,  val_binary_crossentropy:0.6906,  val_loss:2.0808,  
....................................................................................................
Epoch: 100, accuracy:0.6586,  binary_crossentropy:0.5961,  loss:0.6196,  val_accuracy:0.6590,  val_binary_crossentropy:0.5953,  val_loss:0.6188,  
....................................................................................................
Epoch: 200, accuracy:0.6736,  binary_crossentropy:0.5817,  loss:0.6037,  val_accuracy:0.6610,  val_binary_crossentropy:0.5796,  val_loss:0.6015,  
....................................................................................................
Epoch: 300, accuracy:0.6840,  binary_crossentropy:0.5771,  loss:0.6019,  val_accuracy:0.6770,  val_binary_crossentropy:0.5868,  val_loss:0.6124,  
....................................................................................................
Epoch: 400, accuracy:0.6926,  binary_crossentropy:0.5668,  loss:0.5924,  val_accuracy:0.6670,  val_binary_crossentropy:0.5748,  val_loss:0.6004,  
....................................................................................................
Epoch: 500, accuracy:0.6991,  binary_crossentropy:0.5550,  loss:0.5824,  val_accuracy:0.6890,  val_binary_crossentropy:0.5743,  val_loss:0.6018,  
....................................................................................................
Epoch: 600, accuracy:0.7073,  binary_crossentropy:0.5475,  loss:0.5758,  val_accuracy:0.6800,  val_binary_crossentropy:0.5734,  val_loss:0.6016,  
....................................................................................................
Epoch: 700, accuracy:0.7139,  binary_crossentropy:0.5381,  loss:0.5666,  val_accuracy:0.6770,  val_binary_crossentropy:0.5848,  val_loss:0.6132,  
....................................................................................................
Epoch: 800, accuracy:0.7169,  binary_crossentropy:0.5354,  loss:0.5645,  val_accuracy:0.6920,  val_binary_crossentropy:0.5835,  val_loss:0.6126,  
...........

l2(0.001) अर्थ है कि परत के भार मैट्रिक्स में प्रत्येक गुणांक नेटवर्क के कुल नुकसान में 0.001 * weight_coefficient_value**2 को जोड़ देगा।

यही कारण है कि हम सीधे binary_crossentropy निगरानी कर रहे हैं। क्योंकि इसमें यह नियमितीकरण घटक मिश्रित नहीं है।

तो, L2 नियमितीकरण के दंड के साथ वही "Large" मॉडल बहुत बेहतर प्रदर्शन करता है:

plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

पींग

जैसा कि आप देख सकते हैं, "L2" नियमित मॉडल अब "Tiny" मॉडल के साथ अधिक प्रतिस्पर्धी है। यह "L2" मॉडल "Large" मॉडल की तुलना में ओवरफिटिंग के लिए बहुत अधिक प्रतिरोधी है, यह समान मापदंडों के होने के बावजूद आधारित था।

और जानकारी

इस तरह के नियमितीकरण के बारे में ध्यान देने योग्य दो महत्वपूर्ण बातें हैं।

पहला: यदि आप अपना खुद का प्रशिक्षण लूप लिख रहे हैं, तो आपको मॉडल को उसके नियमितीकरण के नुकसान के बारे में पूछना सुनिश्चित करना होगा।

result = l2_model(features)
regularization_loss=tf.add_n(l2_model.losses)

दूसरा: यह कार्यान्वयन मॉडल के नुकसान के लिए वजन दंड को जोड़कर काम करता है, और फिर उसके बाद एक मानक अनुकूलन प्रक्रिया लागू करता है।

एक दूसरा दृष्टिकोण है कि इसके बजाय केवल कच्चे नुकसान पर ऑप्टिमाइज़र चलाता है, और फिर गणना किए गए कदम को लागू करते समय ऑप्टिमाइज़र कुछ वजन घटाने पर भी लागू होता है। यह "decoupled भार क्षय" की तरह optimizers में देखा जाता है optimizers.FTRL और optimizers.AdamW

ड्रॉपआउट जोड़ें

ड्रॉपआउट तंत्रिका नेटवर्क के लिए सबसे प्रभावी और सबसे अधिक इस्तेमाल किया जाने वाला नियमितीकरण तकनीकों में से एक है, जिसे टोरंटो विश्वविद्यालय में हिंटन और उनके छात्रों द्वारा विकसित किया गया है।

ड्रॉपआउट के लिए सहज स्पष्टीकरण यह है कि क्योंकि नेटवर्क में अलग-अलग नोड्स दूसरों के आउटपुट पर भरोसा नहीं कर सकते हैं, प्रत्येक नोड को आउटपुट सुविधाओं का उत्पादन करना होगा जो अपने आप में उपयोगी हैं।

ड्रॉपआउट, एक परत पर लगाया जाता है, जिसमें बेतरतीब ढंग से "ड्रॉप आउट" होता है (यानी शून्य पर सेट) प्रशिक्षण के बाद परत की कई आउटपुट विशेषताएं। मान लीजिए कि एक दी गई परत सामान्य रूप से प्रशिक्षण के दौरान दिए गए इनपुट नमूने के लिए एक वेक्टर [0.2, 0.5, 1.3, 0.8, 1.1] लौटाएगी; ड्रॉपआउट को लागू करने के बाद, इस वेक्टर में यादृच्छिक, जैसे [0, 0.5, 1.3, 0, 1.1] वितरित की गई कुछ शून्य प्रविष्टियाँ होंगी।

"ड्रॉपआउट दर" उन विशेषताओं का अंश है जो शून्य-आउट हो रही हैं; यह आमतौर पर 0.2 और 0.5 के बीच निर्धारित किया जाता है। परीक्षण के समय, कोई भी इकाइयां बाहर नहीं जाती हैं, और इसके बजाय परत के आउटपुट मानों को ड्रॉपआउट दर के बराबर एक कारक द्वारा कम किया जाता है, ताकि इस तथ्य के लिए संतुलन हो सके कि प्रशिक्षण समय की तुलना में अधिक इकाइयां सक्रिय हैं।

tf.keras आप ड्रॉपआउट लेयर के माध्यम से एक नेटवर्क में ड्रॉपआउट का परिचय दे सकते हैं, जो लेयर के आउटपुट पर ठीक पहले लागू होता है।

चलो हमारे नेटवर्क में दो ड्रॉपआउट परतें जोड़ते हैं यह देखने के लिए कि वे ओवरफिटिंग को कम करने में कितना अच्छा करते हैं:

dropout_model = tf.keras.Sequential([
    layers.Dense(512, activation='elu', input_shape=(FEATURES,)),
    layers.Dropout(0.5),
    layers.Dense(512, activation='elu'),
    layers.Dropout(0.5),
    layers.Dense(512, activation='elu'),
    layers.Dropout(0.5),
    layers.Dense(512, activation='elu'),
    layers.Dropout(0.5),
    layers.Dense(1)
])

regularizer_histories['dropout'] = compile_and_fit(dropout_model, "regularizers/dropout")
Model: "sequential_5"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_19 (Dense)             (None, 512)               14848     
_________________________________________________________________
dropout (Dropout)            (None, 512)               0         
_________________________________________________________________
dense_20 (Dense)             (None, 512)               262656    
_________________________________________________________________
dropout_1 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_21 (Dense)             (None, 512)               262656    
_________________________________________________________________
dropout_2 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_22 (Dense)             (None, 512)               262656    
_________________________________________________________________
dropout_3 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_23 (Dense)             (None, 1)                 513       
=================================================================
Total params: 803,329
Trainable params: 803,329
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0036s vs `on_train_batch_end` time: 0.0141s). Check your callbacks.

Epoch: 0, accuracy:0.4944,  binary_crossentropy:0.8070,  loss:0.8070,  val_accuracy:0.5630,  val_binary_crossentropy:0.6919,  val_loss:0.6919,  
....................................................................................................
Epoch: 100, accuracy:0.6579,  binary_crossentropy:0.5956,  loss:0.5956,  val_accuracy:0.6780,  val_binary_crossentropy:0.5794,  val_loss:0.5794,  
....................................................................................................
Epoch: 200, accuracy:0.6878,  binary_crossentropy:0.5569,  loss:0.5569,  val_accuracy:0.6760,  val_binary_crossentropy:0.5896,  val_loss:0.5896,  
....................................................................................................
Epoch: 300, accuracy:0.7189,  binary_crossentropy:0.5084,  loss:0.5084,  val_accuracy:0.6960,  val_binary_crossentropy:0.6009,  val_loss:0.6009,  
....................
plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

पींग

इस कथानक से यह स्पष्ट है कि ये दोनों नियमितीकरण दृष्टिकोण "Large" मॉडल के व्यवहार में सुधार करते हैं। लेकिन यह अभी भी "Tiny" बेसलाइन को हरा नहीं करता है।

अगला उन दोनों को एक साथ आज़माएं, और देखें कि क्या यह बेहतर है।

संयुक्त L2 + ड्रॉपआउट

combined_model = tf.keras.Sequential([
    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),
                 activation='elu', input_shape=(FEATURES,)),
    layers.Dropout(0.5),
    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),
                 activation='elu'),
    layers.Dropout(0.5),
    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),
                 activation='elu'),
    layers.Dropout(0.5),
    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),
                 activation='elu'),
    layers.Dropout(0.5),
    layers.Dense(1)
])

regularizer_histories['combined'] = compile_and_fit(combined_model, "regularizers/combined")
Model: "sequential_6"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_24 (Dense)             (None, 512)               14848     
_________________________________________________________________
dropout_4 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_25 (Dense)             (None, 512)               262656    
_________________________________________________________________
dropout_5 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_26 (Dense)             (None, 512)               262656    
_________________________________________________________________
dropout_6 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_27 (Dense)             (None, 512)               262656    
_________________________________________________________________
dropout_7 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_28 (Dense)             (None, 1)                 513       
=================================================================
Total params: 803,329
Trainable params: 803,329
Non-trainable params: 0
_________________________________________________________________
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0040s vs `on_train_batch_end` time: 0.0151s). Check your callbacks.

Epoch: 0, accuracy:0.5052,  binary_crossentropy:0.8050,  loss:0.9634,  val_accuracy:0.4700,  val_binary_crossentropy:0.6965,  val_loss:0.8544,  
....................................................................................................
Epoch: 100, accuracy:0.6432,  binary_crossentropy:0.6061,  loss:0.6349,  val_accuracy:0.6440,  val_binary_crossentropy:0.5868,  val_loss:0.6154,  
....................................................................................................
Epoch: 200, accuracy:0.6633,  binary_crossentropy:0.5916,  loss:0.6159,  val_accuracy:0.6420,  val_binary_crossentropy:0.5788,  val_loss:0.6031,  
....................................................................................................
Epoch: 300, accuracy:0.6685,  binary_crossentropy:0.5828,  loss:0.6107,  val_accuracy:0.6900,  val_binary_crossentropy:0.5632,  val_loss:0.5911,  
....................................................................................................
Epoch: 400, accuracy:0.6719,  binary_crossentropy:0.5808,  loss:0.6102,  val_accuracy:0.6880,  val_binary_crossentropy:0.5620,  val_loss:0.5914,  
....................................................................................................
Epoch: 500, accuracy:0.6776,  binary_crossentropy:0.5739,  loss:0.6050,  val_accuracy:0.6880,  val_binary_crossentropy:0.5539,  val_loss:0.5851,  
....................................................................................................
Epoch: 600, accuracy:0.6856,  binary_crossentropy:0.5669,  loss:0.6006,  val_accuracy:0.6960,  val_binary_crossentropy:0.5493,  val_loss:0.5830,  
....................................................................................................
Epoch: 700, accuracy:0.6833,  binary_crossentropy:0.5648,  loss:0.5996,  val_accuracy:0.6980,  val_binary_crossentropy:0.5430,  val_loss:0.5778,  
....................................................................................................
Epoch: 800, accuracy:0.6943,  binary_crossentropy:0.5594,  loss:0.5955,  val_accuracy:0.6930,  val_binary_crossentropy:0.5412,  val_loss:0.5772,  
....................................................................................................
Epoch: 900, accuracy:0.6966,  binary_crossentropy:0.5558,  loss:0.5932,  val_accuracy:0.7060,  val_binary_crossentropy:0.5419,  val_loss:0.5793,  
.................................................................................................
plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

पींग

"Combined" नियमितीकरण वाला यह मॉडल स्पष्ट रूप से अब तक का सबसे अच्छा है।

TensorBoard में देखें

इन मॉडलों में टेन्सॉर बोर्ड लॉग भी दर्ज किए गए।

नोटबुक के अंदर एक एम्बेडेड टेंसरबोर्ड व्यूअर खोलने के लिए, कोड-सेल में निम्नलिखित को कॉपी करें:

%tensorboard --logdir {logdir}/regularizers

आप TensorDoard.dev पर इस नोटबुक के पिछले रन के परिणाम देख सकते हैं।

यह सुविधा के लिए एक <iframe> में भी शामिल है:

display.IFrame(
    src="https://tensorboard.dev/experiment/fGInKDo8TXes1z7HQku9mw/#scalars&_smoothingWeight=0.97",
    width = "100%",
    height="800px")

इसके साथ अपलोड किया गया था:

tensorboard dev upload --logdir  {logdir}/regularizers

निष्कर्ष

पुनरावृत्ति करने के लिए: यहां तंत्रिका नेटवर्क में ओवरफिटिंग को रोकने के सबसे सामान्य तरीके हैं:

  • अधिक प्रशिक्षण डेटा प्राप्त करें।
  • नेटवर्क की क्षमता कम करें।
  • वजन नियमितीकरण जोड़ें।
  • ड्रॉपआउट जोड़ें।

इस गाइड में शामिल नहीं दो महत्वपूर्ण दृष्टिकोण हैं:

  • डेटा-वृद्धि
  • बैच का सामान्यीकरण

याद रखें कि प्रत्येक विधि अपने दम पर मदद कर सकती है, लेकिन अक्सर उनका संयोजन और भी अधिक प्रभावी हो सकता है।

# MIT License
#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.