บันทึกวันที่! Google I / O ส่งคืนวันที่ 18-20 พฤษภาคม ลงทะเบียนเลย
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

เครื่องแต่งกายและชุดชั้นใน

ดูใน TensorFlow.org เรียกใช้ใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดสมุดบันทึก

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

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

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

สิ่งที่ตรงกันข้ามกับ overfitting คือ underfitting Underfitting เกิดขึ้นเมื่อยังมีช่องว่างสำหรับการปรับปรุงข้อมูลรถไฟ สิ่งนี้อาจเกิดขึ้นได้จากหลายสาเหตุ: หากแบบจำลองมีประสิทธิภาพไม่เพียงพอมีความสม่ำเสมอมากเกินไปหรือไม่ได้รับการฝึกฝนมานานพอ ซึ่งหมายความว่าเครือข่ายไม่ได้เรียนรู้รูปแบบที่เกี่ยวข้องในข้อมูลการฝึกอบรม

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

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

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

ในสมุดบันทึกนี้เราจะสำรวจเทคนิคการทำให้เป็นมาตรฐานทั่วไปหลายประการและใช้เพื่อปรับปรุงรูปแบบการจำแนกประเภท

ติดตั้ง

ก่อนเริ่มต้นให้นำเข้าแพ็คเกจที่จำเป็น:

import tensorflow as tf

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

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

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

import numpy as np

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

ชุดข้อมูล 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 [==============================] - 120s 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 ใหม่ที่ใช้กลุ่มตัวอย่าง 10,000 ตัวอย่างให้ใช้ฟังก์ชัน 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 วิธีการในการสร้างกระบวนการของมีขนาดที่เหมาะสมสำหรับการฝึกอบรม ก่อนทำการแบทช์อย่าลืม. .shuffle และ. ทำ .repeat ชุดการฝึกอบรม

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

สาธิตการฟิตติ้งมากเกินไป

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

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

โปรดคำนึงถึงสิ่งนี้เสมอ: โมเดลการเรียนรู้เชิงลึกมักจะเข้ากับข้อมูลการฝึกอบรมได้ดี แต่ความท้าทายที่แท้จริงคือการวางนัยทั่วไปไม่เหมาะสม

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

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

ในการค้นหาขนาดโมเดลที่เหมาะสมควรเริ่มต้นด้วยเลเยอร์และพารามิเตอร์ที่ค่อนข้างน้อยจากนั้นเริ่มเพิ่มขนาดของเลเยอร์หรือเพิ่มเลเยอร์ใหม่จนกว่าคุณจะเห็นผลตอบแทนที่ลดลงจากการสูญเสียการตรวจสอบความถูกต้อง

เริ่มต้นด้วยโมเดลง่ายๆโดยใช้ layers.Dense เพียงอย่างเดียว layers.Dense เป็นพื้นฐานจากนั้นสร้างเวอร์ชันที่ใหญ่ขึ้นและเปรียบเทียบ

ขั้นตอนการฝึกอบรม

หลายรุ่นฝึกได้ดีขึ้นหากคุณค่อยๆลดอัตราการเรียนรู้ระหว่างการฝึก ใช้ optimizers.schedules เพื่อลดอัตราการเรียนรู้เมื่อเวลาผ่านไป:

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

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

รหัสด้านบนกำหนดschedules.InverseTimeDecay InverseTimeDecay เพื่อลดอัตราการเรียนรู้เกินจริงเป็น 1/2 ของอัตราฐานที่ 1,000 ยุค 1/3 ที่ 2,000 ยุคเป็นต้น

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 เพื่อสร้างบันทึก 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.fit และ Model.compile เดียวกัน:

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

  model.summary()

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

โมเดลจิ๋ว

เริ่มต้นด้วยการฝึกโมเดล:

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

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

ตอนนี้ตรวจสอบว่าโมเดลเป็นอย่างไร:

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

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_end` is slow compared to the batch time (batch time: 0.0028s vs `on_train_batch_end` time: 0.0112s). Check your callbacks.

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

รุ่นกลาง

ตอนนี้ลอง 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_end` is slow compared to the batch time (batch time: 0.0026s vs `on_train_batch_end` time: 0.0107s). Check your callbacks.

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

รุ่นใหญ่

ในการออกกำลังกายคุณสามารถสร้างหุ่นจำลองที่มีขนาดใหญ่ขึ้นและดูว่ามันเริ่มสวมใส่มากเกินไปได้เร็วเพียงใด ต่อไปเรามาเพิ่มเกณฑ์มาตรฐานเครือข่ายที่มีความจุมากกว่าที่ปัญหาจะรับประกันได้:

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

และอีกครั้งฝึกโมเดลโดยใช้ข้อมูลเดียวกัน:

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

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

วางแผนการสูญเสียการฝึกอบรมและการตรวจสอบความถูกต้อง

เส้นทึบแสดงการสูญเสียการฝึกและเส้นประแสดงการสูญเสียการตรวจสอบความถูกต้อง (โปรดจำไว้ว่า: การสูญเสียการตรวจสอบความถูกต้องที่ต่ำกว่าแสดงถึงรูปแบบที่ดีกว่า)

ในขณะที่การสร้างโมเดลที่ใหญ่ขึ้นจะทำให้มีพลังมากขึ้นหากพลังนี้ไม่ได้ถูก จำกัด ไว้ก็สามารถทำให้ชุดฝึกมากเกินไปได้อย่างง่ายดาย

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

สิ่งนี้จะเห็นได้ชัดหากคุณวางแผนและเปรียบเทียบเมตริกการตรวจสอบความถูกต้องกับเมตริกการฝึกอบรม

  • เป็นเรื่องปกติที่จะมีความแตกต่างเล็กน้อย
  • หากเมตริกทั้งสองไปในทิศทางเดียวกันทุกอย่างก็เรียบร้อย
  • หากเมตริกการตรวจสอบความถูกต้องเริ่มหยุดนิ่งในขณะที่เมตริกการฝึกยังคงปรับปรุงอยู่คุณอาจใกล้จะฟิตติ้งมากเกินไป
  • หากเมตริกการตรวจสอบความถูกต้องไปในทิศทางที่ไม่ถูกต้องแสดงว่าแบบจำลองนั้นมีการติดตั้งมากเกินไปอย่างชัดเจน
plotter.plot(size_histories)
a = plt.xscale('log')
plt.xlim([5, max(plt.xlim())])
plt.ylim([0.5, 0.7])
plt.xlabel("Epochs [Log Scale]")
Text(0.5, 0, 'Epochs [Log Scale]')

png

ดูใน TensorBoard

โมเดลเหล่านี้ทั้งหมดเขียนบันทึก 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/tmpr1cbfjvl/tensorboard_logs/regularizers/Tiny')
regularizer_histories = {}
regularizer_histories['Tiny'] = size_histories['Tiny']

เพิ่มน้ำหนักสม่ำเสมอ

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

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

  • การทำให้เป็นมาตรฐาน L1 โดยที่ต้นทุนที่เพิ่มเป็นสัดส่วนกับค่าสัมบูรณ์ของค่าสัมประสิทธิ์น้ำหนัก (กล่าวคือสิ่งที่เรียกว่า "บรรทัดฐาน L1" ของน้ำหนัก)

  • การทำให้เป็นมาตรฐาน L2 โดยที่ต้นทุนที่เพิ่มจะเป็นสัดส่วนกับกำลังสองของค่าสัมประสิทธิ์น้ำหนัก (กล่าวคือสิ่งที่เรียกว่า "บรรทัดฐาน L2" ของน้ำหนักกำลังสอง การทำให้เป็นมาตรฐาน L2 เรียกอีกอย่างว่าการสลายตัวของน้ำหนักในบริบทของโครงข่ายประสาทเทียม อย่าปล่อยให้ชื่อที่แตกต่างกันทำให้คุณสับสนเพราะการลดน้ำหนักนั้นมีความหมายทางคณิตศาสตร์เหมือนกับการทำให้เป็นมาตรฐานของ L2 ทุกประการ

การทำให้เป็นมาตรฐาน L1 ทำให้น้ำหนักไปที่ศูนย์เพื่อกระตุ้นให้เกิดโมเดลที่เบาบาง การทำให้เป็นมาตรฐาน L2 จะลงโทษพารามิเตอร์น้ำหนักโดยไม่ทำให้เบาบางลงเนื่องจากการปรับลดลงเป็นศูนย์เนื่องจากน้ำหนักน้อย - เหตุผลหนึ่งที่ทำให้ L2 เป็นเรื่องปกติมากขึ้น

ใน tf.keras น้ำหนักให้เป็นมาตรฐานจะถูกเพิ่มโดยการส่งอินสแตนซ์ weight 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_end` is slow compared to the batch time (batch time: 0.0034s vs `on_train_batch_end` time: 0.0134s). Check your callbacks.

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

l2(0.001) หมายความว่าทุกสัมประสิทธิ์ในเมทริกซ์น้ำหนักของเลเยอร์จะเพิ่ม 0.001 * weight_coefficient_value**2 ให้กับการ สูญเสีย ทั้งหมดของเครือข่าย

นั่นคือเหตุผลที่เราตรวจสอบ binary_crossentropy โดยตรง เนื่องจากไม่มีองค์ประกอบการทำให้เป็นมาตรฐานนี้ปะปนอยู่

ดังนั้นโมเดล "Large" เดียวกันที่มีการลงโทษตามลำดับ L2 ทำงานได้ดีกว่ามาก:

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

png

อย่างที่คุณเห็นรุ่นปกติ "L2" สามารถแข่งขันกับรุ่น "Tiny" ได้มากขึ้น นอกจากนี้โมเดล "L2" นี้ยังทนทานต่อการโอเวอร์ฟิตติ้งได้ดีกว่ารุ่น "Large" มีพื้นฐานมาจากแม้ว่าจะมีพารามิเตอร์จำนวนเท่ากันก็ตาม

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

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

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

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

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

มีแนวทางที่สองที่จะเรียกใช้เครื่องมือเพิ่มประสิทธิภาพเฉพาะกับการสูญเสียดิบเท่านั้นจากนั้นในขณะที่ใช้ขั้นตอนที่คำนวณได้เครื่องมือเพิ่มประสิทธิภาพจะใช้การลดน้ำหนักบางส่วนด้วย "Decoupled Weight Decay" นี้มีให้เห็นในเครื่องมือเพิ่มประสิทธิภาพเช่น 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 ซึ่งจะถูกนำไปใช้กับเอาต์พุตของเลเยอร์ก่อนหน้านี้

ลองเพิ่มเลเยอร์ 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_end` is slow compared to the batch time (batch time: 0.0036s vs `on_train_batch_end` time: 0.0141s). Check your callbacks.

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

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_end` is slow compared to the batch time (batch time: 0.0040s vs `on_train_batch_end` time: 0.0151s). Check your callbacks.

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

png

โมเดลที่มีการทำให้เป็นระเบียบ "Combined" นี้เป็นรุ่นที่ดีที่สุดอย่างเห็นได้ชัด

ดูใน TensorBoard

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

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

%tensorboard --logdir {logdir}/regularizers

คุณสามารถดู ผลลัพธ์ของการเรียกใช้ สมุดบันทึกนี้ ก่อนหน้า นี้ได้ที่ TensorDoard.dev

นอกจากนี้ยังรวมอยู่ใน <iframe> เพื่อความสะดวก:

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

อัปโหลดด้วย:

tensorboard dev upload --logdir  {logdir}/regularizers

ข้อสรุป

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

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

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

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

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

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