सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

डेटा वृद्धि

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.

पीएनजी

केरस प्रीप्रोसेसिंग परतों का प्रयोग करें

आकार बदलना और आकार बदलना

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

पीएनजी

सत्यापित करें कि पिक्सल में हैं [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")

पीएनजी

वहाँ preprocessing परतों आप सहित डेटा वृद्धि के लिए उपयोग कर सकते हैं की एक किस्म है tf.keras.layers.RandomContrast , tf.keras.layers.RandomCrop , tf.keras.layers.RandomZoom , व अन्य।

केरस प्रीप्रोसेसिंग परतों का उपयोग करने के लिए दो विकल्प

महत्वपूर्ण ट्रेड-ऑफ के साथ, आप इन प्रीप्रोसेसिंग परतों का उपयोग करने के दो तरीके हैं।

विकल्प 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 एक डाटासेट बनाने के लिए है कि संवर्धित छवियों की पैदावार बैचों। इस मामले में:

  • डेटा संवर्द्धन सीपीयू पर अतुल्यकालिक रूप से होगा, और गैर-अवरुद्ध है। आप preprocessing, का उपयोग कर डेटा के साथ GPU पर अपने मॉडल के प्रशिक्षण ओवरलैप कर सकते हैं Dataset.prefetch , नीचे दिखाया गया है।
  • इस मामले में preprocessing परतों मॉडल जब आप कॉल के साथ निर्यात नहीं की जाएंगी Model.save । आपको इसे सहेजने या सर्वर-साइड को फिर से लागू करने से पहले उन्हें अपने मॉडल में संलग्न करना होगा। प्रशिक्षण के बाद, आप निर्यात से पहले प्रीप्रोसेसिंग परतों को संलग्न कर सकते हैं।

आप में पहला विकल्प का एक उदाहरण मिल सकते हैं छवि वर्गीकरण ट्यूटोरियल। आइए यहां दूसरा विकल्प प्रदर्शित करें।

डेटासेट पर प्रीप्रोसेसिंग परतें लागू करें

आपके द्वारा पहले बनाई गई केरस प्रीप्रोसेसिंग परतों के साथ प्रशिक्षण, सत्यापन और परीक्षण डेटासेट को कॉन्फ़िगर करें। आप प्रदर्शन के लिए डेटासेट भी कॉन्फ़िगर करेंगे, समानांतर रीड और बफर्ड प्रीफ़ेचिंग का उपयोग करके डिस्क से बैचों को I/O ब्लॉक किए बिना प्राप्त करने के लिए। (में और अधिक डाटासेट प्रदर्शन जानें 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 ) है कि एक Relu सक्रियण समारोह (द्वारा सक्रिय किया जाता सब के ऊपर 128 इकाइयों के साथ '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 परत। संक्षिप्त कोड लिखने का यह एक अच्छा तरीका है।
  • इसके बाद, आप के माध्यम से एक नई परत को लिखेंगे उपवर्गीकरण जो आप अधिक नियंत्रण देता है,।

कुछ संभावना के अनुसार, दोनों परतें एक छवि में रंगों को बेतरतीब ढंग से उलट देंगी।

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

पीएनजी

इसके बाद, एक कस्टम परत को लागू उपवर्गीकरण :

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

पीएनजी

इन दोनों परतों का उपयोग ऊपर दिए गए विकल्प 1 और 2 में बताए अनुसार किया जा सकता है।

tf.छवि का उपयोग करना

उपरोक्त केरस प्रीप्रोसेसिंग उपयोगिताओं सुविधाजनक हैं। लेकिन, बेहतर नियंत्रण के लिए, आप अपने खुद के डेटा वृद्धि पाइपलाइनों या का उपयोग कर परतों में लिख सकते हैं tf.data और tf.image । (तुम भी बाहर की जाँच कर सकते हैं TensorFlow ऐड-ऑन छवि: संचालन और 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,
)

साथ काम करने के लिए एक छवि प्राप्त करें:

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.

पीएनजी

आइए मूल और संवर्धित छवियों को साथ-साथ देखने और तुलना करने के लिए निम्नलिखित फ़ंक्शन का उपयोग करें:

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)

पीएनजी

छवि को ग्रेस्केल करें

आप के साथ एक छवि स्केल कर सकते हैं tf.image.rgb_to_grayscale :

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

पीएनजी

एक छवि संतृप्त करें

के साथ एक छवि सैच्युरेट tf.image.adjust_saturation एक संतृप्ति कारक प्रदान करके:

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

पीएनजी

छवि चमक बदलें

साथ छवि की चमक परिवर्तित tf.image.adjust_brightness एक चमक कारक प्रदान करके:

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

पीएनजी

केंद्र में एक छवि क्रॉप करें

छवि हिस्सा आप का उपयोग कर इच्छा के लिए केंद्र से छवि को काटें tf.image.central_crop :

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

पीएनजी

एक छवि घुमाएँ

साथ 90 डिग्री द्वारा एक छवि घुमाएँ tf.image.rot90 :

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

पीएनजी

यादृच्छिक परिवर्तन

छवियों में यादृच्छिक परिवर्तन लागू करने से डेटासेट को सामान्य बनाने और विस्तारित करने में मदद मिल सकती है। वर्तमान tf.image एपीआई आठ ऐसे यादृच्छिक छवि परिचालन (ऑप्स) प्रदान करता है:

ये रैंडम इमेज ऑप्स विशुद्ध रूप से कार्यात्मक हैं: आउटपुट केवल इनपुट पर निर्भर करता है। यह उन्हें उच्च प्रदर्शन, नियतात्मक इनपुट पाइपलाइनों में उपयोग करने में आसान बनाता है। वे एक आवश्यकता 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)

पीएनजी

पीएनजी

पीएनजी

छवि कंट्रास्ट को बेतरतीब ढंग से बदलें

बेतरतीब ढंग से की विपरीत बदल 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)

पीएनजी

पीएनजी

पीएनजी

छवि को बेतरतीब ढंग से क्रॉप करें

बेतरतीब ढंग से फसल image का उपयोग करते हुए tf.image.stateless_random_crop लक्ष्य प्रदान करके size और seed । भाग कि से बाहर काटा जाता है image में चुना एक बेतरतीब ढंग से ऑफसेट है और दिए गए साथ जुड़ा हुआ है 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)

पीएनजी

पीएनजी

पीएनजी

डेटासेट में वृद्धि लागू करें

आइए पहले छवि डेटासेट को फिर से डाउनलोड करें यदि वे पिछले अनुभागों में संशोधित किए गए हैं।

(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

के भी परिभाषित करते हैं 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 इस में गाइड है, और आप प्रदर्शन के लिए अपने इनपुट पाइपलाइनों को कॉन्फ़िगर कैसे सीख सकते हैं यहां