अपने स्थानीय TensorFlow के लिए RSVP आज हर जगह घटना!
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

एक छवि क्लासिफायरियर को फिर से देखना

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

परिचय

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

यह कोलाब दर्शाता है कि इमेज प्रॉपर्टी एक्सट्रैक्शन के लिए टेन्सरफ्लो हब से प्री-प्रशिक्षित TF2 SavedModel का उपयोग करके फूलों की पांच प्रजातियों को वर्गीकृत करने के लिए एक केरस मॉडल का निर्माण करना है, जो कि अधिक बड़े और अधिक सामान्य इमेजनेट डेटासेट पर प्रशिक्षित होता है। वैकल्पिक रूप से, फ़ीचर एक्सट्रैक्टर को नए जोड़े गए क्लासिफायरियर के साथ ("ठीक-ठीक") प्रशिक्षित किया जा सकता है।

इसके बजाय एक उपकरण के लिए खोज रहे हैं?

यह एक TensorFlow कोडिंग ट्यूटोरियल है। यदि आप ऐसा टूल चाहते हैं, जो सिर्फ TensorFlow या TF Lite मॉडल बनाता है, तो PIP पैकेज tensorflow-hub[make_image_classifier] या इस TF लाइट कोलाब द्वारा स्थापित मेक_इमेज_क्लासीफायर कमांड-लाइन टूल पर एक नज़र डालें।

सेट अप

import itertools
import os

import matplotlib.pylab as plt
import numpy as np

import tensorflow as tf
import tensorflow_hub as hub

print("TF version:", tf.__version__)
print("Hub version:", hub.__version__)
print("GPU is", "available" if tf.test.is_gpu_available() else "NOT AVAILABLE")
TF version: 2.4.0
Hub version: 0.11.0
WARNING:tensorflow:From <ipython-input-1-0831fa394ed3>:12: is_gpu_available (from tensorflow.python.framework.test_util) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.config.list_physical_devices('GPU')` instead.
GPU is available

उपयोग करने के लिए TF2 SavedModel मॉड्यूल का चयन करें

शुरुआत के लिए, https: //tfhub.dev/google/imagenet/mobetenet_v2_100_224/feature_vector/4 का उपयोग करें । SavedModel की पहचान करने के लिए और अपने ब्राउज़र में इसका प्रलेखन दिखाने के लिए उसी URL का उपयोग कोड में किया जा सकता है। (ध्यान दें कि TF1 हब प्रारूप में मॉडल यहां काम नहीं करेंगे।)

आप यहां अधिक TF2 मॉडल पा सकते हैं जो यहां छवि सुविधा वैक्टर उत्पन्न करते हैं

module_selection = ("mobilenet_v2_100_224", 224)
handle_base, pixels = module_selection
MODULE_HANDLE ="https://tfhub.dev/google/imagenet/{}/feature_vector/4".format(handle_base)
IMAGE_SIZE = (pixels, pixels)
print("Using {} with input size {}".format(MODULE_HANDLE, IMAGE_SIZE))

BATCH_SIZE = 32
Using https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4 with input size (224, 224)

फूल डाटासेट सेट करें

चयनित मॉड्यूल के लिए इनपुट उपयुक्त हैं। डेटासेट वृद्धि (यानी, हर बार पढ़ने के बाद एक छवि का यादृच्छिक विकृतियों) प्रशिक्षण, एस्प में सुधार होता है। जब ठीक हो।

data_dir = 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 [==============================] - 9s 0us/step

datagen_kwargs = dict(rescale=1./255, validation_split=.20)
dataflow_kwargs = dict(target_size=IMAGE_SIZE, batch_size=BATCH_SIZE,
                   interpolation="bilinear")

valid_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
    **datagen_kwargs)
valid_generator = valid_datagen.flow_from_directory(
    data_dir, subset="validation", shuffle=False, **dataflow_kwargs)

do_data_augmentation = False
if do_data_augmentation:
  train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
      rotation_range=40,
      horizontal_flip=True,
      width_shift_range=0.2, height_shift_range=0.2,
      shear_range=0.2, zoom_range=0.2,
      **datagen_kwargs)
else:
  train_datagen = valid_datagen
train_generator = train_datagen.flow_from_directory(
    data_dir, subset="training", shuffle=True, **dataflow_kwargs)
Found 731 images belonging to 5 classes.
Found 2939 images belonging to 5 classes.

मॉडल को परिभाषित करना

यह सब लेता है हब मॉड्यूल के साथ feature_extractor_layer शीर्ष पर एक रैखिक क्लासिफायरियर है।

गति के लिए, हम एक गैर-ट्रेन करने feature_extractor_layer साथ शुरू करते हैं, लेकिन आप अधिक सटीकता के साथ फाइन-ट्यूनिंग को भी सक्षम कर सकते हैं।

do_fine_tuning = False
print("Building model with", MODULE_HANDLE)
model = tf.keras.Sequential([
    # Explicitly define the input shape so the model can be properly
    # loaded by the TFLiteConverter
    tf.keras.layers.InputLayer(input_shape=IMAGE_SIZE + (3,)),
    hub.KerasLayer(MODULE_HANDLE, trainable=do_fine_tuning),
    tf.keras.layers.Dropout(rate=0.2),
    tf.keras.layers.Dense(train_generator.num_classes,
                          kernel_regularizer=tf.keras.regularizers.l2(0.0001))
])
model.build((None,)+IMAGE_SIZE+(3,))
model.summary()
Building model with https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
keras_layer (KerasLayer)     (None, 1280)              2257984   
_________________________________________________________________
dropout (Dropout)            (None, 1280)              0         
_________________________________________________________________
dense (Dense)                (None, 5)                 6405      
=================================================================
Total params: 2,264,389
Trainable params: 6,405
Non-trainable params: 2,257,984
_________________________________________________________________

मॉडल को प्रशिक्षित करना

model.compile(
  optimizer=tf.keras.optimizers.SGD(lr=0.005, momentum=0.9), 
  loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True, label_smoothing=0.1),
  metrics=['accuracy'])
steps_per_epoch = train_generator.samples // train_generator.batch_size
validation_steps = valid_generator.samples // valid_generator.batch_size
hist = model.fit(
    train_generator,
    epochs=5, steps_per_epoch=steps_per_epoch,
    validation_data=valid_generator,
    validation_steps=validation_steps).history
Epoch 1/5
91/91 [==============================] - 30s 180ms/step - loss: 1.1586 - accuracy: 0.5967 - val_loss: 0.7162 - val_accuracy: 0.8580
Epoch 2/5
91/91 [==============================] - 15s 162ms/step - loss: 0.7058 - accuracy: 0.8653 - val_loss: 0.7084 - val_accuracy: 0.8665
Epoch 3/5
91/91 [==============================] - 15s 164ms/step - loss: 0.6474 - accuracy: 0.9006 - val_loss: 0.7143 - val_accuracy: 0.8580
Epoch 4/5
91/91 [==============================] - 15s 162ms/step - loss: 0.6193 - accuracy: 0.9169 - val_loss: 0.6762 - val_accuracy: 0.8651
Epoch 5/5
91/91 [==============================] - 15s 161ms/step - loss: 0.5973 - accuracy: 0.9335 - val_loss: 0.6766 - val_accuracy: 0.8778

plt.figure()
plt.ylabel("Loss (training and validation)")
plt.xlabel("Training Steps")
plt.ylim([0,2])
plt.plot(hist["loss"])
plt.plot(hist["val_loss"])

plt.figure()
plt.ylabel("Accuracy (training and validation)")
plt.xlabel("Training Steps")
plt.ylim([0,1])
plt.plot(hist["accuracy"])
plt.plot(hist["val_accuracy"])
01a63b00000

पींग

पींग

सत्यापन डेटा से छवि पर मॉडल आज़माएं:

def get_class_string_from_index(index):
   for class_string, class_index in valid_generator.class_indices.items():
      if class_index == index:
         return class_string

x, y = next(valid_generator)
image = x[0, :, :, :]
true_index = np.argmax(y[0])
plt.imshow(image)
plt.axis('off')
plt.show()

# Expand the validation image to (1, 224, 224, 3) before predicting the label
prediction_scores = model.predict(np.expand_dims(image, axis=0))
predicted_index = np.argmax(prediction_scores)
print("True label: " + get_class_string_from_index(true_index))
print("Predicted label: " + get_class_string_from_index(predicted_index))

पींग

True label: daisy
Predicted label: daisy

अंत में, प्रशिक्षित मॉडल को निम्नानुसार टीएफ सर्विंग या टीएफ लाइट (मोबाइल पर) पर तैनाती के लिए बचाया जा सकता है।

saved_model_path = "/tmp/saved_flowers_model"
tf.saved_model.save(model, saved_model_path)
INFO:tensorflow:Assets written to: /tmp/saved_flowers_model/assets

INFO:tensorflow:Assets written to: /tmp/saved_flowers_model/assets

वैकल्पिक: TensorFlow Lite की तैनाती

TensorFlow Lite आपको मोबाइल और IoT उपकरणों के लिए TensorFlow मॉडल तैनात करने देता है। नीचे दिए गए कोड से पता चलता है कि प्रशिक्षित मॉडल को टीएफ लाइट में कैसे बदला जाए और टेन्सरफ्लो मॉडल ऑप्टिमाइज़ेशन टूलकिट से प्रशिक्षण के बाद के उपकरण लागू करें। अंत में, यह TF लाइट इंटरप्रेटर में परिणामी गुणवत्ता की जांच करने के लिए इसे चलाता है

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

अनुकूलन सेटिंग्स

Wrote TFLite model of 8873044 bytes.

interpreter = tf.lite.Interpreter(model_content=lite_model_content)
# This little helper wraps the TF Lite interpreter as a numpy-to-numpy function.
def lite_model(images):
  interpreter.allocate_tensors()
  interpreter.set_tensor(interpreter.get_input_details()[0]['index'], images)
  interpreter.invoke()
  return interpreter.get_tensor(interpreter.get_output_details()[0]['index'])
04f5b8b5b5
TF Lite model agrees with original model on 50 of 50 examples (100%).
TF Lite model is accurate on 48 of 50 examples (96%).