Merken Sie den Termin vor! Google I / O kehrt vom 18. bis 20. Mai zurück Registrieren Sie sich jetzt
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Bildklassifizierung mit TensorFlow Lite Model Maker

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen Siehe TF Hub-Modell

Die Model Maker-Bibliothek vereinfacht das Anpassen und Konvertieren eines TensorFlow-Modells für neuronale Netze an bestimmte Eingabedaten, wenn dieses Modell für ML-Anwendungen auf dem Gerät bereitgestellt wird.

Dieses Notizbuch zeigt ein End-to-End-Beispiel, das diese Model Maker-Bibliothek verwendet, um die Anpassung und Konvertierung eines häufig verwendeten Bildklassifizierungsmodells zur Klassifizierung von Blumen auf einem mobilen Gerät zu veranschaulichen.

Voraussetzungen

Um dieses Beispiel auszuführen, müssen wir zuerst mehrere erforderliche Pakete installieren, einschließlich des Model Maker-Pakets, das in GitHub repo enthalten ist .

pip install -q tflite-model-maker

Importieren Sie die erforderlichen Pakete.

import os

import numpy as np

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

from tflite_model_maker import model_spec
from tflite_model_maker import image_classifier
from tflite_model_maker.config import ExportFormat
from tflite_model_maker.config import QuantizationConfig
from tflite_model_maker.image_classifier import DataLoader
from tflite_model_maker.image_classifier import ModelSpec

import matplotlib.pyplot as plt
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/numba/core/errors.py:154: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)

Einfaches Ende-zu-Ende-Beispiel

Holen Sie sich den Datenpfad

Lassen Sie uns einige Bilder mit diesem einfachen End-to-End-Beispiel abspielen. Hunderte von Bildern sind ein guter Anfang für Model Maker, während mehr Daten eine bessere Genauigkeit erzielen könnten.

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

Sie können image_path durch Ihre eigenen image_path ersetzen. Zum Hochladen von Daten in colab finden Sie die Schaltfläche zum Hochladen in der linken Seitenleiste, die im Bild unten mit dem roten Rechteck dargestellt ist. Versuchen Sie einfach, eine Zip-Datei hochzuladen und zu entpacken. Der Stammdateipfad ist der aktuelle Pfad.

Datei hochladen

Wenn Sie Ihre Bilder nicht in die Cloud hochladen möchten, können Sie versuchen, die Bibliothek lokal auszuführen, indem Sie der Anleitung in GitHub folgen.

Führen Sie das Beispiel aus

Das Beispiel besteht nur aus 4 Codezeilen (siehe unten), von denen jede einen Schritt des Gesamtprozesses darstellt.

Schritt 1. Laden Sie Eingabedaten, die für eine ML-App auf dem Gerät spezifisch sind. Teilen Sie es in Trainingsdaten und Testdaten auf.

data = DataLoader.from_folder(image_path)
train_data, test_data = data.split(0.9)
INFO:tensorflow:Load image with size: 3670, num_label: 5, labels: daisy, dandelion, roses, sunflowers, tulips.

Schritt 2. Passen Sie das TensorFlow-Modell an.

model = image_classifier.create(train_data)
INFO:tensorflow:Retraining the models...
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2 (HubKer (None, 1280)              3413024   
_________________________________________________________________
dropout (Dropout)            (None, 1280)              0         
_________________________________________________________________
dense (Dense)                (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
103/103 [==============================] - 7s 34ms/step - loss: 1.0969 - accuracy: 0.6321
Epoch 2/5
103/103 [==============================] - 4s 34ms/step - loss: 0.6606 - accuracy: 0.8880
Epoch 3/5
103/103 [==============================] - 4s 35ms/step - loss: 0.6250 - accuracy: 0.9158
Epoch 4/5
103/103 [==============================] - 3s 34ms/step - loss: 0.6017 - accuracy: 0.9259
Epoch 5/5
103/103 [==============================] - 3s 34ms/step - loss: 0.5924 - accuracy: 0.9337

Schritt 3. Bewerten Sie das Modell.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 2s 40ms/step - loss: 0.6305 - accuracy: 0.9101

Schritt 4. In TensorFlow Lite-Modell exportieren.

Hier exportieren wir das TensorFlow Lite-Modell mit Metadaten, die einen Standard für Modellbeschreibungen darstellen. Die Etikettendatei ist in Metadaten eingebettet.

Sie können es in der linken Seitenleiste genauso herunterladen wie den Upload-Teil für Ihren eigenen Gebrauch.

model.export(export_dir='.')
INFO:tensorflow:Assets written to: /tmp/tmpeb1fklnk/assets
INFO:tensorflow:Assets written to: /tmp/tmpeb1fklnk/assets
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/tmpyy9_y74n/labels.txt.
INFO:tensorflow:Saving labels in /tmp/tmpyy9_y74n/labels.txt.
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite

Nach diesen einfachen 4 Schritten können wir die TensorFlow Lite-Modelldatei in Anwendungen auf dem Gerät wie in der Referenzanwendung für die Bildklassifizierung weiter verwenden.

Detaillierter Prozess

Derzeit unterstützen wir verschiedene Modelle wie EfficientNet-Lite * -Modelle, MobileNetV2, ResNet50 als vorab trainierte Modelle für die Bildklassifizierung. Es ist jedoch sehr flexibel, dieser Bibliothek mit nur wenigen Codezeilen neue vorgefertigte Modelle hinzuzufügen.

Im Folgenden wird dieses End-to-End-Beispiel Schritt für Schritt beschrieben, um weitere Details anzuzeigen.

Schritt 1: Laden Sie die Eingabedaten, die für eine ML-App auf dem Gerät spezifisch sind

Der Blumendatensatz enthält 3670 Bilder aus 5 Klassen. Laden Sie die Archivversion des Datensatzes herunter und entpacken Sie sie.

Der Datensatz hat die folgende Verzeichnisstruktur:

flower_photos
|__ daisy
    |______ 100080576_f52e8ee070_n.jpg
    |______ 14167534527_781ceb1b7a_n.jpg
    |______ ...
|__ dandelion
    |______ 10043234166_e6dd915111_n.jpg
    |______ 1426682852_e62169221f_m.jpg
    |______ ...
|__ roses
    |______ 102501987_3cdb8e5394_n.jpg
    |______ 14982802401_a3dfb22afb.jpg
    |______ ...
|__ sunflowers
    |______ 12471791574_bb1be83df4.jpg
    |______ 15122112402_cafa41934f.jpg
    |______ ...
|__ tulips
    |______ 13976522214_ccec508fe7.jpg
    |______ 14487943607_651e8062a1_m.jpg
    |______ ...
image_path = tf.keras.utils.get_file(
      'flower_photos.tgz',
      'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
      extract=True)
image_path = os.path.join(os.path.dirname(image_path), 'flower_photos')

Verwenden Sie die DataLoader Klasse, um Daten zu laden.

Die Methode from_folder() kann Daten aus dem Ordner laden. Es wird davon ausgegangen, dass sich die Bilddaten derselben Klasse im selben Unterverzeichnis befinden und der Name des Unterordners der Klassenname ist. Derzeit werden JPEG-codierte Bilder und PNG-codierte Bilder unterstützt.

data = DataLoader.from_folder(image_path)
INFO:tensorflow:Load image with size: 3670, num_label: 5, labels: daisy, dandelion, roses, sunflowers, tulips.
INFO:tensorflow:Load image with size: 3670, num_label: 5, labels: daisy, dandelion, roses, sunflowers, tulips.

Teilen Sie es in Trainingsdaten (80%), Validierungsdaten (10%, optional) und Testdaten (10%) auf.

train_data, rest_data = data.split(0.8)
validation_data, test_data = rest_data.split(0.5)

Zeigen Sie 25 Bildbeispiele mit Beschriftungen.

plt.figure(figsize=(10,10))
for i, (image, label) in enumerate(data.gen_dataset().unbatch().take(25)):
  plt.subplot(5,5,i+1)
  plt.xticks([])
  plt.yticks([])
  plt.grid(False)
  plt.imshow(image.numpy(), cmap=plt.cm.gray)
  plt.xlabel(data.index_to_label[label.numpy()])
plt.show()

Schritt 2: Passen Sie das TensorFlow-Modell an

Erstellen Sie ein benutzerdefiniertes Bildklassifizierungsmodell basierend auf den geladenen Daten. Das Standardmodell ist EfficientNet-Lite0.

model = image_classifier.create(train_data, validation_data=validation_data)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_1 (HubK (None, 1280)              3413024   
_________________________________________________________________
dropout_1 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
91/91 [==============================] - 8s 61ms/step - loss: 1.1242 - accuracy: 0.6081 - val_loss: 0.6954 - val_accuracy: 0.8665
Epoch 2/5
91/91 [==============================] - 5s 53ms/step - loss: 0.6672 - accuracy: 0.8865 - val_loss: 0.6541 - val_accuracy: 0.8920
Epoch 3/5
91/91 [==============================] - 5s 53ms/step - loss: 0.6252 - accuracy: 0.9163 - val_loss: 0.6399 - val_accuracy: 0.8920
Epoch 4/5
91/91 [==============================] - 5s 54ms/step - loss: 0.6023 - accuracy: 0.9184 - val_loss: 0.6287 - val_accuracy: 0.9062
Epoch 5/5
91/91 [==============================] - 5s 57ms/step - loss: 0.5865 - accuracy: 0.9285 - val_loss: 0.6229 - val_accuracy: 0.9119

Schauen Sie sich die detaillierte Modellstruktur an.

model.summary()
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_1 (HubK (None, 1280)              3413024   
_________________________________________________________________
dropout_1 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________

Schritt 3: Bewerten Sie das benutzerdefinierte Modell

Bewerten Sie das Ergebnis des Modells und ermitteln Sie den Verlust und die Genauigkeit des Modells.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 1s 30ms/step - loss: 0.6314 - accuracy: 0.8992

Wir konnten die vorhergesagten Ergebnisse in 100 Testbildern darstellen. Vorausgesagte Etiketten mit roter Farbe sind die falschen vorhergesagten Ergebnisse, während andere korrekt sind.

# A helper function that returns 'red'/'black' depending on if its two input
# parameter matches or not.
def get_label_color(val1, val2):
  if val1 == val2:
    return 'black'
  else:
    return 'red'

# Then plot 100 test images and their predicted labels.
# If a prediction result is different from the label provided label in "test"
# dataset, we will highlight it in red color.
plt.figure(figsize=(20, 20))
predicts = model.predict_top_k(test_data)
for i, (image, label) in enumerate(test_data.gen_dataset().unbatch().take(100)):
  ax = plt.subplot(10, 10, i+1)
  plt.xticks([])
  plt.yticks([])
  plt.grid(False)
  plt.imshow(image.numpy(), cmap=plt.cm.gray)

  predict_label = predicts[i][0][0]
  color = get_label_color(predict_label,
                          test_data.index_to_label[label.numpy()])
  ax.xaxis.label.set_color(color)
  plt.xlabel('Predicted: %s' % predict_label)
plt.show()

Wenn die Genauigkeit nicht den App-Anforderungen entspricht, können Sie unter Erweiterte Verwendung nach Alternativen wie dem Wechsel zu einem größeren Modell, dem Anpassen von Umschulungsparametern usw. suchen.

Schritt 4: Exportieren in das TensorFlow Lite-Modell

Konvertieren Sie das vorhandene Modell in das TensorFlow Lite-Modellformat mit Metadaten . Der Standard-TFLite-Dateiname lautet model.tflite .

model.export(export_dir='.')
INFO:tensorflow:Assets written to: /tmp/tmpushsped8/assets
INFO:tensorflow:Assets written to: /tmp/tmpushsped8/assets
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/tmpuq5z2goo/labels.txt.
INFO:tensorflow:Saving labels in /tmp/tmpuq5z2goo/labels.txt.
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite

Weitere Informationen zum Integrieren des TensorFlow Lite-Modells in mobile Apps finden Sie in Beispielanwendungen und Handbüchern zur Bildklassifizierung.

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

  • ExportFormat.TFLITE
  • ExportFormat.LABEL
  • ExportFormat.SAVED_MODEL

Standardmäßig wird nur das TensorFlow Lite-Modell mit Metadaten exportiert. Sie können auch selektiv verschiedene Dateien exportieren. Exportieren Sie beispielsweise nur die Etikettendatei wie folgt:

model.export(export_dir='.', export_format=ExportFormat.LABEL)
INFO:tensorflow:Saving labels in ./labels.txt.
INFO:tensorflow:Saving labels in ./labels.txt.

Sie können das tflite-Modell auch mit der Methode evaluate_tflite .

model.evaluate_tflite('model.tflite', test_data)
{'accuracy': 0.9182561307901907}

Erweiterte Verwendung

Die create ist der kritische Teil dieser Bibliothek. Es verwendet Transferlernen mit einem vorab trainierten Modell, das dem Lernprogramm ähnelt.

Die create enthält die folgenden Schritte:

  1. test_ratio Daten gemäß den Parametern validation_ratio und test_ratio in Trainings-, validation_ratio und test_ratio . Der Standardwert von validation_ratio und test_ratio ist 0.1 und 0.1 .
  2. Laden Sie einen Image Feature Vector als Basismodell von TensorFlow Hub herunter. Das voreingestellte Standardmodell ist EfficientNet-Lite0.
  3. Fügen Sie einen Klassifiziererkopf mit einer Dropout-Ebene mit dropout_rate zwischen der dropout_rate und dem vorab trainierten Modell hinzu. Die Standard- dropout_rate ist der Standard- dropout_rate Wert von make_image_classifier_lib von TensorFlow Hub.
  4. Verarbeiten Sie die rohen Eingabedaten vor. Derzeit werden Vorverarbeitungsschritte durchgeführt, einschließlich des Normalisierens des Werts jedes Bildpixels auf die Modelleingabeskala und des Änderns der Größe auf die Modelleingabegröße. EfficientNet-Lite0 hat die Eingabeskala [0, 1] und die Eingabebildgröße [224, 224, 3] .
  5. Geben Sie die Daten in das Klassifikatormodell ein. Standardmäßig sind die Trainingsparameter wie Trainingsepochen, Stapelgröße , Lernrate und Impuls die Standardwerte von make_image_classifier_lib von TensorFlow Hub. Nur der Klassifikatorkopf wird trainiert.

In diesem Abschnitt werden verschiedene fortgeschrittene Themen beschrieben, darunter das Wechseln zu einem anderen Bildklassifizierungsmodell, das Ändern der Trainingshyperparameter usw.

Quantisierung nach dem Training mit dem TensorFLow Lite-Modell

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

Model Maker unterstützt mehrere Quantisierungsoptionen nach dem Training. Nehmen wir als Instanz die vollständige Ganzzahlquantisierung. Definieren Sie zunächst die Quantisierungskonfiguration, um die vollständige Ganzzahlquantisierung für alle Operationen einschließlich der Eingabe und Ausgabe zu erzwingen. Der Eingabetyp und der Ausgabetyp sind standardmäßig uint8 . Sie können sie auch in andere Typen wie int8 indem Sie inference_input_type und inference_output_type in config int8 .

config = QuantizationConfig.for_int8(representative_data=test_data)

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

model.export(export_dir='.', tflite_filename='model_quant.tflite', quantization_config=config)
INFO:tensorflow:Assets written to: /tmp/tmp2s0inx6w/assets
INFO:tensorflow:Assets written to: /tmp/tmp2s0inx6w/assets
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/tmp2c5e91zz/labels.txt.
INFO:tensorflow:Saving labels in /tmp/tmp2c5e91zz/labels.txt.
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model_quant.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model_quant.tflite

In Colab können Sie das Modell model_quant.tflite von der linken Seitenleiste herunterladen, genau wie der oben erwähnte Upload-Teil.

Ändern Sie das Modell

Wechseln Sie zu dem Modell, das in dieser Bibliothek unterstützt wird.

Diese Bibliothek unterstützt jetzt EfficientNet-Lite-Modelle, MobileNetV2, ResNet50. EfficientNet-Lite ist eine Familie von Bildklassifizierungsmodellen, die eine Genauigkeit auf dem neuesten Stand der Technik erreichen können und für Edge-Geräte geeignet sind. Das Standardmodell ist EfficientNet-Lite0.

Wir könnten das Modell auf model_spec umstellen, indem wir einfach den Parameter model_spec auf die MobileNetV2-Modellspezifikation in der Methode create .

model = image_classifier.create(train_data, model_spec=model_spec.get('mobilenet_v2'), validation_data=validation_data)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_2 (HubK (None, 1280)              2257984   
_________________________________________________________________
dropout_2 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_2 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 2,264,389
Trainable params: 6,405
Non-trainable params: 2,257,984
_________________________________________________________________
None
Epoch 1/5
91/91 [==============================] - 8s 56ms/step - loss: 1.1977 - accuracy: 0.6116 - val_loss: 0.7188 - val_accuracy: 0.8523
Epoch 2/5
91/91 [==============================] - 5s 52ms/step - loss: 0.7043 - accuracy: 0.8709 - val_loss: 0.6749 - val_accuracy: 0.8750
Epoch 3/5
91/91 [==============================] - 5s 53ms/step - loss: 0.6536 - accuracy: 0.8970 - val_loss: 0.6807 - val_accuracy: 0.8920
Epoch 4/5
91/91 [==============================] - 5s 55ms/step - loss: 0.6229 - accuracy: 0.9084 - val_loss: 0.6605 - val_accuracy: 0.9062
Epoch 5/5
91/91 [==============================] - 5s 57ms/step - loss: 0.6029 - accuracy: 0.9272 - val_loss: 0.6629 - val_accuracy: 0.8920

Bewerten Sie das neu trainierte MobileNetV2-Modell, um die Genauigkeit und den Verlust von Testdaten festzustellen.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 2s 39ms/step - loss: 0.6733 - accuracy: 0.8801

Wechseln Sie in TensorFlow Hub zum Modell

Darüber hinaus könnten wir auch zu anderen neuen Modellen wechseln, die ein Bild eingeben und einen Merkmalsvektor im TensorFlow Hub-Format ausgeben.

Als Auflegungs V3 Modell als Beispiel könnten wir definieren inception_v3_spec , die ein Objekt von ist ModelSpec und enthält die Spezifikation des Modells Auflegungs V3.

Wir müssen die Modellnamen angeben , name , die URL der TensorFlow Hub Modell uri . In der Zwischenzeit ist der Standardwert von input_image_shape [224, 224] . Wir müssen es für das Inception V3-Modell in [299, 299] ändern.

inception_v3_spec = ModelSpec(
    uri='https://tfhub.dev/google/imagenet/inception_v3/feature_vector/1')
inception_v3_spec.input_image_shape = [299, 299]

Dann wird durch Einstellparameter model_spec zu inception_v3_spec in create Methode, könnten wir die Inception V3 Modell umschulen.

Die verbleibenden Schritte sind genau gleich und wir könnten am Ende ein angepasstes InceptionV3 TensorFlow Lite-Modell erhalten.

Ändern Sie Ihr eigenes benutzerdefiniertes Modell

Wenn wir das benutzerdefinierte Modell verwenden möchten , das nicht in TensorFlow Hub enthalten ist, sollten wir ModelSpec in TensorFlow Hub erstellen und exportieren.

Beginnen Sie dann damit, das ModelSpec Objekt wie oben beschrieben zu definieren.

Ändern Sie die Trainingshyperparameter

Wir könnten auch die Trainingshyperparameter wie epochs , dropout_rate und batch_size dropout_rate batch_size , die die Modellgenauigkeit beeinflussen könnten. Die Modellparameter, die Sie anpassen können, sind:

  • epochs : Mehr Epochen könnten eine bessere Genauigkeit erzielen, bis sie konvergieren, aber das Training für zu viele Epochen kann zu einer Überanpassung führen.
  • dropout_rate : Die Rate für Dropout, vermeiden Sie eine Überanpassung. Standardmäßig keine.
  • batch_size : Anzahl der Proben, die in einem Trainingsschritt verwendet werden sollen. Standardmäßig keine.
  • validation_data : Validierungsdaten. Wenn Keine, wird der Validierungsprozess übersprungen. Standardmäßig keine.
  • train_whole_model : Wenn true, wird das Hub-Modul zusammen mit der darüber liegenden Klassifizierungsschicht trainiert. Andernfalls trainieren Sie nur die oberste Klassifizierungsschicht. Standardmäßig keine.
  • learning_rate : Basislernrate. Standardmäßig keine.
  • momentum : Ein Python-Float, der an den Optimierer weitergeleitet wird. use_hub_library nur verwendet, wenn use_hub_library True ist. Standardmäßig keine.
  • shuffle : Boolean, ob die Daten gemischt werden sollen. Standardmäßig falsch.
  • use_augmentation : Boolean, use_augmentation für die Vorverarbeitung verwenden. Standardmäßig falsch.
  • use_hub_library : Boolean, verwenden Sie make_image_classifier_lib vom Tensorflow-Hub, um das Modell neu zu trainieren. Diese Trainingspipeline könnte eine bessere Leistung für komplizierte Datensätze mit vielen Kategorien erzielen. Standardmäßig True.
  • warmup_steps : Anzahl der Aufwärmschritte für den Aufwärmplan für die Lernrate. Wenn Keine, wird der Standard warmup_steps verwendet, der die gesamten Trainingsschritte in zwei Epochen darstellt. use_hub_library nur verwendet, wenn use_hub_library False ist. Standardmäßig keine.
  • model_dir : Optional der Speicherort der Modellprüfpunktdateien. use_hub_library nur verwendet, wenn use_hub_library False ist. Standardmäßig keine.

Parameter, die standardmäßig None sind, wie epochs , erhalten die konkreten Standardparameter in make_image_classifier_lib aus der TensorFlow Hub-Bibliothek oder train_image_classifier_lib .

Zum Beispiel könnten wir mit mehr Epochen trainieren.

model = image_classifier.create(train_data, validation_data=validation_data, epochs=10)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_3 (HubK (None, 1280)              3413024   
_________________________________________________________________
dropout_3 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_3 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/10
91/91 [==============================] - 8s 66ms/step - loss: 1.0908 - accuracy: 0.6347 - val_loss: 0.6812 - val_accuracy: 0.8523
Epoch 2/10
91/91 [==============================] - 5s 53ms/step - loss: 0.6627 - accuracy: 0.8904 - val_loss: 0.6498 - val_accuracy: 0.8864
Epoch 3/10
91/91 [==============================] - 5s 54ms/step - loss: 0.6242 - accuracy: 0.9153 - val_loss: 0.6299 - val_accuracy: 0.9062
Epoch 4/10
91/91 [==============================] - 5s 53ms/step - loss: 0.6068 - accuracy: 0.9229 - val_loss: 0.6221 - val_accuracy: 0.9176
Epoch 5/10
91/91 [==============================] - 5s 56ms/step - loss: 0.5920 - accuracy: 0.9270 - val_loss: 0.6161 - val_accuracy: 0.9176
Epoch 6/10
91/91 [==============================] - 4s 49ms/step - loss: 0.5825 - accuracy: 0.9363 - val_loss: 0.6179 - val_accuracy: 0.9091
Epoch 7/10
91/91 [==============================] - 5s 56ms/step - loss: 0.5752 - accuracy: 0.9400 - val_loss: 0.6143 - val_accuracy: 0.9148
Epoch 8/10
91/91 [==============================] - 5s 50ms/step - loss: 0.5620 - accuracy: 0.9430 - val_loss: 0.6134 - val_accuracy: 0.9091
Epoch 9/10
91/91 [==============================] - 4s 47ms/step - loss: 0.5544 - accuracy: 0.9578 - val_loss: 0.6143 - val_accuracy: 0.9119
Epoch 10/10
91/91 [==============================] - 4s 49ms/step - loss: 0.5554 - accuracy: 0.9507 - val_loss: 0.6103 - val_accuracy: 0.9119

Bewerten Sie das neu umgeschulte Modell mit 10 Trainingsepochen.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 1s 30ms/step - loss: 0.6359 - accuracy: 0.9101