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

छवि वर्गीकरण

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

इस ट्यूटोरियल दिखाता है कि कैसे फूलों की छवियों को वर्गीकृत करने के। यह एक का उपयोग कर एक छवि वर्गीकारक बनाता keras.Sequential मॉडल, और भार डेटा का उपयोग कर preprocessing.image_dataset_from_directory । आप नीचे दिए गए अवधारणाओं के साथ व्यावहारिक अनुभव प्राप्त होगा:

  • कुशलतापूर्वक डिस्क बंद एक डाटासेट लोड हो रहा है।
  • overfitting की पहचान करना और यह कम करने के लिए तकनीक, डेटा वृद्धि और छोड़ने वालों सहित लागू करने।

इस ट्यूटोरियल एक बुनियादी मशीन सीखने कार्यप्रवाह इस प्रकार है:

  1. जांच करना और डेटा को समझने
  2. एक इनपुट पाइपलाइन का निर्माण
  3. मॉडल का निर्माण
  4. मॉडल ट्रेन
  5. मॉडल का परीक्षण करें
  6. मॉडल में सुधार और प्रक्रिया दोहराएं
pip install -q tf-nightly

आयात TensorFlow और अन्य पुस्तकालयों

 import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf

from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
 

डाउनलोड करें और डाटासेट का पता लगाने

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

 flower_photo/
  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('flower_photos', origin=dataset_url, untar=True)
data_dir = pathlib.Path(data_dir)
 
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
228818944/228813984 [==============================] - 4s 0us/step

डाउनलोड के बाद, अब डाटासेट की एक प्रति उपलब्ध होना चाहिए। वहाँ 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

 PIL.Image.open(str(roses[1]))
 

png

और कुछ: ट्यूलिप

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

png

 PIL.Image.open(str(tulips[1]))
 

png

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

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

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

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

 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 छवियों लेबल इसी रहे हैं।

आप कॉल कर सकते हैं .numpy() पर image_batch और labels_batch tensors उन्हें एक में बदलने के लिए numpy.ndarray

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

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

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

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

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

 AUTOTUNE = tf.data.experimental.AUTOTUNE

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

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

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

 normalization_layer = 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 1.0

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

मॉडल बनाएं

मॉडल उनमें से प्रत्येक में एक अधिकतम पूल परत के साथ तीन घुमाव के ब्लॉक के होते हैं। वहाँ है कि एक से सक्रिय होता है सब के ऊपर 128 इकाइयों के साथ एक पूरी तरह से जुड़ा हुआ परत है relu सक्रियण कार्य करते हैं। यह मॉडल उच्च सटीकता के लिए देखते नहीं किया गया है, इस ट्यूटोरियल के लक्ष्य को एक मानक दृष्टिकोण को दिखाने के लिए है।

 num_classes = 5

model = Sequential([
  layers.experimental.preprocessing.Rescaling(1./255, input_shape=(img_height, img_width, 3)),
  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)
])
 

मॉडल संकलित करें

इस ट्यूटोरियल के लिए, चुनें optimizers.Adam अनुकूलक और losses.SparseCategoricalCrossentropy नुकसान कार्य करते हैं। प्रत्येक प्रशिक्षण युग के लिए दृश्य प्रशिक्षण और मान्यता सटीकता के लिए, पारित metrics तर्क।

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

मॉडल सारांश

मॉडल का उपयोग कर नेटवर्क के सभी स्तर देखें summary विधि:

 model.summary()
 
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
rescaling_1 (Rescaling)      (None, 180, 180, 3)       0         
_________________________________________________________________
conv2d (Conv2D)              (None, 180, 180, 16)      448       
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 90, 90, 16)        0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 90, 90, 32)        4640      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 45, 45, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 45, 45, 64)        18496     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 22, 22, 64)        0         
_________________________________________________________________
flatten (Flatten)            (None, 30976)             0         
_________________________________________________________________
dense (Dense)                (None, 128)               3965056   
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 645       
=================================================================
Total params: 3,989,285
Trainable params: 3,989,285
Non-trainable params: 0
_________________________________________________________________

मॉडल ट्रेन

 epochs=10
history = model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=epochs
)
 
Epoch 1/10
92/92 [==============================] - 4s 47ms/step - loss: 1.9328 - accuracy: 0.2896 - val_loss: 1.1022 - val_accuracy: 0.5245
Epoch 2/10
92/92 [==============================] - 1s 10ms/step - loss: 1.0441 - accuracy: 0.5761 - val_loss: 1.0057 - val_accuracy: 0.5913
Epoch 3/10
92/92 [==============================] - 1s 10ms/step - loss: 0.8640 - accuracy: 0.6763 - val_loss: 0.8951 - val_accuracy: 0.6499
Epoch 4/10
92/92 [==============================] - 1s 10ms/step - loss: 0.7106 - accuracy: 0.7472 - val_loss: 0.8992 - val_accuracy: 0.6621
Epoch 5/10
92/92 [==============================] - 1s 10ms/step - loss: 0.4817 - accuracy: 0.8285 - val_loss: 0.8997 - val_accuracy: 0.6662
Epoch 6/10
92/92 [==============================] - 1s 10ms/step - loss: 0.3131 - accuracy: 0.8903 - val_loss: 1.0014 - val_accuracy: 0.6567
Epoch 7/10
92/92 [==============================] - 1s 10ms/step - loss: 0.1782 - accuracy: 0.9436 - val_loss: 1.2140 - val_accuracy: 0.6431
Epoch 8/10
92/92 [==============================] - 1s 10ms/step - loss: 0.1024 - accuracy: 0.9703 - val_loss: 1.5144 - val_accuracy: 0.6240
Epoch 9/10
92/92 [==============================] - 1s 10ms/step - loss: 0.0736 - accuracy: 0.9815 - val_loss: 1.7651 - val_accuracy: 0.5926
Epoch 10/10
92/92 [==============================] - 1s 10ms/step - loss: 0.0761 - accuracy: 0.9775 - val_loss: 2.0429 - val_accuracy: 0.5967

कल्पना प्रशिक्षण परिणाम

हानि और प्रशिक्षण और सत्यापन सेट पर सटीकता के भूखंडों बनाएँ।

 acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss=history.history['loss']
val_loss=history.history['val_loss']

epochs_range = range(epochs)

plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
 

png

आप भूखंडों से देख सकते हैं, प्रशिक्षण सटीकता और मान्यता सटीकता बड़े अंतर से बंद कर रहे हैं और मॉडल सत्यापन सेट पर केवल 60 के आसपास% सटीकता हासिल की है।

पर आइए नज़र क्या गलत हुआ और मॉडल के समग्र प्रदर्शन को बढ़ाने के लिए प्रयास करें।

Overfitting

ऊपर भूखंडों में, प्रशिक्षण सटीकता समय के साथ सीध में बढ़ते है, जबकि मान्यता सटीकता प्रशिक्षण प्रक्रिया में लगभग 60% रुक जाता। इसके अलावा, प्रशिक्षण और मान्यता सटीकता के बीच सटीकता में अंतर ध्यान देने योग्य-एक की निशानी है overfitting

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

वहाँ प्रशिक्षण प्रक्रिया में overfitting लड़ने के लिए कई तरीके हैं। इस ट्यूटोरियल में, आप डेटा वृद्धि का उपयोग करें और अपने मॉडल में छोड़ने वालों जोड़ देंगे।

डाटा वृद्धि

आम तौर पर Overfitting तब होती है जब प्रशिक्षण उदाहरण की एक छोटी संख्या है। डाटा वृद्धि तो बढ़ाने यादृच्छिक परिवर्तनों कि विश्वसनीय दिखने छवियों उपज का उपयोग करके अपने मौजूदा उदाहरण से अतिरिक्त प्रशिक्षण डेटा पैदा करने की दृष्टिकोण लेता है। इस डेटा के अधिक पहलुओं को मॉडल का पर्दाफाश और बेहतर सामान्यीकरण मदद करता है।

हम प्रयोगात्मक का उपयोग कर डेटा वृद्धि को लागू करेगा Keras Preprocessing परतें । ये अन्य परतों की तरह अपने मॉडल के अंदर शामिल किया जा सकता है, और GPU पर चलते हैं।

 data_augmentation = keras.Sequential(
  [
    layers.experimental.preprocessing.RandomFlip("horizontal", 
                                                 input_shape=(img_height, 
                                                              img_width,
                                                              3)),
    layers.experimental.preprocessing.RandomRotation(0.1),
    layers.experimental.preprocessing.RandomZoom(0.1),
  ]
)
 

आइए कल्पना क्या कुछ संवर्धित उदाहरण कई बार एक ही छवि के लिए डेटा वृद्धि लगाने से की तरह लग रहे:

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

png

हम डेटा वृद्धि का उपयोग एक पल में एक मॉडल को प्रशिक्षित करने होंगे।

ड्रॉप आउट

एक और तकनीक overfitting कम करने के लिए लागू करने के लिए है छोड़ने वालों नेटवर्क, नियमितीकरण का एक रूप है।

जब आप एक परत को बाहर निकाला हुआ लागू यह बेतरतीब ढंग से प्रशिक्षण की प्रक्रिया के दौरान परत से उत्पादन इकाइयों के एक नंबर (सक्रियण शून्य करने के लिए सेट करके) बाहर चला जाता है। छोड़ने वालों रूप में इस तरह के 0.1, 0.2, 0.4, आदि के रूप यह साधन लागू परत से बेतरतीब ढंग से 10%, 20% या उत्पादन इकाइयों का 40% ही छोड़ने में अपने इनपुट मूल्य के रूप में एक भिन्नात्मक संख्या लेता है,।

के उपयोग कर एक नया तंत्रिका नेटवर्क बनाएँ layers.Dropout , तो यह संवर्धित छवियों का उपयोग कर ट्रेन।

 model = Sequential([
  data_augmentation,
  layers.experimental.preprocessing.Rescaling(1./255),
  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.Dropout(0.2),
  layers.Flatten(),
  layers.Dense(128, activation='relu'),
  layers.Dense(num_classes)
])
 

संकलित करें और मॉडल को प्रशिक्षित

 model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])
 
 model.summary()
 
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
sequential_1 (Sequential)    (None, 180, 180, 3)       0         
_________________________________________________________________
rescaling_2 (Rescaling)      (None, 180, 180, 3)       0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 180, 180, 16)      448       
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 90, 90, 16)        0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 90, 90, 32)        4640      
_________________________________________________________________
max_pooling2d_4 (MaxPooling2 (None, 45, 45, 32)        0         
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 45, 45, 64)        18496     
_________________________________________________________________
max_pooling2d_5 (MaxPooling2 (None, 22, 22, 64)        0         
_________________________________________________________________
dropout (Dropout)            (None, 22, 22, 64)        0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 30976)             0         
_________________________________________________________________
dense_2 (Dense)              (None, 128)               3965056   
_________________________________________________________________
dense_3 (Dense)              (None, 5)                 645       
=================================================================
Total params: 3,989,285
Trainable params: 3,989,285
Non-trainable params: 0
_________________________________________________________________

 epochs = 15
history = model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=epochs
)
 
Epoch 1/15
92/92 [==============================] - 2s 20ms/step - loss: 1.4842 - accuracy: 0.3279 - val_loss: 1.0863 - val_accuracy: 0.5640
Epoch 2/15
92/92 [==============================] - 1s 12ms/step - loss: 1.1215 - accuracy: 0.5284 - val_loss: 1.0374 - val_accuracy: 0.6022
Epoch 3/15
92/92 [==============================] - 1s 12ms/step - loss: 0.9680 - accuracy: 0.6117 - val_loss: 0.9200 - val_accuracy: 0.6485
Epoch 4/15
92/92 [==============================] - 1s 12ms/step - loss: 0.8538 - accuracy: 0.6753 - val_loss: 0.9206 - val_accuracy: 0.6417
Epoch 5/15
92/92 [==============================] - 1s 12ms/step - loss: 0.7744 - accuracy: 0.6977 - val_loss: 0.8169 - val_accuracy: 0.6839
Epoch 6/15
92/92 [==============================] - 1s 13ms/step - loss: 0.7758 - accuracy: 0.7093 - val_loss: 0.7743 - val_accuracy: 0.6880
Epoch 7/15
92/92 [==============================] - 1s 13ms/step - loss: 0.6805 - accuracy: 0.7481 - val_loss: 0.8598 - val_accuracy: 0.6540
Epoch 8/15
92/92 [==============================] - 1s 13ms/step - loss: 0.7132 - accuracy: 0.7278 - val_loss: 0.7177 - val_accuracy: 0.7207
Epoch 9/15
92/92 [==============================] - 1s 13ms/step - loss: 0.6634 - accuracy: 0.7580 - val_loss: 0.7152 - val_accuracy: 0.7166
Epoch 10/15
92/92 [==============================] - 1s 13ms/step - loss: 0.6562 - accuracy: 0.7538 - val_loss: 0.7251 - val_accuracy: 0.7248
Epoch 11/15
92/92 [==============================] - 1s 13ms/step - loss: 0.5798 - accuracy: 0.7840 - val_loss: 0.7016 - val_accuracy: 0.7357
Epoch 12/15
92/92 [==============================] - 1s 13ms/step - loss: 0.5635 - accuracy: 0.7913 - val_loss: 0.7755 - val_accuracy: 0.7248
Epoch 13/15
92/92 [==============================] - 1s 13ms/step - loss: 0.5361 - accuracy: 0.7982 - val_loss: 0.7575 - val_accuracy: 0.7153
Epoch 14/15
92/92 [==============================] - 1s 13ms/step - loss: 0.5420 - accuracy: 0.8022 - val_loss: 0.7375 - val_accuracy: 0.7302
Epoch 15/15
92/92 [==============================] - 1s 12ms/step - loss: 0.5132 - accuracy: 0.8120 - val_loss: 0.7561 - val_accuracy: 0.7289

कल्पना प्रशिक्षण परिणाम

डेटा वृद्धि और छोड़ने वालों को लागू करने के बाद, वहाँ कम से पहले की तुलना overfitting है, और प्रशिक्षण और मान्यता सटीकता करीब गठबंधन कर रहे हैं।

 acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(epochs)

plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
 

png

नए आंकड़ों पर भविष्यवाणी

अंत में, चलो हमारे मॉडल का उपयोग करने वाला कोई चित्र प्रशिक्षण या मान्यता सेटों में शामिल नहीं किया गया वर्गीकृत करने के लिए करते हैं।

 sunflower_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg"
sunflower_path = tf.keras.utils.get_file('Red_sunflower', origin=sunflower_url)

img = keras.preprocessing.image.load_img(
    sunflower_path, target_size=(img_height, img_width)
)
img_array = keras.preprocessing.image.img_to_array(img)
img_array = tf.expand_dims(img_array, 0) # Create a batch

predictions = model.predict(img_array)
score = tf.nn.softmax(predictions[0])

print(
    "This image most likely belongs to {} with a {:.2f} percent confidence."
    .format(class_names[np.argmax(score)], 100 * np.max(score))
)
 
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg
122880/117948 [===============================] - 0s 0us/step
This image most likely belongs to sunflowers with a 89.39 percent confidence.