Textklassifizierung mit TensorFlow Lite Model Maker

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

Die TensorFlow Lite Model Maker-Bibliothek vereinfacht das Anpassen und Konvertieren eines TensorFlow-Modells 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 die Model Maker-Bibliothek verwendet, um die Anpassung und Konvertierung eines häufig verwendeten Textklassifizierungsmodells zur Klassifizierung von Filmkritiken auf einem mobilen Gerät zu veranschaulichen. Das Textklassifizierungsmodell klassifiziert Text in vordefinierte Kategorien. Die Eingaben sollten vorverarbeiteter Text sein und die Ausgaben sind die Wahrscheinlichkeiten der Kategorien. Der in diesem Tutorial verwendete Datensatz besteht aus positiven und negativen Filmkritiken.

Voraussetzungen

Installieren Sie die erforderlichen Pakete

Installieren Sie zum Ausführen dieses Beispiels die erforderlichen Pakete, einschließlich des Model Maker-Pakets aus dem GitHub-Repo .

pip install -q tflite-model-maker

Importieren Sie die erforderlichen Pakete.

import numpy as np
import os

from tflite_model_maker import model_spec
from tflite_model_maker import text_classifier
from tflite_model_maker.config import ExportFormat
from tflite_model_maker.text_classifier import AverageWordVecSpec
from tflite_model_maker.text_classifier import DataLoader

import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('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)

Laden Sie die Beispieltrainingsdaten herunter.

In diesem Tutorial verwenden wir die SST-2 (Stanford Sentiment Treebank), eine der Aufgaben im GLUE- Benchmark. Es enthält 67.349 Filmkritiken zum Training und 872 Filmkritiken zum Testen. Der Datensatz hat zwei Klassen: positive und negative Filmkritiken.

data_dir = tf.keras.utils.get_file(
      fname='SST-2.zip',
      origin='https://dl.fbaipublicfiles.com/glue/data/SST-2.zip',
      extract=True)
data_dir = os.path.join(os.path.dirname(data_dir), 'SST-2')
Downloading data from https://dl.fbaipublicfiles.com/glue/data/SST-2.zip
7446528/7439277 [==============================] - 2s 0us/step

Der SST-2-Datensatz wird im TSV-Format gespeichert. Der einzige Unterschied zwischen TSV und CSV ist , dass TSV ein Register verwendet \t Zeichen als Trennzeichen anstelle eines Kommas , im CSV - Format.

Hier sind die ersten 5 Zeilen des Trainingsdatensatzes. label = 0 bedeutet negativ, label = 1 bedeutet positiv.

Satz Etikette
verstecke neue Sekrete vor den Elterneinheiten 0
enthält keinen Witz, nur mühsame Knebel 0
das liebt seine Charaktere und vermittelt etwas ziemlich Schönes über die menschliche Natur 1
bleibt äußerst zufrieden, durchgehend gleich zu bleiben 0
Bei den schlimmsten Klischees der Rache der Nerds konnten die Filmemacher ausgraben 0

Als Nächstes laden wir den Datensatz in einen Pandas-Datenrahmen und ändern die aktuellen Labelnamen ( 0 und 1 ) in besser lesbare ( negative und positive ) und verwenden sie für das Modelltraining.

import pandas as pd

def replace_label(original_file, new_file):
  # Load the original file to pandas. We need to specify the separator as
  # '\t' as the training data is stored in TSV format
  df = pd.read_csv(original_file, sep='\t')

  # Define how we want to change the label name
  label_map = {0: 'negative', 1: 'positive'}

  # Excute the label change
  df.replace({'label': label_map}, inplace=True)

  # Write the updated dataset to a new file
  df.to_csv(new_file)

# Replace the label name for both the training and test dataset. Then write the
# updated CSV dataset to the current folder.
replace_label(os.path.join(os.path.join(data_dir, 'train.tsv')), 'train.csv')
replace_label(os.path.join(os.path.join(data_dir, 'dev.tsv')), 'dev.csv')

Schnellstart

Es gibt fünf Schritte, um ein Textklassifizierungsmodell zu trainieren:

Schritt 1. Wählen Sie eine Textklassifizierungsmodellarchitektur.

Hier verwenden wir die durchschnittliche Welteinbettungsmodellarchitektur, die ein kleines und schnelles Modell mit angemessener Genauigkeit erzeugt.

spec = model_spec.get('average_word_vec')

Model Maker unterstützt auch andere Modellarchitekturen wie BERT . Wenn Sie mehr über andere Architekturen erfahren möchten, lesen Sie den Abschnitt Wählen Sie eine Modellarchitektur für den Textklassifizierer weiter unten.

Schritt 2. Laden Sie die Trainings- und Testdaten und verarbeiten Sie sie gemäß einer bestimmten model_spec .

Model Maker kann Eingabedaten im CSV-Format erfassen. Wir werden den Trainings- und Testdatensatz mit dem zuvor vom Menschen lesbaren Markennamen laden, der zuvor erstellt wurde.

Für jede Modellarchitektur müssen Eingabedaten auf eine bestimmte Weise verarbeitet werden. DataLoader liest die Anforderung aus model_spec und führt automatisch die erforderliche Vorverarbeitung aus.

train_data = DataLoader.from_csv(
      filename='train.csv',
      text_column='sentence',
      label_column='label',
      model_spec=spec,
      is_training=True)
test_data = DataLoader.from_csv(
      filename='dev.csv',
      text_column='sentence',
      label_column='label',
      model_spec=spec,
      is_training=False)

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

Das durchschnittliche batch_size = 32 standardmäßig batch_size = 32 . Daher werden Sie sehen, dass 2104 Schritte erforderlich sind, um die 67.349 Sätze im Trainingsdatensatz durchzugehen. Wir werden das Modell für 10 Epochen trainieren, was bedeutet, dass wir den Trainingsdatensatz 10 Mal durchgehen.

model = text_classifier.create(train_data, model_spec=spec, epochs=10)
Epoch 1/10
2104/2104 [==============================] - 8s 3ms/step - loss: 0.6808 - accuracy: 0.5622
Epoch 2/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.5791 - accuracy: 0.7025
Epoch 3/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4578 - accuracy: 0.7896
Epoch 4/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4040 - accuracy: 0.8222
Epoch 5/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3768 - accuracy: 0.8380
Epoch 6/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3614 - accuracy: 0.8481
Epoch 7/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3490 - accuracy: 0.8553
Epoch 8/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3420 - accuracy: 0.8600
Epoch 9/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3354 - accuracy: 0.8630
Epoch 10/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3293 - accuracy: 0.8660

Schritt 4. Bewerten Sie das Modell mit den Testdaten.

Nach dem Training des Textklassifizierungsmodells anhand der Sätze im Trainingsdatensatz werden die verbleibenden 872 Sätze im Testdatensatz verwendet, um die Leistung des Modells anhand neuer Daten zu bewerten, die es noch nie zuvor gesehen hat.

Da die Standardstapelgröße 32 ist, sind 28 Schritte erforderlich, um die 872 Sätze im Testdatensatz durchzugehen.

loss, acc = model.evaluate(test_data)
28/28 [==============================] - 0s 2ms/step - loss: 0.5155 - accuracy: 0.8337

Schritt 5. Als TensorFlow Lite-Modell exportieren.

Exportieren wir die Textklassifizierung, die wir im TensorFlow Lite-Format trainiert haben. Wir geben an, in welchen Ordner das Modell exportiert werden soll. Standardmäßig wird das Float-TFLite-Modell für die durchschnittliche Welteinbettungsmodellarchitektur exportiert.

model.export(export_dir='average_word_vec')

Sie können die TensorFlow Lite-Modelldatei über die linke Seitenleiste von Colab herunterladen. Gehen Sie in den Ordner " average_word_vec ", wie oben im Parameter " export_dir angegeben, klicken Sie mit der rechten model.tflite auf die Datei " model.tflite " und wählen Sie " Download , um sie auf Ihren lokalen Computer herunterzuladen.

Dieses Modell kann mithilfe der NLClassifier-API der TensorFlow Lite Task Library 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-Textklassifizierung .

Hinweis 1: Die Android Studio-Modellbindung unterstützt noch keine Textklassifizierung. Verwenden Sie daher die TensorFlow Lite-Aufgabenbibliothek.

Anmerkung 2: Es gibt eine model.json - Datei im selben Ordner mit dem TFLite Modell. Es enthält die JSON-Darstellung der im TensorFlow Lite-Modell gebündelten Metadaten . Mithilfe von Modellmetadaten weiß die TFLite-Aufgabenbibliothek, was das Modell tut und wie Daten für das Modell vor- / nachbearbeitet werden. Sie müssen die Datei model.json nicht herunterladen, da sie nur zu Informationszwecken dient und ihr Inhalt bereits in der TFLite-Datei enthalten ist.

Hinweis 3: Wenn Sie ein Textklassifizierungsmodell mit der MobileBERT- oder BERT-Base-Architektur trainieren, müssen Sie stattdessen die BertNLClassifier-API verwenden, um das trainierte Modell in eine mobile App zu integrieren.

In den folgenden Abschnitten wird das Beispiel Schritt für Schritt durchgearbeitet, um weitere Details anzuzeigen.

Wählen Sie eine Modellarchitektur für Text Classifier

Jedes model_spec Objekt repräsentiert ein bestimmtes Modell für den Textklassifizierer. TensorFlow Lite Model Maker unterstützt derzeit MobileBERT , die Mittelung von Worteinbettungen und BERT-Base- Modellen.

Unterstütztes Modell Name von model_spec Modellbeschreibung Modellgröße
Mittelung der Worteinbettung 'durchschnittliches_wort_vec' Mittelung von Textworteinbettungen mit RELU-Aktivierung. <1 MB
MobileBERT 'mobilebert_classifier' 4,3x kleiner und 5,5x schneller als BERT-Base bei gleichzeitiger Erzielung wettbewerbsfähiger Ergebnisse, geeignet für Anwendungen auf dem Gerät. 25 MB mit Quantisierung
100 MB ohne Quantisierung
BERT-Basis 'bert_classifier' Standard-BERT-Modell, das in NLP-Aufgaben weit verbreitet ist. 300 MB

Für den Schnellstart haben wir das durchschnittliche Worteinbettungsmodell verwendet. Wechseln wir zu MobileBERT , um ein Modell mit höherer Genauigkeit zu trainieren.

mb_spec = model_spec.get('mobilebert_classifier')

Trainingsdaten laden

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.

Um es einfach zu halten, werden wir den zuvor heruntergeladenen SST-2-Datensatz wiederverwenden. Verwenden wir die DataLoader.from_csv Methode, um die Daten zu laden.

Bitte beachten Sie, dass wir, da wir die Modellarchitektur geändert haben, den Trainings- und Testdatensatz neu laden müssen, um die neue Vorverarbeitungslogik anzuwenden.

train_data = DataLoader.from_csv(
      filename='train.csv',
      text_column='sentence',
      label_column='label',
      model_spec=mb_spec,
      is_training=True)
test_data = DataLoader.from_csv(
      filename='dev.csv',
      text_column='sentence',
      label_column='label',
      model_spec=mb_spec,
      is_training=False)

Die Model Maker-Bibliothek unterstützt auch die from_folder() -Methode zum Laden von Daten. Es wird davon ausgegangen, dass sich die Textdaten derselben Klasse im selben Unterverzeichnis befinden und dass der Name des Unterordners der Klassenname ist. Jede Textdatei enthält ein Beispiel für eine Filmkritik. Der Parameter class_labels wird verwendet, um anzugeben, welche Unterordner verwendet werden sollen.

Trainiere ein TensorFlow-Modell

Trainieren Sie ein Textklassifizierungsmodell anhand der Trainingsdaten.

model = text_classifier.create(train_data, model_spec=mb_spec, epochs=3)
Epoch 1/3
1403/1403 [==============================] - 319s 191ms/step - loss: 0.3808 - test_accuracy: 0.8441
Epoch 2/3
1403/1403 [==============================] - 262s 187ms/step - loss: 0.1296 - test_accuracy: 0.9534
Epoch 3/3
1403/1403 [==============================] - 264s 188ms/step - loss: 0.0750 - test_accuracy: 0.9759

Untersuchen Sie die detaillierte Modellstruktur.

model.summary()
Model: "model"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
input_word_ids (InputLayer)     [(None, 128)]        0                                            
__________________________________________________________________________________________________
input_mask (InputLayer)         [(None, 128)]        0                                            
__________________________________________________________________________________________________
input_type_ids (InputLayer)     [(None, 128)]        0                                            
__________________________________________________________________________________________________
hub_keras_layer_v1v2 (HubKerasL (None, 512)          24581888    input_word_ids[0][0]             
                                                                 input_mask[0][0]                 
                                                                 input_type_ids[0][0]             
__________________________________________________________________________________________________
dropout_1 (Dropout)             (None, 512)          0           hub_keras_layer_v1v2[0][0]       
__________________________________________________________________________________________________
output (Dense)                  (None, 2)            1026        dropout_1[0][0]                  
==================================================================================================
Total params: 24,582,914
Trainable params: 24,582,914
Non-trainable params: 0
__________________________________________________________________________________________________

Bewerten Sie das Modell

Bewerten Sie das Modell, das wir gerade trainiert haben, anhand der Testdaten und messen Sie den Verlust- und Genauigkeitswert.

loss, acc = model.evaluate(test_data)
28/28 [==============================] - 7s 50ms/step - loss: 0.3626 - test_accuracy: 0.9037

Export als TensorFlow Lite-Modell

Konvertieren Sie das trainierte Modell in das TensorFlow Lite-Modellformat mit Metadaten, damit Sie es später in einer ML-Anwendung auf dem Gerät verwenden können. Die Beschriftungsdatei und die Vokabeldatei sind in Metadaten eingebettet. Der Standard-TFLite-Dateiname lautet model.tflite .

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. Die Standardquantisierungstechnik nach dem Training ist die Dynamikbereichsquantisierung für die Modelle BERT und MobileBERT.

model.export(export_dir='mobilebert/')

Die TensorFlow Lite-Modelldatei kann mithilfe der BertNLClassifier-API in der TensorFlow Lite-Aufgabenbibliothek in eine mobile App integriert werden. Bitte beachten Sie, dass dies unterscheidet sich von der NLClassifier API verwendet , um die Textklassifikation zur Integration mit dem mittleren Wortvektormodell Architektur ausgebildet.

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

Standardmäßig wird nur die TensorFlow Lite-Modelldatei exportiert, die die Modellmetadaten enthält. Sie können auch andere Dateien zum Modell exportieren, um sie besser untersuchen zu können. Exportieren Sie beispielsweise nur die Etikettendatei und die Vokabeldatei wie folgt:

model.export(export_dir='mobilebert/', export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])

Sie können das TFLite-Modell mit evaluate_tflite Methode evalu_tflite evaluate_tflite , um seine Genauigkeit zu messen. Das Konvertieren des trainierten TensorFlow-Modells in das TFLite-Format und das Anwenden der Quantisierung kann die Genauigkeit beeinträchtigen. Es wird daher empfohlen, die Genauigkeit des TFLite-Modells vor der Bereitstellung zu bewerten.

accuracy = model.evaluate_tflite('mobilebert/model.tflite', test_data)
print('TFLite model accuracy: ', accuracy)
TFLite model accuracy:  {'accuracy': 0.9071100917431193}

Erweiterte Verwendung

Die create ist die Treiberfunktion, mit der die Model Maker-Bibliothek Modelle erstellt. Der Parameter model_spec definiert die Modellspezifikation. Die Klassen AverageWordVecSpec und BertClassifierSpec werden derzeit unterstützt. Die create umfasst die folgenden Schritte:

  1. Erstellt das Modell für den Textklassifizierer gemäß model_spec .
  2. Trainiert das Klassifikatormodell. Die Standardepochen und die Standardstapelgröße werden durch die Variablen default_training_epochs und default_batch_size im model_spec Objekt festgelegt.

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

Passen Sie die Hyperparameter des MobileBERT-Modells an

Die Modellparameter, die Sie anpassen können, sind:

  • seq_len : Länge der Sequenz, die in das Modell seq_len .
  • initializer_range : Die Standardabweichung des truncated_normal_initializer zum Initialisieren aller Gewichtsmatrizen.
  • trainable : Boolescher trainable , der angibt, ob die vorab trainierte Ebene trainierbar ist.

Die Parameter der Trainingspipeline, die Sie anpassen können, sind:

  • model_dir : Der Speicherort der Modellprüfpunktdateien. Wenn nicht festgelegt, wird ein temporäres Verzeichnis verwendet.
  • dropout_rate : Die Dropout-Rate.
  • learning_rate : Die anfängliche Lernrate für den Adam-Optimierer.
  • tpu : TPU-Adresse, zu der eine Verbindung hergestellt werden soll.

Sie können beispielsweise seq_len=256 (Standard ist 128). Dadurch kann das Modell längeren Text klassifizieren.

new_model_spec = model_spec.get('mobilebert_classifier')
new_model_spec.seq_len = 256

Passen Sie die durchschnittlichen Hyperparameter des Worteinbettungsmodells an

Sie können die Modellinfrastruktur wie die Variablen wordvec_dim und seq_len in der Klasse AverageWordVecSpec .

Beispielsweise können Sie das Modell mit einem größeren Wert von wordvec_dim . Beachten Sie, dass Sie eine neue model_spec wenn Sie das Modell ändern.

new_model_spec = AverageWordVecSpec(wordvec_dim=32)

Holen Sie sich die vorverarbeiteten Daten.

new_train_data = DataLoader.from_csv(
      filename='train.csv',
      text_column='sentence',
      label_column='label',
      model_spec=new_model_spec,
      is_training=True)

Trainiere das neue Modell.

model = text_classifier.create(new_train_data, model_spec=new_model_spec)
Epoch 1/3
2104/2104 [==============================] - 9s 4ms/step - loss: 0.6725 - accuracy: 0.5775
Epoch 2/3
2104/2104 [==============================] - 7s 3ms/step - loss: 0.5202 - accuracy: 0.7484
Epoch 3/3
2104/2104 [==============================] - 7s 3ms/step - loss: 0.4149 - accuracy: 0.8130

Stellen Sie die Trainingshyperparameter ein

Sie können auch die Trainingshyperparameter wie epochs und batch_size , die sich auf die Modellgenauigkeit auswirken. Beispielsweise,

  • epochs : Mehr Epochen könnten eine bessere Genauigkeit erzielen, können jedoch zu einer Überanpassung führen.
  • batch_size : Die Anzahl der Proben, die in einem Trainingsschritt verwendet werden sollen.

Zum Beispiel können Sie mit mehr Epochen trainieren.

model = text_classifier.create(new_train_data, model_spec=new_model_spec, epochs=20)
Epoch 1/20
2104/2104 [==============================] - 8s 3ms/step - loss: 0.6646 - accuracy: 0.5916
Epoch 2/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.4966 - accuracy: 0.7625
Epoch 3/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.4063 - accuracy: 0.8183
Epoch 4/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3713 - accuracy: 0.8380
Epoch 5/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3530 - accuracy: 0.8508
Epoch 6/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3409 - accuracy: 0.8565
Epoch 7/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3305 - accuracy: 0.8611
Epoch 8/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3240 - accuracy: 0.8663
Epoch 9/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3186 - accuracy: 0.8677
Epoch 10/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3137 - accuracy: 0.8701
Epoch 11/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3100 - accuracy: 0.8725
Epoch 12/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3071 - accuracy: 0.8732
Epoch 13/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3041 - accuracy: 0.8740
Epoch 14/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3013 - accuracy: 0.8767
Epoch 15/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2999 - accuracy: 0.8772
Epoch 16/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2976 - accuracy: 0.8772
Epoch 17/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2963 - accuracy: 0.8797
Epoch 18/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2942 - accuracy: 0.8806
Epoch 19/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2927 - accuracy: 0.8807
Epoch 20/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2900 - accuracy: 0.8818

Bewerten Sie das neu umgeschulte Modell mit 20 Trainingsepochen.

new_test_data = DataLoader.from_csv(
      filename='dev.csv',
      text_column='sentence',
      label_column='label',
      model_spec=new_model_spec,
      is_training=False)

loss, accuracy = model.evaluate(new_test_data)
28/28 [==============================] - 0s 2ms/step - loss: 0.4985 - accuracy: 0.8326

Ändern Sie die Modellarchitektur

Sie können das Modell ändern, indem Sie die model_spec . Im Folgenden wird gezeigt, wie Sie zum BERT-Base-Modell wechseln.

Ändern Sie die model_spec in das BERT-Base-Modell für den Textklassifizierer.

spec = model_spec.get('bert_classifier')

Die restlichen Schritte sind die gleichen.

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

Sie können unser Beispiel für die Textklassifizierung lesen, um technische Details zu erfahren. Weitere Informationen finden Sie unter: