ML Community Day คือวันที่ 9 พฤศจิกายน! ร่วมกับเราสำหรับการปรับปรุงจาก TensorFlow, JAX และอื่น ๆ เรียนรู้เพิ่มเติม

การถดถอยพื้นฐาน: ทำนายประสิทธิภาพการใช้เชื้อเพลิง

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

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

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

ตัวอย่างนี้ใช้ Keras API (เยี่ยมชม Keras บทเรียน และ คำแนะนำ ที่จะเรียนรู้เพิ่มเติม.)

# Use seaborn for pairplot.
pip install -q seaborn
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

# Make NumPy printouts easier to read.
np.set_printoptions(precision=3, suppress=True)
import tensorflow as tf

from tensorflow import keras
from tensorflow.keras import layers

print(tf.__version__)
2.6.0

ชุดข้อมูล MPG อัตโนมัติ

ชุดข้อมูลที่สามารถใช้ได้จาก UCI เครื่องเรียนรู้ Repository

รับข้อมูล

ขั้นแรกให้ดาวน์โหลดและนำเข้าชุดข้อมูลโดยใช้แพนด้า:

url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
                'Acceleration', 'Model Year', 'Origin']

raw_dataset = pd.read_csv(url, names=column_names,
                          na_values='?', comment='\t',
                          sep=' ', skipinitialspace=True)
dataset = raw_dataset.copy()
dataset.tail()

ทำความสะอาดข้อมูล

ชุดข้อมูลมีค่าที่ไม่รู้จักสองสามค่า:

dataset.isna().sum()
MPG             0
Cylinders       0
Displacement    0
Horsepower      6
Weight          0
Acceleration    0
Model Year      0
Origin          0
dtype: int64

วางแถวเหล่านั้นเพื่อให้บทแนะนำเบื้องต้นนี้เรียบง่าย:

dataset = dataset.dropna()

"Origin" คอลัมน์เด็ดขาดไม่ใช่ตัวเลข ดังนั้นขั้นตอนต่อไปคือการเข้ารหัสร้อนหนึ่งค่าในคอลัมน์ที่มี pd.get_dummies

dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, columns=['Origin'], prefix='', prefix_sep='')
dataset.tail()

แบ่งข้อมูลออกเป็นชุดฝึกและชุดทดสอบ

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

train_dataset = dataset.sample(frac=0.8, random_state=0)
test_dataset = dataset.drop(train_dataset.index)

ตรวจสอบข้อมูล

ทบทวนการแจกแจงร่วมของเสาสองสามคู่จากชุดการฝึก

แถวบนสุดแสดงให้เห็นว่าประสิทธิภาพการใช้เชื้อเพลิง (MPG) เป็นฟังก์ชันของพารามิเตอร์อื่นๆ ทั้งหมด แถวอื่น ๆ ระบุว่าเป็นหน้าที่ของกันและกัน

sns.pairplot(train_dataset[['MPG', 'Cylinders', 'Displacement', 'Weight']], diag_kind='kde')
<seaborn.axisgrid.PairGrid at 0x7fb1a5e66bd0>

png

ลองตรวจสอบสถิติโดยรวมด้วย โปรดทราบว่าคุณลักษณะแต่ละอย่างครอบคลุมช่วงที่แตกต่างกันมาก:

train_dataset.describe().transpose()

แยกคุณสมบัติออกจากป้ายกำกับ

แยกค่าเป้าหมาย—"ป้ายกำกับ"—ออกจากคุณสมบัติ ป้ายกำกับนี้เป็นค่าที่คุณจะฝึกให้โมเดลคาดการณ์

train_features = train_dataset.copy()
test_features = test_dataset.copy()

train_labels = train_features.pop('MPG')
test_labels = test_features.pop('MPG')

การทำให้เป็นมาตรฐาน

ในตารางสถิติ จะเห็นว่าช่วงของแต่ละฟีเจอร์แตกต่างกันอย่างไร:

train_dataset.describe().transpose()[['mean', 'std']]

แนวทางปฏิบัติที่ดีในการทำให้คุณสมบัติปกติที่ใช้มาตราส่วนและช่วงต่างกัน

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

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

ชั้น Normalization

tf.keras.layers.Normalization เป็นวิธีที่สะอาดและเรียบง่ายในการเพิ่มคุณลักษณะการฟื้นฟูในรูปแบบของคุณ

ขั้นตอนแรกคือการสร้างเลเยอร์:

normalizer = tf.keras.layers.Normalization(axis=-1)

จากนั้นพอดีกับรัฐของชั้น preprocessing ข้อมูลโดยการโทรที่ Normalization.adapt :

normalizer.adapt(np.array(train_features))

คำนวณค่าเฉลี่ยและความแปรปรวน และเก็บไว้ในเลเยอร์:

print(normalizer.mean.numpy())
[[   5.478  195.318  104.869 2990.252   15.559   75.898    0.178    0.197
     0.624]]

เมื่อเลเยอร์ถูกเรียก มันจะส่งคืนข้อมูลที่ป้อน โดยแต่ละฟีเจอร์จะถูกทำให้เป็นมาตรฐานโดยอิสระ:

first = np.array(train_features[:1])

with np.printoptions(precision=2, suppress=True):
  print('First example:', first)
  print()
  print('Normalized:', normalizer(first).numpy())
First example: [[   4.    90.    75.  2125.    14.5   74.     0.     0.     1. ]]

Normalized: [[-0.87 -1.01 -0.79 -1.03 -0.38 -0.52 -0.47 -0.5   0.78]]

การถดถอยเชิงเส้น

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

การถดถอยเชิงเส้นกับตัวแปรเดียว

เริ่มต้นด้วยการถดถอยเชิงเส้นเดียวตัวแปรในการทำนาย 'MPG' จาก 'Horsepower'

การฝึกอบรมรุ่นที่มี tf.keras มักจะเริ่มต้นด้วยการกำหนดรูปแบบสถาปัตยกรรม ใช้ tf.keras.Sequential รุ่นซึ่ง แสดงให้เห็นถึงลำดับขั้นตอน

มีสองขั้นตอนในแบบจำลองการถดถอยเชิงเส้นแบบตัวแปรเดียวของคุณ:

  • ปกติ 'Horsepower' ป้อนข้อมูลมีการใช้ tf.keras.layers.Normalization ชั้น preprocessing
  • ใช้การแปลงเชิงเส้น ($ การ y = mx + B $) ในการผลิตการส่งออกโดยใช้ 1 ชั้นเชิงเส้น ( tf.keras.layers.Dense )

จำนวนของปัจจัยการผลิตสามารถตั้งค่าโดย input_shape โต้แย้งหรือรุ่นโดยอัตโนมัติเมื่อมีการเรียกใช้เป็นครั้งแรก

ขั้นแรกให้สร้างอาร์เรย์ NumPy ทำจาก 'Horsepower' คุณสมบัติ จากนั้นยกตัวอย่าง tf.keras.layers.Normalization และพอดีกับรัฐในการ horsepower ข้อมูล:

horsepower = np.array(train_features['Horsepower'])

horsepower_normalizer = layers.Normalization(input_shape=[1,], axis=None)
horsepower_normalizer.adapt(horsepower)

สร้างโมเดล Keras Sequential:

horsepower_model = tf.keras.Sequential([
    horsepower_normalizer,
    layers.Dense(units=1)
])

horsepower_model.summary()
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
normalization_1 (Normalizati (None, 1)                 3         
_________________________________________________________________
dense (Dense)                (None, 1)                 2         
=================================================================
Total params: 5
Trainable params: 2
Non-trainable params: 3
_________________________________________________________________

รุ่นนี้จะทำนาย 'MPG' จาก 'Horsepower'

เรียกใช้โมเดลที่ไม่ได้รับการฝึกฝนในค่า 'แรงม้า' 10 ค่าแรก การส่งออกจะไม่ดี แต่แจ้งให้ทราบว่ามันมีรูปร่างที่คาดหวังของ (10, 1) :

horsepower_model.predict(horsepower[:10])
array([[ 1.208],
       [ 0.682],
       [-2.229],
       [ 1.693],
       [ 1.531],
       [ 0.601],
       [ 1.814],
       [ 1.531],
       [ 0.399],
       [ 0.682]], dtype=float32)

เมื่อรูปแบบเป็นตัวกำหนดค่าขั้นตอนการฝึกอบรมโดยใช้ Keras Model.compile วิธี ข้อโต้แย้งที่สำคัญที่สุดที่จะรวบรวมเป็น loss และ optimizer ตั้งแต่เหล่านี้กำหนดสิ่งที่จะได้รับการปรับให้เหมาะสม ( mean_absolute_error ) และวิธีการ (โดยใช้ tf.keras.optimizers.Adam )

horsepower_model.compile(
    optimizer=tf.optimizers.Adam(learning_rate=0.1),
    loss='mean_absolute_error')

มีการกำหนดค่าการฝึกอบรมการกำหนดค่าใช้ Keras Model.fit ในการดำเนินการฝึกอบรมสำหรับ 100 epochs:

%%time
history = horsepower_model.fit(
    train_features['Horsepower'],
    train_labels,
    epochs=100,
    # Suppress logging.
    verbose=0,
    # Calculate validation results on 20% of the training data.
    validation_split = 0.2)
CPU times: user 3.97 s, sys: 765 ms, total: 4.74 s
Wall time: 3.02 s

เห็นภาพความคืบหน้าการฝึกอบรมรุ่นที่ใช้สถิติที่เก็บไว้ใน history วัตถุ:

hist = pd.DataFrame(history.history)
hist['epoch'] = history.epoch
hist.tail()
def plot_loss(history):
  plt.plot(history.history['loss'], label='loss')
  plt.plot(history.history['val_loss'], label='val_loss')
  plt.ylim([0, 10])
  plt.xlabel('Epoch')
  plt.ylabel('Error [MPG]')
  plt.legend()
  plt.grid(True)
plot_loss(history)

png

เก็บผลในชุดทดสอบในภายหลัง:

test_results = {}

test_results['horsepower_model'] = horsepower_model.evaluate(
    test_features['Horsepower'],
    test_labels, verbose=0)

เนื่องจากนี่เป็นการถดถอยตัวแปรเดียว จึงง่ายต่อการดูการคาดการณ์ของแบบจำลองว่าเป็นฟังก์ชันของอินพุต:

x = tf.linspace(0.0, 250, 251)
y = horsepower_model.predict(x)
def plot_horsepower(x, y):
  plt.scatter(train_features['Horsepower'], train_labels, label='Data')
  plt.plot(x, y, color='k', label='Predictions')
  plt.xlabel('Horsepower')
  plt.ylabel('MPG')
  plt.legend()
plot_horsepower(x,y)

png

การถดถอยเชิงเส้นที่มีหลายอินพุต

คุณสามารถใช้การตั้งค่าที่เกือบจะเหมือนกันเพื่อคาดการณ์โดยอิงจากอินพุตหลายตัว โมเดลนี้ยังคงทำเหมือนเดิม $y = mx+b$ ยกเว้นว่า $m$ เป็นเมทริกซ์และ $b$ เป็นเวกเตอร์

สร้างสองขั้นตอนรูปแบบ Keras ต่อเนื่องอีกครั้งกับชั้นแรกเป็น normalizer ( tf.keras.layers.Normalization(axis=-1) ) คุณกำหนดไว้ก่อนหน้านี้และปรับให้เข้ากับชุดข้อมูลทั้งหมด:

linear_model = tf.keras.Sequential([
    normalizer,
    layers.Dense(units=1)
])

เมื่อคุณเรียก Model.predict ในชุดของปัจจัยการผลิตจะผลิต units=1 ผลสำหรับแต่ละตัวอย่างเช่น:

linear_model.predict(train_features[:10])
array([[-0.026],
       [ 1.078],
       [-0.645],
       [ 0.771],
       [ 1.044],
       [ 1.031],
       [ 1.247],
       [ 1.5  ],
       [ 0.614],
       [ 0.496]], dtype=float32)

เมื่อคุณเรียกรูปแบบการฝึกอบรมน้ำหนักของมันจะถูกสร้างขึ้นมาตรวจสอบว่า kernel น้ำหนัก (ราคา $ ม $ $ ในการ y = mx + B $) มีรูปทรงของ (9, 1) :

linear_model.layers[1].kernel
<tf.Variable 'dense_1/kernel:0' shape=(9, 1) dtype=float32, numpy=
array([[ 0.426],
       [-0.703],
       [-0.434],
       [ 0.546],
       [ 0.643],
       [ 0.328],
       [-0.515],
       [-0.215],
       [-0.101]], dtype=float32)>

กำหนดค่ารุ่นที่มี Keras Model.compile และรถไฟ Model.fit 100 epochs:

linear_model.compile(
    optimizer=tf.optimizers.Adam(learning_rate=0.1),
    loss='mean_absolute_error')
%%time
history = linear_model.fit(
    train_features,
    train_labels,
    epochs=100,
    # Suppress logging.
    verbose=0,
    # Calculate validation results on 20% of the training data.
    validation_split = 0.2)
CPU times: user 3.97 s, sys: 641 ms, total: 4.61 s
Wall time: 2.92 s

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

plot_loss(history)

png

เก็บผลในชุดทดสอบในภายหลัง:

test_results['linear_model'] = linear_model.evaluate(
    test_features, test_labels, verbose=0)

การถดถอยด้วยโครงข่ายประสาทลึก (DNN)

ในส่วนก่อนหน้านี้ คุณใช้โมเดลเชิงเส้นสองแบบสำหรับอินพุตเดี่ยวและหลายอินพุต

ที่นี่ คุณจะใช้โมเดล DNN แบบอินพุตเดียวและหลายอินพุต

โดยพื้นฐานแล้วโค้ดจะเหมือนกัน ยกเว้นโมเดลถูกขยายเพื่อรวมเลเยอร์ที่ไม่ใช่เชิงเส้น "ที่ซ่อนอยู่" บางส่วน ชื่อ "ซ่อน" ในที่นี้หมายความว่าไม่ได้เชื่อมต่อโดยตรงกับอินพุตหรือเอาต์พุต

โมเดลเหล่านี้จะมีเลเยอร์มากกว่าโมเดลเชิงเส้นเล็กน้อย:

  • ชั้นฟื้นฟูเป็นก่อน (กับ horsepower_normalizer สำหรับรูปแบบเดียวเข้าและ normalizer สำหรับรูปแบบหลายอินพุต)
  • สองซ่อนไม่ใช่เชิงเส้น Dense ชั้นกับ Relu ( relu ) ไม่เป็นเชิงเส้นเปิดใช้งานฟังก์ชั่น
  • เชิงเส้น Dense ชั้นเดียวเอาท์พุท

ทั้งสองรุ่นจะใช้ขั้นตอนการฝึกอบรมเดียวกันดังนั้น compile วิธีการจะรวมอยู่ใน build_and_compile_model ฟังก์ชั่นดังต่อไปนี้

def build_and_compile_model(norm):
  model = keras.Sequential([
      norm,
      layers.Dense(64, activation='relu'),
      layers.Dense(64, activation='relu'),
      layers.Dense(1)
  ])

  model.compile(loss='mean_absolute_error',
                optimizer=tf.keras.optimizers.Adam(0.001))
  return model

การถดถอยโดยใช้ DNN และอินพุตเดียว

สร้างรูปแบบ DNN มีเพียง 'Horsepower' เป็น input และ horsepower_normalizer (ที่กำหนดไว้ก่อนหน้านี้) เป็นชั้นฟื้นฟู:

dnn_horsepower_model = build_and_compile_model(horsepower_normalizer)

โมเดลนี้มีพารามิเตอร์ที่ฝึกได้ค่อนข้างน้อยกว่าโมเดลเชิงเส้น:

dnn_horsepower_model.summary()
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
normalization_1 (Normalizati (None, 1)                 3         
_________________________________________________________________
dense_2 (Dense)              (None, 64)                128       
_________________________________________________________________
dense_3 (Dense)              (None, 64)                4160      
_________________________________________________________________
dense_4 (Dense)              (None, 1)                 65        
=================================================================
Total params: 4,356
Trainable params: 4,353
Non-trainable params: 3
_________________________________________________________________

การฝึกอบรมรุ่นที่มี Keras Model.fit :

%%time
history = dnn_horsepower_model.fit(
    train_features['Horsepower'],
    train_labels,
    validation_split=0.2,
    verbose=0, epochs=100)
CPU times: user 4.38 s, sys: 734 ms, total: 5.12 s
Wall time: 3.37 s

รูปแบบนี้จะดีกว่าเล็กน้อยกว่าเดียวป้อนข้อมูลเชิงเส้น horsepower_model :

plot_loss(history)

png

หากคุณวางแผนการคาดการณ์เป็นหน้าที่ของ 'Horsepower' คุณควรแจ้งให้ทราบว่ารุ่นนี้ใช้ประโยชน์จากการไม่เป็นเชิงเส้นที่มีให้โดยชั้นที่ซ่อนอยู่:

x = tf.linspace(0.0, 250, 251)
y = dnn_horsepower_model.predict(x)
plot_horsepower(x, y)

png

เก็บผลในชุดทดสอบในภายหลัง:

test_results['dnn_horsepower_model'] = dnn_horsepower_model.evaluate(
    test_features['Horsepower'], test_labels,
    verbose=0)

การถดถอยโดยใช้ DNN และอินพุตหลายตัว

ทำซ้ำขั้นตอนก่อนหน้าโดยใช้อินพุตทั้งหมด ประสิทธิภาพของโมเดลดีขึ้นเล็กน้อยในชุดข้อมูลการตรวจสอบ

dnn_model = build_and_compile_model(normalizer)
dnn_model.summary()
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
normalization (Normalization (None, 9)                 19        
_________________________________________________________________
dense_5 (Dense)              (None, 64)                640       
_________________________________________________________________
dense_6 (Dense)              (None, 64)                4160      
_________________________________________________________________
dense_7 (Dense)              (None, 1)                 65        
=================================================================
Total params: 4,884
Trainable params: 4,865
Non-trainable params: 19
_________________________________________________________________
%%time
history = dnn_model.fit(
    train_features,
    train_labels,
    validation_split=0.2,
    verbose=0, epochs=100)
CPU times: user 4.15 s, sys: 711 ms, total: 4.86 s
Wall time: 3.16 s
plot_loss(history)

png

เก็บผลในชุดทดสอบ:

test_results['dnn_model'] = dnn_model.evaluate(test_features, test_labels, verbose=0)

ประสิทธิภาพ

เนื่องจากทุกรุ่นได้รับการฝึกอบรม คุณจึงตรวจสอบประสิทธิภาพของชุดทดสอบได้:

pd.DataFrame(test_results, index=['Mean absolute error [MPG]']).T

ผลลัพธ์เหล่านี้ตรงกับข้อผิดพลาดในการตรวจสอบที่สังเกตได้ระหว่างการฝึก

ทำนายฝัน

ขณะนี้คุณสามารถทำให้การคาดการณ์กับ dnn_model ในชุดทดสอบโดยใช้ Keras Model.predict และตรวจทานการสูญเสีย:

test_predictions = dnn_model.predict(test_features).flatten()

a = plt.axes(aspect='equal')
plt.scatter(test_labels, test_predictions)
plt.xlabel('True Values [MPG]')
plt.ylabel('Predictions [MPG]')
lims = [0, 50]
plt.xlim(lims)
plt.ylim(lims)
_ = plt.plot(lims, lims)

png

ดูเหมือนว่าโมเดลคาดการณ์ได้ดีพอสมควร

ตอนนี้ ตรวจสอบการกระจายข้อผิดพลาด:

error = test_predictions - test_labels
plt.hist(error, bins=25)
plt.xlabel('Prediction Error [MPG]')
_ = plt.ylabel('Count')

png

หากคุณมีความสุขกับรูปแบบที่เก็บไว้เพื่อใช้ในภายหลังกับ Model.save :

dnn_model.save('dnn_model')
2021-10-13 01:25:59.246092: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: dnn_model/assets

หากคุณรีโหลดโมเดลใหม่ มันจะให้ผลลัพธ์ที่เหมือนกัน:

reloaded = tf.keras.models.load_model('dnn_model')

test_results['reloaded'] = reloaded.evaluate(
    test_features, test_labels, verbose=0)
pd.DataFrame(test_results, index=['Mean absolute error [MPG]']).T

บทสรุป

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

  • คลาดเคลื่อนกำลังสองเฉลี่ย (MSE) ( tf.losses.MeanMeanSquaredError ) และความผิดพลาดแน่นอนค่าเฉลี่ย (MAE) ( tf.losses.MeanAbsoluteError ) เป็นฟังก์ชั่นการสูญเสียทั่วไปที่ใช้สำหรับการแก้ไขปัญหาการถดถอย MAE มีความไวต่อค่าผิดปกติน้อยกว่า ฟังก์ชันการสูญเสียต่างๆ ใช้สำหรับปัญหาการจำแนกประเภท
  • ในทำนองเดียวกัน ตัวชี้วัดการประเมินที่ใช้สำหรับการถดถอยแตกต่างจากการจัดประเภท
  • เมื่อคุณลักษณะข้อมูลป้อนที่เป็นตัวเลขมีค่าที่มีช่วงต่างกัน คุณลักษณะแต่ละอย่างควรได้รับการปรับขนาดอย่างอิสระเพื่อให้อยู่ในช่วงเดียวกัน
  • Overfitting เป็นปัญหาทั่วไปสำหรับโมเดล DNN แม้ว่าจะไม่ใช่ปัญหาสำหรับบทช่วยสอนนี้ เยี่ยมชม Overfit และ underfit กวดวิชาสำหรับความช่วยเหลือเพิ่มเติมกับเรื่องนี้
# MIT License
#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.