หน้านี้ได้รับการแปลโดย 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.3.0

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

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

from  IPython import display
from matplotlib import pyplot as plt

import numpy as np

import pathlib
import shutil
import tempfile

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

ชุดข้อมูล 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 [==============================] - 195s 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:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/summary_ops_v2.py:1277: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.
WARNING:tensorflow:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0030s vs `on_train_batch_end` time: 0.0237s). Check your callbacks.

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

ตรวจสอบว่าโมเดลทำอย่างไร:

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

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

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

โมเดลขนาดกลาง

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

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

รุ่นใหญ่

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ดังนั้นโมเดล "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:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0045s vs `on_train_batch_end` time: 0.0648s). Check your callbacks.

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

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

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

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

ข้อสรุป

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

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

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

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

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


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