Trang này được dịch bởi Cloud Translation API.
Switch to English

Overfit and underfit

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải xuống sổ tay

Như mọi khi, mã trong ví dụ này sẽ sử dụng API tf.keras mà bạn có thể tìm hiểu thêm trong hướng dẫn TensorFlow Keras .

Trong cả hai ví dụ trước - phân loại văn bảndự đoán hiệu suất nhiên liệu - chúng tôi thấy rằng độ chính xác của mô hình của chúng tôi đối với dữ liệu xác thực sẽ đạt mức cao nhất sau khi đào tạo trong một số kỷ nguyên và sau đó sẽ trì trệ hoặc bắt đầu giảm.

Nói cách khác, mô hình của chúng tôi sẽ quá phù hợp với dữ liệu đào tạo. Học cách đối phó với việc mặc trang phục quá sức là quan trọng. Mặc dù thường có thể đạt được độ chính xác cao trên tập huấn luyện , nhưng điều chúng tôi thực sự muốn là phát triển các mô hình tổng quát hóa tốt cho tập thử nghiệm (hoặc dữ liệu mà họ chưa từng thấy trước đây).

Ngược lại của overfitting là underfitting . Việc trang bị thiếu xảy ra khi dữ liệu thử nghiệm vẫn còn chỗ để cải thiện. Điều này có thể xảy ra vì một số lý do: Nếu mô hình không đủ mạnh, được quy định quá mức hoặc đơn giản là chưa được đào tạo đủ lâu. Điều này có nghĩa là mạng chưa học được các mẫu liên quan trong dữ liệu đào tạo.

Tuy nhiên, nếu bạn đào tạo quá lâu, mô hình sẽ bắt đầu quá mức và học các mẫu từ dữ liệu đào tạo không tổng quát hóa thành dữ liệu thử nghiệm. Chúng ta cần phải cân bằng. Hiểu cách đào tạo cho một số kỷ nguyên thích hợp như chúng ta sẽ khám phá bên dưới là một kỹ năng hữu ích.

Để tránh trang bị quá mức, giải pháp tốt nhất là sử dụng dữ liệu đào tạo đầy đủ hơn. Tập dữ liệu phải bao gồm đầy đủ các đầu vào mà mô hình dự kiến ​​sẽ xử lý. Dữ liệu bổ sung có thể chỉ hữu ích nếu nó bao gồm các trường hợp mới và thú vị.

Một mô hình được đào tạo trên dữ liệu đầy đủ hơn sẽ tổng quát hóa tốt hơn một cách tự nhiên. Khi điều đó không còn nữa, giải pháp tốt nhất tiếp theo là sử dụng các kỹ thuật như chính quy hóa. Những ràng buộc này đặt ra những hạn chế về số lượng và loại thông tin mà mô hình của bạn có thể lưu trữ. Nếu một mạng chỉ có khả năng ghi nhớ một số lượng nhỏ các mẫu, thì quá trình tối ưu hóa sẽ buộc nó phải tập trung vào các mẫu nổi bật nhất, có cơ hội tổng quát hóa tốt hơn.

Trong sổ tay này, chúng ta sẽ khám phá một số kỹ thuật chính quy hóa phổ biến và sử dụng chúng để cải thiện mô hình phân loại.

Thiết lập

Trước khi bắt đầu, hãy nhập các gói cần thiết:

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)

Tập dữ liệu Higgs

Mục tiêu của hướng dẫn này không phải để làm vật lý hạt, vì vậy đừng tập trung vào các chi tiết của tập dữ liệu. Nó chứa 11 000 000 ví dụ, mỗi ví dụ có 28 tính năng và nhãn lớp nhị phân.

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

Lớp tf.data.experimental.CsvDataset có thể được sử dụng để đọc bản ghi csv trực tiếp từ tệp gzip mà không cần bước giải nén trung gian.

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

Lớp trình đọc csv đó trả về danh sách các đại lượng vô hướng cho mỗi bản ghi. Hàm sau đây đóng gói lại danh sách các đại lượng vô hướng đó thành một cặp (feature_vector, label).

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

TensorFlow hiệu quả nhất khi hoạt động trên một loạt dữ liệu lớn.

Vì vậy, thay vì đóng gói lại từng hàng riêng lẻ, hãy tạo Dataset mới lấy các lô 10000 ví dụ, hãy áp dụng hàm pack_row cho từng lô, rồi chia các lô sao lưu thành các bản ghi riêng lẻ:

packed_ds = ds.batch(10000).map(pack_row).unbatch()

Hãy xem một số bản ghi từ packed_ds mới này.

Các tính năng không được chuẩn hóa hoàn toàn, nhưng điều này là đủ cho hướng dẫn này.

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

Để giữ cho hướng dẫn này tương đối ngắn, chỉ sử dụng 1000 mẫu đầu tiên để xác nhận và 10000 mẫu tiếp theo để đào tạo:

N_VALIDATION = int(1e3)
N_TRAIN = int(1e4)
BUFFER_SIZE = int(1e4)
BATCH_SIZE = 500
STEPS_PER_EPOCH = N_TRAIN//BATCH_SIZE

Các Dataset.skipDataset.take phương pháp thực hiện điều này dễ dàng.

Đồng thời, sử dụng phương thức Dataset.cache để đảm bảo rằng trình tải không cần đọc lại dữ liệu từ tệp trên mỗi kỷ nguyên:

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

Các tập dữ liệu này trả về các ví dụ riêng lẻ. Sử dụng phương thức .batch để tạo các lô có kích thước thích hợp để đào tạo. Trước khi chia lô cũng nhớ .shuffle.repeat tập huấn luyện.

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

Thể hiện trang phục quá mức

Cách đơn giản nhất để ngăn chặn việc trang bị quá mức là bắt đầu với một mô hình nhỏ: Một mô hình có một số lượng nhỏ các tham số có thể học được (được xác định bởi số lớp và số đơn vị trên mỗi lớp). Trong học sâu, số lượng các tham số có thể học được trong một mô hình thường được gọi là "năng lực" của mô hình.

Theo trực giác, một mô hình có nhiều tham số hơn sẽ có nhiều "khả năng ghi nhớ" hơn và do đó sẽ có thể dễ dàng học một ánh xạ giống như từ điển hoàn hảo giữa các mẫu đào tạo và mục tiêu của chúng, một ánh xạ không có bất kỳ sức mạnh tổng quát nào, nhưng điều này sẽ vô ích khi đưa ra dự đoán trên dữ liệu chưa từng thấy trước đây.

Luôn ghi nhớ điều này: các mô hình học sâu có xu hướng phù hợp tốt với dữ liệu đào tạo, nhưng thách thức thực sự là tổng quát hóa chứ không phải phù hợp.

Mặt khác, nếu mạng có tài nguyên ghi nhớ hạn chế, nó sẽ không thể học ánh xạ một cách dễ dàng. Để giảm thiểu sự mất mát của nó, nó sẽ phải học các biểu diễn nén có nhiều khả năng dự đoán hơn. Đồng thời, nếu bạn làm cho mô hình của mình quá nhỏ, nó sẽ khó phù hợp với dữ liệu đào tạo. Có sự cân bằng giữa "quá nhiều công suất" và "không đủ công suất".

Thật không may, không có công thức kỳ diệu nào để xác định kích thước hoặc kiến ​​trúc phù hợp của mô hình của bạn (về số lớp hoặc kích thước phù hợp cho mỗi lớp). Bạn sẽ phải thử nghiệm bằng cách sử dụng một loạt các kiến ​​trúc khác nhau.

Để tìm kích thước mô hình thích hợp, tốt nhất nên bắt đầu với tương đối ít lớp và tham số, sau đó bắt đầu tăng kích thước của các lớp hoặc thêm các lớp mới cho đến khi bạn thấy lợi nhuận giảm dần khi mất xác thực.

Bắt đầu với một mô hình đơn giản chỉ sử dụng các layers.Dense làm đường cơ sở, sau đó tạo các phiên bản lớn hơn và so sánh chúng.

Quy trình đào tạo

Nhiều mô hình đào tạo tốt hơn nếu bạn giảm dần tỷ lệ học tập trong quá trình đào tạo. Sử dụng chương trình optimizers.schedules để giảm tỷ lệ học tập theo thời gian:

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)

Đoạn mã trên thiết lập một schedules.InverseTimeDecay InverseTimeDecay giảm tốc độ học tập xuống 1/2 tốc độ cơ bản ở 1000 kỷ nguyên, 1/3 ở 2000 kỷ nguyên, v.v.

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

Mỗi mô hình trong hướng dẫn này sẽ sử dụng cùng một cấu hình đào tạo. Vì vậy, hãy thiết lập chúng theo cách có thể sử dụng lại, bắt đầu với danh sách các lệnh gọi lại.

Việc đào tạo cho hướng dẫn này kéo dài trong nhiều thời kỳ ngắn. Để giảm tiếng ồn ghi nhật ký, hãy sử dụng tfdocs.EpochDots mà chỉ cần in ra một . cho mỗi kỷ nguyên và một bộ số liệu đầy đủ cứ sau 100 kỷ nguyên.

Tiếp theo bao gồm callbacks.EarlyStopping để tránh thời gian đào tạo lâu và không cần thiết. Lưu ý rằng lệnh gọi lại này được đặt để giám sát val_binary_crossentropy , không phải val_loss . Sự khác biệt này sẽ quan trọng sau này.

Sử dụng callbacks.TensorBoard để tạo nhật ký TensorBoard cho khóa đào tạo.

def get_callbacks(name):
  return [
    tfdocs.modeling.EpochDots(),
    tf.keras.callbacks.EarlyStopping(monitor='val_binary_crossentropy', patience=200),
    tf.keras.callbacks.TensorBoard(logdir/name),
  ]

Tương tự như vậy mỗi mô hình sẽ sử dụng cùng một Model.compileModel.fit cài đặt:

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

Mô hình tí hon

Bắt đầu bằng cách đào tạo một người mẫu:

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

Bây giờ hãy kiểm tra xem mô hình đã hoạt động như thế nào:

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

Mô hình nhỏ

Để xem bạn có thể đánh bại hiệu suất của mô hình nhỏ hay không, hãy dần dần đào tạo một số mô hình lớn hơn.

Hãy thử hai lớp ẩn với 16 đơn vị mỗi lớp:

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

Mô hình trung bình

Bây giờ hãy thử 3 lớp ẩn với 64 đơn vị mỗi lớp:

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

Và đào tạo mô hình bằng cách sử dụng cùng một dữ liệu:

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

Mô hình lớn

Như một bài tập, bạn có thể tạo một mô hình thậm chí còn lớn hơn và xem nó bắt đầu quá mức nhanh như thế nào. Tiếp theo, hãy thêm vào điểm chuẩn này một mạng có dung lượng lớn hơn nhiều so với vấn đề sẽ đảm bảo:

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

Và, một lần nữa, đào tạo mô hình bằng cách sử dụng cùng một dữ liệu:

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

Lập kế hoạch đào tạo và đánh giá tổn thất

Các đường liền nét cho thấy mất mát trong quá trình huấn luyện và các đường đứt nét cho thấy mất xác thực (hãy nhớ: mất xác thực thấp hơn cho thấy một mô hình tốt hơn).

Trong khi xây dựng một mô hình lớn hơn mang lại cho nó nhiều sức mạnh hơn, nếu sức mạnh này không bị hạn chế bằng cách nào đó, nó có thể dễ dàng quá mức cho phép tập luyện.

Trong ví dụ này, thông thường, chỉ có mô hình "Tiny" quản lý để tránh trang bị quá mức hoàn toàn và mỗi mô hình lớn hơn trang bị dữ liệu nhanh hơn. Điều này trở nên nghiêm trọng đối với mô hình "large" đến mức bạn cần chuyển cốt truyện sang quy mô nhật ký để thực sự xem điều gì đang xảy ra.

Điều này rõ ràng nếu bạn vẽ và so sánh số liệu xác thực với số liệu đào tạo.

  • Đó là điều bình thường khi có một sự khác biệt nhỏ.
  • Nếu cả hai chỉ số đều di chuyển theo cùng một hướng, mọi thứ đều ổn.
  • Nếu chỉ số xác thực bắt đầu đình trệ trong khi chỉ số đào tạo tiếp tục được cải thiện, có thể bạn đã gần đến việc trang bị quá mức.
  • Nếu chỉ số xác thực đi sai hướng, thì rõ ràng là mô hình đang được trang bị quá mức.
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

Xem trong TensorBoard

Các mô hình này đều viết nhật ký TensorBoard trong quá trình đào tạo.

Mở trình xem TensorBoard được nhúng bên trong sổ ghi chép:


# Load the TensorBoard notebook extension
%load_ext tensorboard

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

Bạn có thể xem kết quả của lần chạy trước đó của sổ ghi chép này trên TensorBoard.dev .

TensorBoard.dev là một trải nghiệm được quản lý để lưu trữ, theo dõi và chia sẻ các thử nghiệm ML với mọi người.

Nó cũng được bao gồm trong một <iframe> để thuận tiện:

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

Nếu bạn muốn chia sẻ kết quả TensorBoard, bạn có thể tải nhật ký lên TensorBoard.dev bằng cách sao chép phần sau vào một ô mã.

tensorboard dev upload --logdir  {logdir}/sizes

Các chiến lược để ngăn chặn việc mặc quá nhiều

Trước khi đi vào nội dung của phần này, hãy sao chép nhật ký huấn luyện từ mô hình "Tiny" ở trên, để làm cơ sở so sánh.

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

Thêm quy định trọng lượng

Bạn có thể quen thuộc với nguyên lý Occam's Razor: đưa ra hai cách giải thích cho một điều gì đó, giải thích có nhiều khả năng đúng nhất là giải thích "đơn giản nhất", giải thích tạo ra ít giả định nhất. Điều này cũng áp dụng cho các mô hình được học bởi mạng nơ-ron: với một số dữ liệu huấn luyện và kiến ​​trúc mạng, có nhiều bộ giá trị trọng số (nhiều mô hình) có thể giải thích dữ liệu và các mô hình đơn giản ít có khả năng bị thừa hơn các mô hình phức tạp.

Một "mô hình đơn giản" trong ngữ cảnh này là một mô hình trong đó phân phối các giá trị tham số có ít entropy hơn (hoặc một mô hình có ít tham số hơn hoàn toàn, như chúng ta đã thấy trong phần trên). Do đó, một cách phổ biến để giảm thiểu việc trang bị quá mức là đặt các hạn chế về độ phức tạp của mạng bằng cách buộc các trọng số của nó chỉ nhận các giá trị nhỏ, điều này làm cho việc phân phối các giá trị trọng số "đều đặn" hơn. Điều này được gọi là "điều chỉnh trọng lượng", và nó được thực hiện bằng cách thêm vào chức năng tổn thất của mạng một chi phí liên quan đến việc có các trọng số lớn. Chi phí này có hai loại:

  • Chính quy hóa L1 , trong đó chi phí tăng thêm tỷ lệ với giá trị tuyệt đối của các hệ số trọng số (tức là với cái được gọi là "định mức L1" của các trọng số).

  • Chính quy hóa L2 , trong đó chi phí tăng thêm tỷ lệ với bình phương giá trị của các hệ số trọng số (nghĩa là với cái được gọi là "định mức L2" bình phương của các trọng số). Sự chính quy hóa L2 còn được gọi là sự phân rã trọng lượng trong ngữ cảnh của mạng nơ-ron. Đừng để cái tên khác khiến bạn nhầm lẫn: sự phân rã trọng lượng về mặt toán học giống hệt như sự chính quy L2.

Chính quy hóa L1 đẩy trọng số về phía chính xác bằng không, khuyến khích một mô hình thưa thớt. Chính quy hóa L2 sẽ phạt các tham số trọng số mà không làm cho chúng trở nên thưa thớt vì hình phạt về 0 đối với các trọng số nhỏ. một lý do tại sao L2 phổ biến hơn.

Trong tf.keras , điều chỉnh trọng số được thêm vào bằng cách chuyển các thể hiện của bộ điều chỉnh trọng số cho các lớp dưới dạng đối số từ khóa. Bây giờ chúng ta hãy thêm chính quy trọng lượng 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) có nghĩa là mọi hệ số trong ma trận trọng số của lớp sẽ thêm 0.001 * weight_coefficient_value**2 vào tổng tổn thất của mạng.

Đó là lý do tại sao chúng tôi đang theo dõi trực tiếp binary_crossentropy . Bởi vì nó không có thành phần chính quy hóa này trộn lẫn vào.

Vì vậy, cùng một mô hình "Large" với hình phạt chính quy L2 tốt hơn nhiều:

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

png

Như bạn có thể thấy, mô hình chính quy "L2" hiện cạnh tranh hơn nhiều với mô hình "Tiny" . Mô hình "L2" này cũng có khả năng chống overfitting tốt hơn nhiều so với mô hình "Large" mà nó dựa trên mặc dù có cùng số lượng thông số.

Thêm thông tin

Có hai điều quan trọng cần lưu ý về kiểu chính quy hóa này.

Đầu tiên: nếu bạn đang viết vòng lặp đào tạo của riêng mình, thì bạn cần đảm bảo yêu cầu mô hình về những tổn thất chính quy của nó.

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

Thứ hai: Việc triển khai này hoạt động bằng cách thêm các hình phạt trọng lượng vào sự mất mát của mô hình và sau đó áp dụng quy trình tối ưu hóa tiêu chuẩn.

Có một cách tiếp cận thứ hai mà thay vào đó chỉ chạy trình tối ưu hóa trên mức hao hụt thô và sau đó trong khi áp dụng bước được tính toán, trình tối ưu hóa cũng áp dụng một số giảm trọng lượng. "Sự giảm trọng lượng được tách rời" này được nhìn thấy trong các trình tối ưu hóa như optimizers.FTRLoptimizers.AdamW .

Thêm học sinh bỏ học

Bỏ học là một trong những kỹ thuật chính quy hóa hiệu quả nhất và được sử dụng phổ biến nhất cho mạng nơ-ron, được phát triển bởi Hinton và các sinh viên của ông tại Đại học Toronto.

Giải thích trực quan cho việc bỏ mạng là bởi vì các nút riêng lẻ trong mạng không thể dựa vào đầu ra của các nút khác, mỗi nút phải tự xuất ra các tính năng hữu ích.

Bỏ học, áp dụng cho một lớp, bao gồm "bỏ học" ngẫu nhiên (nghĩa là được đặt thành 0) một số tính năng đầu ra của lớp trong quá trình đào tạo. Giả sử một lớp nhất định thông thường sẽ trả về một vectơ [0,2, 0,5, 1,3, 0,8, 1,1] cho một mẫu đầu vào nhất định trong quá trình đào tạo; sau khi áp dụng loại bỏ, vectơ này sẽ có một vài mục không phân phối ngẫu nhiên, ví dụ: [0, 0.5, 1.3, 0, 1.1].

"Tỷ lệ bỏ học" là phần nhỏ của các đối tượng địa lý đang bị loại bỏ; nó thường được đặt từ 0,2 đến 0,5. Tại thời điểm kiểm tra, không có đơn vị nào bị loại bỏ, và thay vào đó, giá trị đầu ra của lớp được thu nhỏ theo hệ số bằng với tỷ lệ bỏ học, để cân bằng thực tế là nhiều đơn vị đang hoạt động hơn so với thời điểm đào tạo.

Trong tf.keras bạn có thể giới thiệu tính năng bỏ qua trong mạng thông qua lớp Bỏ qua, lớp này được áp dụng cho đầu ra của lớp ngay trước đó.

Hãy thêm hai lớp Dropout trong mạng của chúng tôi để xem chúng hoạt động như thế nào trong việc giảm trang bị quá mức:

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

Rõ ràng từ âm mưu này rằng cả hai cách tiếp cận chính quy hóa này đều cải thiện hành vi của mô hình "Large" . Nhưng điều này vẫn không đánh bại ngay cả đường cơ sở của "Tiny" .

Tiếp theo, hãy thử cả hai cùng nhau và xem liệu điều đó có tốt hơn không.

Kết hợp L2 + bỏ học

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

Mô hình này với sự chính quy hóa "Combined" rõ ràng là mô hình tốt nhất cho đến nay.

Xem trong TensorBoard

Các mô hình này cũng ghi lại nhật ký TensorBoard.

Để mở trình xem tensorboard được nhúng bên trong máy tính xách tay, hãy sao chép thông tin sau vào một ô mã:

%tensorboard --logdir {logdir}/regularizers

Bạn có thể xem kết quả của lần chạy trước đó của sổ ghi chép này trên TensorDoard.dev .

Nó cũng được bao gồm trong một <iframe> để thuận tiện:

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

Cái này đã được tải lên với:

tensorboard dev upload --logdir  {logdir}/regularizers

Kết luận

Tóm lại: đây là những cách phổ biến nhất để ngăn chặn việc trang bị quá mức trong mạng thần kinh:

  • Nhận thêm dữ liệu đào tạo.
  • Giảm dung lượng của mạng.
  • Thêm quy định trọng lượng.
  • Thêm học sinh bỏ học.

Hai cách tiếp cận quan trọng không được đề cập trong hướng dẫn này là:

  • tăng dữ liệu
  • bình thường hóa hàng loạt

Hãy nhớ rằng mỗi phương pháp có thể giúp ích cho riêng mình, nhưng thường xuyên kết hợp chúng có thể hiệu quả hơn.


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