This page was translated by the Cloud Translation API.
Switch to English

চিত্রের শ্রেণিবিন্যাস

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

এই টিউটোরিয়ালটি দেখায় যে কীভাবে ফুলের চিত্রকে শ্রেণিবদ্ধ করা যায়। এটা একটা ব্যবহার করে একটি ইমেজ ক্লাসিফায়ার সৃষ্টি keras.Sequential মডেল, এবং লোড ডেটা ব্যবহার preprocessing.image_dataset_from_directory । আপনি নিম্নলিখিত ধারণাগুলি সহ ব্যবহারিক অভিজ্ঞতা অর্জন করবেন:

  • দক্ষতার সাথে একটি ডেটাসেট অফ ডিস্ক লোড করা হচ্ছে।
  • উপাত্তবৃদ্ধি এবং ড্রপআউট সহ এটিকে কমাতে কৌশলগুলি প্রয়োগ ও প্রয়োগ করা।

এই টিউটোরিয়ালটি একটি মৌলিক মেশিন শেখার ওয়ার্কফ্লো অনুসরণ করে:

  1. ডেটা পরীক্ষা করে দেখুন
  2. একটি ইনপুট পাইপলাইন তৈরি করুন
  3. মডেল তৈরি করুন
  4. মডেল প্রশিক্ষণ
  5. মডেল পরীক্ষা
  6. মডেলটি উন্নত করুন এবং প্রক্রিয়াটি পুনরাবৃত্তি করুন
pip install -q tf-nightly

টেনসরফ্লো এবং অন্যান্য লাইব্রেরি আমদানি করুন

 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

ডাউনলোডের পরে আপনার কাছে এখন ডেটাসেটের একটি অনুলিপি পাওয়া উচিত। মোট চিত্র আছে 3,670:

 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

কেরাস.প্রিপ্রসেসিং ব্যবহার করে লোড করুন

সহায়ক চিত্র_ডেটসেট_ফর্ম_ডাইরেক্টরি ইউটিলিটি ব্যবহার করে এই চিত্রগুলি ডিস্কের বাইরে লোড করি load এটি আপনাকে ডিস্কের চিত্রগুলির একটি ডিরেক্টরি থেকে tf.data.Dataset কয়েকটি লাইনে একটি 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 আকৃতির একটি image_batch (32, 180, 180, 3) । এটি 180x180x3 আকারের 32 টি চিত্রের একটি ব্যাচ (রঙের চ্যানেল আরজিবিতে শেষ মাত্রাটি 180x180x3 করে)। label_batch (32,) আকৃতির একটি label_batch , এটি 32 টি চিত্রের সাথে সম্পর্কিত লেবেল।

আপনি কল করতে পারেন .numpy() উপর image_batch এবং labels_batch tensors তাদের রূপান্তর numpy.ndarray

পারফরম্যান্সের জন্য ডেটাসেট কনফিগার করুন

আসুন আমরা বাফার প্রিফেচিং ব্যবহার নিশ্চিত করে থাকি যাতে I / O ব্লক হয়ে না গিয়ে আমরা ডিস্ক থেকে ডেটা উপার্জন করতে পারি। ডেটা লোড করার সময় আপনার এই দুটি গুরুত্বপূর্ণ পদ্ধতি ব্যবহার করা উচিত।

প্রথম পর্বের সময় ডিস্কটি লোড করার পরে চিত্রগুলি মেমরিতে রাখে Dataset.cache() । এটি আপনার মডেলকে প্রশিক্ষণ দেওয়ার সময় ডেটাসেটটি কোনও বাধা হয়ে উঠবে না তা নিশ্চিত করবে। যদি আপনার ডেটাসেট মেমরির সাথে ফিট করার জন্য খুব বড় হয় তবে আপনি অন-ডিস্ক ক্যাশে পারফরম্যান্স তৈরি করতে এই পদ্ধতিটিও ব্যবহার করতে পারেন।

Dataset.prefetch() প্রশিক্ষণের সময় ডেটা Dataset.prefetch() এবং মডেল এক্সিকিউশনকে ওভারল্যাপ করে।

আগ্রহী পাঠকরা উভয় পদ্ধতি এবং সেইসাথে কীভাবে ডেটা পারফরম্যান্স গাইডের মধ্যে ডিস্কে ডেটা ক্যাশে করবেন সে সম্পর্কে আরও জানতে পারবেন।

 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] মানগুলিকে মানীকৃত করব।

 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 অপটিমাইজার এবং ক্ষয় 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% স্টল করে। এছাড়াও, প্রশিক্ষণ এবং বৈধতা যথার্থতার মধ্যে নির্ভুলতার মধ্যে পার্থক্য লক্ষণীয় - অতিরিক্ত মানানসই একটি চিহ্ন।

যখন কয়েকটি সংখ্যক প্রশিক্ষণের উদাহরণ থাকে, তখন মডেলটি কখনও কখনও প্রশিক্ষণের উদাহরণগুলি থেকে শোরগোল বা অযাচিত বিবরণগুলি থেকে এমন কিছু শিখে। এমন একটি পরিমাণে যে এটি নতুন উদাহরণগুলিতে মডেলটির কার্যকারিতাটিকে নেতিবাচকভাবে প্রভাবিত করে। এই ঘটনাটি ওভারফিটিং হিসাবে পরিচিত। এর অর্থ হল যে নতুন ডেটাসেটটিতে মডেলটির সাধারণীকরণে একটি কঠিন সময় আসবে।

প্রশিক্ষণ প্রক্রিয়ায় ওভারফিটিংয়ের লড়াইয়ের একাধিক উপায় রয়েছে। এই টিউটোরিয়ালে, আপনি ডেটা বৃদ্ধি ব্যবহার করবেন এবং আপনার মডেলটিতে ড্রপআউট যুক্ত করবেন।

ডেটা বৃদ্ধি

ওভারফিটিং সাধারণত তখন ঘটে যখন প্রশিক্ষণের কয়েকটি সংখ্যার উদাহরণ থাকে। ডেটা অগমেন্টেশন আপনার বিদ্যমান উদাহরণগুলি থেকে বর্ধিত করে বিশ্বাসযোগ্য-দর্শনীয় চিত্রগুলি প্রাপ্ত এলোমেলো রূপান্তরগুলি ব্যবহার করে অতিরিক্ত প্রশিক্ষণ ডেটা জেনার পদ্ধতিকে গ্রহণ করে। এটি ডেটাটির আরও দিকগুলিতে মডেলটি প্রকাশ করতে এবং আরও সাধারণকরণে সহায়তা করে।

আমরা পরীক্ষামূলক কেরাস প্রিপ্রোসেসিং লেয়ারগুলি ব্যবহার করে ডেটা বৃদ্ধির বাস্তবায়ন করব। এগুলি অন্যান্য স্তরগুলির মতো আপনার মডেলের অভ্যন্তরে অন্তর্ভুক্ত হতে পারে এবং জিপিইউতে চলে।

 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

আমরা কোনও মুহুর্তে কোনও মডেলকে প্রশিক্ষণের জন্য ডেটা অগমেন্টেশন ব্যবহার করব।

বাদ পড়া

ওভারফিটিং হ্রাস করার আরেকটি কৌশল হ'ল নেটওয়ার্কে ড্রপআউট চালু করা, এটি নিয়মিতকরণের একধরণের

আপনি যখন কোনও স্তরে ড্রপআউট প্রয়োগ করেন তা প্রশিক্ষণ প্রক্রিয়া চলাকালীন এলোমেলোভাবে (অ্যাক্টিভেশনটি শূন্যে সেট করে) স্তর থেকে বেরিয়ে যায়। ড্রপআউট তার ইনপুট মান হিসাবে ভগ্নাংশের সংখ্যা গ্রহণ করে, যেমন 0.1, 0.2, 0.4, ইত্যাদি হিসাবে। এর অর্থ প্রয়োগকৃত স্তর থেকে এলোমেলোভাবে 10%, 20% বা 40% আউটপুট ইউনিট বাদ দেওয়া হয়।

আসুন layers.Dropout ব্যবহার করে একটি নতুন নিউরাল নেটওয়ার্ক তৈরি করুন 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

প্রশিক্ষণের ফলাফল ভিজ্যুয়ালাইজ করুন

ডেটা অগমেন্টেশন এবং ড্রপআউট প্রয়োগ করার পরে, আগের তুলনায় খুব বেশি ফিট করা হয় এবং প্রশিক্ষণ এবং বৈধতার যথাযথতা আরও কাছাকাছি সংযুক্ত থাকে।

 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.