โอเวอร์ฟิตและอันเดอร์ฟิต

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดโน๊ตบุ๊ค

และเช่นเคยรหัสในตัวอย่างนี้จะใช้ tf.keras API ซึ่งคุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับใน TensorFlow คู่มือ Keras

ในทั้งสองก่อนหน้านี้ examples- ข้อความการจำแนกประเภท และ การคาดการณ์ประสิทธิภาพการใช้เชื้อเพลิง - เราเห็นว่าถูกต้องของรูปแบบของเราในการตรวจสอบข้อมูลที่จะสูงสุดหลังจากการฝึกอบรมสำหรับจำนวนของยุคสมัยและจากนั้นก็จะทำให้เมื่อยล้าหรือเริ่มลดลง

ในคำอื่น ๆ รูปแบบของเราจะ overfit ข้อมูลการฝึกอบรม การเรียนรู้วิธีจัดการกับการสวมใส่มากเกินไปเป็นสิ่งสำคัญ แม้ว่ามันมักจะเป็นไปได้เพื่อให้บรรลุความแม่นยำสูงในชุดฝึกอบรมสิ่งที่เราต้องการจริงๆคือการพัฒนารูปแบบที่คุยกันดีกับชุดทดสอบ (หรือข้อมูลที่พวกเขาไม่เคยเห็นมาก่อน)

ตรงข้ามจะอิง underfitting 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)

ชุดข้อมูล Higgs

เป้าหมายของบทช่วยสอนนี้ไม่ใช่การทำฟิสิกส์ของอนุภาค ดังนั้นอย่ายึดติดกับรายละเอียดของชุดข้อมูล ประกอบด้วยตัวอย่าง 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 ระดับสามารถใช้ในการอ่านบันทึก CSV โดยตรงจากไฟล์ gzip ที่ไม่มีขั้นตอนการบีบอัดกลาง

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

คลาสตัวอ่าน csv นั้นส่งคืนรายการสเกลาร์สำหรับแต่ละเร็กคอร์ด ฟังก์ชันต่อไปนี้บรรจุรายการสเกลาร์เป็นคู่ (feature_vector, label)

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

TensorFlow มีประสิทธิภาพสูงสุดเมื่อทำงานกับข้อมูลจำนวนมาก

ดังนั้นแทนที่จะบรรจุแต่ละแถวเป็นรายบุคคลให้ใหม่ 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)

png

เพื่อให้บทช่วยสอนนี้ค่อนข้างสั้น ให้ใช้เพียง 1,000 ตัวอย่างแรกสำหรับการตรวจสอบ และอีก 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 วิธีการในการสร้างกระบวนการของมีขนาดที่เหมาะสมสำหรับการฝึกอบรม ก่อน 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 ลดอัตราการเรียนรู้ถึง 1/2 ของอัตราฐานที่ 1000 epochs 1/3 2000 epochs และอื่น ๆ

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

รุ่นกลาง

ตอนนี้ลอง 3 เลเยอร์ที่ซ่อนอยู่โดยแต่ละ 64 ยูนิต:

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

ดูในเทนเซอร์บอร์ด

โมเดลเหล่านี้ทั้งหมดเขียนบันทึก TensorBoard ระหว่างการฝึก

เปิดโปรแกรมดู TensorBoard ที่ฝังไว้ภายในโน้ตบุ๊ก:


# 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']

เพิ่มการปรับน้ำหนักให้สม่ำเสมอ

คุณอาจคุ้นเคยกับหลักการมีดโกนของ Occam: ให้คำอธิบายสองข้อสำหรับบางสิ่ง คำอธิบายที่มีแนวโน้มว่าจะถูกต้องมากที่สุดคือคำอธิบายที่ "ง่ายที่สุด" ซึ่งเป็นคำอธิบายที่ให้การสันนิษฐานน้อยที่สุด สิ่งนี้ยังใช้กับแบบจำลองที่เรียนรู้โดยโครงข่ายประสาทเทียม: เมื่อพิจารณาจากข้อมูลการฝึกและสถาปัตยกรรมเครือข่ายแล้ว มีค่าน้ำหนักหลายชุด (หลายรุ่น) ที่สามารถอธิบายข้อมูลได้ และแบบจำลองที่ง่ายกว่าจะมีแนวโน้มน้อยกว่าที่จะใส่เกินขนาดที่ซับซ้อน

"โมเดลอย่างง่าย" ในบริบทนี้คือโมเดลที่การกระจายค่าพารามิเตอร์มีเอนโทรปีน้อยกว่า (หรือโมเดลที่มีพารามิเตอร์น้อยกว่าทั้งหมด ดังที่เราเห็นในส่วนด้านบน) ดังนั้น วิธีทั่วไปในการบรรเทาความเหมาะสมคือการวางข้อจำกัดในความซับซ้อนของเครือข่าย โดยการบังคับให้น้ำหนักของเครือข่ายรับค่าเพียงเล็กน้อยเท่านั้น ซึ่งทำให้การกระจายของค่าน้ำหนัก "ปกติ" มากขึ้น สิ่งนี้เรียกว่า "การปรับน้ำหนักให้เป็นมาตรฐาน" และทำได้โดยการเพิ่มต้นทุนที่เกี่ยวข้องกับการมีน้ำหนักมากในฟังก์ชันการสูญเสียของเครือข่าย ค่าใช้จ่ายนี้มาในสองรสชาติ:

  • 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" regularized รุ่นอยู่ในขณะนี้การแข่งขันมากขึ้นกับการที่ "Tiny" รุ่น นี้ "L2" รูปแบบยังเป็นมากขึ้นทนต่อการ overfitting กว่า "Large" รูปแบบมันก็ขึ้นอยู่แม้จะมีหมายเลขเดียวกันของพารามิเตอร์

ข้อมูลเพิ่มเติม

มีสองสิ่งสำคัญที่ควรทราบเกี่ยวกับการทำให้เป็นมาตรฐานประเภทนี้

แม่: ถ้าคุณเขียนห่วงการฝึกอบรมของคุณเองแล้วคุณจะต้องแน่ใจว่าจะถามแบบจำลองสำหรับการสูญเสียของกู

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

ประการที่สอง: การดำเนินการนี้จะทำงานโดยการเพิ่มบทลงโทษน้ำหนักการสูญเสียของแบบจำลองและจากนั้นใช้ขั้นตอนการเพิ่มประสิทธิภาพมาตรฐานหลังจากนั้น

มีวิธีที่สองที่เรียกใช้ตัวเพิ่มประสิทธิภาพเฉพาะกับการสูญเสียดิบแทน จากนั้นในขณะที่ใช้ขั้นตอนที่คำนวณ เครื่องมือเพิ่มประสิทธิภาพก็ใช้การลดน้ำหนักบางส่วนด้วย นี้ "Decoupled น้ำหนักสลาย" มีให้เห็นในการเพิ่มประสิทธิภาพเช่น optimizers.FTRL และ optimizers.AdamW

เพิ่มการออกกลางคัน

Dropout เป็นหนึ่งในเทคนิคการทำให้เป็นมาตรฐานและมีประสิทธิภาพมากที่สุดสำหรับโครงข่ายประสาทเทียม พัฒนาโดยฮินตันและนักศึกษาของเขาที่มหาวิทยาลัยโตรอนโต

คำอธิบายที่เข้าใจง่ายสำหรับการออกกลางคันคือ เนื่องจากแต่ละโหนดในเครือข่ายไม่สามารถพึ่งพาเอาต์พุตของโหนดอื่นๆ ได้ แต่ละโหนดต้องแสดงคุณลักษณะที่เป็นประโยชน์ในตัวเอง

การออกกลางคัน นำไปใช้กับเลเยอร์ประกอบด้วย "การหลุดออก" แบบสุ่ม (เช่น ตั้งค่าเป็นศูนย์) คุณลักษณะเอาต์พุตจำนวนหนึ่งของเลเยอร์ระหว่างการฝึก สมมติว่าเลเยอร์ที่กำหนดโดยปกติจะส่งเวกเตอร์ [0.2, 0.5, 1.3, 0.8, 1.1] สำหรับตัวอย่างอินพุตที่กำหนดระหว่างการฝึก หลังจากใช้ dropout เวกเตอร์นี้จะมีรายการศูนย์สองสามรายการโดยสุ่มแจก เช่น [0, 0.5, 1.3, 0, 1.1]

"อัตราการออกกลางคัน" คือเศษส่วนของคุณสมบัติที่ถูกทำให้เป็นศูนย์ โดยปกติจะถูกตั้งค่าระหว่าง 0.2 ถึง 0.5 ในขณะทดสอบ จะไม่มีการถอดหน่วยใดออก และค่าเอาท์พุตของเลเยอร์จะถูกลดขนาดลงด้วยปัจจัยที่เท่ากับอัตราการออกกลางคันแทน เพื่อให้สมดุลกับความจริงที่ว่าหน่วยมีการใช้งานมากกว่าเวลาฝึก

ใน tf.keras คุณสามารถแนะนำการออกกลางคันในเครือข่ายผ่านทางชั้นกลางคันที่ได้รับนำไปใช้กับการส่งออกของชั้นที่ถูกต้องก่อน

มาเพิ่มเลเยอร์ Dropout สองเลเยอร์ในเครือข่ายของเราเพื่อดูว่าพวกมันช่วยลดการโอเวอร์ฟิตได้ดีเพียงใด:

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 ด้วย

ในการเปิดดูเทนเซอร์บอร์ดที่ฝังไว้ภายในโน้ตบุ๊ก ให้คัดลอกสิ่งต่อไปนี้ลงในเซลล์รหัส:

%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

บทสรุป

เพื่อสรุป: ต่อไปนี้เป็นวิธีทั่วไปในการป้องกันการ overfitting ในโครงข่ายประสาทเทียม:

  • รับข้อมูลการฝึกอบรมเพิ่มเติม
  • ลดความจุของเครือข่าย
  • เพิ่มการปรับน้ำหนักให้สม่ำเสมอ
  • เพิ่มการออกกลางคัน

แนวทางสำคัญสองประการที่ไม่ได้กล่าวถึงในคู่มือนี้คือ:

  • ข้อมูลเสริม
  • การทำให้เป็นมาตรฐานแบบแบตช์

โปรดจำไว้ว่าแต่ละวิธีสามารถช่วยได้ด้วยตัวเอง แต่บ่อยครั้งที่รวมเข้าด้วยกันอาจมีประสิทธิภาพมากกว่า

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