TensorFlow हब के साथ सीखने को स्थानांतरित करें

TensorFlow.org पर देखें Google Colab में चलाएं गिटहब पर देखें नोटबुक डाउनलोड करें टीएफ हब मॉडल देखें

TensorFlow हब पूर्व-प्रशिक्षित TensorFlow मॉडल का भंडार है।

यह ट्यूटोरियल दर्शाता है कि कैसे:

  1. TensorFlow हब से tf.keras के साथ मॉडल का उपयोग करें।
  2. TensorFlow हब से छवि वर्गीकरण मॉडल का उपयोग करें।
  3. अपने स्वयं के छवि वर्गों के लिए एक मॉडल को फाइन-ट्यून करने के लिए सरल स्थानांतरण शिक्षण करें।

सेट अप

import numpy as np
import time

import PIL.Image as Image
import matplotlib.pylab as plt

import tensorflow as tf
import tensorflow_hub as hub

import datetime

%load_ext tensorboard

एक इमेजनेट क्लासिफायरियर

आप इमेजनेट बेंचमार्क डेटासेट पर पूर्व-प्रशिक्षित क्लासिफायर मॉडल का उपयोग करके शुरू करेंगे—किसी प्रारंभिक प्रशिक्षण की आवश्यकता नहीं है!

क्लासिफायरियर डाउनलोड करें

TensorFlow हब से एक MobileNetV2 पूर्व-प्रशिक्षित मॉडल का चयन करें और इसे हब के साथ केरस परत के रूप में लपेटें। hub.KerasLayer । TensorFlow हब का कोई भी संगत इमेज क्लासिफायर मॉडल यहां काम करेगा, जिसमें नीचे दिए गए ड्रॉप-डाउन में दिए गए उदाहरण भी शामिल हैं।

mobilenet_v2 ="https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/4"
inception_v3 = "https://tfhub.dev/google/imagenet/inception_v3/classification/5"

classifier_model = mobilenet_v2

IMAGE_SHAPE = (224, 224)

classifier = tf.keras.Sequential([
    hub.KerasLayer(classifier_model, input_shape=IMAGE_SHAPE+(3,))
])

इसे एक ही छवि पर चलाएँ

मॉडल को आज़माने के लिए एक छवि डाउनलोड करें:

grace_hopper = tf.keras.utils.get_file('image.jpg','https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg')
grace_hopper = Image.open(grace_hopper).resize(IMAGE_SHAPE)
grace_hopper

Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg
65536/61306 [================================] - 0s 0us/step
73728/61306 [====================================] - 0s 0us/step

पीएनजी

grace_hopper = np.array(grace_hopper)/255.0
grace_hopper.shape

(224, 224, 3)

बैच आयाम जोड़ें ( np.newaxis के साथ) और छवि को मॉडल में पास करें:

result = classifier.predict(grace_hopper[np.newaxis, ...])
result.shape

(1, 1001)

परिणाम लॉग का 1001-तत्व वेक्टर है, छवि के लिए प्रत्येक वर्ग की संभावना को रेटिंग देता है।

शीर्ष श्रेणी आईडी tf.math.argmax के साथ मिल सकती है:

predicted_class = tf.math.argmax(result[0], axis=-1)
predicted_class

<tf.Tensor: shape=(), dtype=int64, numpy=653>

भविष्यवाणियों को डिकोड करें

predicted_class आईडी (जैसे 653 ) लें और भविष्यवाणियों को डीकोड करने के लिए इमेजनेट डेटासेट लेबल प्राप्त करें:

labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')
imagenet_labels = np.array(open(labels_path).read().splitlines())

Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt
16384/10484 [==============================================] - 0s 0us/step
24576/10484 [======================================================================] - 0s 0us/step

plt.imshow(grace_hopper)
plt.axis('off')
predicted_class_name = imagenet_labels[predicted_class]
_ = plt.title("Prediction: " + predicted_class_name.title())

पीएनजी

सरल स्थानांतरण सीखना

लेकिन क्या होगा यदि आप अपने स्वयं के डेटासेट का उपयोग करके एक कस्टम क्लासिफायरियर बनाना चाहते हैं जिसमें ऐसी कक्षाएं हैं जो मूल इमेजनेट डेटासेट में शामिल नहीं हैं (जिस पर पूर्व-प्रशिक्षित मॉडल को प्रशिक्षित किया गया था)?

ऐसा करने के लिए, आप कर सकते हैं:

  1. TensorFlow हब से पूर्व-प्रशिक्षित मॉडल का चयन करें; तथा
  2. अपने कस्टम डेटासेट से कक्षाओं को पहचानने के लिए शीर्ष (अंतिम) परत को फिर से प्रशिक्षित करें।

डेटासेट

इस उदाहरण में, आप TensorFlow फूल डेटासेट का उपयोग करेंगे:

data_root = tf.keras.utils.get_file(
  'flower_photos',
  'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
   untar=True)

Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
228818944/228813984 [==============================] - 7s 0us/step
228827136/228813984 [==============================] - 7s 0us/step

सबसे पहले, इस डेटा को tf.keras.utils.image_dataset_from_directory के साथ डिस्क से छवि डेटा का उपयोग करके मॉडल में लोड करें, जो एक tf.data.Dataset उत्पन्न करेगा:

batch_size = 32
img_height = 224
img_width = 224

train_ds = tf.keras.utils.image_dataset_from_directory(
  str(data_root),
  validation_split=0.2,
  subset="training",
  seed=123,
  image_size=(img_height, img_width),
  batch_size=batch_size
)

val_ds = tf.keras.utils.image_dataset_from_directory(
  str(data_root),
  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 2936 files for training.
Found 3670 files belonging to 5 classes.
Using 734 files for validation.

फूल डेटासेट में पाँच वर्ग होते हैं:

class_names = np.array(train_ds.class_names)
print(class_names)

['daisy' 'dandelion' 'roses' 'sunflowers' 'tulips']

दूसरा, क्योंकि छवि मॉडल के लिए TensorFlow हब का सम्मेलन [0, 1] श्रेणी में फ्लोट इनपुट की अपेक्षा करना है, इसे प्राप्त करने के लिए tf.keras.layers.Rescaling प्रीप्रोसेसिंग परत का उपयोग करें।

normalization_layer = tf.keras.layers.Rescaling(1./255)
train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y)) # Where x—images, y—labels.
val_ds = val_ds.map(lambda x, y: (normalization_layer(x), y)) # Where x—images, y—labels.

तीसरा, Dataset.prefetch के साथ बफ़र्ड प्रीफ़ेचिंग का उपयोग करके इनपुट पाइपलाइन को समाप्त करें, ताकि आप I/O अवरोधित समस्याओं के बिना डिस्क से डेटा प्राप्त कर सकें।

ये कुछ सबसे महत्वपूर्ण tf.data विधियाँ हैं जिनका उपयोग आपको डेटा लोड करते समय करना चाहिए। इच्छुक पाठक उनके बारे में अधिक जान सकते हैं, साथ ही tf.data API गाइड के साथ बेहतर प्रदर्शन में डिस्क और अन्य तकनीकों में डेटा को कैश करने के तरीके के बारे में जान सकते हैं।

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

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

(32, 224, 224, 3)
(32,)
2022-01-26 05:06:19.465331: 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.

छवियों के एक बैच पर क्लासिफायरियर चलाएँ

अब, क्लासिफायर को इमेज बैच पर चलाएँ:

result_batch = classifier.predict(train_ds)

predicted_class_names = imagenet_labels[tf.math.argmax(result_batch, axis=-1)]
predicted_class_names
प्लेसहोल्डर26 l10n-प्लेसहोल्डर
array(['daisy', 'coral fungus', 'rapeseed', ..., 'daisy', 'daisy',
       'birdhouse'], dtype='<U30')

जांचें कि ये भविष्यवाणियां छवियों के साथ कैसे मेल खाती हैं:

plt.figure(figsize=(10,9))
plt.subplots_adjust(hspace=0.5)
for n in range(30):
  plt.subplot(6,5,n+1)
  plt.imshow(image_batch[n])
  plt.title(predicted_class_names[n])
  plt.axis('off')
_ = plt.suptitle("ImageNet predictions")

पीएनजी

परिणाम सही से बहुत दूर हैं, लेकिन यह देखते हुए उचित है कि ये वे वर्ग नहीं हैं जिनके लिए मॉडल को प्रशिक्षित किया गया था ("डेज़ी" को छोड़कर)।

हेडलेस मॉडल डाउनलोड करें

TensorFlow हब शीर्ष वर्गीकरण परत के बिना भी मॉडल वितरित करता है। इनका उपयोग ट्रांसफर लर्निंग को आसानी से करने के लिए किया जा सकता है।

TensorFlow हब से एक MobileNetV2 पूर्व-प्रशिक्षित मॉडल चुनें। TensorFlow हब से कोई भी संगत छवि सुविधा वेक्टर मॉडल यहां काम करेगा, जिसमें ड्रॉप-डाउन मेनू के उदाहरण भी शामिल हैं।

mobilenet_v2 = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4"
inception_v3 = "https://tfhub.dev/google/tf2-preview/inception_v3/feature_vector/4"

feature_extractor_model = mobilenet_v2

हब के साथ hub.KerasLayer परत के रूप में पूर्व-प्रशिक्षित मॉडल को लपेटकर फीचर एक्सट्रैक्टर बनाएं। चर को फ्रीज करने के लिए trainable=False तर्क का उपयोग करें, ताकि प्रशिक्षण केवल नई क्लासिफायरियर परत को संशोधित करे:

feature_extractor_layer = hub.KerasLayer(
    feature_extractor_model,
    input_shape=(224, 224, 3),
    trainable=False)

फीचर एक्सट्रैक्टर प्रत्येक छवि के लिए 1280-लंबा वेक्टर देता है (इस उदाहरण में छवि बैच का आकार 32 पर रहता है):

feature_batch = feature_extractor_layer(image_batch)
print(feature_batch.shape)

(32, 1280)

एक वर्गीकरण शीर्ष संलग्न करें

मॉडल को पूरा करने के लिए, फीचर एक्सट्रैक्टर लेयर को tf.keras.Sequential मॉडल में लपेटें और वर्गीकरण के लिए पूरी तरह से कनेक्टेड लेयर जोड़ें:

num_classes = len(class_names)

model = tf.keras.Sequential([
  feature_extractor_layer,
  tf.keras.layers.Dense(num_classes)
])

model.summary()

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 keras_layer_1 (KerasLayer)  (None, 1280)              2257984   
                                                                 
 dense (Dense)               (None, 5)                 6405      
                                                                 
=================================================================
Total params: 2,264,389
Trainable params: 6,405
Non-trainable params: 2,257,984
_________________________________________________________________

predictions = model(image_batch)

predictions.shape

TensorShape([32, 5])

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

प्रशिक्षण प्रक्रिया को कॉन्फ़िगर करने के लिए Model.compile का उपयोग करें और लॉग बनाने और संग्रहीत करने के लिए tf.keras.callbacks.TensorBoard कॉलबैक जोड़ें:

model.compile(
  optimizer=tf.keras.optimizers.Adam(),
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
  metrics=['acc'])

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir=log_dir,
    histogram_freq=1) # Enable histogram computation for every epoch.

अब मॉडल को प्रशिक्षित करने के लिए Model.fit पद्धति का उपयोग करें।

इस उदाहरण को छोटा रखने के लिए, आप केवल 10 युगों के लिए प्रशिक्षण लेंगे। बाद में TensorBoard में प्रशिक्षण प्रगति की कल्पना करने के लिए, एक TensorBoard कॉलबैक लॉग बनाएँ और संग्रहीत करें।

NUM_EPOCHS = 10

history = model.fit(train_ds,
                    validation_data=val_ds,
                    epochs=NUM_EPOCHS,
                    callbacks=tensorboard_callback)

Epoch 1/10
92/92 [==============================] - 7s 42ms/step - loss: 0.7904 - acc: 0.7210 - val_loss: 0.4592 - val_acc: 0.8515
Epoch 2/10
92/92 [==============================] - 3s 33ms/step - loss: 0.3850 - acc: 0.8713 - val_loss: 0.3694 - val_acc: 0.8787
Epoch 3/10
92/92 [==============================] - 3s 33ms/step - loss: 0.3027 - acc: 0.9057 - val_loss: 0.3367 - val_acc: 0.8856
Epoch 4/10
92/92 [==============================] - 3s 33ms/step - loss: 0.2524 - acc: 0.9237 - val_loss: 0.3210 - val_acc: 0.8869
Epoch 5/10
92/92 [==============================] - 3s 33ms/step - loss: 0.2164 - acc: 0.9373 - val_loss: 0.3124 - val_acc: 0.8896
Epoch 6/10
92/92 [==============================] - 3s 33ms/step - loss: 0.1888 - acc: 0.9469 - val_loss: 0.3070 - val_acc: 0.8937
Epoch 7/10
92/92 [==============================] - 3s 33ms/step - loss: 0.1668 - acc: 0.9550 - val_loss: 0.3032 - val_acc: 0.9005
Epoch 8/10
92/92 [==============================] - 3s 33ms/step - loss: 0.1487 - acc: 0.9619 - val_loss: 0.3004 - val_acc: 0.9005
Epoch 9/10
92/92 [==============================] - 3s 33ms/step - loss: 0.1335 - acc: 0.9687 - val_loss: 0.2981 - val_acc: 0.9019
Epoch 10/10
92/92 [==============================] - 3s 33ms/step - loss: 0.1206 - acc: 0.9748 - val_loss: 0.2964 - val_acc: 0.9046

प्रत्येक युग के साथ मीट्रिक कैसे बदलते हैं और अन्य स्केलर मानों को ट्रैक करने के लिए TensorBoard प्रारंभ करें:

%tensorboard --logdir logs/fit

भविष्यवाणियों की जाँच करें

मॉडल भविष्यवाणियों से वर्ग के नामों की क्रमबद्ध सूची प्राप्त करें:

predicted_batch = model.predict(image_batch)
predicted_id = tf.math.argmax(predicted_batch, axis=-1)
predicted_label_batch = class_names[predicted_id]
print(predicted_label_batch)

['roses' 'dandelion' 'tulips' 'sunflowers' 'dandelion' 'roses' 'dandelion'
 'roses' 'tulips' 'dandelion' 'tulips' 'tulips' 'sunflowers' 'tulips'
 'dandelion' 'roses' 'daisy' 'tulips' 'dandelion' 'dandelion' 'dandelion'
 'tulips' 'sunflowers' 'roses' 'sunflowers' 'dandelion' 'tulips' 'roses'
 'roses' 'sunflowers' 'tulips' 'sunflowers']

मॉडल भविष्यवाणियों को प्लॉट करें:

plt.figure(figsize=(10,9))
plt.subplots_adjust(hspace=0.5)

for n in range(30):
  plt.subplot(6,5,n+1)
  plt.imshow(image_batch[n])
  plt.title(predicted_label_batch[n].title())
  plt.axis('off')
_ = plt.suptitle("Model predictions")

पीएनजी

अपने मॉडल को निर्यात और पुनः लोड करें

अब जब आपने मॉडल को प्रशिक्षित कर लिया है, तो इसे बाद में पुन: उपयोग करने के लिए सहेजे गए मॉडल के रूप में निर्यात करें।

t = time.time()

export_path = "/tmp/saved_models/{}".format(int(t))
model.save(export_path)

export_path

2022-01-26 05:07:03.429901: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/saved_models/1643173621/assets
INFO:tensorflow:Assets written to: /tmp/saved_models/1643173621/assets
'/tmp/saved_models/1643173621'

पुष्टि करें कि आप सहेजे गए मॉडल को पुनः लोड कर सकते हैं और मॉडल समान परिणाम आउटपुट करने में सक्षम है:

reloaded = tf.keras.models.load_model(export_path)

result_batch = model.predict(image_batch)
reloaded_result_batch = reloaded.predict(image_batch)

abs(reloaded_result_batch - result_batch).max()

0.0
51 l10n-
reloaded_predicted_id = tf.math.argmax(reloaded_result_batch, axis=-1)
reloaded_predicted_label_batch = class_names[reloaded_predicted_id]
print(reloaded_predicted_label_batch)

['roses' 'dandelion' 'tulips' 'sunflowers' 'dandelion' 'roses' 'dandelion'
 'roses' 'tulips' 'dandelion' 'tulips' 'tulips' 'sunflowers' 'tulips'
 'dandelion' 'roses' 'daisy' 'tulips' 'dandelion' 'dandelion' 'dandelion'
 'tulips' 'sunflowers' 'roses' 'sunflowers' 'dandelion' 'tulips' 'roses'
 'roses' 'sunflowers' 'tulips' 'sunflowers']

plt.figure(figsize=(10,9))
plt.subplots_adjust(hspace=0.5)
for n in range(30):
  plt.subplot(6,5,n+1)
  plt.imshow(image_batch[n])
  plt.title(reloaded_predicted_label_batch[n].title())
  plt.axis('off')
_ = plt.suptitle("Model predictions")

पीएनजी

अगले कदम

आप अनुमान के लिए लोड करने के लिए SavedModel का उपयोग कर सकते हैं या इसे TensorFlow Lite मॉडल (ऑन-डिवाइस मशीन लर्निंग के लिए) या TensorFlow.js मॉडल (जावास्क्रिप्ट में मशीन लर्निंग के लिए) में बदल सकते हैं।

छवि, पाठ, ऑडियो और वीडियो कार्यों पर TensorFlow हब से पूर्व-प्रशिक्षित मॉडल का उपयोग करने का तरीका जानने के लिए और अधिक ट्यूटोरियल खोजें।