This page was translated by the Cloud Translation API.
Switch to English

ওভারফিট এবং আন্ডারফিট

টেনসরফ্লো.অর্গ.এ দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

সর্বদা হিসাবে, এই উদাহরণের tf.keras API ব্যবহার করবে, যা আপনি tf.keras কেরাস গাইডে আরও শিখতে পারেন।

পূর্ববর্তী উভয় উদাহরণে - পাঠ্যকে শ্রেণিবদ্ধকরণ এবং জ্বালানী দক্ষতার পূর্বাভাস - আমরা দেখেছি যে বৈধতা ডেটাতে আমাদের মডেলটির যথার্থতা বেশ কয়েকটি যুগের প্রশিক্ষণের পরে শীর্ষে উঠবে এবং তারপরে স্তিমিত বা কমতে শুরু করবে।

অন্য কথায়, আমাদের মডেল প্রশিক্ষণের ডেটা থেকে সজ্জিত হবে। ওভারফিটিংয়ের সাথে কীভাবে ডিল করতে হয় তা শিখতে গুরুত্বপূর্ণ। যদিও প্রশিক্ষণ সংস্থায় উচ্চ নির্ভুলতা অর্জন করা প্রায়শই সম্ভব, আমরা যা চাই তা হ'ল এমন একটি মডেল বিকাশ করা যা পরীক্ষার সেটগুলিতে ভাল জেনারেলাইজ হয় (বা ডেটা তারা আগে দেখেনি)।

ওভারফিটিংয়ের বিপরীতটি হ'ল আন্ডারফিটিং । টেস্টের ডেটাগুলিতে উন্নতির জন্য এখনও জায়গা থাকা অবস্থায় আন্ডারফিটিংটি ঘটে। এটি বেশ কয়েকটি কারণে ঘটতে পারে: যদি মডেলটি যথেষ্ট শক্তিশালী না হয় তবে অতিরিক্ত-নিয়মিত করা হয়, বা যথেষ্ট দীর্ঘ প্রশিক্ষণ দেওয়া হয়নি। এর অর্থ প্রশিক্ষণ ডেটাতে নেটওয়ার্ক প্রাসঙ্গিক নিদর্শনগুলি শিখেনি।

আপনি যদি খুব বেশি সময়ের জন্য প্রশিক্ষণ নেন তবে মডেলটি প্রশিক্ষণের ডেটা থেকে পরীক্ষার তথ্যগুলিতে সাধারণীকরণ না করে প্যাটার্নগুলি অত্যধিক উপায়ে এবং শিখতে শুরু করবে। আমাদের ভারসাম্য বজায় রাখতে হবে। আমরা নীচে অন্বেষণ করব যেভাবে উপযুক্ত সংখ্যক যুগের প্রশিক্ষণের জন্য তা বোঝা একটি দরকারী দক্ষতা।

অতিরিক্ত সাফল্য রোধ করতে, আরও সম্পূর্ণ প্রশিক্ষণের ডেটা ব্যবহার করা সবচেয়ে ভাল সমাধান। মডেলটি হ্যান্ডেল করবে বলে প্রত্যাশনের সম্পূর্ণ পরিসীমাটি ডেটাসেটের কভার করা উচিত। অতিরিক্ত ডেটা কেবল তখনই কার্যকর হতে পারে যদি এটি নতুন এবং আকর্ষণীয় কেসগুলি কভার করে।

আরও সম্পূর্ণ ডেটা সম্পর্কে প্রশিক্ষিত একটি মডেল প্রাকৃতিকভাবে আরও ভাল সাধারণকরণ করবে। যখন এটি আর সম্ভব হয় না, তার পরের সেরা সমাধানটি নিয়মিতকরণের মতো কৌশল ব্যবহার করা। আপনার মডেল যে পরিমাণ তথ্য সংরক্ষণ করতে পারে তার পরিমাণ এবং ধরণের ক্ষেত্রে এই স্থানগুলি সীমাবদ্ধ করে। যদি কোনও নেটওয়ার্ক কেবলমাত্র কয়েকটি সংখ্যক নিদর্শন মুখস্থ করতে পারে তবে অনুকূলিতকরণ প্রক্রিয়া এটি সর্বাধিক বিশিষ্ট নিদর্শনগুলিতে ফোকাস করতে বাধ্য করবে, যার ভাল জেনারেলাইজ করার আরও ভাল সম্ভাবনা রয়েছে।

এই নোটবুকে, আমরা বেশ কয়েকটি সাধারণ নিয়ন্ত্রণ কৌশলগুলি আবিষ্কার করব এবং একটি শ্রেণিবদ্ধকরণের মডেলটিতে উন্নতি করতে সেগুলি ব্যবহার করব।

সেটআপ

শুরু করার আগে, প্রয়োজনীয় প্যাকেজগুলি আমদানি করুন:

import tensorflow as tf

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

print(tf.__version__)
2.3.0

!pip install -q git+https://github.com/tensorflow/docs

import tensorflow_docs as tfdocs
import tensorflow_docs.modeling
import tensorflow_docs.plots
WARNING: You are using pip version 20.2.2; however, version 20.2.3 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.

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 [==============================] - 195s 0us/step

FEATURES = 28

tf.data.experimental.CsvDataset ক্লাসটি কোনও মধ্যবর্তী ডিকম্প্রেশন পদক্ষেপ ছাড়াই tf.data.experimental.CsvDataset ফাইল থেকে সরাসরি tf.data.experimental.CsvDataset রেকর্ড পড়তে ব্যবহার করা যেতে পারে।

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

সেই সিএসভি পাঠক শ্রেণি প্রতিটি রেকর্ডের জন্য স্কেলারের একটি তালিকা ফেরত দেয়। নিম্নলিখিত ফাংশনটি স্কেলারগুলির তালিকাটিকে একটি (বৈশিষ্ট্য_ভেক্টর, লেবেল) জুটিতে পুনরায় পোস্ট করে।

243795f23 বি

টেনসরফ্লো বৃহত্তর ডেটা ব্যাচগুলিতে অপারেট করার সময় সবচেয়ে কার্যকরী।

সুতরাং প্রতিটি সারি পৃথকভাবে পৃথকভাবে নতুন করে 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 ব্যবহার করুন:

211720a12 ডি

Dataset.skip এবং Dataset.take পদ্ধতিগুলি এটিকে সহজ করে তোলে।

একই সাথে, প্রতিটি Dataset.cache লোডারের ফাইল থেকে ডেটা পুনরায় পড়ার প্রয়োজন নেই তা নিশ্চিত করতে 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 সেট। .shuffle এবং .repeat করতেও মনে রাখবেন।

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

অত্যধিক উত্সাহ প্রদর্শন

ওভারফিটিং প্রতিরোধের সহজ উপায়টি একটি ছোট মডেল দিয়ে শুরু করা: একটি সংখ্যক শিখতে পরামিতিগুলির একটি মডেল (যা স্তরগুলির স্তর এবং প্রতি স্তর ইউনিটের সংখ্যা দ্বারা নির্ধারিত হয়)। গভীর শিক্ষায়, মডেলটিতে শেখার যোগ্য পরামিতিগুলির সংখ্যা প্রায়শই মডেলের "ক্ষমতা" হিসাবে পরিচিত।

স্বজ্ঞাতভাবে, আরও পরামিতিগুলির একটি মডেলটির আরও "মুখস্থকরণ ক্ষমতা" থাকবে এবং সুতরাং প্রশিক্ষণের নমুনা এবং তাদের লক্ষ্যগুলির মধ্যে একটি নিখুঁত অভিধান-জাতীয় ম্যাপিং সহজেই শিখতে সক্ষম হবে, কোনও সাধারণীকরণ শক্তি ছাড়াই একটি ম্যাপিং, তবে ভবিষ্যদ্বাণী করার সময় এটি অকেজো হবে পূর্বে অদেখা তথ্য

সর্বদা এটি মাথায় রাখুন: গভীর শেখার মডেলগুলি প্রশিক্ষণের ডেটার সাথে মানানসই প্রবণতা রাখে, তবে আসল চ্যালেঞ্জটি জেনারালাইজেশন, ফিটিং নয়।

অন্যদিকে, যদি নেটওয়ার্কের মুখস্তের সংস্থান সীমিত থাকে তবে এটি ম্যাপিংটি সহজেই শিখতে পারবে না। এর ক্ষয় হ্রাস করতে, এটি সঙ্কুচিত উপস্থাপনাগুলি শিখতে হবে যাদের আরও ভবিষ্যদ্বাণীপূর্ণ শক্তি রয়েছে। একই সময়ে, আপনি যদি নিজের মডেলটিকে খুব ছোট করে তুলেন তবে প্রশিক্ষণের ডেটা ফিট করতে অসুবিধা হবে। "খুব বেশি ক্ষমতা" এবং "পর্যাপ্ত ক্ষমতা নেই" এর মধ্যে ভারসাম্য রয়েছে।

দুর্ভাগ্যক্রমে, আপনার মডেলের সঠিক আকার বা আর্কিটেকচার (স্তরগুলির সংখ্যার ভিত্তিতে বা প্রতিটি স্তরের জন্য সঠিক আকারের নিরিখে) নির্ধারণ করার জন্য কোনও জাদুকরী সূত্র নেই। আপনাকে বিভিন্ন আর্কিটেকচারের একটি সিরিজ ব্যবহার করে পরীক্ষা করতে হবে।

উপযুক্ত মডেলের আকার সন্ধানের জন্য তুলনামূলকভাবে কয়েকটি স্তর এবং পরামিতি দিয়ে শুরু করা ভাল, তারপরে স্তরগুলির আকার বাড়াতে বা নতুন স্তর যুক্ত করা শুরু করুন যতক্ষণ না আপনি বৈধতা ক্ষয়কে কমিয়ে দেখবেন returns

কেবলমাত্র layers.Dense ব্যবহার করে একটি সাধারণ মডেল দিয়ে শুরু করুন a বেসলাইন হিসাবে 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 সেট করে। বিপরীতকালীন সময়কে হাইপারলিকভাবে শিখার হারকে 1000 এর যুগের বেস হারের ১/২ এ হ্রাস করতে, 2000 এপ্রোচে 1/3 এবং আরও।

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 অন্তর্ভুক্ত রয়েছে callbacks.EarlyStopping দীর্ঘ এবং অপ্রয়োজনীয় প্রশিক্ষণের সময় এড়াতে callbacks.EarlyStopping । উল্লেখ্য এই কলব্যাক নিরীক্ষণ করতে সেট করা হয় যে val_binary_crossentropy না val_loss । এই পার্থক্যটি পরে গুরুত্বপূর্ণ হবে।

ব্যবহারের callbacks.TensorBoard প্রশিক্ষণের জন্য 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:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/summary_ops_v2.py:1277: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.
WARNING:tensorflow:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0030s vs `on_train_batch_end` time: 0.0237s). Check your callbacks.

Epoch: 0, accuracy:0.4851,  binary_crossentropy:0.7694,  loss:0.7694,  val_accuracy:0.5020,  val_binary_crossentropy:0.7430,  val_loss:0.7430,  
....................................................................................................
Epoch: 100, accuracy:0.5922,  binary_crossentropy:0.6288,  loss:0.6288,  val_accuracy:0.5730,  val_binary_crossentropy:0.6331,  val_loss:0.6331,  
....................................................................................................
Epoch: 200, accuracy:0.6069,  binary_crossentropy:0.6215,  loss:0.6215,  val_accuracy:0.5820,  val_binary_crossentropy:0.6277,  val_loss:0.6277,  
....................................................................................................
Epoch: 300, accuracy:0.6131,  binary_crossentropy:0.6165,  loss:0.6165,  val_accuracy:0.6040,  val_binary_crossentropy:0.6208,  val_loss:0.6208,  
....................................................................................................
Epoch: 400, accuracy:0.6213,  binary_crossentropy:0.6111,  loss:0.6111,  val_accuracy:0.5980,  val_binary_crossentropy:0.6179,  val_loss:0.6179,  
....................................................................................................
Epoch: 500, accuracy:0.6344,  binary_crossentropy:0.6045,  loss:0.6045,  val_accuracy:0.6250,  val_binary_crossentropy:0.6092,  val_loss:0.6092,  
....................................................................................................
Epoch: 600, accuracy:0.6408,  binary_crossentropy:0.5985,  loss:0.5985,  val_accuracy:0.6170,  val_binary_crossentropy:0.6068,  val_loss:0.6068,  
....................................................................................................
Epoch: 700, accuracy:0.6454,  binary_crossentropy:0.5941,  loss:0.5941,  val_accuracy:0.6380,  val_binary_crossentropy:0.6033,  val_loss:0.6033,  
....................................................................................................
Epoch: 800, accuracy:0.6571,  binary_crossentropy:0.5907,  loss:0.5907,  val_accuracy:0.6350,  val_binary_crossentropy:0.6023,  val_loss:0.6023,  
....................................................................................................
Epoch: 900, accuracy:0.6568,  binary_crossentropy:0.5879,  loss:0.5879,  val_accuracy:0.6390,  val_binary_crossentropy:0.6022,  val_loss:0.6022,  
....................................................................................................
Epoch: 1000, accuracy:0.6592,  binary_crossentropy:0.5860,  loss:0.5860,  val_accuracy:0.6410,  val_binary_crossentropy:0.6006,  val_loss:0.6006,  
....................................................................................................
Epoch: 1100, accuracy:0.6674,  binary_crossentropy:0.5833,  loss:0.5833,  val_accuracy:0.6310,  val_binary_crossentropy:0.6020,  val_loss:0.6020,  
....................................................................................................
Epoch: 1200, accuracy:0.6681,  binary_crossentropy:0.5814,  loss:0.5814,  val_accuracy:0.6300,  val_binary_crossentropy:0.6013,  val_loss:0.6013,  
....................................................................................................
Epoch: 1300, accuracy:0.6711,  binary_crossentropy:0.5798,  loss:0.5798,  val_accuracy:0.6430,  val_binary_crossentropy:0.5985,  val_loss:0.5985,  
....................................................................................................
Epoch: 1400, accuracy:0.6723,  binary_crossentropy:0.5781,  loss:0.5781,  val_accuracy:0.6440,  val_binary_crossentropy:0.5984,  val_loss:0.5984,  
....................................................................................................
Epoch: 1500, accuracy:0.6723,  binary_crossentropy:0.5773,  loss:0.5773,  val_accuracy:0.6490,  val_binary_crossentropy:0.5969,  val_loss:0.5969,  
....................................................................................................
Epoch: 1600, accuracy:0.6710,  binary_crossentropy:0.5762,  loss:0.5762,  val_accuracy:0.6620,  val_binary_crossentropy:0.5953,  val_loss:0.5953,  
....................................................................................................
Epoch: 1700, accuracy:0.6757,  binary_crossentropy:0.5744,  loss:0.5744,  val_accuracy:0.6510,  val_binary_crossentropy:0.5956,  val_loss:0.5956,  
....................................................................................................
Epoch: 1800, accuracy:0.6771,  binary_crossentropy:0.5734,  loss:0.5734,  val_accuracy:0.6560,  val_binary_crossentropy:0.5947,  val_loss:0.5947,  
....................................................................................................
Epoch: 1900, accuracy:0.6780,  binary_crossentropy:0.5723,  loss:0.5723,  val_accuracy:0.6550,  val_binary_crossentropy:0.5942,  val_loss:0.5942,  
....................................................................................................
Epoch: 2000, accuracy:0.6794,  binary_crossentropy:0.5716,  loss:0.5716,  val_accuracy:0.6590,  val_binary_crossentropy:0.5930,  val_loss:0.5930,  
....................................................................................................
Epoch: 2100, accuracy:0.6777,  binary_crossentropy:0.5707,  loss:0.5707,  val_accuracy:0.6560,  val_binary_crossentropy:0.5938,  val_loss:0.5938,  
....................................................................................................
Epoch: 2200, accuracy:0.6817,  binary_crossentropy:0.5699,  loss:0.5699,  val_accuracy:0.6480,  val_binary_crossentropy:0.5942,  val_loss:0.5942,  
....................................................................................................
Epoch: 2300, accuracy:0.6796,  binary_crossentropy:0.5696,  loss:0.5696,  val_accuracy:0.6540,  val_binary_crossentropy:0.5922,  val_loss:0.5922,  
....................................................................................................
Epoch: 2400, accuracy:0.6823,  binary_crossentropy:0.5695,  loss:0.5695,  val_accuracy:0.6530,  val_binary_crossentropy:0.5919,  val_loss:0.5919,  
....................................................................................................
Epoch: 2500, accuracy:0.6848,  binary_crossentropy:0.5688,  loss:0.5688,  val_accuracy:0.6530,  val_binary_crossentropy:0.5943,  val_loss:0.5943,  
....................................................................................................
Epoch: 2600, accuracy:0.6837,  binary_crossentropy:0.5683,  loss:0.5683,  val_accuracy:0.6580,  val_binary_crossentropy:0.5920,  val_loss:0.5920,  
....................................................................................................
Epoch: 2700, accuracy:0.6867,  binary_crossentropy:0.5687,  loss:0.5687,  val_accuracy:0.6560,  val_binary_crossentropy:0.5938,  val_loss:0.5938,  
....................................................................................................
Epoch: 2800, accuracy:0.6874,  binary_crossentropy:0.5671,  loss:0.5671,  val_accuracy:0.6550,  val_binary_crossentropy:0.5922,  val_loss:0.5922,  
....................................................................................................
Epoch: 2900, accuracy:0.6814,  binary_crossentropy:0.5666,  loss:0.5666,  val_accuracy:0.6590,  val_binary_crossentropy:0.5907,  val_loss:0.5907,  
.......................................................

এখন কীভাবে মডেলটি করেছে তা পরীক্ষা করুন:

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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0034s vs `on_train_batch_end` time: 0.0481s). Check your callbacks.

Epoch: 0, accuracy:0.4760,  binary_crossentropy:0.7078,  loss:0.7078,  val_accuracy:0.4700,  val_binary_crossentropy:0.6948,  val_loss:0.6948,  
....................................................................................................
Epoch: 100, accuracy:0.6241,  binary_crossentropy:0.6134,  loss:0.6134,  val_accuracy:0.5950,  val_binary_crossentropy:0.6196,  val_loss:0.6196,  
....................................................................................................
Epoch: 200, accuracy:0.6435,  binary_crossentropy:0.5975,  loss:0.5975,  val_accuracy:0.6290,  val_binary_crossentropy:0.6116,  val_loss:0.6116,  
....................................................................................................
Epoch: 300, accuracy:0.6636,  binary_crossentropy:0.5827,  loss:0.5827,  val_accuracy:0.6310,  val_binary_crossentropy:0.6020,  val_loss:0.6020,  
....................................................................................................
Epoch: 400, accuracy:0.6742,  binary_crossentropy:0.5730,  loss:0.5730,  val_accuracy:0.6500,  val_binary_crossentropy:0.5945,  val_loss:0.5945,  
....................................................................................................
Epoch: 500, accuracy:0.6822,  binary_crossentropy:0.5670,  loss:0.5670,  val_accuracy:0.6470,  val_binary_crossentropy:0.5919,  val_loss:0.5919,  
....................................................................................................
Epoch: 600, accuracy:0.6864,  binary_crossentropy:0.5631,  loss:0.5631,  val_accuracy:0.6510,  val_binary_crossentropy:0.5909,  val_loss:0.5909,  
....................................................................................................
Epoch: 700, accuracy:0.6928,  binary_crossentropy:0.5596,  loss:0.5596,  val_accuracy:0.6600,  val_binary_crossentropy:0.5910,  val_loss:0.5910,  
....................................................................................................
Epoch: 800, accuracy:0.6965,  binary_crossentropy:0.5564,  loss:0.5564,  val_accuracy:0.6620,  val_binary_crossentropy:0.5898,  val_loss:0.5898,  
....................................................................................................
Epoch: 900, accuracy:0.7008,  binary_crossentropy:0.5544,  loss:0.5544,  val_accuracy:0.6480,  val_binary_crossentropy:0.5921,  val_loss:0.5921,  
...............................................

মাঝারি মডেল

এখন প্রতিটি 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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0037s vs `on_train_batch_end` time: 0.0511s). Check your callbacks.

Epoch: 0, accuracy:0.4852,  binary_crossentropy:0.6982,  loss:0.6982,  val_accuracy:0.4830,  val_binary_crossentropy:0.6815,  val_loss:0.6815,  
....................................................................................................
Epoch: 100, accuracy:0.7123,  binary_crossentropy:0.5315,  loss:0.5315,  val_accuracy:0.6540,  val_binary_crossentropy:0.5983,  val_loss:0.5983,  
....................................................................................................
Epoch: 200, accuracy:0.7796,  binary_crossentropy:0.4328,  loss:0.4328,  val_accuracy:0.6590,  val_binary_crossentropy:0.6763,  val_loss:0.6763,  
...................................................

বড় মডেল

অনুশীলন হিসাবে, আপনি আরও বৃহত্তর একটি মডেল তৈরি করতে পারেন এবং দেখুন যে এটি কত দ্রুত ওভারফিটিং শুরু করে। এরপরে, আসুন এই বেঞ্চমার্কটিতে এমন একটি নেটওয়ার্ক যুক্ত করা যাক যা আরও অনেক বেশি ক্ষমতা সম্পন্ন, যা সমস্যার চেয়ে বেশি ওয়্যারেন্টি দেয়:

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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0038s vs `on_train_batch_end` time: 0.0571s). Check your callbacks.

Epoch: 0, accuracy:0.5119,  binary_crossentropy:0.7993,  loss:0.7993,  val_accuracy:0.4630,  val_binary_crossentropy:0.7125,  val_loss:0.7125,  
....................................................................................................
Epoch: 100, accuracy:1.0000,  binary_crossentropy:0.0021,  loss:0.0021,  val_accuracy:0.6640,  val_binary_crossentropy:1.8146,  val_loss:1.8146,  
....................................................................................................
Epoch: 200, accuracy:1.0000,  binary_crossentropy:0.0001,  loss:0.0001,  val_accuracy:0.6630,  val_binary_crossentropy:2.4702,  val_loss:2.4702,  
............................

প্রশিক্ষণ এবং বৈধতা হ্রাস প্লট করুন

কঠিন লাইনগুলি প্রশিক্ষণ ক্ষতি দেখায় এবং ড্যাশযুক্ত রেখাগুলি বৈধতা হ্রাস দেখায় (মনে রাখবেন: একটি কম বৈধতা ক্ষতি আরও ভাল মডেলকে নির্দেশ করে)।

একটি বৃহত্তর মডেল তৈরি করার সময় এটি আরও শক্তি দেয়, যদি এই শক্তিটি কোনওভাবেই সীমাবদ্ধ না করা হয় তবে এটি প্রশিক্ষণের সেটকে সহজেই উপসৃত করতে পারে।

এই উদাহরণস্বরূপ, সাধারণত, কেবলমাত্র "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]')

পিএনজি

টেনসরবোর্ডে দেখুন

এই মডেলগুলি প্রশিক্ষণের সময় টেনসরবোর্ড লগগুলি লিখেছিলেন।

একটি নোটবুকের ভিতরে এম্বেড থাকা টেনসরবোর্ড দর্শকটি খুলুন:


# Load the TensorBoard notebook extension
%load_ext tensorboard

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

আপনি এই নোটবুকের আগের রানের ফলাফলগুলি টেনসরবোর্ড.দেভে দেখতে পারেন

টেনসরবোর্ড.দেব হোল্ডিং, ট্র্যাকিং এবং সবার সাথে এমএল পরীক্ষা ভাগ করে নেওয়ার জন্য পরিচালিত অভিজ্ঞতা।

এটি সুবিধার জন্য একটি <iframe> এর মধ্যে অন্তর্ভুক্ত রয়েছে:

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

আপনি যদি টেনসরবোর্ডের ফলাফলগুলি ভাগ করতে চান তবে নিচের কোডগুলি ঘরে অনুলিপি করে আপনি টেনসরবোর্ড.দেমে লগগুলি আপলোড করতে পারেন।

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/tmpnnkr5005/tensorboard_logs/regularizers/Tiny')
regularizer_histories = {}
regularizer_histories['Tiny'] = size_histories['Tiny']

ওজন নিয়মিতকরণ যুক্ত করুন

আপনি ওকামের রেজার নীতিটির সাথে পরিচিত হতে পারেন: কোনও কিছুর জন্য দুটি ব্যাখ্যা দেওয়া গেলে, ব্যাখ্যাটি সবচেয়ে সম্ভবত সঠিক বলে মনে হয় এটি হ'ল "সরলতম", এটি একটি যা কমপক্ষে অনুমানের পরিমাণ তৈরি করে। এটি নিউরাল নেটওয়ার্কগুলি দ্বারা শিখে নেওয়া মডেলগুলির ক্ষেত্রেও প্রযোজ্য: কিছু প্রশিক্ষণ ডেটা এবং একটি নেটওয়ার্ক আর্কিটেকচার দেওয়া আছে, এমন একাধিক ওজন মান (একাধিক মডেল) রয়েছে যা ডেটা ব্যাখ্যা করতে পারে, এবং সহজ মডেলগুলি জটিলগুলির চেয়ে বেশি মানায়।

এই প্রসঙ্গে একটি "সাধারণ মডেল" এমন একটি মডেল যেখানে প্যারামিটার মানগুলির বন্টন কম এনট্রপি থাকে (বা উপরের অংশে আমরা যেমন দেখেছি তেমন কম পরামিতি সহ একটি মডেল)। সুতরাং অতিরিক্ত মান কমাতে সাধারণ উপায় হ'ল কোনও নেটওয়ার্কের জটিলতায় বাধা সৃষ্টি করে তার ওজনকে কেবলমাত্র ছোট মান নিতে বাধ্য করা, যা ওজন মূল্যগুলির বিতরণকে আরও "নিয়মিত" করে তোলে। এটিকে "ওজন নিয়ন্ত্রণ" বলা হয় এবং এটি নেটওয়ার্কের ক্ষয়ক্ষতি ফাংশন যোগ করে একটি বড় ব্যয়ের সাথে যুক্ত ব্যয় করে done এই ব্যয় দুটি স্বাদে আসে:

  • এল 1 নিয়মিতকরণ , যেখানে যুক্ত হওয়া ব্যয়টি ওজন সহগের (যেমন ওজনকে "এল 1 আদর্শ" বলা হয়) এর পরম মানের সাথে সমানুপাতিক।

  • এল 2 নিয়মিতকরণ , যেখানে যুক্ত হওয়া ব্যয়টি ওজন সহগের (যেমন ওজনগুলির স্কোয়ার্ড "এল 2 আদর্শ" বলা হয়) এর বর্গক্ষেত্রের সমানুপাতিক। এল 2 নিয়ন্ত্রনকে নিউরাল নেটওয়ার্কগুলির প্রসঙ্গে ওজন ক্ষয়ও বলা হয়। পৃথক নামটি আপনাকে বিভ্রান্ত করতে দেবেন না: ওজন ক্ষয় হ'ল গাণিতিকভাবে এল 2 নিয়মিতকরণের মতোই হ'ল।

এল 1 নিয়মিতকরণ খুব কম শূন্যের দিকে ওজনকে একটি বিরল মডেলকে উত্সাহিত করে p ছোট ওজনের জন্য পেনাল্টি শূন্যে চলে যাওয়ার কারণে এল 2 নিয়মিতকরণ ওজন পরামিতিগুলিকে বিচ্ছিন্ন না করে শাস্তি দেবে। এল 2 আরও সাধারণ হওয়ার এক কারণ।

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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0039s vs `on_train_batch_end` time: 0.0601s). Check your callbacks.

Epoch: 0, accuracy:0.5034,  binary_crossentropy:0.7595,  loss:2.2567,  val_accuracy:0.5360,  val_binary_crossentropy:0.6737,  val_loss:2.0767,  
....................................................................................................
Epoch: 100, accuracy:0.6562,  binary_crossentropy:0.5978,  loss:0.6212,  val_accuracy:0.6240,  val_binary_crossentropy:0.5912,  val_loss:0.6144,  
....................................................................................................
Epoch: 200, accuracy:0.6610,  binary_crossentropy:0.5914,  loss:0.6147,  val_accuracy:0.6480,  val_binary_crossentropy:0.5813,  val_loss:0.6055,  
....................................................................................................
Epoch: 300, accuracy:0.6794,  binary_crossentropy:0.5768,  loss:0.5998,  val_accuracy:0.6730,  val_binary_crossentropy:0.5780,  val_loss:0.6009,  
....................................................................................................
Epoch: 400, accuracy:0.6843,  binary_crossentropy:0.5685,  loss:0.5914,  val_accuracy:0.6760,  val_binary_crossentropy:0.5798,  val_loss:0.6027,  
....................................................................................................
Epoch: 500, accuracy:0.6971,  binary_crossentropy:0.5602,  loss:0.5856,  val_accuracy:0.6600,  val_binary_crossentropy:0.5855,  val_loss:0.6107,  
................................................................................................

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)

দ্বিতীয়: এই বাস্তবায়নটি মডেলের ক্ষতির ক্ষেত্রে ওজনের জরিমানা যুক্ত করে এবং তারপরে একটি মানক অপ্টিমাইজেশন পদ্ধতি প্রয়োগ করে কাজ করে।

একটি দ্বিতীয় পদ্ধতি রয়েছে যা পরিবর্তে কেবল কাঁচা লোকসানে অপ্টিমাইজার চালায় এবং তারপরে গণনা করা পদক্ষেপটি প্রয়োগ করার সময় অপ্টিমাইজারটি কিছু ওজন ক্ষয়কেও প্রয়োগ করে। এই "পৃথক ওজন ক্ষয়" মত optimizers দেখা যায় optimizers.FTRL এবং optimizers.AdamW

ড্রপআউট যুক্ত করুন

টরন্টো বিশ্ববিদ্যালয়ের হিন্টন এবং তার শিক্ষার্থীরা নিউরাল নেটওয়ার্কগুলির জন্য সবচেয়ে কার্যকর এবং সর্বাধিক ব্যবহৃত নিয়মিতকরণ কৌশলগুলির মধ্যে একটি, ড্রপআউট is

ড্রপআউটের স্বজ্ঞাত ব্যাখ্যাটি হ'ল যেহেতু নেটওয়ার্কের পৃথক নোডগুলি অন্যের আউটপুটে নির্ভর করতে পারে না, তাই প্রতিটি নোডকে অবশ্যই নিজস্ব বৈশিষ্ট্যগুলি আউটপুট আউটপুট দেয়।

ড্রপআউট, একটি স্তরের সাথে প্রয়োগ করা হয়, প্রশিক্ষণের সময় এলোমেলোভাবে "ড্রপ আউট" (অর্থাৎ শূন্যতে সেট করা) স্তরটির বেশ কয়েকটি আউটপুট বৈশিষ্ট্যযুক্ত। আসুন বলি যে প্রদত্ত স্তরটি সাধারণত প্রশিক্ষণের সময় প্রদত্ত ইনপুট নমুনার জন্য একটি ভেক্টর [0.2, 0.5, 1.3, 0.8, 1.1] ফিরে আসত; ড্রপআউট প্রয়োগের পরে, এই ভেক্টরের কয়েকটি শূন্য এন্ট্রি এলোমেলোভাবে বিতরণ করা হবে, যেমন [0, 0.5, 1.3, 0, 1.1]।

"ড্রপআউট হার" হ'ল বৈশিষ্ট্যগুলির ভগ্নাংশ যা শূন্য-আউট হচ্ছে; এটি সাধারণত 0.2 এবং 0.5 এর মধ্যে সেট করা থাকে। পরীক্ষার সময় কোনও ইউনিট বাদ পড়ে না এবং তার পরিবর্তে স্তরের আউটপুট মানগুলি ড্রপআউট হারের সমান একটি ফ্যাক্টর দ্বারা ছোট করে দেওয়া হয়, যাতে প্রশিক্ষণের সময়কালের চেয়ে আরও বেশি ইউনিট সক্রিয় থাকার বিষয়টি সম্পর্কে ভারসাম্য বজায় রাখতে পারে।

tf.keras আপনি ড্রপআউট স্তরের মাধ্যমে কোনও নেটওয়ার্কে ড্রপআউট প্রবর্তন করতে পারেন, যা স্তরটির আউটপুটটিতে ঠিক আগে প্রয়োগ হয় applied

ওভারফিটিং কমাতে তারা কতটা ভাল করে তা দেখতে আমাদের নেটওয়ার্কে দুটি ড্রপআউট স্তর যুক্ত করুন:

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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0045s vs `on_train_batch_end` time: 0.0648s). Check your callbacks.

Epoch: 0, accuracy:0.4955,  binary_crossentropy:0.8108,  loss:0.8108,  val_accuracy:0.4970,  val_binary_crossentropy:0.6725,  val_loss:0.6725,  
....................................................................................................
Epoch: 100, accuracy:0.6590,  binary_crossentropy:0.5943,  loss:0.5943,  val_accuracy:0.6730,  val_binary_crossentropy:0.5780,  val_loss:0.5780,  
....................................................................................................
Epoch: 200, accuracy:0.6894,  binary_crossentropy:0.5594,  loss:0.5594,  val_accuracy:0.6820,  val_binary_crossentropy:0.5753,  val_loss:0.5753,  
....................................................................................................
Epoch: 300, accuracy:0.7231,  binary_crossentropy:0.5111,  loss:0.5111,  val_accuracy:0.6830,  val_binary_crossentropy:0.6013,  val_loss:0.6013,  
.....................
plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

পিএনজি

এই প্লট থেকে এটি স্পষ্ট যে এই দুটি নিয়মিতকরণের পদ্ধতিরই "Large" মডেলের আচরণ উন্নত করে। তবে এটি এখনও "Tiny" বেসলাইনটিকে পরাস্ত করে না।

এরপরে তাদের উভয়কে এক সাথে করে দেখুন এবং দেখুন এটি আরও ভাল হয় কিনা।

সংযুক্ত এল 2 + ​​ড্রপআউট

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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0041s vs `on_train_batch_end` time: 0.0627s). Check your callbacks.

Epoch: 0, accuracy:0.5101,  binary_crossentropy:0.7867,  loss:0.9452,  val_accuracy:0.5440,  val_binary_crossentropy:0.6681,  val_loss:0.8258,  
....................................................................................................
Epoch: 100, accuracy:0.6491,  binary_crossentropy:0.6032,  loss:0.6321,  val_accuracy:0.6660,  val_binary_crossentropy:0.5830,  val_loss:0.6116,  
....................................................................................................
Epoch: 200, accuracy:0.6667,  binary_crossentropy:0.5912,  loss:0.6171,  val_accuracy:0.6850,  val_binary_crossentropy:0.5687,  val_loss:0.5946,  
....................................................................................................
Epoch: 300, accuracy:0.6718,  binary_crossentropy:0.5828,  loss:0.6106,  val_accuracy:0.6840,  val_binary_crossentropy:0.5667,  val_loss:0.5945,  
....................................................................................................
Epoch: 400, accuracy:0.6750,  binary_crossentropy:0.5770,  loss:0.6067,  val_accuracy:0.6870,  val_binary_crossentropy:0.5534,  val_loss:0.5832,  
....................................................................................................
Epoch: 500, accuracy:0.6733,  binary_crossentropy:0.5752,  loss:0.6071,  val_accuracy:0.6910,  val_binary_crossentropy:0.5526,  val_loss:0.5846,  
....................................................................................................
Epoch: 600, accuracy:0.6895,  binary_crossentropy:0.5634,  loss:0.5976,  val_accuracy:0.7060,  val_binary_crossentropy:0.5466,  val_loss:0.5809,  
....................................................................................................
Epoch: 700, accuracy:0.6876,  binary_crossentropy:0.5590,  loss:0.5940,  val_accuracy:0.6860,  val_binary_crossentropy:0.5502,  val_loss:0.5852,  
....................................................................................................
Epoch: 800, accuracy:0.6921,  binary_crossentropy:0.5594,  loss:0.5956,  val_accuracy:0.6990,  val_binary_crossentropy:0.5496,  val_loss:0.5858,  
....................................................................................................
Epoch: 900, accuracy:0.6900,  binary_crossentropy:0.5603,  loss:0.5975,  val_accuracy:0.7000,  val_binary_crossentropy:0.5393,  val_loss:0.5765,  
....................................................................................................
Epoch: 1000, accuracy:0.6946,  binary_crossentropy:0.5592,  loss:0.5975,  val_accuracy:0.6750,  val_binary_crossentropy:0.5564,  val_loss:0.5947,  
....................................................................................................
Epoch: 1100, accuracy:0.7000,  binary_crossentropy:0.5476,  loss:0.5872,  val_accuracy:0.7030,  val_binary_crossentropy:0.5460,  val_loss:0.5856,  
....................................................................................................
Epoch: 1200, accuracy:0.7045,  binary_crossentropy:0.5474,  loss:0.5879,  val_accuracy:0.6860,  val_binary_crossentropy:0.5480,  val_loss:0.5886,  
...........
plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

পিএনজি

"Combined" নিয়মিতকরণ সহ এই মডেলটি সম্ভবত এখনও পর্যন্ত সেরা।

টেনসরবোর্ডে দেখুন

এই মডেলগুলি টেনসরবোর্ড লগগুলিও রেকর্ড করে।

একটি নোটবুকের ভিতরে এমবেডড টেনসরবোর্ড ভিউয়ার খুলতে, নিম্নলিখিতটি একটি কোড-ঘরে অনুলিপি করুন:

%tensorboard --logdir {logdir}/regularizers

আপনি এই নোটবুকের আগের রানের ফলাফলগুলি টেনসরডোরড.দেভে দেখতে পারেন

এটি সুবিধার জন্য একটি <iframe> এর মধ্যে অন্তর্ভুক্ত রয়েছে:

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

এটি দিয়ে আপলোড করা হয়েছিল:

tensorboard dev upload --logdir  {logdir}/regularizers

সিদ্ধান্তে

পুনরুদ্ধার করার জন্য: স্নায়বিক নেটওয়ার্কগুলিতে অত্যধিক মানসিক চাপ প্রতিরোধের সবচেয়ে সাধারণ উপায় এখানে:

  • আরও প্রশিক্ষণের ডেটা পান।
  • নেটওয়ার্কের সক্ষমতা হ্রাস করুন।
  • ওজন নিয়মিতকরণ যুক্ত করুন।
  • ড্রপআউট যুক্ত করুন।

এই গাইডের অন্তর্ভুক্ত নয় এমন দুটি গুরুত্বপূর্ণ পন্থা হ'ল:

  • ডেটা-বর্ধন
  • ব্যাচ সাধারণীকরণ

মনে রাখবেন যে প্রতিটি পদ্ধতি নিজস্বভাবে সহায়তা করতে পারে তবে প্রায়শই তাদের সংমিশ্রণ আরও কার্যকর হতে পারে।


#
# 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.