Google I/O สำเร็จแล้ว! ติดตามเซสชัน TensorFlow ดูเซสชัน

เทนเซอร์โฟลว์ที่มีประสิทธิภาพ 2

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

ภาพรวม

คู่มือนี้แสดงรายการแนวทางปฏิบัติที่ดีที่สุดสำหรับการเขียนโค้ดโดยใช้ TensorFlow 2 (TF2) ซึ่งเขียนขึ้นสำหรับผู้ใช้ที่เพิ่งเปลี่ยนจาก TensorFlow 1 (TF1) อ้างถึง ส่วนการย้ายข้อมูลของคู่มือ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการย้ายรหัส TF1 ของคุณไปยัง TF2

ติดตั้ง

นำเข้า TensorFlow และการอ้างอิงอื่นๆ สำหรับตัวอย่างในคู่มือนี้

import tensorflow as tf
import tensorflow_datasets as tfds

คำแนะนำสำหรับ TensorFlow 2 . ที่เป็นสำนวน

รีแฟกเตอร์โค้ดของคุณเป็นโมดูลที่เล็กลง

แนวปฏิบัติที่ดีคือการจัดโครงสร้างโค้ดของคุณใหม่ให้เป็นฟังก์ชันขนาดเล็กลงซึ่งเรียกว่าตามความจำเป็น เพื่อประสิทธิภาพที่ดีที่สุด คุณควรพยายามตกแต่งบล็อคการคำนวณที่ใหญ่ที่สุดที่คุณสามารถทำได้ใน tf.function (โปรดทราบว่าฟังก์ชัน python ที่ซ้อนกันที่เรียกโดย tf.function ไม่จำเป็นต้องมีการตกแต่งแยกต่างหาก เว้นแต่คุณต้องการใช้ jit_compile การตั้งค่าสำหรับ tf.function ) ขึ้นอยู่กับกรณีการใช้งานของคุณ นี่อาจเป็นขั้นตอนการฝึกอบรมหลายขั้นตอนหรือแม้แต่รอบการฝึกทั้งหมดของคุณ สำหรับกรณีการใช้งานการอนุมาน อาจเป็นการส่งต่อรูปแบบเดียว

ปรับอัตราการเรียนรู้เริ่มต้นสำหรับบาง tf.keras.optimizer s

เครื่องมือเพิ่มประสิทธิภาพ Keras บางตัวมีอัตราการเรียนรู้ที่แตกต่างกันใน TF2 หากคุณเห็นการเปลี่ยนแปลงในลักษณะการบรรจบกันสำหรับโมเดลของคุณ ให้ตรวจสอบอัตราการเรียนรู้เริ่มต้น

จะไม่มีการเปลี่ยนแปลงสำหรับ optimizers.SGD SGD , เครื่องมือเพิ่ม optimizers.Adam .Adam หรือ optimizers.RMSprop

อัตราการเรียนรู้เริ่มต้นต่อไปนี้มีการเปลี่ยนแปลง:

ใช้ tf.Module s และ Keras เพื่อจัดการตัวแปร

tf.Module s และ tf.keras.layers.Layer นำเสนอ variables ที่สะดวกและคุณสมบัติ trainable_variables ซึ่งจะรวบรวมตัวแปรตามแบบเรียกซ้ำทั้งหมด ทำให้ง่ายต่อการจัดการตัวแปรภายในเครื่องที่ถูกใช้

เลเยอร์/โมเดล Keras สืบทอดจาก tf.train.Checkpointable และรวมเข้ากับ @tf.function ซึ่งทำให้สามารถเช็คพอยต์โดยตรงหรือส่งออก SavedModels จากวัตถุ Keras คุณไม่จำเป็นต้องใช้ Model.fit API ของ Model.fit เพื่อใช้ประโยชน์จากการผสานรวมเหล่านี้

อ่านหัวข้อเกี่ยวกับ การถ่ายโอนการเรียนรู้และการปรับแต่งอย่างละเอียด ในคู่มือ Keras เพื่อเรียนรู้วิธีรวบรวมชุดย่อยของตัวแปรที่เกี่ยวข้องโดยใช้ Keras

รวม tf.data.Dataset s และ tf.function

แพ็คเกจ TensorFlow Datasets ( tfds ) มียูทิลิตี้สำหรับการโหลดชุดข้อมูลที่กำหนดไว้ล่วงหน้าเป็น tf.data.Dataset สำหรับตัวอย่างนี้ คุณสามารถโหลดชุดข้อมูล MNIST โดยใช้ tfds :

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']

จากนั้นเตรียมข้อมูลสำหรับการฝึกอบรม:

  • ปรับขนาดภาพแต่ละภาพอีกครั้ง
  • สับเปลี่ยนลำดับของตัวอย่าง
  • รวบรวมชุดรูปภาพและป้ายกำกับ
BUFFER_SIZE = 10 # Use a much larger value for real code
BATCH_SIZE = 64
NUM_EPOCHS = 5


def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label

เพื่อให้ตัวอย่างสั้น ให้ตัดชุดข้อมูลเพื่อส่งคืน 5 แบตช์เท่านั้น:

train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)

STEPS_PER_EPOCH = 5

train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)
image_batch, label_batch = next(iter(train_data))
2021-12-08 17:15:01.637157: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

ใช้การวนซ้ำ Python ปกติเพื่อวนซ้ำข้อมูลการฝึกที่เหมาะสมกับหน่วยความจำ มิฉะนั้น tf.data.Dataset เป็นวิธีที่ดีที่สุดในการสตรีมข้อมูลการฝึกจากดิสก์ ชุดข้อมูลเป็นแบบ iterables (ไม่ใช่ iterators) และทำงานเหมือนกับ Python iterables อื่น ๆ ในการดำเนินการอย่างกระตือรือร้น คุณสามารถใช้คุณลักษณะการดึงข้อมูลล่วงหน้า/การสตรีมชุดข้อมูล async ได้อย่างเต็มที่โดยใส่โค้ดของคุณใน tf.function ซึ่งจะแทนที่ Python iteration ด้วยการดำเนินการกราฟที่เทียบเท่ากันโดยใช้ AutoGraph

@tf.function
def train(model, dataset, optimizer):
  for x, y in dataset:
    with tf.GradientTape() as tape:
      # training=True is only needed if there are layers with different
      # behavior during training versus inference (e.g. Dropout).
      prediction = model(x, training=True)
      loss = loss_fn(prediction, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

หากคุณใช้ Keras Model.fit API คุณจะไม่ต้องกังวลกับการวนซ้ำชุดข้อมูล

model.compile(optimizer=optimizer, loss=loss_fn)
model.fit(dataset)

ใช้ลูปการฝึกของ Keras

หากคุณไม่ต้องการการควบคุมระดับต่ำของกระบวนการฝึกของคุณ ขอแนะนำให้ใช้วิธี fit ในตัว evaluate และ predict ของ Keras เมธอดเหล่านี้จัดเตรียมอินเทอร์เฟซที่เหมือนกันเพื่อฝึกโมเดลโดยไม่คำนึงถึงการใช้งาน (ตามลำดับ ฟังก์ชัน หรือคลาสย่อย)

ข้อดีของวิธีการเหล่านี้ ได้แก่ :

  • พวกเขายอมรับอาร์เรย์ Numpy เครื่องกำเนิด Python และ tf.data.Datasets
  • พวกเขาใช้การทำให้เป็นมาตรฐานและการสูญเสียการเปิดใช้งานโดยอัตโนมัติ
  • รองรับ tf.distribute โดยที่รหัสการฝึกยังคงเหมือนเดิม โดยไม่คำนึงถึงการกำหนดค่าฮาร์ดแวร์
  • พวกเขาสนับสนุน callables โดยพลการเป็นการสูญเสียและตัวชี้วัด
  • รองรับการโทรกลับเช่น tf.keras.callbacks.TensorBoard และการโทรกลับแบบกำหนดเอง
  • พวกมันมีประสิทธิภาพ โดยอัตโนมัติโดยใช้กราฟ TensorFlow

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

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)

print("Loss {}, Accuracy {}".format(loss, acc))
Epoch 1/5
5/5 [==============================] - 9s 7ms/step - loss: 1.5762 - accuracy: 0.4938
Epoch 2/5
2021-12-08 17:15:11.145429: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 6ms/step - loss: 0.5087 - accuracy: 0.8969
Epoch 3/5
2021-12-08 17:15:11.559374: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 2s 5ms/step - loss: 0.3348 - accuracy: 0.9469
Epoch 4/5
2021-12-08 17:15:13.860407: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 5ms/step - loss: 0.2445 - accuracy: 0.9688
Epoch 5/5
2021-12-08 17:15:14.269850: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 6ms/step - loss: 0.2006 - accuracy: 0.9719
2021-12-08 17:15:14.717552: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 1s 4ms/step - loss: 1.4553 - accuracy: 0.5781
Loss 1.4552843570709229, Accuracy 0.578125
2021-12-08 17:15:15.862684: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

ปรับแต่งการฝึกอบรมและเขียนลูปของคุณเอง

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

คุณยังสามารถใช้งานหลายอย่างเป็น tf.keras.callbacks.Callback

วิธีนี้มีข้อดีหลายประการที่ กล่าวถึงก่อนหน้านี้ แต่ให้คุณควบคุมขั้นของรถไฟและแม้แต่วงรอบนอกได้

มีสามขั้นตอนในการวนรอบการฝึกมาตรฐาน:

  1. วนซ้ำบนตัวสร้าง Python หรือ tf.data.Dataset เพื่อรับกลุ่มตัวอย่าง
  2. ใช้ tf.GradientTape เพื่อรวบรวมการไล่ระดับสี
  3. ใช้ tf.keras.optimizers ตัวใดตัวหนึ่งเพื่อใช้การอัพเดตน้ำหนักกับตัวแปรของโมเดล

จดจำ:

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

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

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

for epoch in range(NUM_EPOCHS):
  for inputs, labels in train_data:
    train_step(inputs, labels)
  print("Finished epoch", epoch)
2021-12-08 17:15:16.714849: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 0
2021-12-08 17:15:17.097043: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 1
2021-12-08 17:15:17.502480: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 2
2021-12-08 17:15:17.873701: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 3
Finished epoch 4
2021-12-08 17:15:18.344196: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

ใช้ประโยชน์จาก tf.function ด้วย Python control flow

tf.function มีวิธีการแปลงโฟลว์การควบคุมที่ขึ้นกับข้อมูลให้เทียบเท่ากับโหมดกราฟ เช่น tf.cond และ tf.while_loop

ตำแหน่งทั่วไปหนึ่งที่ซึ่งโฟลว์การควบคุมที่ขึ้นกับข้อมูลปรากฏขึ้นอยู่ในแบบจำลองลำดับ tf.keras.layers.RNN ล้อมเซลล์ RNN ไว้ ทำให้คุณสามารถคลายการเกิดซ้ำแบบสแตติกหรือไดนามิก ตัวอย่างเช่น คุณสามารถใช้ไดนามิก unroll ใหม่ได้ดังนี้

class DynamicRNN(tf.keras.Model):

  def __init__(self, rnn_cell):
    super(DynamicRNN, self).__init__(self)
    self.cell = rnn_cell

  @tf.function(input_signature=[tf.TensorSpec(dtype=tf.float32, shape=[None, None, 3])])
  def call(self, input_data):

    # [batch, time, features] -> [time, batch, features]
    input_data = tf.transpose(input_data, [1, 0, 2])
    timesteps =  tf.shape(input_data)[0]
    batch_size = tf.shape(input_data)[1]
    outputs = tf.TensorArray(tf.float32, timesteps)
    state = self.cell.get_initial_state(batch_size = batch_size, dtype=tf.float32)
    for i in tf.range(timesteps):
      output, state = self.cell(input_data[i], state)
      outputs = outputs.write(i, output)
    return tf.transpose(outputs.stack(), [1, 0, 2]), state
lstm_cell = tf.keras.layers.LSTMCell(units = 13)

my_rnn = DynamicRNN(lstm_cell)
outputs, state = my_rnn(tf.random.normal(shape=[10,20,3]))
print(outputs.shape)
(10, 20, 13)

อ่าน คู่มือ tf.function สำหรับข้อมูลเพิ่มเติม

เมตริกและการขาดทุนรูปแบบใหม่

เมตริกและความสูญเสียเป็นทั้งวัตถุที่ทำงานอย่างกระตือรือร้นและใน tf.function s

วัตถุที่สูญเสียสามารถเรียกได้และคาดหวัง ( y_true , y_pred ) เป็นอาร์กิวเมนต์:

cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
4.01815

ใช้เมตริกเพื่อรวบรวมและแสดงข้อมูล

คุณสามารถใช้ tf.metrics เพื่อรวบรวมข้อมูลและ tf.summary เพื่อบันทึกสรุปและเปลี่ยนเส้นทางไปยังตัวเขียนโดยใช้ตัวจัดการบริบท สรุปจะถูกส่งตรงไปยังผู้เขียน ซึ่งหมายความว่าคุณต้องระบุค่า step ที่ callsite

summary_writer = tf.summary.create_file_writer('/tmp/summaries')
with summary_writer.as_default():
  tf.summary.scalar('loss', 0.1, step=42)

ใช้ tf.metrics เพื่อรวบรวมข้อมูลก่อนที่จะบันทึกเป็นข้อมูลสรุป เมตริกเป็นแบบเก็บสถานะ พวกมันสะสมค่าและส่งคืนผลลัพธ์สะสมเมื่อคุณเรียกใช้เมธอด result (เช่น Mean.result ) ล้างค่าสะสมด้วย Model.reset_states

def train(model, optimizer, dataset, log_freq=10):
  avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
  for images, labels in dataset:
    loss = train_step(model, optimizer, images, labels)
    avg_loss.update_state(loss)
    if tf.equal(optimizer.iterations % log_freq, 0):
      tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations)
      avg_loss.reset_states()

def test(model, test_x, test_y, step_num):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  loss = loss_fn(model(test_x, training=False), test_y)
  tf.summary.scalar('loss', loss, step=step_num)

train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train')
test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test')

with train_summary_writer.as_default():
  train(model, optimizer, dataset)

with test_summary_writer.as_default():
  test(model, test_x, test_y, optimizer.iterations)

เห็นภาพสรุปที่สร้างขึ้นโดยชี้ TensorBoard ไปที่ไดเร็กทอรีบันทึกสรุป:

tensorboard --logdir /tmp/summaries

ใช้ tf.summary API เพื่อเขียนข้อมูลสรุปสำหรับการแสดงภาพใน TensorBoard สำหรับข้อมูลเพิ่มเติม อ่าน คู่มือ tf.summary

# Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  # Update the metrics
  loss_metric.update_state(total_loss)
  accuracy_metric.update_state(labels, predictions)


for epoch in range(NUM_EPOCHS):
  # Reset the metrics
  loss_metric.reset_states()
  accuracy_metric.reset_states()

  for inputs, labels in train_data:
    train_step(inputs, labels)
  # Get the metric results
  mean_loss=loss_metric.result()
  mean_accuracy = accuracy_metric.result()

  print('Epoch: ', epoch)
  print('  loss:     {:.3f}'.format(mean_loss))
  print('  accuracy: {:.3f}'.format(mean_accuracy))
2021-12-08 17:15:19.339736: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  0
  loss:     0.142
  accuracy: 0.991
2021-12-08 17:15:19.781743: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  1
  loss:     0.125
  accuracy: 0.997
2021-12-08 17:15:20.219033: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  2
  loss:     0.110
  accuracy: 0.997
2021-12-08 17:15:20.598085: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  3
  loss:     0.099
  accuracy: 0.997
Epoch:  4
  loss:     0.085
  accuracy: 1.000
2021-12-08 17:15:20.981787: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
ตัวยึดตำแหน่ง22

ชื่อเมตริก Keras

โมเดล Keras มีความสอดคล้องกันเกี่ยวกับการจัดการชื่อเมตริก เมื่อคุณส่งสตริงในรายการของตัวชี้วัด สตริง ที่แน่นอน นั้นจะถูกใช้เป็น name ของตัวชี้วัด ชื่อเหล่านี้จะมองเห็นได้ในออบเจ็กต์ประวัติที่ส่งคืนโดย model.fit และในบันทึกที่ส่งไปยัง keras.callbacks ถูกตั้งค่าเป็นสตริงที่คุณส่งผ่านในรายการเมทริก

model.compile(
    optimizer = tf.keras.optimizers.Adam(0.001),
    loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)
5/5 [==============================] - 1s 5ms/step - loss: 0.0963 - acc: 0.9969 - accuracy: 0.9969 - my_accuracy: 0.9969
2021-12-08 17:15:21.942940: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
history.history.keys()
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

แก้จุดบกพร่อง

ใช้การดำเนินการอย่างกระตือรือร้นเพื่อรันโค้ดของคุณทีละขั้นตอนเพื่อตรวจสอบรูปร่าง ประเภทข้อมูล และค่า API บางอย่าง เช่น tf.function , tf.keras ฯลฯ ได้รับการออกแบบมาเพื่อใช้การประมวลผลกราฟ เพื่อประสิทธิภาพและการพกพา เมื่อทำการดีบั๊ก ให้ใช้ tf.config.run_functions_eagerly(True) เพื่อใช้การดำเนินการอย่างกระตือรือร้นภายในโค้ดนี้

ตัวอย่างเช่น:

@tf.function
def f(x):
  if x > 0:
    import pdb
    pdb.set_trace()
    x = x + 1
  return x

tf.config.run_functions_eagerly(True)
f(tf.constant(1))
>>> f()
-> x = x + 1
(Pdb) l
  6     @tf.function
  7     def f(x):
  8       if x > 0:
  9         import pdb
 10         pdb.set_trace()
 11  ->     x = x + 1
 12       return x
 13
 14     tf.config.run_functions_eagerly(True)
 15     f(tf.constant(1))
[EOF]

สิ่งนี้ยังใช้งานได้ในโมเดล Keras และ API อื่น ๆ ที่รองรับการดำเนินการอย่างกระตือรือร้น:

class CustomModel(tf.keras.models.Model):

  @tf.function
  def call(self, input_data):
    if tf.reduce_mean(input_data) > 0:
      return input_data
    else:
      import pdb
      pdb.set_trace()
      return input_data // 2


tf.config.run_functions_eagerly(True)
model = CustomModel()
model(tf.constant([-2, -4]))
>>> call()
-> return input_data // 2
(Pdb) l
 10         if tf.reduce_mean(input_data) > 0:
 11           return input_data
 12         else:
 13           import pdb
 14           pdb.set_trace()
 15  ->       return input_data // 2
 16
 17
 18     tf.config.run_functions_eagerly(True)
 19     model = CustomModel()
 20     model(tf.constant([-2, -4]))

หมายเหตุ:

อย่าเก็บ tf.Tensors ไว้ในวัตถุของคุณ

ออบเจ็กต์เทนเซอร์เหล่านี้อาจถูกสร้างขึ้นใน tf.function หรือในบริบทที่กระตือรือร้น และเทนเซอร์เหล่านี้มีพฤติกรรมแตกต่างกัน ใช้ tf.Tensor เสมอสำหรับค่ากลางเท่านั้น

ในการติดตามสถานะ ให้ใช้ tf.Variable s เนื่องจากสามารถใช้งานได้จากทั้งสองบริบทเสมอ อ่าน คู่มือ tf.Variable เพื่อเรียนรู้เพิ่มเติม

แหล่งข้อมูลและการอ่านเพิ่มเติม

  • อ่าน คำแนะนำ และบทช่วย สอน TF2 เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับวิธีใช้ TF2

  • หากคุณเคยใช้ TF1.x มาก่อน ขอแนะนำเป็นอย่างยิ่งให้คุณย้ายรหัสของคุณไปที่ TF2 อ่าน คู่มือการย้ายข้อมูล เพื่อเรียนรู้เพิ่มเติม