সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

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

TensorFlow.org এ দেখুন GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

সর্বদা হিসাবে, এই উদাহরণে কোড ব্যবহার করবে tf.keras এপিআই, যা আপনি TensorFlow সম্পর্কে আরও জানতে পারেন Keras নির্দেশিকা

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

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

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

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

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

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

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

সেটআপ

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

import tensorflow as tf

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

print(tf.__version__)
2.5.0
!pip install 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 [==============================] - 148s 0us/step
FEATURES = 28

tf.data.experimental.CsvDataset বর্গ কোন মধ্যবর্তী decompression পদক্ষেপ সঙ্গে একটি gzip, ফাইল থেকে সরাসরি CSV রেকর্ড পড়তে ব্যবহার করা যাবে।

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

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

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

ডেটার বড় ব্যাচগুলিতে কাজ করার সময় টেনসরফ্লো সবচেয়ে কার্যকর।

সুতরাং repacking প্রতিটি সারির স্বতন্ত্রভাবে একটি নতুন করতে পরিবর্তে Dataset যে 10000-উদাহরণ কয়েক ব্যাচ লাগে, প্রযোজ্য pack_row প্রতিটি ব্যাচ ফাংশন, এবং তারপর splits ব্যাচ পৃথক রেকর্ড ফিরে আপ:

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)

png

এই টিউটোরিয়ালটি তুলনামূলকভাবে সংক্ষিপ্ত রাখতে বৈধতার জন্য প্রথম 1000টি নমুনা এবং পরবর্তী 10000টি প্রশিক্ষণের জন্য ব্যবহার করুন:

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 প্রশিক্ষণের জন্য একটি যথাযথ আকারের ব্যাচ তৈরি করতে পদ্ধতি। এছাড়াও Batching আগে মনে রাখবেন .shuffle এবং .repeat প্রশিক্ষণ সেট।

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

ওভারফিটিং প্রদর্শন করুন

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

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

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

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

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

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

শুধুমাত্র ব্যবহার করে একটি সহজ মডেল দিয়ে শুরু করুন 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 hyperbolically 1000 সময়কাল, 2000 সময়কাল ইত্যাদি এ 1/3 এ বেস হার 1/2 শেখার হার হ্রাস।

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')

png

এই টিউটোরিয়ালের প্রতিটি মডেল একই প্রশিক্ষণ কনফিগারেশন ব্যবহার করবে। সুতরাং কলব্যাকের তালিকা থেকে শুরু করে এইগুলিকে পুনরায় ব্যবহারযোগ্য উপায়ে সেট আপ করুন৷

এই টিউটোরিয়ালের প্রশিক্ষণ অনেক ছোট যুগের জন্য চলে। লগিং কমাতে গোলমাল ব্যবহার tfdocs.EpochDots যা কেবল একটি ছাপে . প্রতিটি যুগের জন্য, এবং প্রতি 100 যুগে মেট্রিক্সের একটি সম্পূর্ণ সেট।

পরবর্তী অন্তর্ভুক্ত 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:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0031s vs `on_train_batch_begin` time: 0.0346s). Check your callbacks.
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0031s vs `on_train_batch_end` time: 0.0125s). Check your callbacks.

Epoch: 0, accuracy:0.5093,  binary_crossentropy:0.7681,  loss:0.7681,  val_accuracy:0.5000,  val_binary_crossentropy:0.7207,  val_loss:0.7207,  
....................................................................................................
Epoch: 100, accuracy:0.6058,  binary_crossentropy:0.6244,  loss:0.6244,  val_accuracy:0.5700,  val_binary_crossentropy:0.6322,  val_loss:0.6322,  
....................................................................................................
Epoch: 200, accuracy:0.6220,  binary_crossentropy:0.6124,  loss:0.6124,  val_accuracy:0.5990,  val_binary_crossentropy:0.6202,  val_loss:0.6202,  
....................................................................................................
Epoch: 300, accuracy:0.6388,  binary_crossentropy:0.6045,  loss:0.6045,  val_accuracy:0.6150,  val_binary_crossentropy:0.6114,  val_loss:0.6114,  
....................................................................................................
Epoch: 400, accuracy:0.6475,  binary_crossentropy:0.5976,  loss:0.5976,  val_accuracy:0.6270,  val_binary_crossentropy:0.6012,  val_loss:0.6012,  
....................................................................................................
Epoch: 500, accuracy:0.6579,  binary_crossentropy:0.5917,  loss:0.5917,  val_accuracy:0.6390,  val_binary_crossentropy:0.5929,  val_loss:0.5929,  
....................................................................................................
Epoch: 600, accuracy:0.6662,  binary_crossentropy:0.5878,  loss:0.5878,  val_accuracy:0.6410,  val_binary_crossentropy:0.5890,  val_loss:0.5890,  
....................................................................................................
Epoch: 700, accuracy:0.6664,  binary_crossentropy:0.5847,  loss:0.5847,  val_accuracy:0.6670,  val_binary_crossentropy:0.5865,  val_loss:0.5865,  
....................................................................................................
Epoch: 800, accuracy:0.6709,  binary_crossentropy:0.5822,  loss:0.5822,  val_accuracy:0.6460,  val_binary_crossentropy:0.5896,  val_loss:0.5896,  
....................................................................................................
Epoch: 900, accuracy:0.6772,  binary_crossentropy:0.5793,  loss:0.5793,  val_accuracy:0.6540,  val_binary_crossentropy:0.5880,  val_loss:0.5880,  
...................

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

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

png

ছোট মডেল

আপনি ছোট মডেলের পারফরম্যান্সকে হারাতে পারেন কিনা তা দেখতে, ধীরে ধীরে কিছু বড় মডেলকে প্রশিক্ষণ দিন।

প্রতিটি 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_begin` is slow compared to the batch time (batch time: 0.0030s vs `on_train_batch_begin` time: 0.0258s). Check your callbacks.
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0030s vs `on_train_batch_end` time: 0.0176s). Check your callbacks.

Epoch: 0, accuracy:0.4757,  binary_crossentropy:0.7130,  loss:0.7130,  val_accuracy:0.4630,  val_binary_crossentropy:0.7012,  val_loss:0.7012,  
....................................................................................................
Epoch: 100, accuracy:0.6295,  binary_crossentropy:0.6092,  loss:0.6092,  val_accuracy:0.6120,  val_binary_crossentropy:0.6145,  val_loss:0.6145,  
....................................................................................................
Epoch: 200, accuracy:0.6575,  binary_crossentropy:0.5879,  loss:0.5879,  val_accuracy:0.6520,  val_binary_crossentropy:0.5976,  val_loss:0.5976,  
....................................................................................................
Epoch: 300, accuracy:0.6758,  binary_crossentropy:0.5774,  loss:0.5774,  val_accuracy:0.6610,  val_binary_crossentropy:0.5958,  val_loss:0.5958,  
....................................................................................................
Epoch: 400, accuracy:0.6830,  binary_crossentropy:0.5698,  loss:0.5698,  val_accuracy:0.6690,  val_binary_crossentropy:0.5949,  val_loss:0.5949,  
....................................................................................................
Epoch: 500, accuracy:0.6873,  binary_crossentropy:0.5650,  loss:0.5650,  val_accuracy:0.6720,  val_binary_crossentropy:0.5930,  val_loss:0.5930,  
....................................................................................................
Epoch: 600, accuracy:0.6923,  binary_crossentropy:0.5600,  loss:0.5600,  val_accuracy:0.6570,  val_binary_crossentropy:0.5946,  val_loss:0.5946,  
......................................................

মাঝারি মডেল

এখন প্রতিটি 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_begin` is slow compared to the batch time (batch time: 0.0033s vs `on_train_batch_begin` time: 0.0251s). Check your callbacks.
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0033s vs `on_train_batch_end` time: 0.0189s). Check your callbacks.

Epoch: 0, accuracy:0.5026,  binary_crossentropy:0.6944,  loss:0.6944,  val_accuracy:0.4740,  val_binary_crossentropy:0.6830,  val_loss:0.6830,  
....................................................................................................
Epoch: 100, accuracy:0.7164,  binary_crossentropy:0.5242,  loss:0.5242,  val_accuracy:0.6490,  val_binary_crossentropy:0.6316,  val_loss:0.6316,  
....................................................................................................
Epoch: 200, accuracy:0.7919,  binary_crossentropy:0.4224,  loss:0.4224,  val_accuracy:0.6480,  val_binary_crossentropy:0.7022,  val_loss:0.7022,  
.......................................

বড় মডেল

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

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_begin` is slow compared to the batch time (batch time: 0.0033s vs `on_train_batch_begin` time: 0.0237s). Check your callbacks.
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0033s vs `on_train_batch_end` time: 0.0182s). Check your callbacks.

Epoch: 0, accuracy:0.5116,  binary_crossentropy:0.7680,  loss:0.7680,  val_accuracy:0.5440,  val_binary_crossentropy:0.6753,  val_loss:0.6753,  
....................................................................................................
Epoch: 100, accuracy:1.0000,  binary_crossentropy:0.0021,  loss:0.0021,  val_accuracy:0.6610,  val_binary_crossentropy:1.8058,  val_loss:1.8058,  
....................................................................................................
Epoch: 200, accuracy:1.0000,  binary_crossentropy:0.0001,  loss:0.0001,  val_accuracy:0.6500,  val_binary_crossentropy:2.4712,  val_loss:2.4712,  
.........................

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

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

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

এই উদাহরণে, সাধারণত, শুধুমাত্র "Tiny" মডেল পুরাপুরি overfitting এড়াতে পরিচালনা করে, এবং বৃহত্তর মডেলের প্রতিটি ডেটা আরো দ্রুত overfit। এই জন্য এত তীব্র হয়ে ওঠে "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]')

png

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

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

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


# Load the TensorBoard notebook extension
%load_ext tensorboard

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

আপনি দেখতে পারেন পূর্ববর্তী রান ফলাফল এই নোটবুক এর TensorBoard.dev

TensorBoard.dev হল হোস্টিং, ট্র্যাকিং এবং ML পরীক্ষা সবার সাথে শেয়ার করার জন্য একটি পরিচালিত অভিজ্ঞতা।

এছাড়া অন্তর্ভুক্ত এটি কোন <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/tmp_tm13yei/tensorboard_logs/regularizers/Tiny')
regularizer_histories = {}
regularizer_histories['Tiny'] = size_histories['Tiny']

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

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

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

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

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

L1 নিয়মিতকরণ একটি স্পার্স মডেলকে উৎসাহিত করে ওজনকে ঠিক শূন্যের দিকে ঠেলে দেয়। L2 নিয়মিতকরণ ওজনের প্যারামিটারগুলিকে স্পার্স না করে শাস্তি দেবে কারণ ছোট ওজনের জন্য জরিমানা শূন্য হয়ে যায়- L2 যে কারণে বেশি সাধারণ।

ইন tf.keras , ওজন নিয়মিতকরণ শব্দ আর্গুমেন্ট হিসাবে স্তর ওজন regularizer দৃষ্টান্ত ক্ষণস্থায়ী দ্বারা যোগ করা হয়। চলুন এখন 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_begin` is slow compared to the batch time (batch time: 0.0038s vs `on_train_batch_begin` time: 0.0242s). Check your callbacks.
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0038s vs `on_train_batch_end` time: 0.0199s). Check your callbacks.

Epoch: 0, accuracy:0.5059,  binary_crossentropy:0.7720,  loss:2.2831,  val_accuracy:0.4620,  val_binary_crossentropy:0.7035,  val_loss:2.1321,  
....................................................................................................
Epoch: 100, accuracy:0.6490,  binary_crossentropy:0.5996,  loss:0.6228,  val_accuracy:0.6270,  val_binary_crossentropy:0.5898,  val_loss:0.6131,  
....................................................................................................
Epoch: 200, accuracy:0.6737,  binary_crossentropy:0.5826,  loss:0.6061,  val_accuracy:0.6680,  val_binary_crossentropy:0.5857,  val_loss:0.6096,  
....................................................................................................
Epoch: 300, accuracy:0.6842,  binary_crossentropy:0.5748,  loss:0.5993,  val_accuracy:0.6840,  val_binary_crossentropy:0.5754,  val_loss:0.5998,  
....................................................................................................
Epoch: 400, accuracy:0.6934,  binary_crossentropy:0.5620,  loss:0.5862,  val_accuracy:0.6690,  val_binary_crossentropy:0.5825,  val_loss:0.6066,  
.....................................................................................

l2(0.001) মানে যে স্তরের ওজন ম্যাট্রিক্স প্রতিটি সহগ যোগ হবে 0.001 * weight_coefficient_value**2 নেটওয়ার্ক মোট ক্ষতি হয়।

এটা কেন আমরা পর্যবেক্ষণ করছি binary_crossentropy সরাসরি। কারণ এটিতে এই নিয়মিতকরণের উপাদানটি মিশ্রিত নেই।

সুতরাং, যে একই "Large" একটি সঙ্গে মডেল L2 নিয়মিতকরণ শাস্তি সঞ্চালিত অনেক ভালো:

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

png

যেহেতু আপনি দেখতে পারেন, "L2" নিয়মিত মডেলটি এখন আরো অনেক কিছু দিয়ে প্রতিযোগিতামূলক "Tiny" মডেল। এই "L2" মডেল অনেক বেশি overfitting প্রতিরোধী "Large" মডেল পরামিতি একই সংখ্যক থাকা সত্বেও তা ভিত্তি করে ছিল।

অধিক তথ্য

এই ধরণের নিয়মিতকরণ সম্পর্কে দুটি গুরুত্বপূর্ণ বিষয় লক্ষ্য করা যায়।

প্রথম: যদি আপনার নিজস্ব প্রশিক্ষণ লুপ লিখছেন, তাহলে আপনি তার নিয়মিতকরণ ক্ষতির জন্য মডেল জিজ্ঞাসা করতে নিশ্চিত করা হবে।

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

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

একটি দ্বিতীয় পদ্ধতি রয়েছে যা পরিবর্তে শুধুমাত্র কাঁচা ক্ষতির উপর অপ্টিমাইজার চালায় এবং তারপরে গণনা করা পদক্ষেপটি প্রয়োগ করার সময় অপ্টিমাইজারটি কিছু ওজন ক্ষয়ও প্রয়োগ করে। এই "পৃথক ওজন ক্ষয়" মত 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_begin` is slow compared to the batch time (batch time: 0.0040s vs `on_train_batch_begin` time: 0.0241s). Check your callbacks.
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.0208s). Check your callbacks.

Epoch: 0, accuracy:0.5060,  binary_crossentropy:0.7949,  loss:0.7949,  val_accuracy:0.5140,  val_binary_crossentropy:0.6710,  val_loss:0.6710,  
....................................................................................................
Epoch: 100, accuracy:0.6623,  binary_crossentropy:0.5950,  loss:0.5950,  val_accuracy:0.6840,  val_binary_crossentropy:0.5723,  val_loss:0.5723,  
....................................................................................................
Epoch: 200, accuracy:0.6897,  binary_crossentropy:0.5559,  loss:0.5559,  val_accuracy:0.6800,  val_binary_crossentropy:0.5971,  val_loss:0.5971,  
....................................................................................................
Epoch: 300, accuracy:0.7202,  binary_crossentropy:0.5114,  loss:0.5114,  val_accuracy:0.6800,  val_binary_crossentropy:0.5984,  val_loss:0.5984,  
...............................................
plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

png

এটা এই নিয়মিতকরণ উভয় আচরণকে উন্নত পন্থা যে, এই চক্রান্ত থেকে পরিষ্কার "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_begin` is slow compared to the batch time (batch time: 0.0040s vs `on_train_batch_begin` time: 0.0245s). Check your callbacks.
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.0214s). Check your callbacks.

Epoch: 0, accuracy:0.5056,  binary_crossentropy:0.8201,  loss:0.9784,  val_accuracy:0.5130,  val_binary_crossentropy:0.6691,  val_loss:0.8269,  
....................................................................................................
Epoch: 100, accuracy:0.6409,  binary_crossentropy:0.6052,  loss:0.6362,  val_accuracy:0.6670,  val_binary_crossentropy:0.5831,  val_loss:0.6139,  
....................................................................................................
Epoch: 200, accuracy:0.6673,  binary_crossentropy:0.5893,  loss:0.6147,  val_accuracy:0.6880,  val_binary_crossentropy:0.5666,  val_loss:0.5920,  
....................................................................................................
Epoch: 300, accuracy:0.6724,  binary_crossentropy:0.5814,  loss:0.6092,  val_accuracy:0.6850,  val_binary_crossentropy:0.5638,  val_loss:0.5916,  
....................................................................................................
Epoch: 400, accuracy:0.6791,  binary_crossentropy:0.5764,  loss:0.6061,  val_accuracy:0.6960,  val_binary_crossentropy:0.5536,  val_loss:0.5832,  
....................................................................................................
Epoch: 500, accuracy:0.6750,  binary_crossentropy:0.5722,  loss:0.6037,  val_accuracy:0.6760,  val_binary_crossentropy:0.5583,  val_loss:0.5899,  
....................................................................................................
Epoch: 600, accuracy:0.6818,  binary_crossentropy:0.5651,  loss:0.5989,  val_accuracy:0.6940,  val_binary_crossentropy:0.5422,  val_loss:0.5761,  
....................................................................................................
Epoch: 700, accuracy:0.6882,  binary_crossentropy:0.5594,  loss:0.5943,  val_accuracy:0.6880,  val_binary_crossentropy:0.5436,  val_loss:0.5786,  
....................................................................................................
Epoch: 800, accuracy:0.6886,  binary_crossentropy:0.5567,  loss:0.5927,  val_accuracy:0.6960,  val_binary_crossentropy:0.5446,  val_loss:0.5807,  
....................................................................................................
Epoch: 900, accuracy:0.6994,  binary_crossentropy:0.5535,  loss:0.5907,  val_accuracy:0.6900,  val_binary_crossentropy:0.5463,  val_loss:0.5835,  
................................................
plotter.plot(regularizer_histories)
plt.ylim([0.5, 0.7])
(0.5, 0.7)

png

সঙ্গে এই মডেল "Combined" নিয়মিতকরণ স্পষ্টত সেরা এক এতদূর হয়।

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

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

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

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