एमएल समुदाय दिवस 9 नवंबर है! TensorFlow, JAX से नई जानकारी के लिए हमसे जुड़ें, और अधिक जानें

पौधों की बीमारी का पता लगाने के लिए फाइन ट्यूनिंग मॉडल

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

इस नोटबुक दिखाता है कि TFDS से एक डाटासेट या अपने खुद के फसल रोग का पता लगाने डेटासेट पर फ़ाइन-ट्यून CropNet मॉडल TensorFlow हब से करने के लिए।

आप:

  • TFDS कसावा डेटासेट या अपना खुद का डेटा लोड करें
  • अधिक मजबूत मॉडल प्राप्त करने के लिए अज्ञात (नकारात्मक) उदाहरणों के साथ डेटा को समृद्ध करें
  • डेटा में छवि संवर्द्धन लागू करें
  • लोड और ठीक धुन एक CropNet मॉडल TF हब से
  • एक TFLite मॉडल निर्यात, तैयार के साथ अपने ऐप्लिकेशन पर तैनात किया जाना टास्क लाइब्रेरी , MLKit या TFLite सीधे

आयात और निर्भरता

शुरू करने से पहले, आप निर्भरता इस तरह की आवश्यकता होगी में से कुछ भी स्थापित करना होगा मॉडल निर्माता और TensorFlow डेटासेट का नवीनतम संस्करण।

pip install --use-deprecated=legacy-resolver tflite-model-maker
pip install -U tensorflow-datasets
import matplotlib.pyplot as plt
import os
import seaborn as sns

import tensorflow as tf
import tensorflow_datasets as tfds

from tensorflow_examples.lite.model_maker.core.export_format import ExportFormat
from tensorflow_examples.lite.model_maker.core.task import image_preprocessing

from tflite_model_maker import image_classifier
from tflite_model_maker import ImageClassifierDataLoader
from tflite_model_maker.image_classifier import ModelSpec
2021-08-03 11:12:13.586965: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/numba/core/errors.py:154: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)

फ़ाइन-ट्यून करने के लिए TFDS डेटासेट लोड करें

सार्वजनिक रूप से उपलब्ध का उपयोग करने देता कसावा पत्ता रोग डाटासेट TFDS से।

tfds_name = 'cassava'
(ds_train, ds_validation, ds_test), ds_info = tfds.load(
    name=tfds_name,
    split=['train', 'validation', 'test'],
    with_info=True,
    as_supervised=True)
TFLITE_NAME_PREFIX = tfds_name
2021-08-03 11:12:19.851067: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-08-03 11:12:20.470539: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:20.471391: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-03 11:12:20.471440: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-03 11:12:20.474552: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-03 11:12:20.474666: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-08-03 11:12:20.475725: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-08-03 11:12:20.476035: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-08-03 11:12:20.477042: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-08-03 11:12:20.477939: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-08-03 11:12:20.478114: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-03 11:12:20.478218: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:20.479123: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:20.479930: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-03 11:12:20.480564: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-03 11:12:20.481075: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:20.481900: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-03 11:12:20.481979: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:20.482818: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:20.483606: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-03 11:12:20.483648: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-03 11:12:21.045245: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-03 11:12:21.045278: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-03 11:12:21.045286: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-03 11:12:21.045507: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:21.046417: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:21.047255: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:12:21.048070: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)

या वैकल्पिक रूप से अपने स्वयं के डेटा को फ़ाइन-ट्यून करने के लिए लोड करें

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

# data_root_dir = tf.keras.utils.get_file(
#     'cassavaleafdata.zip',
#     'https://storage.googleapis.com/emcassavadata/cassavaleafdata.zip',
#     extract=True)
# data_root_dir = os.path.splitext(data_root_dir)[0]  # Remove the .zip extension

# builder = tfds.ImageFolder(data_root_dir)

# ds_info = builder.info
# ds_train = builder.as_dataset(split='train', as_supervised=True)
# ds_validation = builder.as_dataset(split='validation', as_supervised=True)
# ds_test = builder.as_dataset(split='test', as_supervised=True)

ट्रेन स्प्लिट से नमूने देखें

आइए डेटासेट से कुछ उदाहरणों पर एक नज़र डालें जिसमें क्लास आईडी और इमेज सैंपल और उनके लेबल के लिए क्लास का नाम शामिल है।

_ = tfds.show_examples(ds_train, ds_info)
2021-08-03 11:12:21.165735: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-08-03 11:12:21.166325: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000179999 Hz

पीएनजी

TFDS डेटासेट से अज्ञात उदाहरणों के रूप में उपयोग की जाने वाली छवियां जोड़ें

प्रशिक्षण डेटासेट में अतिरिक्त अज्ञात (नकारात्मक) उदाहरण जोड़ें और उन्हें एक नया अज्ञात वर्ग लेबल नंबर असाइन करें। लक्ष्य एक ऐसा मॉडल तैयार करना है, जो व्यवहार में (जैसे क्षेत्र में) उपयोग किए जाने पर, "अज्ञात" की भविष्यवाणी करने का विकल्प हो, जब वह कुछ अप्रत्याशित देखता है।

नीचे आप उन डेटासेट की सूची देख सकते हैं जिनका उपयोग अतिरिक्त अज्ञात इमेजरी के नमूने के लिए किया जाएगा। इसमें विविधता बढ़ाने के लिए 3 पूरी तरह से अलग डेटासेट शामिल हैं। उनमें से एक बीन्स लीफ डिजीज डेटासेट है, ताकि मॉडल में कसावा के अलावा अन्य रोगग्रस्त पौधों के संपर्क में रहे।

UNKNOWN_TFDS_DATASETS = [{
    'tfds_name': 'imagenet_v2/matched-frequency',
    'train_split': 'test[:80%]',
    'test_split': 'test[80%:]',
    'num_examples_ratio_to_normal': 1.0,
}, {
    'tfds_name': 'oxford_flowers102',
    'train_split': 'train',
    'test_split': 'test',
    'num_examples_ratio_to_normal': 1.0,
}, {
    'tfds_name': 'beans',
    'train_split': 'train',
    'test_split': 'test',
    'num_examples_ratio_to_normal': 1.0,
}]

UNKNOWN डेटासेट भी TFDS से लोड किए जाते हैं।

# Load unknown datasets.
weights = [
    spec['num_examples_ratio_to_normal'] for spec in UNKNOWN_TFDS_DATASETS
]
num_unknown_train_examples = sum(
    int(w * ds_train.cardinality().numpy()) for w in weights)
ds_unknown_train = tf.data.experimental.sample_from_datasets([
    tfds.load(
        name=spec['tfds_name'], split=spec['train_split'],
        as_supervised=True).repeat(-1) for spec in UNKNOWN_TFDS_DATASETS
], weights).take(num_unknown_train_examples)
ds_unknown_train = ds_unknown_train.apply(
    tf.data.experimental.assert_cardinality(num_unknown_train_examples))
ds_unknown_tests = [
    tfds.load(
        name=spec['tfds_name'], split=spec['test_split'], as_supervised=True)
    for spec in UNKNOWN_TFDS_DATASETS
]
ds_unknown_test = ds_unknown_tests[0]
for ds in ds_unknown_tests[1:]:
  ds_unknown_test = ds_unknown_test.concatenate(ds)

# All examples from the unknown datasets will get a new class label number.
num_normal_classes = len(ds_info.features['label'].names)
unknown_label_value = tf.convert_to_tensor(num_normal_classes, tf.int64)
ds_unknown_train = ds_unknown_train.map(lambda image, _:
                                        (image, unknown_label_value))
ds_unknown_test = ds_unknown_test.map(lambda image, _:
                                      (image, unknown_label_value))

# Merge the normal train dataset with the unknown train dataset.
weights = [
    ds_train.cardinality().numpy(),
    ds_unknown_train.cardinality().numpy()
]
ds_train_with_unknown = tf.data.experimental.sample_from_datasets(
    [ds_train, ds_unknown_train], [float(w) for w in weights])
ds_train_with_unknown = ds_train_with_unknown.apply(
    tf.data.experimental.assert_cardinality(sum(weights)))

print((f"Added {ds_unknown_train.cardinality().numpy()} negative examples."
       f"Training dataset has now {ds_train_with_unknown.cardinality().numpy()}"
       ' examples in total.'))
Added 16968 negative examples.Training dataset has now 22624 examples in total.

संवर्द्धन लागू करें

सभी छवियों के लिए, उन्हें और अधिक विविधतापूर्ण बनाने के लिए, आप कुछ संवर्द्धन लागू करेंगे, जैसे कि इसमें परिवर्तन:

  • चमक
  • अंतर
  • परिपूर्णता
  • रंग
  • काटना

इस प्रकार के संवर्द्धन छवि इनपुट में बदलाव के लिए मॉडल को और अधिक मजबूत बनाने में मदद करते हैं।

def random_crop_and_random_augmentations_fn(image):
  # preprocess_for_train does random crop and resize internally.
  image = image_preprocessing.preprocess_for_train(image)
  image = tf.image.random_brightness(image, 0.2)
  image = tf.image.random_contrast(image, 0.5, 2.0)
  image = tf.image.random_saturation(image, 0.75, 1.25)
  image = tf.image.random_hue(image, 0.1)
  return image


def random_crop_fn(image):
  # preprocess_for_train does random crop and resize internally.
  image = image_preprocessing.preprocess_for_train(image)
  return image


def resize_and_center_crop_fn(image):
  image = tf.image.resize(image, (256, 256))
  image = image[16:240, 16:240]
  return image


no_augment_fn = lambda image: image

train_augment_fn = lambda image, label: (
    random_crop_and_random_augmentations_fn(image), label)
eval_augment_fn = lambda image, label: (resize_and_center_crop_fn(image), label)

वृद्धि लागू करने के लिए इसे इस्तेमाल करता है map डेटासेट वर्ग से विधि।

ds_train_with_unknown = ds_train_with_unknown.map(train_augment_fn)
ds_validation = ds_validation.map(eval_augment_fn)
ds_test = ds_test.map(eval_augment_fn)
ds_unknown_test = ds_unknown_test.map(eval_augment_fn)
INFO:tensorflow:Use default resize_bicubic.
INFO:tensorflow:Use default resize_bicubic.
INFO:tensorflow:Use customized resize method bilinear
INFO:tensorflow:Use customized resize method bilinear

डेटा को मॉडल निर्माता के अनुकूल प्रारूप में लपेटें

मॉडल मेकर के साथ इन डेटासेट का उपयोग करने के लिए, उन्हें एक ImageClassifierDataLoader वर्ग में होना चाहिए।

label_names = ds_info.features['label'].names + ['UNKNOWN']

train_data = ImageClassifierDataLoader(ds_train_with_unknown,
                                       ds_train_with_unknown.cardinality(),
                                       label_names)
validation_data = ImageClassifierDataLoader(ds_validation,
                                            ds_validation.cardinality(),
                                            label_names)
test_data = ImageClassifierDataLoader(ds_test, ds_test.cardinality(),
                                      label_names)
unknown_test_data = ImageClassifierDataLoader(ds_unknown_test,
                                              ds_unknown_test.cardinality(),
                                              label_names)

प्रशिक्षण चलाएं

TensorFlow हब कई स्थानांतरित करें सीखने के लिए उपलब्ध मॉडल है।

यहां आप किसी एक को चुन सकते हैं और बेहतर परिणाम प्राप्त करने के लिए आप अन्य के साथ प्रयोग भी जारी रख सकते हैं।

आप का प्रयास करने के लिए और भी अधिक मॉडल चाहते हैं, तो आप उन्हें इस से जोड़ सकते हैं संग्रह

एक आधार मॉडल चुनें

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

मॉडल निर्माता इस रूपांतरण को सर्वोत्तम संभव बनाता है और बाद में मॉडल को डिवाइस पर आसानी से परिनियोजित करने के लिए सभी आवश्यक जानकारी देता है।

मॉडल युक्ति यह है कि आप मॉडल निर्माता को कैसे बताते हैं कि आप किस आधार मॉडल का उपयोग करना चाहते हैं।

image_model_spec = ModelSpec(uri=model_handle)

यहाँ एक महत्वपूर्ण विस्तार सेटिंग है train_whole_model जो बेस मॉडल ठीक प्रशिक्षण के दौरान देखते कर देगा। यह प्रक्रिया को धीमा कर देता है लेकिन अंतिम मॉडल में उच्च सटीकता होती है। स्थापना shuffle कर देगा यकीन है कि मॉडल एक यादृच्छिक फेरबदल जिस क्रम मॉडल सीखने के लिए एक सबसे अच्छा अभ्यास है में डेटा को देखता है।

model = image_classifier.create(
    train_data,
    model_spec=image_model_spec,
    batch_size=128,
    learning_rate=0.03,
    epochs=5,
    shuffle=True,
    train_whole_model=True,
    validation_data=validation_data)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2 (HubKer (None, 1280)              4226432   
_________________________________________________________________
dropout (Dropout)            (None, 1280)              0         
_________________________________________________________________
dense (Dense)                (None, 6)                 7686      
=================================================================
Total params: 4,234,118
Trainable params: 4,209,718
Non-trainable params: 24,400
_________________________________________________________________
None
Epoch 1/5
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:375: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  "The `lr` argument is deprecated, use `learning_rate` instead.")
2021-08-03 11:13:10.609025: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:177] Filling up shuffle buffer (this may take a while): 9 of 384
2021-08-03 11:13:12.110052: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:230] Shuffle buffer filled.
2021-08-03 11:13:12.711088: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-03 11:13:14.660885: I tensorflow/stream_executor/cuda/cuda_dnn.cc:359] Loaded cuDNN version 8100
2021-08-03 11:13:19.473383: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-03 11:13:19.828557: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
176/176 [==============================] - 118s 504ms/step - loss: 0.8846 - accuracy: 0.9160 - val_loss: 1.1304 - val_accuracy: 0.8114
Epoch 2/5
176/176 [==============================] - 74s 420ms/step - loss: 0.7897 - accuracy: 0.9528 - val_loss: 1.0500 - val_accuracy: 0.8287
Epoch 3/5
176/176 [==============================] - 69s 390ms/step - loss: 0.7751 - accuracy: 0.9579 - val_loss: 1.0461 - val_accuracy: 0.8504
Epoch 4/5
176/176 [==============================] - 68s 388ms/step - loss: 0.7639 - accuracy: 0.9624 - val_loss: 1.0187 - val_accuracy: 0.8426
Epoch 5/5
176/176 [==============================] - 67s 383ms/step - loss: 0.7562 - accuracy: 0.9640 - val_loss: 0.9985 - val_accuracy: 0.8588

परीक्षण विभाजन पर मॉडल का मूल्यांकन करें

model.evaluate(test_data)
59/59 [==============================] - 7s 42ms/step - loss: 0.9776 - accuracy: 0.8700
[0.9775904417037964, 0.8700265288352966]

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

def predict_class_label_number(dataset):
  """Runs inference and returns predictions as class label numbers."""
  rev_label_names = {l: i for i, l in enumerate(label_names)}
  return [
      rev_label_names[o[0][0]]
      for o in model.predict_top_k(dataset, batch_size=128)
  ]

def show_confusion_matrix(cm, labels):
  plt.figure(figsize=(10, 8))
  sns.heatmap(cm, xticklabels=labels, yticklabels=labels, 
              annot=True, fmt='g')
  plt.xlabel('Prediction')
  plt.ylabel('Label')
  plt.show()
confusion_mtx = tf.math.confusion_matrix(
    predict_class_label_number(test_data),
    list(ds_test.map(lambda x, y: y)),
    num_classes=len(label_names))

show_confusion_matrix(confusion_mtx, label_names)

पीएनजी

अज्ञात परीक्षण डेटा पर मॉडल का मूल्यांकन करें

इस मूल्यांकन में हम उम्मीद करते हैं कि मॉडल में लगभग 1 की सटीकता होगी। मॉडल का परीक्षण करने वाली सभी छवियां सामान्य डेटासेट से संबंधित नहीं हैं और इसलिए हम मॉडल से "अज्ञात" वर्ग लेबल की भविष्यवाणी करने की अपेक्षा करते हैं।

model.evaluate(unknown_test_data)
259/259 [==============================] - 27s 86ms/step - loss: 0.6791 - accuracy: 0.9994
[0.6791346073150635, 0.9993959069252014]

भ्रम मैट्रिक्स प्रिंट करें।

unknown_confusion_mtx = tf.math.confusion_matrix(
    predict_class_label_number(unknown_test_data),
    list(ds_unknown_test.map(lambda x, y: y)),
    num_classes=len(label_names))

show_confusion_matrix(unknown_confusion_mtx, label_names)

पीएनजी

मॉडल को TFlite और SavedModel के रूप में निर्यात करें

अब हम प्रशिक्षित मॉडल को TFLite और SavedModel प्रारूपों में ऑन-डिवाइस परिनियोजित करने और TensorFlow में अनुमान के लिए उपयोग करने के लिए निर्यात कर सकते हैं।

tflite_filename = f'{TFLITE_NAME_PREFIX}_model_{model_name}.tflite'
model.export(export_dir='.', tflite_filename=tflite_filename)
2021-08-03 11:20:40.891091: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tmpqd3gxept/assets
INFO:tensorflow:Assets written to: /tmp/tmpqd3gxept/assets
2021-08-03 11:20:45.106389: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:45.106760: I tensorflow/core/grappler/devices.cc:69] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 1
2021-08-03 11:20:45.106878: I tensorflow/core/grappler/clusters/single_machine.cc:357] Starting new session
2021-08-03 11:20:45.107380: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:45.107711: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-03 11:20:45.107789: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:45.108105: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:45.108354: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-03 11:20:45.108392: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-03 11:20:45.108399: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-03 11:20:45.108405: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-03 11:20:45.108523: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:45.108837: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:45.109120: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
2021-08-03 11:20:45.169874: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1144] Optimization results for grappler item: graph_to_optimize
  function_optimizer: Graph size after: 1838 nodes (1563), 2745 edges (2468), time = 36.007ms.
  function_optimizer: function_optimizer did nothing. time = 0.545ms.

2021-08-03 11:20:46.679127: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:345] Ignored output_format.
2021-08-03 11:20:46.679196: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:348] Ignored drop_control_dependency.
2021-08-03 11:20:46.762709: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:210] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.
2021-08-03 11:20:46.788606: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:46.789013: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-03 11:20:46.789183: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:46.789498: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:46.789752: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-03 11:20:46.789791: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-03 11:20:46.789798: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-03 11:20:46.789804: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-03 11:20:46.789927: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:46.790275: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-03 11:20:46.790551: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 3
WARNING:absl:For model inputs containing unsupported operations which cannot be quantized, the `inference_input_type` attribute will default to the original type.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Saving labels in /tmp/tmpd8km8exy/labels.txt
INFO:tensorflow:Saving labels in /tmp/tmpd8km8exy/labels.txt
INFO:tensorflow:TensorFlow Lite model exported successfully: ./cassava_model_mobilenet_v3_large_100_224.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./cassava_model_mobilenet_v3_large_100_224.tflite
# Export saved model version.
model.export(export_dir='.', export_format=ExportFormat.SAVED_MODEL)
INFO:tensorflow:Assets written to: ./saved_model/assets
INFO:tensorflow:Assets written to: ./saved_model/assets

अगले कदम

जिस मॉडल को आपने अभी-अभी प्रशिक्षित किया है उसका उपयोग मोबाइल उपकरणों पर किया जा सकता है और यहां तक ​​कि क्षेत्र में भी तैनात किया जा सकता है!

मॉडल डाउनलोड करने के लिए, कोलाब के बाईं ओर स्थित फ़ाइलें मेनू के लिए फ़ोल्डर आइकन पर क्लिक करें और डाउनलोड विकल्प चुनें।

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