ช่วยปกป้อง Great Barrier Reef กับ TensorFlow บน Kaggle เข้าร่วมท้าทาย

การเสริมข้อมูล

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

ภาพรวม

บทช่วยสอนนี้สาธิตการเพิ่มข้อมูล: เทคนิคในการเพิ่มความหลากหลายของชุดการฝึกของคุณโดยใช้การแปลงแบบสุ่ม (แต่เหมือนจริง) เช่น การหมุนภาพ

คุณจะได้เรียนรู้วิธีใช้การเพิ่มข้อมูลในสองวิธี:

ติดตั้ง

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds

from tensorflow.keras import layers

ดาวน์โหลดชุดข้อมูล

กวดวิชานี้ใช้ tf_flowers ชุด เพื่ออำนวยความสะดวกให้ดาวน์โหลดชุดข้อมูลโดยใช้ TensorFlow ชุดข้อมูล หากคุณต้องการที่จะเรียนรู้เกี่ยวกับวิธีการอื่น ๆ ของการนำเข้าข้อมูลให้ตรวจสอบ ภาพโหลด กวดวิชา

(train_ds, val_ds, test_ds), metadata = tfds.load(
    'tf_flowers',
    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
    with_info=True,
    as_supervised=True,
)

ชุดข้อมูลดอกไม้มีห้าคลาส

num_classes = metadata.features['label'].num_classes
print(num_classes)
5

มาดึงรูปภาพจากชุดข้อมูลและใช้เพื่อสาธิตการเพิ่มข้อมูล

get_label_name = metadata.features['label'].int2str

image, label = next(iter(train_ds))
_ = plt.imshow(image)
_ = plt.title(get_label_name(label))
2021-10-22 01:22:18.891161: 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.

png

ใช้เลเยอร์การประมวลผลล่วงหน้าของ Keras

การปรับขนาดและการปรับขนาด

คุณสามารถใช้ Keras preprocessing ชั้นในการปรับขนาดภาพของคุณให้เป็นรูปร่างที่สอดคล้องกัน (กับ tf.keras.layers.Resizing ) และค่าพิกเซล rescale (กับ tf.keras.layers.Rescaling )

IMG_SIZE = 180

resize_and_rescale = tf.keras.Sequential([
  layers.Resizing(IMG_SIZE, IMG_SIZE),
  layers.Rescaling(1./255)
])

คุณสามารถเห็นภาพผลลัพธ์ของการใช้เลเยอร์เหล่านี้กับรูปภาพ

result = resize_and_rescale(image)
_ = plt.imshow(result)

png

ตรวจสอบว่าพิกเซลอยู่ใน [0, 1] ช่วง:

print("Min and max pixel values:", result.numpy().min(), result.numpy().max())
Min and max pixel values: 0.0 1.0

การเสริมข้อมูล

คุณสามารถใช้ Keras preprocessing ชั้นสำหรับการเสริมข้อมูลเป็นอย่างดีเช่น tf.keras.layers.RandomFlip และ tf.keras.layers.RandomRotation

มาสร้างเลเยอร์การประมวลผลล่วงหน้าสองสามเลเยอร์แล้วนำไปใช้กับรูปภาพเดียวกันซ้ำๆ

data_augmentation = tf.keras.Sequential([
  layers.RandomFlip("horizontal_and_vertical"),
  layers.RandomRotation(0.2),
])
# Add the image to a batch.
image = tf.expand_dims(image, 0)
plt.figure(figsize=(10, 10))
for i in range(9):
  augmented_image = data_augmentation(image)
  ax = plt.subplot(3, 3, i + 1)
  plt.imshow(augmented_image[0])
  plt.axis("off")

png

มีความหลากหลายของชั้น preprocessing ที่คุณสามารถใช้สำหรับการเสริมข้อมูลรวมทั้ง tf.keras.layers.RandomContrast , tf.keras.layers.RandomCrop , tf.keras.layers.RandomZoom และอื่น ๆ

สองตัวเลือกในการใช้เลเยอร์การประมวลผลล่วงหน้าของ Keras

มีสองวิธีที่คุณสามารถใช้เลเยอร์การประมวลผลล่วงหน้าเหล่านี้ โดยมีข้อดีข้อเสีย

ตัวเลือกที่ 1: ทำให้เลเยอร์ก่อนการประมวลผลเป็นส่วนหนึ่งของโมเดลของคุณ

model = tf.keras.Sequential([
  # Add the preprocessing layers you created earlier.
  resize_and_rescale,
  data_augmentation,
  layers.Conv2D(16, 3, padding='same', activation='relu'),
  layers.MaxPooling2D(),
  # Rest of your model.
])

มีสองประเด็นสำคัญที่ควรทราบในกรณีนี้:

  • การเพิ่มข้อมูลจะทำงานบนอุปกรณ์ ซิงโครนัสกับเลเยอร์ที่เหลือของคุณ และได้รับประโยชน์จากการเร่งความเร็วของ GPU

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

ตัวเลือกที่ 2: ใช้เลเยอร์การประมวลผลล่วงหน้ากับชุดข้อมูลของคุณ

aug_ds = train_ds.map(
  lambda x, y: (resize_and_rescale(x, training=True), y))

ด้วยวิธีนี้คุณจะใช้ Dataset.map เพื่อสร้างชุดข้อมูลที่อัตราผลตอบแทนกระบวนการของภาพยิ่ง ในกรณีนี้:

  • การเพิ่มข้อมูลจะเกิดขึ้นแบบอะซิงโครนัสบน CPU และไม่มีการบล็อก คุณสามารถซ้อนทับกันของรูปแบบการฝึกอบรมของคุณบน GPU ที่มีข้อมูล preprocessing ใช้ Dataset.prefetch แสดงด้านล่าง
  • ในกรณีนี้ชั้น preprocessing จะไม่ถูกส่งออกกับรูปแบบเมื่อคุณเรียก Model.save คุณจะต้องแนบไฟล์เหล่านี้กับโมเดลของคุณก่อนที่จะบันทึกหรือปรับใช้ใหม่ทางฝั่งเซิร์ฟเวอร์ หลังการฝึก คุณสามารถแนบเลเยอร์การประมวลผลล่วงหน้าก่อนส่งออกได้

คุณสามารถค้นหาตัวอย่างของตัวเลือกแรกในที่ จัดหมวดหมู่ภาพ กวดวิชา มาสาธิตตัวเลือกที่สองกันที่นี่

ใช้เลเยอร์การประมวลผลล่วงหน้ากับชุดข้อมูล

กำหนดค่าการฝึกอบรม การตรวจสอบ และทดสอบชุดข้อมูลด้วยเลเยอร์การประมวลผลล่วงหน้าของ Keras ที่คุณสร้างไว้ก่อนหน้านี้ คุณยังกำหนดค่าชุดข้อมูลเพื่อประสิทธิภาพ โดยใช้การอ่านแบบขนานและการดึงข้อมูลล่วงหน้าแบบบัฟเฟอร์เพื่อให้แบตช์จากดิสก์ที่ไม่มี I/O กลายเป็นการบล็อก (เรียนรู้ประสิทธิภาพการทำงานของชุดข้อมูลที่มากขึ้นใน การปฏิบัติงานที่ดีขึ้นด้วย API tf.data คู่มือ.)

batch_size = 32
AUTOTUNE = tf.data.AUTOTUNE

def prepare(ds, shuffle=False, augment=False):
  # Resize and rescale all datasets.
  ds = ds.map(lambda x, y: (resize_and_rescale(x), y), 
              num_parallel_calls=AUTOTUNE)

  if shuffle:
    ds = ds.shuffle(1000)

  # Batch all datasets.
  ds = ds.batch(batch_size)

  # Use data augmentation only on the training set.
  if augment:
    ds = ds.map(lambda x, y: (data_augmentation(x, training=True), y), 
                num_parallel_calls=AUTOTUNE)

  # Use buffered prefetching on all datasets.
  return ds.prefetch(buffer_size=AUTOTUNE)
train_ds = prepare(train_ds, shuffle=True, augment=True)
val_ds = prepare(val_ds)
test_ds = prepare(test_ds)

ฝึกโมเดล

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

ลำดับ รุ่นประกอบด้วยสามช่วงตึกบิด ( tf.keras.layers.Conv2D ) ด้วยชั้นสูงสุดร่วมกัน ( tf.keras.layers.MaxPooling2D ) ในแต่ละของพวกเขา มีชั้นอย่างเต็มที่ที่เกี่ยวโยงกัน (เป็น tf.keras.layers.Dense ) กับ 128 หน่วยด้านบนของมันที่มีการเปิดใช้งานโดยการเปิดใช้งานฟังก์ชั่น Relu ( 'relu' ) โมเดลนี้ไม่ได้รับการปรับแต่งเพื่อความแม่นยำ (เป้าหมายคือเพื่อแสดงกลไกให้คุณเห็น)

model = tf.keras.Sequential([
  layers.Conv2D(16, 3, padding='same', activation='relu'),
  layers.MaxPooling2D(),
  layers.Conv2D(32, 3, padding='same', activation='relu'),
  layers.MaxPooling2D(),
  layers.Conv2D(64, 3, padding='same', activation='relu'),
  layers.MaxPooling2D(),
  layers.Flatten(),
  layers.Dense(128, activation='relu'),
  layers.Dense(num_classes)
])

เลือก tf.keras.optimizers.Adam เพิ่มประสิทธิภาพและ tf.keras.losses.SparseCategoricalCrossentropy ฟังก์ชั่นการสูญเสีย เพื่อดูการฝึกอบรมและความถูกต้องในการตรวจสอบในแต่ละยุคการฝึกอบรมผ่าน metrics อาร์กิวเมนต์ Model.compile

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

ฝึกสองสามยุค:

epochs=5
history = model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=epochs
)
Epoch 1/5
92/92 [==============================] - 30s 190ms/step - loss: 1.3237 - accuracy: 0.4183 - val_loss: 1.0881 - val_accuracy: 0.5668
Epoch 2/5
92/92 [==============================] - 3s 26ms/step - loss: 1.0428 - accuracy: 0.5841 - val_loss: 1.0630 - val_accuracy: 0.5886
Epoch 3/5
92/92 [==============================] - 3s 26ms/step - loss: 0.9704 - accuracy: 0.6202 - val_loss: 1.0317 - val_accuracy: 0.6076
Epoch 4/5
92/92 [==============================] - 3s 26ms/step - loss: 0.9190 - accuracy: 0.6356 - val_loss: 0.8869 - val_accuracy: 0.6621
Epoch 5/5
92/92 [==============================] - 3s 26ms/step - loss: 0.8766 - accuracy: 0.6594 - val_loss: 0.8312 - val_accuracy: 0.6730
loss, acc = model.evaluate(test_ds)
print("Accuracy", acc)
12/12 [==============================] - 3s 32ms/step - loss: 0.8001 - accuracy: 0.7030
Accuracy 0.7029972672462463

การเพิ่มข้อมูลที่กำหนดเอง

คุณยังสามารถสร้างเลเยอร์การเพิ่มข้อมูลที่กำหนดเองได้อีกด้วย

บทช่วยสอนนี้แสดงวิธีดำเนินการสองวิธี:

  • ครั้งแรกที่คุณจะสร้าง tf.keras.layers.Lambda ชั้น นี่เป็นวิธีที่ดีในการเขียนโค้ดที่กระชับ
  • ถัดไปคุณจะเขียนเลเยอร์ใหม่ผ่าน subclassing ซึ่งจะช่วยให้คุณสามารถควบคุมได้มากขึ้น

ทั้งสองเลเยอร์จะสุ่มสลับสีในภาพตามความน่าจะเป็น

def random_invert_img(x, p=0.5):
  if  tf.random.uniform([]) < p:
    x = (255-x)
  else:
    x
  return x
def random_invert(factor=0.5):
  return layers.Lambda(lambda x: random_invert_img(x, factor))

random_invert = random_invert()
plt.figure(figsize=(10, 10))
for i in range(9):
  augmented_image = random_invert(image)
  ax = plt.subplot(3, 3, i + 1)
  plt.imshow(augmented_image[0].numpy().astype("uint8"))
  plt.axis("off")

png

ถัดไปใช้เป็นชั้นที่กำหนดเองโดย subclassing :

class RandomInvert(layers.Layer):
  def __init__(self, factor=0.5, **kwargs):
    super().__init__(**kwargs)
    self.factor = factor

  def call(self, x):
    return random_invert_img(x)
_ = plt.imshow(RandomInvert()(image)[0])

png

เลเยอร์ทั้งสองนี้สามารถใช้ได้ตามที่อธิบายไว้ในตัวเลือกที่ 1 และ 2 ด้านบน

ใช้ tf.image

ยูทิลิตี้การประมวลผลล่วงหน้าของ Keras ด้านบนนั้นสะดวก แต่สำหรับการควบคุมปลีกย่อยคุณสามารถเขียนท่อเสริมข้อมูลของคุณเองหรือชั้นใช้ tf.data และ tf.image (คุณยังอาจต้องการตรวจสอบ TensorFlow Addons ภาพ: การดำเนินงาน และ TensorFlow I / O: สีพื้นที่การแปลง .)

เนื่องจากก่อนหน้านี้ชุดข้อมูลดอกไม้ได้รับการกำหนดค่าด้วยการเพิ่มข้อมูล ให้นำเข้าใหม่เพื่อเริ่มต้นใหม่:

(train_ds, val_ds, test_ds), metadata = tfds.load(
    'tf_flowers',
    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
    with_info=True,
    as_supervised=True,
)

ดึงภาพที่จะทำงานกับ:

image, label = next(iter(train_ds))
_ = plt.imshow(image)
_ = plt.title(get_label_name(label))
2021-10-22 01:23:14.609482: 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.

png

ลองใช้ฟังก์ชันต่อไปนี้ในการแสดงภาพและเปรียบเทียบภาพต้นฉบับและภาพเสริมกัน:

def visualize(original, augmented):
  fig = plt.figure()
  plt.subplot(1,2,1)
  plt.title('Original image')
  plt.imshow(original)

  plt.subplot(1,2,2)
  plt.title('Augmented image')
  plt.imshow(augmented)

การเสริมข้อมูล

พลิกภาพ

พลิกภาพทั้งในแนวตั้งหรือแนวนอนกับ tf.image.flip_left_right :

flipped = tf.image.flip_left_right(image)
visualize(image, flipped)

png

ภาพสีเทา

คุณสามารถระดับสีเทาภาพกับ tf.image.rgb_to_grayscale :

grayscaled = tf.image.rgb_to_grayscale(image)
visualize(image, tf.squeeze(grayscaled))
_ = plt.colorbar()

png

อิ่มตัวภาพ

เปียกโชกภาพกับ tf.image.adjust_saturation โดยการให้ปัจจัยอิ่มตัว:

saturated = tf.image.adjust_saturation(image, 3)
visualize(image, saturated)

png

เปลี่ยนความสว่างของภาพ

เปลี่ยนความสว่างของภาพกับ tf.image.adjust_brightness โดยการให้ปัจจัยความสว่าง:

bright = tf.image.adjust_brightness(image, 0.4)
visualize(image, bright)

png

ครอบตัดรูปภาพตรงกลาง

ตัดภาพจากใจกลางขึ้นเพื่อเป็นส่วนหนึ่งของภาพที่คุณต้องการใช้ tf.image.central_crop :

cropped = tf.image.central_crop(image, central_fraction=0.5)
visualize(image,cropped)

png

หมุนภาพ

หมุนภาพ 90 องศากับ tf.image.rot90 :

rotated = tf.image.rot90(image)
visualize(image, rotated)

png

การแปลงแบบสุ่ม

การใช้การแปลงแบบสุ่มกับรูปภาพสามารถช่วยทำให้ภาพรวมและขยายชุดข้อมูลได้กว้างขึ้น ปัจจุบัน tf.image API ให้แปดเช่นการดำเนินงานภาพแบบสุ่ม (OPS):

ops ภาพสุ่มเหล่านี้ทำงานได้อย่างหมดจด: เอาต์พุตขึ้นอยู่กับอินพุตเท่านั้น ซึ่งทำให้ง่ายต่อการใช้งานในไพพ์ไลน์อินพุตที่มีประสิทธิภาพสูงและกำหนดได้ พวกเขาต้องมี seed ค่าป้อนข้อมูลในแต่ละขั้นตอน ได้รับเดียวกัน seed พวกเขากลับผลลัพธ์เดียวกันอิสระของวิธีการหลายครั้งที่พวกเขาจะเรียกว่า

ในส่วนต่อไปนี้ คุณจะ:

  1. ดูตัวอย่างการใช้การดำเนินการรูปภาพแบบสุ่มเพื่อแปลงรูปภาพ และ
  2. สาธิตวิธีการใช้การแปลงแบบสุ่มกับชุดข้อมูลการฝึกอบรม

สุ่มเปลี่ยนความสว่างของภาพ

สุ่มเปลี่ยนความสว่างของ image โดยใช้ tf.image.stateless_random_brightness โดยการให้ปัจจัยที่สว่างและ seed ปัจจัยที่มีความสว่างจะสุ่มเลือกในช่วง [-max_delta, max_delta) และมีความเกี่ยวข้องกับที่ได้รับ seed

for i in range(3):
  seed = (i, 0)  # tuple of size (2,)
  stateless_random_brightness = tf.image.stateless_random_brightness(
      image, max_delta=0.95, seed=seed)
  visualize(image, stateless_random_brightness)

png

png

png

สุ่มเปลี่ยนความคมชัดของภาพ

สุ่มปรับความคมชัดของ image โดยใช้ tf.image.stateless_random_contrast โดยการให้ช่วงความคมชัดและ seed ช่วงความคมชัดจะสุ่มเลือกในช่วง [lower, upper] และมีความเกี่ยวข้องกับที่ได้รับ seed

for i in range(3):
  seed = (i, 0)  # tuple of size (2,)
  stateless_random_contrast = tf.image.stateless_random_contrast(
      image, lower=0.1, upper=0.9, seed=seed)
  visualize(image, stateless_random_contrast)

png

png

png

ครอบตัดรูปภาพแบบสุ่ม

สุ่มตัด image โดยใช้ tf.image.stateless_random_crop โดยการให้เป้าหมาย size และ seed ส่วนที่ได้รับการตัดออกจาก image ที่สุ่มเลือกที่ offset และมีความเกี่ยวข้องกับที่ได้รับ seed

for i in range(3):
  seed = (i, 0)  # tuple of size (2,)
  stateless_random_crop = tf.image.stateless_random_crop(
      image, size=[210, 300, 3], seed=seed)
  visualize(image, stateless_random_crop)

png

png

png

ใช้การเสริมกับชุดข้อมูล

เรามาดาวน์โหลดชุดข้อมูลภาพกันก่อนอีกครั้งในกรณีที่มีการแก้ไขในส่วนก่อนหน้า

(train_datasets, val_ds, test_ds), metadata = tfds.load(
    'tf_flowers',
    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
    with_info=True,
    as_supervised=True,
)

ถัดไป กำหนดฟังก์ชันยูทิลิตี้สำหรับการปรับขนาดและปรับขนาดรูปภาพ ฟังก์ชันนี้จะใช้ในการรวมขนาดและขนาดของรูปภาพในชุดข้อมูล:

def resize_and_rescale(image, label):
  image = tf.cast(image, tf.float32)
  image = tf.image.resize(image, [IMG_SIZE, IMG_SIZE])
  image = (image / 255.0)
  return image, label

Let 's ยังกำหนด augment ฟังก์ชั่นที่สามารถใช้การแปลงสุ่มภาพ ฟังก์ชันนี้จะใช้กับชุดข้อมูลในขั้นตอนต่อไป

def augment(image_label, seed):
  image, label = image_label
  image, label = resize_and_rescale(image, label)
  image = tf.image.resize_with_crop_or_pad(image, IMG_SIZE + 6, IMG_SIZE + 6)
  # Make a new seed.
  new_seed = tf.random.experimental.stateless_split(seed, num=1)[0, :]
  # Random crop back to the original size.
  image = tf.image.stateless_random_crop(
      image, size=[IMG_SIZE, IMG_SIZE, 3], seed=seed)
  # Random brightness.
  image = tf.image.stateless_random_brightness(
      image, max_delta=0.5, seed=new_seed)
  image = tf.clip_by_value(image, 0, 1)
  return image, label

ตัวเลือกที่ 1: การใช้ tf.data.experimental.Counter

สร้าง tf.data.experimental.Counter วัตถุ (ขอเรียกว่า counter ) และ Dataset.zip ชุดข้อมูลที่มี (counter, counter) นี้จะให้แน่ใจว่าภาพในชุดข้อมูลที่แต่ละคนได้รับการเชื่อมโยงกับค่าที่ไม่ซ้ำ (ของรูปร่าง (2,) ) ตาม counter ซึ่งต่อมาได้รับการผ่านเข้าสู่ augment การทำงานเป็น seed คุ้มค่าต่อการเปลี่ยนแปลงแบบสุ่ม

# Create a `Counter` object and `Dataset.zip` it together with the trainining set.
counter = tf.data.experimental.Counter()
train_ds = tf.data.Dataset.zip((train_datasets, (counter, counter)))
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/data/experimental/ops/counter.py:66: scan (from tensorflow.python.data.experimental.ops.scan_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Dataset.scan(...) instead
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/data/experimental/ops/counter.py:66: scan (from tensorflow.python.data.experimental.ops.scan_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Dataset.scan(...) instead

แผนที่ augment ฟังก์ชั่นชุดฝึกอบรม:

train_ds = (
    train_ds
    .shuffle(1000)
    .map(augment, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)
val_ds = (
    val_ds
    .map(resize_and_rescale, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)
test_ds = (
    test_ds
    .map(resize_and_rescale, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)

ตัวเลือกที่ 2: การใช้ tf.random.Generator

  • สร้าง tf.random.Generator วัตถุที่มีเริ่มต้น seed ค่า เรียก make_seeds ฟังก์ชั่นบนวัตถุกำเนิดเดียวกันเสมอกลับใหม่ที่ไม่ซ้ำกัน seed ค่า
  • กำหนดฟังก์ชั่นเสื้อคลุมที่: 1) เรียก make_seeds ทำงาน; และ 2) ผ่านที่สร้างใหม่ seed ค่าเป็นการ augment ฟังก์ชั่นสำหรับการแปลงแบบสุ่ม
# Create a generator.
rng = tf.random.Generator.from_seed(123, alg='philox')
# Create a wrapper function for updating seeds.
def f(x, y):
  seed = rng.make_seeds(2)[0]
  image, label = augment((x, y), seed)
  return image, label

แผนที่ฟังก์ชั่นเสื้อคลุม f ไปชุดการฝึกอบรมและ resize_and_rescale ฟังก์ชั่นการตรวจสอบและการทดสอบชุด:

train_ds = (
    train_datasets
    .shuffle(1000)
    .map(f, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)
val_ds = (
    val_ds
    .map(resize_and_rescale, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)
test_ds = (
    test_ds
    .map(resize_and_rescale, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)

ตอนนี้ชุดข้อมูลเหล่านี้สามารถใช้ในการฝึกโมเดลดังที่แสดงไว้ก่อนหน้านี้

ขั้นตอนถัดไป

กวดวิชาแสดงให้เห็นถึงการเสริมข้อมูลนี้จะใช้ชั้น Keras preprocessing และ tf.image

  • ต้องการเรียนรู้วิธีที่จะรวม preprocessing ชั้นภายในรูปแบบของคุณให้ดูที่ ภาพการจำแนกประเภท กวดวิชา
  • นอกจากนี้คุณยังอาจจะสนใจในการเรียนรู้วิธีชั้น preprocessing สามารถช่วยให้คุณข้อความประเภทดังที่แสดงใน ข้อความพื้นฐานการจำแนกประเภท กวดวิชา
  • คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับ tf.data ในนี้ คู่มือ และคุณสามารถเรียนรู้วิธีการกำหนดค่าท่อป้อนข้อมูลของคุณสำหรับการทำงาน ที่นี่