इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

छवि लेाड करें

TensorFlow.org पर देखें गूगल Colab में चलाएँ GitHub पर स्रोत देखें डाउनलोड नोटबुक

इस ट्यूटोरियल दिखाता है कि कैसे लोड और दो तरह से एक छवि डाटासेट preprocess करने के लिए। सबसे पहले, आप उच्च स्तर के Keras का उपयोग preprocessing जाएगा उपयोगिताओं और परतों । इसके बाद, आप का उपयोग कर खरोंच से अपने स्वयं के इनपुट पाइपलाइन लिखेंगे tf.data

सेट अप

 import numpy as np
import os
import PIL
import PIL.Image
import tensorflow as tf
 
 print(tf.__version__)
 
2.3.0

डाउनलोड फूल डाटासेट

इस ट्यूटोरियल फूलों की कई हजार तस्वीरों की एक डाटासेट उपयोग करता है। फूल डाटासेट 5 उप-निर्देशिका, वर्ग प्रति एक में शामिल हैं:

 flowers_photos/
  daisy/
  dandelion/
  roses/
  sunflowers/
  tulips/
 
 import pathlib
dataset_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"
data_dir = tf.keras.utils.get_file(origin=dataset_url, 
                                   fname='flower_photos', 
                                   untar=True)
data_dir = pathlib.Path(data_dir)
 

(218MB) डाउनलोड करने के बाद, आप अब उपलब्ध फूल फ़ोटो की एक प्रति होनी चाहिए। वहाँ 3670 कुल छवियों हैं:

 image_count = len(list(data_dir.glob('*/*.jpg')))
print(image_count)
 
3670

प्रत्येक निर्देशिका फूल के उस प्रकार के चित्र शामिल हैं। यहाँ कुछ गुलाब हैं:

 roses = list(data_dir.glob('roses/*'))
PIL.Image.open(str(roses[0]))
 

png

 roses = list(data_dir.glob('roses/*'))
PIL.Image.open(str(roses[1]))
 

png

keras.preprocessing का उपयोग कर लोड

आइए लोड डिस्क बंद इन छवियों का उपयोग image_dataset_from_directory

एक डाटासेट बनाएं

लोडर के लिए कुछ मानकों को परिभाषित करें:

 batch_size = 32
img_height = 180
img_width = 180
 

यह अपने मॉडल को विकसित करने के लिए एक मान्यता स्प्लिट का उपयोग करने अच्छी आदत है। हम प्रशिक्षण के लिए छवियों का 80%, और सत्यापन के लिए 20% का उपयोग करेगा।

 train_ds = tf.keras.preprocessing.image_dataset_from_directory(
  data_dir,
  validation_split=0.2,
  subset="training",
  seed=123,
  image_size=(img_height, img_width),
  batch_size=batch_size)
 
Found 3670 files belonging to 5 classes.
Using 2936 files for training.

 val_ds = tf.keras.preprocessing.image_dataset_from_directory(
  data_dir,
  validation_split=0.2,
  subset="validation",
  seed=123,
  image_size=(img_height, img_width),
  batch_size=batch_size)
 
Found 3670 files belonging to 5 classes.
Using 734 files for validation.

आप में वर्ग के नाम पा सकते हैं class_names इन डेटासेट पर विशेषता।

 class_names = train_ds.class_names
print(class_names)
 
['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']

डेटा को विज़ुअलाइज़ करें

यहाँ प्रशिक्षण डाटासेट से पहले 9 छवियाँ हैं।

 import matplotlib.pyplot as plt

plt.figure(figsize=(10, 10))
for images, labels in train_ds.take(1):
  for i in range(9):
    ax = plt.subplot(3, 3, i + 1)
    plt.imshow(images[i].numpy().astype("uint8"))
    plt.title(class_names[labels[i]])
    plt.axis("off")
 

png

आप उन्हें पारित करके इन डेटासेट का उपयोग कर एक मॉडल को प्रशिक्षित कर सकते model.fit (इस ट्यूटोरियल में बाद में दिखाया गया है)। आप चाहें, तो आप भी कर सकते हैं मैन्युअल रूप से पुनरावृति डाटासेट से अधिक और छवियों के बैच को पुनः प्राप्त:

 for image_batch, labels_batch in train_ds:
  print(image_batch.shape)
  print(labels_batch.shape)
  break
 
(32, 180, 180, 3)
(32,)

image_batch आकार का एक टेन्सर है (32, 180, 180, 3) । इस आकार के 32 छवियों का एक बैच है 180x180x3 (रंग चैनल आरजीबी करने के लिए पिछले आयाम referes)। label_batch आकार का एक टेन्सर है (32,) , इन 32 छवियों लेबल इसी रहे हैं।

डेटा का मानकीकरण

आरजीबी चैनल मूल्यों में हैं [0, 255] रेंज। यह एक तंत्रिका नेटवर्क के लिए आदर्श नहीं है, सामान्य रूप में आप अपने इनपुट मानों छोटे बनाने के लिए लेनी चाहिए। यहाँ, हम मूल्यों का मानकीकरण में होना होगा [0, 1] एक rescaling परत का उपयोग करके।

 from tensorflow.keras import layers

normalization_layer = tf.keras.layers.experimental.preprocessing.Rescaling(1./255)
 

इस परत का उपयोग करने के दो तरीके हैं। आप मानचित्र पर कॉल करके डाटासेट में इसे लागू कर सकते हैं:

 normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
image_batch, labels_batch = next(iter(normalized_ds))
first_image = image_batch[0]
# Notice the pixels values are now in `[0,1]`.
print(np.min(first_image), np.max(first_image)) 
 
0.0 0.96902645

या, आप सरल तैनाती के लिए अपने मॉडल परिभाषा के अंदर परत शामिल कर सकते हैं। हम यहाँ दूसरा दृष्टिकोण का प्रयोग करेंगे।

प्रदर्शन के लिए डाटासेट कॉन्फ़िगर

आइए सुनिश्चित करें कि करने के लिए बफ़र उपयोग करती हैं इसलिए हम आई / ओ अवरुद्ध हो जाते हैं बिना डिस्क से डाटा प्राप्त हो सकते हैं प्रीफ़ेचिंग करते हैं। इन दो महत्वपूर्ण तरीकों जब डेटा लोड हो रहा उपयोग करना चाहिए रहे हैं।

.cache() के बाद वे पहली बार युग के दौरान डिस्क बंद लोड कर रहे हैं स्मृति में छवियों रहता है। यह डेटासेट सुनिश्चित करेगा एक टोंटी, जबकि अपने मॉडल को प्रशिक्षण नहीं बन जाता है। यदि आपका डाटासेट स्मृति में फिट करने के लिए बहुत बड़ी है, तो आप भी एक performant ऑन-डिस्क कैश बनाने के लिए इस विधि का उपयोग कर सकते हैं।

.prefetch() preprocessing डेटा और मॉडल निष्पादन करते हुए प्रशिक्षण चढ़ जाता है।

इच्छुक पाठकों अधिक दोनों विधियों के बारे में डिस्क के लिए कैश डेटा सीख सकते हैं, साथ ही साथ कैसे डेटा प्रदर्शन गाइड

 AUTOTUNE = tf.data.experimental.AUTOTUNE

train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
 

एक मॉडल ट्रेन

पूर्णता के लिए, हम डेटासेट हम सिर्फ तैयार का उपयोग कर एक साधारण मॉडल प्रशिक्षित करने के लिए कैसे दिखा देंगे। यह मॉडल किसी भी तरह से देखते नहीं किया गया है - लक्ष्य आप डेटासेट आपने अभी बनाया का उपयोग कर यांत्रिकी को दिखाने के लिए है। छवि वर्गीकरण के बारे में अधिक जानकारी के लिए इस पर जाएँ ट्यूटोरियल

 num_classes = 5

model = tf.keras.Sequential([
  layers.experimental.preprocessing.Rescaling(1./255),
  layers.Conv2D(32, 3, activation='relu'),
  layers.MaxPooling2D(),
  layers.Conv2D(32, 3, activation='relu'),
  layers.MaxPooling2D(),
  layers.Conv2D(32, 3, activation='relu'),
  layers.MaxPooling2D(),
  layers.Flatten(),
  layers.Dense(128, activation='relu'),
  layers.Dense(num_classes)
])
 
 model.compile(
  optimizer='adam',
  loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),
  metrics=['accuracy'])
 
 model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=3
)
 
Epoch 1/3
92/92 [==============================] - 6s 66ms/step - loss: 1.3282 - accuracy: 0.4240 - val_loss: 1.1035 - val_accuracy: 0.5804
Epoch 2/3
92/92 [==============================] - 1s 11ms/step - loss: 1.0304 - accuracy: 0.5913 - val_loss: 0.9515 - val_accuracy: 0.6267
Epoch 3/3
92/92 [==============================] - 1s 11ms/step - loss: 0.8712 - accuracy: 0.6689 - val_loss: 0.9268 - val_accuracy: 0.6471

<tensorflow.python.keras.callbacks.History at 0x7f86d80ad128>

आप देख सकते हैं मान्यता सटीकता प्रशिक्षण सटीकता की तुलना करने के लिए कम है, हमारे मॉडल overfitting है का संकेत है। आप overfitting और कैसे इस में इसे कम करने के बारे में अधिक सीख सकते हैं ट्यूटोरियल

बेहतर नियंत्रण के लिए tf.data का उपयोग करना

ऊपर keras.preprocessing उपयोगिताओं लिए एक सुविधाजनक तरीका एक बनाने के लिए कर रहे हैं tf.data.Dataset छवियों का एक निर्देशिका से। महीन अनाज नियंत्रण के लिए, आप का उपयोग कर अपने स्वयं के इनपुट पाइप लाइन लिख सकते हैं tf.data । इस अनुभाग में पता चलता है कि कैसे सिर्फ इतना है कि ऐसा करने के लिए, फ़ाइल पथ के साथ शुरुआत ज़िप से हम पहले डाउनलोड।

 list_ds = tf.data.Dataset.list_files(str(data_dir/'*/*'), shuffle=False)
list_ds = list_ds.shuffle(image_count, reshuffle_each_iteration=False)
 
 for f in list_ds.take(5):
  print(f.numpy())
 
b'/home/kbuilder/.keras/datasets/flower_photos/roses/1445228333_59a07e0801.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/dandelion/14128835667_b6a916222c.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/roses/7551637034_55ae047756_n.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/dandelion/4574736702_b15ecf97d0_m.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/roses/6867597533_d65d1c39fb_n.jpg'

फ़ाइलों के वृक्ष संरचना एक संकलित करने के लिए इस्तेमाल किया जा सकता class_names सूची।

 class_names = np.array(sorted([item.name for item in data_dir.glob('*') if item.name != "LICENSE.txt"]))
print(class_names)
 
['daisy' 'dandelion' 'roses' 'sunflowers' 'tulips']

ट्रेन और सत्यापन में डाटासेट विभाजित करें:

 val_size = int(image_count * 0.2)
train_ds = list_ds.skip(val_size)
val_ds = list_ds.take(val_size)
 

इस प्रकार आप प्रत्येक डाटासेट की लंबाई देख सकते हैं:

 print(tf.data.experimental.cardinality(train_ds).numpy())
print(tf.data.experimental.cardinality(val_ds).numpy())
 
2936
734

एक छोटी समारोह है कि एक करने के लिए एक फ़ाइल पथ धर्मान्तरित लिखें (img, label) जोड़ी:

 def get_label(file_path):
  # convert the path to a list of path components
  parts = tf.strings.split(file_path, os.path.sep)
  # The second to last is the class-directory
  one_hot = parts[-2] == class_names
  # Integer encode the label
  return tf.argmax(one_hot)
 
 def decode_img(img):
  # convert the compressed string to a 3D uint8 tensor
  img = tf.image.decode_jpeg(img, channels=3)
  # resize the image to the desired size
  return tf.image.resize(img, [img_height, img_width])
 
 def process_path(file_path):
  label = get_label(file_path)
  # load the raw data from the file as a string
  img = tf.io.read_file(file_path)
  img = decode_img(img)
  return img, label
 

उपयोग Dataset.map की एक डाटासेट बनाने के लिए image, label जोड़े:

 # Set `num_parallel_calls` so multiple images are loaded/processed in parallel.
train_ds = train_ds.map(process_path, num_parallel_calls=AUTOTUNE)
val_ds = val_ds.map(process_path, num_parallel_calls=AUTOTUNE)
 
 for image, label in train_ds.take(1):
  print("Image shape: ", image.numpy().shape)
  print("Label: ", label.numpy())
 
Image shape:  (180, 180, 3)
Label:  2

प्रदर्शन के लिए कॉन्फ़िगर डाटासेट

इस डेटासेट के साथ एक मॉडल को प्रशिक्षित करने के लिए आप डेटा चाहते हैं:

  • अच्छी तरह से फेरबदल किया जाना है।
  • batched किया जाना है।
  • बैचों संभव के रूप में जल्द ही के रूप में उपलब्ध हो सकता है।

इन सुविधाओं का उपयोग कर जोड़ा जा सकता है tf.data एपीआई। अधिक जानकारी के लिए, इनपुट पाइपलाइन प्रदर्शन गाइड।

 def configure_for_performance(ds):
  ds = ds.cache()
  ds = ds.shuffle(buffer_size=1000)
  ds = ds.batch(batch_size)
  ds = ds.prefetch(buffer_size=AUTOTUNE)
  return ds

train_ds = configure_for_performance(train_ds)
val_ds = configure_for_performance(val_ds)
 

डेटा को विज़ुअलाइज़ करें

आप एक आपने पहले बनाया था की तरह ही इस डेटासेट कल्पना कर सकते हैं।

 image_batch, label_batch = next(iter(train_ds))

plt.figure(figsize=(10, 10))
for i in range(9):
  ax = plt.subplot(3, 3, i + 1)
  plt.imshow(image_batch[i].numpy().astype("uint8"))
  label = label_batch[i]
  plt.title(class_names[label])
  plt.axis("off")
 

png

मॉडल प्रशिक्षण जारी

अब आप स्वयं एक समान का निर्माण किया है tf.data.Dataset द्वारा बनाई गई एक के लिए keras.preprocessing ऊपर। आप इसके साथ मॉडल प्रशिक्षण जारी रख सकते हैं। पहले के रूप में, हम बस कुछ ही अवधियों के लिए ट्रेन चलने का समय कम रखने का होगा।

 model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=3
)
 
Epoch 1/3
92/92 [==============================] - 2s 19ms/step - loss: 0.7267 - accuracy: 0.7272 - val_loss: 0.7963 - val_accuracy: 0.7098
Epoch 2/3
92/92 [==============================] - 1s 11ms/step - loss: 0.5384 - accuracy: 0.7987 - val_loss: 0.8067 - val_accuracy: 0.6894
Epoch 3/3
92/92 [==============================] - 1s 11ms/step - loss: 0.3382 - accuracy: 0.8770 - val_loss: 1.0317 - val_accuracy: 0.6662

<tensorflow.python.keras.callbacks.History at 0x7f87cd496320>

अगला कदम

इस ट्यूटोरियल डिस्क बंद चित्र लोड करने के दो तरीके से पता चला है। सबसे पहले, आप लोड और Keras preprocessing परतों और उपयोगिताओं का उपयोग कर एक छवि डाटासेट preprocess का तरीका सीखा। इसके बाद, आप सीखा कि कैसे tf.data का उपयोग कर खरोंच से एक इनपुट पाइप लाइन लिखने के लिए। अगले कदम के रूप, तो आप इस पर जाकर डेटा वृद्धि को जोड़ने का तरीका सीख सकते हैं ट्यूटोरियल । Tf.data के बारे में अधिक जानने के लिए, तो आप इस यात्रा कर सकते हैं गाइड