Objekterkennung mit TensorFlow Lite Model Maker

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

In diesem Colab-Notizbuch erfahren Sie, wie Sie mit der TensorFlow Lite Model Maker- Bibliothek ein benutzerdefiniertes Objekterkennungsmodell trainieren, mit dem Salate in Bildern auf einem mobilen Gerät erkannt werden können.

Die Model Maker-Bibliothek verwendet Transfer Learning , um das Trainieren eines TensorFlow Lite-Modells mithilfe eines benutzerdefinierten Datasets zu vereinfachen. Durch die Umschulung eines TensorFlow Lite-Modells mit Ihrem eigenen benutzerdefinierten Datensatz wird die Menge der erforderlichen Trainingsdaten reduziert und die Trainingszeit verkürzt.

Sie verwenden das öffentlich verfügbare Salads- Dataset, das aus dem Open Images-Dataset V4 erstellt wurde .

Jedes Bild im Datensatz enthält Objekte, die als eine der folgenden Klassen gekennzeichnet sind:

  • Gut gebacken
  • Käse
  • Salat
  • Meeresfrüchte
  • Tomate

Das Dataset enthält die Begrenzungsrahmen, die zusammen mit der Objektbezeichnung angeben, wo sich die einzelnen Objekte befinden.

Hier ist ein Beispielbild aus dem Datensatz:


Voraussetzungen

Installieren Sie die erforderlichen Pakete

Installieren Sie zunächst die erforderlichen Pakete, einschließlich des Model Maker-Pakets aus dem GitHub-Repo und der Pycocotools-Bibliothek, die Sie für die Evaluierung verwenden.

pip install -q tflite-model-maker
pip install -q pycocotools

Importieren Sie die erforderlichen Pakete.

import numpy as np
import os

from tflite_model_maker.config import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import object_detector

import tensorflow as tf
assert tf.__version__.startswith('2')

tf.get_logger().setLevel('ERROR')
from absl import logging
logging.set_verbosity(logging.ERROR)
/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)

Bereiten Sie den Datensatz vor

Hier verwenden Sie denselben Datensatz wie beim AutoML- Schnellstart .

Das Salads- Dataset ist verfügbar unter: gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv .

Es enthält 175 Bilder für das Training, 25 Bilder für die Validierung und 25 Bilder zum Testen. Der Datensatz hat fünf Klassen: Salad , Seafood , Tomato , Baked goods , Cheese .


Der Datensatz wird im CSV-Format bereitgestellt:

TRAINING,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Salad,0.0,0.0954,,,0.977,0.957,,
VALIDATION,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Seafood,0.0154,0.1538,,,1.0,0.802,,
TEST,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Tomato,0.0,0.655,,,0.231,0.839,,
  • Jede Zeile entspricht einem Objekt, das in einem größeren Bild lokalisiert ist, wobei jedes Objekt speziell als Test-, Zug- oder Validierungsdaten bezeichnet wird. Mehr darüber erfahren Sie zu einem späteren Zeitpunkt in diesem Notizbuch.
  • Die drei hier enthaltenen Zeilen geben drei verschiedene Objekte an, die sich innerhalb desselben Bildes befinden und unter gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg verfügbar sind gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg .
  • Jede Reihe hat ein anderes Etikett: Salad , Seafood , Tomato usw.
  • Begrenzungsrahmen werden für jedes Bild unter Verwendung der oberen linken und unteren rechten Scheitelpunkte angegeben.

Hier ist eine Visualisierung dieser drei Zeilen:


Wenn Sie mehr über die Vorbereitung Ihrer eigenen CSV-Datei und die Mindestanforderungen für die Erstellung eines gültigen Datensatzes erfahren möchten, finden Sie weitere Informationen im Handbuch Vorbereitung Ihrer Trainingsdaten .

Wenn Sie Google Cloud noch nicht kennen, fragen Sie sich möglicherweise, was die URL gs:// bedeutet. Dies sind URLs von Dateien, die in Google Cloud Storage (GCS) gespeichert sind. Wenn Sie Ihre Dateien in GCS veröffentlichen oder Ihren Client authentifizieren , kann Model Maker diese Dateien ähnlich wie Ihre lokalen Dateien lesen.

Sie müssen Ihre Bilder jedoch nicht in Google Cloud speichern, um Model Maker verwenden zu können. Sie können einen lokalen Pfad in Ihrer CSV-Datei verwenden, und Model Maker funktioniert einfach.

Schnellstart

Es gibt sechs Schritte zum Trainieren eines Objekterkennungsmodells:

Schritt 1. Wählen Sie eine Objekterkennungsmodell-Architektur aus.

Dieses Tutorial verwendet das EfficientDet-Lite0-Modell. EfficientDet-Lite [0-4] ist eine Familie mobiler / IoT-freundlicher Objekterkennungsmodelle, die von der EfficientDet- Architektur abgeleitet sind.

Hier ist die Leistung jedes EfficientDet-Lite-Modells im Vergleich zueinander.

Modellarchitektur Größe (MB) * Latenz (ms) ** Durchschnittliche Präzision ***
EfficientDet-Lite0 4.4 37 25,69%
EfficientDet-Lite1 5.8 49 30,55%
EfficientDet-Lite2 7.2 69 33,97%
EfficientDet-Lite3 11.4 116 37,70%
EfficientDet-Lite4 19.9 260 41,96%

* Größe der ganzzahligen quantisierten Modelle.
** Latenz gemessen auf Pixel 4 mit 4 Threads auf der CPU.
*** Durchschnittliche Genauigkeit ist der mAP (mittlere durchschnittliche Genauigkeit) im COCO 2017-Validierungsdatensatz.

spec = model_spec.get('efficientdet_lite0')

Schritt 2. Laden Sie den Datensatz.

Model Maker nimmt Eingabedaten im CSV-Format auf. Verwenden Sie die Methode object_detector.DataLoader.from_csv , um das Dataset zu laden und in Trainings-, Validierungs- und Testbilder aufzuteilen.

  • Trainingsbilder: Diese Bilder werden verwendet, um das Objekterkennungsmodell zu trainieren, um Salatzutaten zu erkennen.
  • Validierungsbilder: Dies sind Bilder, die das Modell während des Trainingsprozesses nicht gesehen hat. Sie werden sie verwenden, um zu entscheiden, wann Sie das Training beenden sollen, um eine Überanpassung zu vermeiden.
  • Testbilder: Diese Bilder werden verwendet, um die endgültige Modellleistung zu bewerten.

Sie können die CSV-Datei direkt aus Google Cloud Storage laden, müssen Ihre Bilder jedoch nicht in Google Cloud speichern, um Model Maker verwenden zu können. Sie können eine lokale CSV-Datei auf Ihrem Computer angeben, und Model Maker funktioniert einwandfrei.

train_data, validation_data, test_data = object_detector.DataLoader.from_csv('gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv')

Schritt 3. Trainieren Sie das TensorFlow-Modell mit den Trainingsdaten.

  • Das EfficientDet-Lite0-Modell verwendet standardmäßig epochs = 50 , was bedeutet, dass es den Trainingsdatensatz 50 Mal durchläuft. Sie können die Validierungsgenauigkeit während des Trainings überprüfen und frühzeitig aufhören, um eine Überanpassung zu vermeiden.
  • Setzen batch_size = 8 hier batch_size = 8 , damit Sie sehen, dass es 21 Schritte dauert, um die 175 Bilder im Trainingsdatensatz durchzugehen.
  • Setzen Sie train_whole_model=True , um das gesamte Modell zu train_whole_model=True anstatt nur die train_whole_model=True zu trainieren, um die Genauigkeit zu verbessern. Der Nachteil ist, dass das Trainieren des Modells möglicherweise länger dauert.
model = object_detector.create(train_data, model_spec=spec, batch_size=8, train_whole_model=True, validation_data=validation_data)
Epoch 1/50
21/21 [==============================] - 38s 549ms/step - det_loss: 1.7530 - cls_loss: 1.1282 - box_loss: 0.0125 - reg_l2_loss: 0.0635 - loss: 1.8165 - learning_rate: 0.0090 - gradient_norm: 0.7150 - val_det_loss: 1.6620 - val_cls_loss: 1.0992 - val_box_loss: 0.0113 - val_reg_l2_loss: 0.0635 - val_loss: 1.7256
Epoch 2/50
21/21 [==============================] - 8s 389ms/step - det_loss: 1.6003 - cls_loss: 1.0620 - box_loss: 0.0108 - reg_l2_loss: 0.0635 - loss: 1.6638 - learning_rate: 0.0100 - gradient_norm: 0.9141 - val_det_loss: 1.5013 - val_cls_loss: 0.9806 - val_box_loss: 0.0104 - val_reg_l2_loss: 0.0635 - val_loss: 1.5648
Epoch 3/50
21/21 [==============================] - 8s 374ms/step - det_loss: 1.4079 - cls_loss: 0.9207 - box_loss: 0.0097 - reg_l2_loss: 0.0635 - loss: 1.4714 - learning_rate: 0.0099 - gradient_norm: 1.4177 - val_det_loss: 1.3774 - val_cls_loss: 0.8889 - val_box_loss: 0.0098 - val_reg_l2_loss: 0.0635 - val_loss: 1.4409
Epoch 4/50
21/21 [==============================] - 8s 370ms/step - det_loss: 1.2396 - cls_loss: 0.7963 - box_loss: 0.0089 - reg_l2_loss: 0.0635 - loss: 1.3031 - learning_rate: 0.0099 - gradient_norm: 1.7533 - val_det_loss: 1.5172 - val_cls_loss: 1.0633 - val_box_loss: 0.0091 - val_reg_l2_loss: 0.0635 - val_loss: 1.5807
Epoch 5/50
21/21 [==============================] - 8s 390ms/step - det_loss: 1.1858 - cls_loss: 0.7351 - box_loss: 0.0090 - reg_l2_loss: 0.0635 - loss: 1.2494 - learning_rate: 0.0098 - gradient_norm: 1.9116 - val_det_loss: 1.2644 - val_cls_loss: 0.8182 - val_box_loss: 0.0089 - val_reg_l2_loss: 0.0635 - val_loss: 1.3279
Epoch 6/50
21/21 [==============================] - 7s 347ms/step - det_loss: 1.0802 - cls_loss: 0.6945 - box_loss: 0.0077 - reg_l2_loss: 0.0635 - loss: 1.1437 - learning_rate: 0.0097 - gradient_norm: 1.9390 - val_det_loss: 1.2302 - val_cls_loss: 0.7889 - val_box_loss: 0.0088 - val_reg_l2_loss: 0.0635 - val_loss: 1.2937
Epoch 7/50
21/21 [==============================] - 8s 389ms/step - det_loss: 1.0491 - cls_loss: 0.6716 - box_loss: 0.0075 - reg_l2_loss: 0.0635 - loss: 1.1126 - learning_rate: 0.0096 - gradient_norm: 1.9816 - val_det_loss: 1.1043 - val_cls_loss: 0.6815 - val_box_loss: 0.0085 - val_reg_l2_loss: 0.0636 - val_loss: 1.1679
Epoch 8/50
21/21 [==============================] - 8s 396ms/step - det_loss: 0.9959 - cls_loss: 0.6383 - box_loss: 0.0072 - reg_l2_loss: 0.0636 - loss: 1.0594 - learning_rate: 0.0094 - gradient_norm: 2.1843 - val_det_loss: 1.1045 - val_cls_loss: 0.7051 - val_box_loss: 0.0080 - val_reg_l2_loss: 0.0636 - val_loss: 1.1681
Epoch 9/50
21/21 [==============================] - 8s 386ms/step - det_loss: 0.9746 - cls_loss: 0.6311 - box_loss: 0.0069 - reg_l2_loss: 0.0636 - loss: 1.0381 - learning_rate: 0.0093 - gradient_norm: 2.0273 - val_det_loss: 1.1609 - val_cls_loss: 0.7531 - val_box_loss: 0.0082 - val_reg_l2_loss: 0.0636 - val_loss: 1.2245
Epoch 10/50
21/21 [==============================] - 8s 389ms/step - det_loss: 0.9162 - cls_loss: 0.6018 - box_loss: 0.0063 - reg_l2_loss: 0.0636 - loss: 0.9798 - learning_rate: 0.0091 - gradient_norm: 1.9476 - val_det_loss: 1.1105 - val_cls_loss: 0.7288 - val_box_loss: 0.0076 - val_reg_l2_loss: 0.0636 - val_loss: 1.1741
Epoch 11/50
21/21 [==============================] - 8s 380ms/step - det_loss: 0.9303 - cls_loss: 0.6111 - box_loss: 0.0064 - reg_l2_loss: 0.0636 - loss: 0.9939 - learning_rate: 0.0089 - gradient_norm: 2.1184 - val_det_loss: 0.9739 - val_cls_loss: 0.6087 - val_box_loss: 0.0073 - val_reg_l2_loss: 0.0636 - val_loss: 1.0375
Epoch 12/50
21/21 [==============================] - 8s 409ms/step - det_loss: 0.8756 - cls_loss: 0.5683 - box_loss: 0.0061 - reg_l2_loss: 0.0636 - loss: 0.9392 - learning_rate: 0.0087 - gradient_norm: 1.8964 - val_det_loss: 0.9707 - val_cls_loss: 0.6038 - val_box_loss: 0.0073 - val_reg_l2_loss: 0.0636 - val_loss: 1.0343
Epoch 13/50
21/21 [==============================] - 8s 404ms/step - det_loss: 0.8492 - cls_loss: 0.5508 - box_loss: 0.0060 - reg_l2_loss: 0.0636 - loss: 0.9128 - learning_rate: 0.0085 - gradient_norm: 2.0299 - val_det_loss: 0.9393 - val_cls_loss: 0.5896 - val_box_loss: 0.0070 - val_reg_l2_loss: 0.0636 - val_loss: 1.0029
Epoch 14/50
21/21 [==============================] - 8s 395ms/step - det_loss: 0.8742 - cls_loss: 0.5632 - box_loss: 0.0062 - reg_l2_loss: 0.0636 - loss: 0.9378 - learning_rate: 0.0082 - gradient_norm: 2.2362 - val_det_loss: 0.9523 - val_cls_loss: 0.6120 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0636 - val_loss: 1.0159
Epoch 15/50
21/21 [==============================] - 8s 377ms/step - det_loss: 0.8488 - cls_loss: 0.5581 - box_loss: 0.0058 - reg_l2_loss: 0.0636 - loss: 0.9124 - learning_rate: 0.0080 - gradient_norm: 2.3419 - val_det_loss: 0.9951 - val_cls_loss: 0.6436 - val_box_loss: 0.0070 - val_reg_l2_loss: 0.0636 - val_loss: 1.0588
Epoch 16/50
21/21 [==============================] - 8s 370ms/step - det_loss: 0.8141 - cls_loss: 0.5252 - box_loss: 0.0058 - reg_l2_loss: 0.0636 - loss: 0.8777 - learning_rate: 0.0077 - gradient_norm: 2.1637 - val_det_loss: 1.0041 - val_cls_loss: 0.6464 - val_box_loss: 0.0072 - val_reg_l2_loss: 0.0636 - val_loss: 1.0677
Epoch 17/50
21/21 [==============================] - 8s 396ms/step - det_loss: 0.8011 - cls_loss: 0.5270 - box_loss: 0.0055 - reg_l2_loss: 0.0636 - loss: 0.8647 - learning_rate: 0.0075 - gradient_norm: 2.2853 - val_det_loss: 0.9154 - val_cls_loss: 0.5768 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0636 - val_loss: 0.9791
Epoch 18/50
21/21 [==============================] - 8s 382ms/step - det_loss: 0.7949 - cls_loss: 0.5132 - box_loss: 0.0056 - reg_l2_loss: 0.0636 - loss: 0.8586 - learning_rate: 0.0072 - gradient_norm: 2.1825 - val_det_loss: 0.8737 - val_cls_loss: 0.5648 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0636 - val_loss: 0.9373
Epoch 19/50
21/21 [==============================] - 8s 384ms/step - det_loss: 0.7672 - cls_loss: 0.4935 - box_loss: 0.0055 - reg_l2_loss: 0.0636 - loss: 0.8309 - learning_rate: 0.0069 - gradient_norm: 2.1202 - val_det_loss: 0.9175 - val_cls_loss: 0.5878 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0636 - val_loss: 0.9812
Epoch 20/50
21/21 [==============================] - 8s 384ms/step - det_loss: 0.7566 - cls_loss: 0.4933 - box_loss: 0.0053 - reg_l2_loss: 0.0636 - loss: 0.8202 - learning_rate: 0.0066 - gradient_norm: 2.2388 - val_det_loss: 0.9889 - val_cls_loss: 0.6390 - val_box_loss: 0.0070 - val_reg_l2_loss: 0.0636 - val_loss: 1.0525
Epoch 21/50
21/21 [==============================] - 8s 394ms/step - det_loss: 0.7754 - cls_loss: 0.5109 - box_loss: 0.0053 - reg_l2_loss: 0.0636 - loss: 0.8390 - learning_rate: 0.0063 - gradient_norm: 2.3627 - val_det_loss: 0.9527 - val_cls_loss: 0.6151 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0636 - val_loss: 1.0164
Epoch 22/50
21/21 [==============================] - 10s 508ms/step - det_loss: 0.7340 - cls_loss: 0.4941 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7976 - learning_rate: 0.0060 - gradient_norm: 2.3235 - val_det_loss: 0.9315 - val_cls_loss: 0.6086 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 0.9952
Epoch 23/50
21/21 [==============================] - 8s 371ms/step - det_loss: 0.7316 - cls_loss: 0.4803 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7952 - learning_rate: 0.0056 - gradient_norm: 2.2284 - val_det_loss: 0.8832 - val_cls_loss: 0.5659 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9469
Epoch 24/50
21/21 [==============================] - 8s 378ms/step - det_loss: 0.7206 - cls_loss: 0.4837 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7843 - learning_rate: 0.0053 - gradient_norm: 2.3365 - val_det_loss: 0.8927 - val_cls_loss: 0.5768 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9564
Epoch 25/50
21/21 [==============================] - 8s 399ms/step - det_loss: 0.7100 - cls_loss: 0.4640 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7736 - learning_rate: 0.0050 - gradient_norm: 2.3680 - val_det_loss: 0.9477 - val_cls_loss: 0.6274 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 1.0114
Epoch 26/50
21/21 [==============================] - 8s 387ms/step - det_loss: 0.7065 - cls_loss: 0.4660 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7702 - learning_rate: 0.0047 - gradient_norm: 2.4108 - val_det_loss: 0.9075 - val_cls_loss: 0.5840 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 0.9712
Epoch 27/50
21/21 [==============================] - 7s 365ms/step - det_loss: 0.7179 - cls_loss: 0.4606 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7815 - learning_rate: 0.0044 - gradient_norm: 2.3896 - val_det_loss: 0.9088 - val_cls_loss: 0.5873 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9725
Epoch 28/50
21/21 [==============================] - 8s 379ms/step - det_loss: 0.7040 - cls_loss: 0.4654 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7677 - learning_rate: 0.0040 - gradient_norm: 2.4966 - val_det_loss: 0.8611 - val_cls_loss: 0.5596 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9247
Epoch 29/50
21/21 [==============================] - 7s 365ms/step - det_loss: 0.6524 - cls_loss: 0.4326 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7160 - learning_rate: 0.0037 - gradient_norm: 2.0710 - val_det_loss: 0.8648 - val_cls_loss: 0.5603 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9284
Epoch 30/50
21/21 [==============================] - 8s 358ms/step - det_loss: 0.6881 - cls_loss: 0.4439 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7518 - learning_rate: 0.0034 - gradient_norm: 2.3615 - val_det_loss: 0.8631 - val_cls_loss: 0.5599 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9268
Epoch 31/50
21/21 [==============================] - 8s 376ms/step - det_loss: 0.7087 - cls_loss: 0.4513 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7724 - learning_rate: 0.0031 - gradient_norm: 2.5183 - val_det_loss: 0.8697 - val_cls_loss: 0.5593 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9334
Epoch 32/50
21/21 [==============================] - 8s 402ms/step - det_loss: 0.6819 - cls_loss: 0.4426 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7456 - learning_rate: 0.0028 - gradient_norm: 2.4280 - val_det_loss: 0.8518 - val_cls_loss: 0.5504 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9155
Epoch 33/50
21/21 [==============================] - 9s 424ms/step - det_loss: 0.6640 - cls_loss: 0.4377 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7276 - learning_rate: 0.0025 - gradient_norm: 2.4404 - val_det_loss: 0.8487 - val_cls_loss: 0.5501 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9123
Epoch 34/50
21/21 [==============================] - 8s 368ms/step - det_loss: 0.6701 - cls_loss: 0.4409 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7338 - learning_rate: 0.0023 - gradient_norm: 2.5033 - val_det_loss: 0.8439 - val_cls_loss: 0.5463 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9075
Epoch 35/50
21/21 [==============================] - 8s 410ms/step - det_loss: 0.6696 - cls_loss: 0.4383 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7333 - learning_rate: 0.0020 - gradient_norm: 2.5512 - val_det_loss: 0.8672 - val_cls_loss: 0.5647 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9309
Epoch 36/50
21/21 [==============================] - 9s 423ms/step - det_loss: 0.6753 - cls_loss: 0.4385 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7389 - learning_rate: 0.0018 - gradient_norm: 2.5067 - val_det_loss: 0.8682 - val_cls_loss: 0.5699 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9318
Epoch 37/50
21/21 [==============================] - 7s 346ms/step - det_loss: 0.6479 - cls_loss: 0.4247 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7116 - learning_rate: 0.0015 - gradient_norm: 2.5669 - val_det_loss: 0.8547 - val_cls_loss: 0.5576 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9184
Epoch 38/50
21/21 [==============================] - 8s 380ms/step - det_loss: 0.6208 - cls_loss: 0.4119 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6844 - learning_rate: 0.0013 - gradient_norm: 2.3728 - val_det_loss: 0.8532 - val_cls_loss: 0.5541 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9169
Epoch 39/50
21/21 [==============================] - 8s 388ms/step - det_loss: 0.6322 - cls_loss: 0.4176 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6959 - learning_rate: 0.0011 - gradient_norm: 2.3884 - val_det_loss: 0.8623 - val_cls_loss: 0.5595 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9260
Epoch 40/50
21/21 [==============================] - 8s 380ms/step - det_loss: 0.6415 - cls_loss: 0.4180 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7052 - learning_rate: 9.0029e-04 - gradient_norm: 2.4224 - val_det_loss: 0.8597 - val_cls_loss: 0.5573 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9234
Epoch 41/50
21/21 [==============================] - 8s 400ms/step - det_loss: 0.6584 - cls_loss: 0.4235 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7220 - learning_rate: 7.2543e-04 - gradient_norm: 2.4889 - val_det_loss: 0.8523 - val_cls_loss: 0.5513 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9159
Epoch 42/50
21/21 [==============================] - 8s 408ms/step - det_loss: 0.6399 - cls_loss: 0.4172 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7036 - learning_rate: 5.6814e-04 - gradient_norm: 2.2832 - val_det_loss: 0.8451 - val_cls_loss: 0.5454 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9088
Epoch 43/50
21/21 [==============================] - 7s 361ms/step - det_loss: 0.6460 - cls_loss: 0.4275 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7097 - learning_rate: 4.2906e-04 - gradient_norm: 2.4440 - val_det_loss: 0.8473 - val_cls_loss: 0.5473 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9110
Epoch 44/50
21/21 [==============================] - 8s 379ms/step - det_loss: 0.6661 - cls_loss: 0.4317 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7298 - learning_rate: 3.0876e-04 - gradient_norm: 2.4835 - val_det_loss: 0.8467 - val_cls_loss: 0.5464 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9103
Epoch 45/50
21/21 [==============================] - 8s 408ms/step - det_loss: 0.6403 - cls_loss: 0.4304 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.7040 - learning_rate: 2.0774e-04 - gradient_norm: 2.6497 - val_det_loss: 0.8475 - val_cls_loss: 0.5465 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9112
Epoch 46/50
21/21 [==============================] - 8s 384ms/step - det_loss: 0.6277 - cls_loss: 0.4124 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6913 - learning_rate: 1.2641e-04 - gradient_norm: 2.3634 - val_det_loss: 0.8471 - val_cls_loss: 0.5463 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9108
Epoch 47/50
21/21 [==============================] - 8s 371ms/step - det_loss: 0.6458 - cls_loss: 0.4292 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.7094 - learning_rate: 6.5107e-05 - gradient_norm: 2.5238 - val_det_loss: 0.8461 - val_cls_loss: 0.5455 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9098
Epoch 48/50
21/21 [==============================] - 7s 356ms/step - det_loss: 0.6279 - cls_loss: 0.4131 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6915 - learning_rate: 2.4083e-05 - gradient_norm: 2.3091 - val_det_loss: 0.8457 - val_cls_loss: 0.5453 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9094
Epoch 49/50
21/21 [==============================] - 9s 426ms/step - det_loss: 0.6504 - cls_loss: 0.4219 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7140 - learning_rate: 3.5074e-06 - gradient_norm: 2.5416 - val_det_loss: 0.8445 - val_cls_loss: 0.5439 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9082
Epoch 50/50
21/21 [==============================] - 8s 396ms/step - det_loss: 0.6351 - cls_loss: 0.4163 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.6988 - learning_rate: 3.4629e-06 - gradient_norm: 2.3083 - val_det_loss: 0.8438 - val_cls_loss: 0.5434 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9075

Schritt 4. Bewerten Sie das Modell mit den Testdaten.

Verwenden Sie nach dem Training des Objekterkennungsmodells anhand der Bilder im Trainingsdatensatz die verbleibenden 25 Bilder im Testdatensatz, um die Leistung des Modells anhand neuer Daten zu bewerten, die es noch nie zuvor gesehen hat.

Da die Standardstapelgröße 64 ist, dauert es 1 Schritt, um die 25 Bilder im Testdatensatz durchzugehen.

Die Bewertungsmetriken sind dieselben wie bei COCO .

model.evaluate(test_data)
1/1 [==============================] - 6s 6s/step
{'AP': 0.2114988,
 'AP50': 0.3486598,
 'AP75': 0.24027638,
 'APs': -1.0,
 'APm': 0.43069783,
 'APl': 0.21045895,
 'ARmax1': 0.16639706,
 'ARmax10': 0.34017715,
 'ARmax100': 0.37929925,
 'ARs': -1.0,
 'ARm': 0.6333333,
 'ARl': 0.37672424,
 'AP_/Baked Goods': 0.0052776425,
 'AP_/Salad': 0.6010458,
 'AP_/Cheese': 0.14969672,
 'AP_/Seafood': 0.029953174,
 'AP_/Tomato': 0.27152067}

Schritt 5. Als TensorFlow Lite-Modell exportieren.

Exportieren Sie das trainierte Objekterkennungsmodell in das TensorFlow Lite-Format, indem Sie angeben, in welchen Ordner Sie das quantisierte Modell exportieren möchten. Die Standardquantisierungstechnik nach dem Training ist die vollständige Ganzzahlquantisierung.

model.export(export_dir='.')

Schritt 6. Bewerten Sie das TensorFlow Lite-Modell.

Beim Exportieren nach TFLite können verschiedene Faktoren die Modellgenauigkeit beeinflussen:

  • Durch die Quantisierung kann die Modellgröße auf Kosten eines gewissen Genauigkeitsabfalls um das Vierfache verkleinert werden.
  • Das ursprüngliche TensorFlow-Modell verwendet NMS ( Class Non-Max Supression) für die Nachbearbeitung, während das TFLite-Modell globales NMS verwendet, das viel schneller, aber weniger genau ist. Keras gibt maximal 100 Erkennungen aus, während tflite maximal 25 Erkennungen ausgibt.

Daher müssen Sie das exportierte TFLite-Modell bewerten und seine Genauigkeit mit dem ursprünglichen TensorFlow-Modell vergleichen.

model.evaluate_tflite('model.tflite', test_data)
25/25 [==============================] - 57s 2s/step
{'AP': 0.18904369,
 'AP50': 0.3112651,
 'AP75': 0.21008497,
 'APs': -1.0,
 'APm': 0.3943723,
 'APl': 0.18786135,
 'ARmax1': 0.14203988,
 'ARmax10': 0.25574532,
 'ARmax100': 0.26657864,
 'ARs': -1.0,
 'ARm': 0.46666667,
 'ARl': 0.26415756,
 'AP_/Baked Goods': 0.0,
 'AP_/Salad': 0.56116146,
 'AP_/Cheese': 0.13825482,
 'AP_/Seafood': 0.0015808303,
 'AP_/Tomato': 0.24422134}

Sie können die TensorFlow Lite-Modelldatei über die linke Seitenleiste von Colab herunterladen. Klicken Sie mit der model.tflite auf die Datei model.tflite und wählen Sie Download , um sie auf Ihren lokalen Computer herunterzuladen.

Dieses Modell kann mithilfe der ObjectDetector-API der TensorFlow Lite-Aufgabenbibliothek in eine Android- oder iOS-App integriert werden.

Weitere Informationen zur Verwendung des Modells in einer funktionierenden App finden Sie in der Beispiel-App zur TFLite-Objekterkennung .

(Optional) Testen Sie das TFLite-Modell auf Ihrem Bild

Sie können das trainierte TFLite-Modell mit Bildern aus dem Internet testen.

  • Ersetzen Sie die unten stehende INPUT_IMAGE_URL durch das gewünschte Eingabebild.
  • Passen Sie DETECTION_THRESHOLD an, um die Empfindlichkeit des Modells zu ändern. Ein niedrigerer Schwellenwert bedeutet, dass das Modell mehr Objekte aufnimmt, aber es wird auch mehr falsche Erkennung geben. Ein höherer Schwellenwert bedeutet, dass das Modell nur Objekte aufnimmt, die es sicher erkannt hat.

Obwohl zum Ausführen des Modells in Python derzeit ein Teil des Boilerplate-Codes erforderlich ist, sind für die Integration des Modells in eine mobile App nur wenige Codezeilen erforderlich.

Laden Sie das trainierte TFLite-Modell und definieren Sie einige Visualisierungsfunktionen

Führen Sie die Objekterkennung aus und zeigen Sie die Erkennungsergebnisse an

png

(Optional) Kompilieren für die Edge-TPU

Nachdem Sie über ein quantisiertes EfficientDet Lite-Modell verfügen, können Sie es kompilieren und auf einer Coral EdgeTPU bereitstellen .

Schritt 1. Installieren Sie den EdgeTPU-Compiler

 curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

 echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

 sudo apt-get update

 sudo apt-get install edgetpu-compiler
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  2537  100  2537    0     0   145k      0 --:--:-- --:--:-- --:--:--  145k
OK
deb https://packages.cloud.google.com/apt coral-edgetpu-stable main
Hit:1 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic InRelease
Get:2 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]
Get:3 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]
Hit:4 https://nvidia.github.io/libnvidia-container/stable/ubuntu18.04/amd64  InRelease
Hit:5 https://nvidia.github.io/nvidia-container-runtime/ubuntu18.04/amd64  InRelease
Hit:6 https://nvidia.github.io/nvidia-docker/ubuntu18.04/amd64  InRelease
Ign:7 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease
Hit:8 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release
Get:9 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]
Hit:10 http://archive.canonical.com/ubuntu bionic InRelease
Get:11 http://packages.cloud.google.com/apt google-cloud-logging-wheezy InRelease [5483 B]
Get:13 https://packages.cloud.google.com/apt coral-edgetpu-stable InRelease [6722 B]
Get:14 https://packages.cloud.google.com/apt eip-cloud-bionic InRelease [5419 B]
Get:15 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 Packages [2174 B]
Fetched 261 kB in 1s (246 kB/s)




The following packages were automatically installed and are no longer required:
  linux-gcp-5.4-headers-5.4.0-1025 linux-headers-5.4.0-1025-gcp
  linux-image-5.4.0-1025-gcp linux-modules-5.4.0-1025-gcp
  linux-modules-extra-5.4.0-1025-gcp
Use 'sudo apt autoremove' to remove them.
The following NEW packages will be installed:
  edgetpu-compiler
0 upgraded, 1 newly installed, 0 to remove and 113 not upgraded.
Need to get 7865 kB of archives.
After this operation, 31.2 MB of additional disk space will be used.
Get:1 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 edgetpu-compiler amd64 15.0 [7865 kB]
Fetched 7865 kB in 1s (10.9 MB/s)
Selecting previously unselected package edgetpu-compiler.
(Reading database ... 228679 files and directories currently installed.)
Preparing to unpack .../edgetpu-compiler_15.0_amd64.deb ...
Unpacking edgetpu-compiler (15.0) ...
Setting up edgetpu-compiler (15.0) ...
Processing triggers for libc-bin (2.27-3ubuntu1.2) ...

Schritt 2. Wählen Sie die Anzahl der Edge-TPUs aus, Kompilieren

Die EdgeTPU verfügt über 8 MB SRAM zum Zwischenspeichern von Modellparametern ( weitere Informationen ). Dies bedeutet, dass bei Modellen, die größer als 8 MB sind, die Inferenzzeit erhöht wird, um über Modellparameter zu übertragen. Eine Möglichkeit, dies zu vermeiden, ist das Model Pipelining - Aufteilen des Modells in Segmente mit einer dedizierten EdgeTPU. Dies kann die Latenz erheblich verbessern.

Die folgende Tabelle kann als Referenz für die Anzahl der zu verwendenden Edge-TPUs verwendet werden. Die größeren Modelle werden nicht für eine einzelne TPU kompiliert, da die Zwischentensoren nicht in den On-Chip-Speicher passen.

Modellarchitektur Minimale TPUs Empfohlene TPUs
EfficientDet-Lite0 1 1
EfficientDet-Lite1 1 1
EfficientDet-Lite2 1 2
EfficientDet-Lite3 2 2
EfficientDet-Lite4 2 3

Edge TPU Compiler version 15.0.340273435

Model compiled successfully in 3516 ms.

Input model: model.tflite
Input size: 4.22MiB
Output model: model_edgetpu.tflite
Output size: 5.62MiB
On-chip memory used for caching model parameters: 4.25MiB
On-chip memory remaining for caching model parameters: 3.38MiB
Off-chip memory used for streaming uncached model parameters: 0.00B
Number of Edge TPU subgraphs: 1
Total number of operations: 267
Operation log: model_edgetpu.log

Model successfully compiled but not all operations are supported by the Edge TPU. A percentage of the model will instead run on the CPU, which is slower. If possible, consider updating your model to use only operations supported by the Edge TPU. For details, visit g.co/coral/model-reqs.
Number of operations that will run on Edge TPU: 264
Number of operations that will run on CPU: 3
See the operation log file for individual operation details.

Schritt 3. Herunterladen, Modell ausführen

Nachdem die Modelle kompiliert wurden, können sie jetzt auf EdgeTPUs zur Objekterkennung ausgeführt werden. Laden Sie zunächst die kompilierte TensorFlow Lite-Modelldatei über die linke Seitenleiste von Colab herunter. Klicken Sie mit der model_edgetpu.tflite auf die Datei model_edgetpu.tflite und wählen Sie Download , um sie auf Ihren lokalen Computer herunterzuladen.

Jetzt können Sie das Modell auf Ihre bevorzugte Weise ausführen. Beispiele für die Erkennung sind:

Erweiterte Verwendung

Dieser Abschnitt behandelt fortgeschrittene Verwendungsthemen wie das Anpassen des Modells und der Trainingshyperparameter.

Laden Sie den Datensatz

Laden Sie Ihre eigenen Daten

Sie können Ihren eigenen Datensatz hochladen, um dieses Tutorial durchzuarbeiten. Laden Sie Ihren Datensatz mithilfe der linken Seitenleiste in Colab hoch.

Datei hochladen

Wenn Sie Ihr Dataset nicht in die Cloud hochladen möchten, können Sie die Bibliothek auch lokal ausführen, indem Sie der Anleitung folgen.

Laden Sie Ihre Daten mit einem anderen Datenformat

Die Model Maker-Bibliothek unterstützt auch die Methode object_detector.DataLoader.from_pascal_voc zum Laden von Daten im PASCAL VOC- Format. makesense.ai und LabelImg sind die Tools, mit denen das Bild mit Anmerkungen versehen und Anmerkungen als XML-Dateien im PASCAL VOC-Datenformat gespeichert werden können:

object_detector.DataLoader.from_pascal_voc(image_dir, annotations_dir, label_map={1: "person", 2: "notperson"})

Passen Sie die Hyperparameter des EfficientDet-Modells an

Die Modell- und Trainings-Pipline-Parameter, die Sie anpassen können, sind:

  • model_dir : Der Speicherort zum Speichern der Modellprüfpunktdateien. Wenn nicht festgelegt, wird ein temporäres Verzeichnis verwendet.
  • steps_per_execution : Anzahl der Schritte pro Trainingsausführung.
  • moving_average_decay : Float. Der Zerfall, der zur Aufrechterhaltung der gleitenden Durchschnitte der trainierten Parameter verwendet werden soll.
  • var_freeze_expr : Der reguläre Ausdruck zum var_freeze_expr der einzufrierenden Variablen, was bedeutet, dass er während des Trainings gleich bleibt. Verwenden re.match(var_freeze_expr, variable_name) gesagt re.match(var_freeze_expr, variable_name) in der Codebasis, um die re.match(var_freeze_expr, variable_name) zuzuordnen.
  • tflite_max_detections : Ganzzahl, standardmäßig 25. Die maximale Anzahl von Ausgabeerkennungen im TFLite-Modell.
  • strategy : Eine Zeichenfolge, die angibt, welche Verteilungsstrategie verwendet werden soll. Akzeptierte Werte sind 'tpu', 'gpus', Keine. tpu 'bedeutet, TPUStrategy zu verwenden. 'gpus' bedeutet, MirroredStrategy für Multi-gpus zu verwenden. Wenn Keine, verwenden Sie die TF-Standardeinstellung mit OneDeviceStrategy.
  • tpu : Die Cloud-TPU, die für das Training verwendet werden soll. Dies sollte entweder der Name sein, der beim Erstellen der Cloud-TPU verwendet wird, oder eine grpc: //ip.address.of.tpu: 8470-URL.
  • use_xla : Verwenden Sie XLA, auch wenn die Strategie nicht tpu ist. Wenn die Strategie tpu ist, verwenden Sie immer XLA, und dieses Flag hat keine Auswirkung.
  • profile : Aktivieren Sie den Profilmodus.
  • debug : Aktivieren Sie den Debug-Modus.

Andere Parameter, die angepasst werden können, werden in hparams_config.py angezeigt .

Sie können beispielsweise var_freeze_expr='efficientnet' wodurch die Variablen mit dem Namenspräfix efficientnet '(efficientnet|fpn_cells|resample_p6)' efficientnet (Standard ist '(efficientnet|fpn_cells|resample_p6)' ). Dies ermöglicht es dem Modell, nicht trainierbare Variablen einzufrieren und ihren Wert durch Training gleich zu halten.

spec = model_spec.get('efficientdet-lite0')
spec.config.var_freeze_expr = 'efficientnet'

Ändern Sie die Modellarchitektur

Sie können die Modellarchitektur ändern, indem Sie die model_spec . Ändern Sie beispielsweise die model_spec in das EfficientDet-Lite4-Modell.

spec = model_spec.get('efficientdet-lite4')

Stellen Sie die Trainingshyperparameter ein

Die create ist die Treiberfunktion, mit der die Model Maker-Bibliothek Modelle erstellt. Der Parameter model_spec definiert die Modellspezifikation. Die Klasse object_detector.EfficientDetSpec wird derzeit unterstützt. Die create umfasst die folgenden Schritte:

  1. Erstellt das Modell für die Objekterkennung gemäß model_spec .
  2. Trainiert das Modell. Die Standardepochen und die Standardstapelgröße werden durch die Variablen epochs und batch_size im model_spec Objekt festgelegt. Sie können auch die Trainingshyperparameter wie epochs und batch_size , die sich auf die Modellgenauigkeit auswirken. Beispielsweise,
  • epochs : Ganzzahl, standardmäßig 50. Mehr Epochen könnten eine bessere Genauigkeit erzielen, aber zu einer Überanpassung führen.
  • batch_size : Integer, standardmäßig 64. Die Anzahl der Proben, die in einem Trainingsschritt verwendet werden sollen.
  • train_whole_model : Boolean, standardmäßig False. Wenn dies zutrifft, trainieren Sie das gesamte Modell. Andernfalls trainieren Sie nur die Ebenen, die nicht mit var_freeze_expr .

Zum Beispiel können Sie mit weniger Epochen und nur der Kopfebene trainieren. Sie können die Anzahl der Epochen erhöhen, um bessere Ergebnisse zu erzielen.

model = object_detector.create(train_data, model_spec=spec, epochs=10, validation_data=validation_data)

In verschiedene Formate exportieren

Die Exportformate können eines oder eine Liste der folgenden sein:

Standardmäßig exportiert es nur die TensorFlow Lite Modelldatei das Modell enthält Metadaten , so dass Sie später in einer On-Gerät ML Anwendung verwenden können. Die Etikettendatei ist in Metadaten eingebettet.

In vielen ML-Anwendungen auf dem Gerät ist die Modellgröße ein wichtiger Faktor. Daher wird empfohlen, das Modell zu quantisieren, um es kleiner zu machen und möglicherweise schneller zu laufen. Bei EfficientDet-Lite-Modellen wird standardmäßig eine vollständige Ganzzahlquantisierung verwendet, um das Modell zu quantisieren. Weitere Informationen finden Sie unter Quantisierung nach dem Training .

model.export(export_dir='.')

Sie können auch andere Dateien zum Modell exportieren, um sie besser untersuchen zu können. Exportieren Sie beispielsweise sowohl das gespeicherte Modell als auch die Etikettendatei wie folgt:

model.export(export_dir='.', export_format=[ExportFormat.SAVED_MODEL, ExportFormat.LABEL])

Passen Sie die Quantisierung nach dem Training an das TensorFlow Lite-Modell an

Die Quantisierung nach dem Training ist eine Konvertierungstechnik, die die Modellgröße und die Inferenzlatenz reduzieren und gleichzeitig die Inferenzgeschwindigkeit von CPU- und Hardwarebeschleunigern verbessern kann, wobei die Modellgenauigkeit geringfügig beeinträchtigt wird. Daher wird es häufig zur Optimierung des Modells verwendet.

Die Model Maker-Bibliothek wendet beim Exportieren des Modells eine Standard-Quantisierungstechnik nach dem Training an. Wenn Sie die Quantisierung nach dem Training anpassen möchten, unterstützt Model Maker auch mehrere Quantisierungsoptionen nach dem Training mit QuantizationConfig . Nehmen wir als Beispiel die float16-Quantisierung. Definieren Sie zunächst die Quantisierungskonfiguration.

config = QuantizationConfig.for_float16()

Dann exportieren wir das TensorFlow Lite-Modell mit einer solchen Konfiguration.

model.export(export_dir='.', tflite_filename='model_fp16.tflite', quantization_config=config)

Weiterlesen

In unserem Objekterkennungsbeispiel erfahren Sie technische Details. Weitere Informationen finden Sie unter: