此页面由 Cloud Translation API 翻译。
Switch to English

Hinzufügen von Metadaten zu TensorFlow Lite-Modellen

TensorFlow Lite-Metadaten bieten einen Standard für Modellbeschreibungen. Die Metadaten sind eine wichtige Wissensquelle über die Funktionsweise des Modells und seine Eingabe- / Ausgabeinformationen. Die Metadaten bestehen aus beiden

Alle auf TensorFlow Lite gehosteten Modellen und TensorFlow Hub veröffentlichten Bildmodelle wurden mit Metadaten gefüllt.

Richten Sie die Metadaten-Tools ein

Bevor Sie Ihrem Modell Metadaten hinzufügen, müssen Sie eine Python-Programmierumgebung einrichten, um TensorFlow ausführen zu können. Es gibt eine detaillierte Anleitung, wie man dies einzurichten hier .

Nach dem Einrichten der Python-Programmierumgebung müssen Sie zusätzliche Tools installieren:

pip install tflite-support

Das Metadaten-Tool von TensorFlow Lite unterstützt sowohl Python 2 als auch Python 3.

Hinzufügen von Metadaten

Die Modellmetadaten im Schema bestehen aus drei Teilen:

  1. Modellinformationen - Allgemeine Beschreibung des Modells sowie Gegenstände wie Lizenzbedingungen. Siehe ModelMetadata .
  2. Eingabeinformationen - Beschreibung der erforderlichen Eingaben und Vorverarbeitung, z. B. Normalisierung. Siehe SubGraphMetadata.input_tensor_metadata .
  3. Ausgabeinformationen - Beschreibung der Ausgang und Nachverarbeitung erforderlich ist, wie beispielsweise Mapping auf Etiketten. Siehe SubGraphMetadata.output_tensor_metadata .

Da TensorFlow Lite zu diesem Zeitpunkt nur einen einzelnen Untergraphen unterstützt, verwenden der TensorFlow Lite-Codegenerator und die Android Studio ML-Bindungsfunktion ModelMetadata.name und ModelMetadata.description anstelle von SubGraphMetadata.name und SubGraphMetadata.description , wenn Metadaten SubGraphMetadata.name und Code generiert werden.

Unterstützte Eingabe- / Ausgabetypen

TensorFlow Lite-Metadaten für Eingabe und Ausgabe sind nicht für bestimmte Modelltypen konzipiert, sondern für Eingabe- und Ausgabetypen. Es spielt keine Rolle, was das Modell funktional tut. Solange der Eingabe- und Ausgabetyp aus den folgenden oder einer Kombination der folgenden besteht, wird es von TensorFlow Lite-Metadaten unterstützt:

  • Feature - Zahlen, die Ganzzahlen ohne Vorzeichen oder float32 sind.
  • Bild - Metadaten unterstützen derzeit RGB- und Graustufenbilder.
  • Begrenzungsrahmen - Rechteckige Begrenzungsrahmen. Das Schema unterstützt eine Vielzahl von Nummerierungsschemata .

Packen Sie die zugehörigen Dateien

TensorFlow Lite-Modelle werden möglicherweise mit verschiedenen zugeordneten Dateien geliefert. Beispielsweise verfügen Modelle in natürlicher Sprache normalerweise über Vokabeldateien, die Wortstücke Wort-IDs zuordnen. Klassifizierungsmodelle können Beschriftungsdateien enthalten, die Objektkategorien angeben. Ohne die zugehörigen Dateien (falls vorhanden) funktioniert ein Modell nicht gut.

Die zugehörigen Dateien können jetzt über die Python-Metadatenbibliothek mit dem Modell gebündelt werden. Das neue TensorFlow Lite-Modell wird zu einer Zip-Datei, die sowohl das Modell als auch die zugehörigen Dateien enthält. Es kann mit gängigen Reißverschlusswerkzeugen ausgepackt werden. Dieses neue Modellformat verwendet weiterhin dieselbe Dateierweiterung .tflite . Es ist kompatibel mit dem vorhandenen TFLite-Framework und Interpreter. Weitere Informationen finden Sie unter Packen von Mtadata und zugehörigen Dateien in das Modell .

Die zugehörigen Dateiinformationen können in den Metadaten aufgezeichnet werden. Abhängig vom Dateityp und dem Ort, an den die Datei angehängt ist (dh ModelMetadata , SubGraphMetadata und TensorMetadata ), TensorMetadata der TensorFlow Lite Android-Codegenerator möglicherweise automatisch die entsprechende Vor- / Nachbearbeitung auf das Objekt an. Weitere Informationen finden Sie im Abschnitt <Codegen-Verwendung> jedes zugeordneten Dateityps im Schema.

Normalisierungs- und Quantisierungsparameter

Die Normalisierung ist eine gängige Datenvorverarbeitungstechnik beim maschinellen Lernen. Ziel der Normalisierung ist es, die Werte auf eine gemeinsame Skala zu ändern, ohne Unterschiede in den Wertebereichen zu verzerren.

Die Modellquantisierung ist eine Technik, die eine präzisere Darstellung von Gewichten und optional Aktivierungen sowohl für die Speicherung als auch für die Berechnung ermöglicht.

In Bezug auf Vorverarbeitung und Nachbearbeitung sind Normalisierung und Quantisierung zwei unabhängige Schritte. Hier sind die Details.

Normalisierung Quantisierung

Ein Beispiel für die Parameterwerte des Eingabebilds in MobileNet für Float- bzw. Quant-Modelle.
Float-Modell :
- Mittelwert: 127,5
- Standard: 127,5
Quant Modell :
- Mittelwert: 127,5
- Standard: 127,5
Float-Modell :
- Nullpunkt: 0
- Maßstab: 1,0
Quant Modell :
- Nullpunkt: 128,0
- Maßstab: 0,0078125f




Wann aufrufen?


Eingaben : Wenn die Eingabedaten im Training normalisiert werden, müssen die Eingabedaten der Inferenz entsprechend normalisiert werden.
Ausgänge : Ausgabedaten werden im Allgemeinen nicht normalisiert.
Float-Modelle benötigen keine Quantisierung.
Das quantisierte Modell muss möglicherweise in der Vor- / Nachbearbeitung quantisiert werden oder nicht. Dies hängt vom Datentyp der Eingabe- / Ausgabe-Tensoren ab.
- Float-Tensoren: Keine Quantisierung in der Vor- / Nachbearbeitung erforderlich. Quant op und dequant op werden in das Modelldiagramm eingebrannt.
- int8 / uint8-Tensoren: Quantisierung in der Vor- / Nachbearbeitung erforderlich.


Formel


normalized_input = (Eingabe - Mittelwert) / std
Quantisieren für Eingaben :
q = f / scale + zeroPoint
Für Ausgaben dequantisieren :
f = (q - Nullpunkt) * Skala

Wo sind die Parameter
Wird vom Modellersteller gefüllt und in Modellmetadaten als NormalizationOptions gespeichert Wird vom TFLite-Konverter automatisch ausgefüllt und in der Tflite-Modelldatei gespeichert.
Wie bekomme ich die Parameter? Über die MetadataExtractor API [2] Über die TFLite Tensor API [1] oder über die MetadataExtractor API [2]
Haben Float- und Quant-Modelle den gleichen Wert? Ja, Float- und Quant-Modelle haben dieselben Normalisierungsparameter Nein, das Float-Modell muss nicht quantisiert werden.
Erzeugt der TFLite-Codegenerator oder die Android Studio ML-Bindung diese automatisch bei der Datenverarbeitung?
Ja

Ja

[1] Die TensorFlow Lite Java-API und die TensorFlow Lite C ++ - API .
[2] Die Metadatenextraktionsbibliothek

Bei der Verarbeitung von Bilddaten für uint8-Modelle werden Normalisierung und Quantisierung manchmal übersprungen. Dies ist in Ordnung, wenn die Pixelwerte im Bereich von [0, 255] liegen. Im Allgemeinen sollten Sie die Daten jedoch immer gemäß den Normalisierungs- und Quantisierungsparametern verarbeiten, falls zutreffend.

Beispiele

Beispiele dafür, wie die Metadaten für verschiedene Modelltypen ausgefüllt werden sollen, finden Sie hier:

Bildklassifizierung

Laden Sie das Skript hier , das Füllen von Metadaten mobilenet_v1_0.75_160_quantized.tflite . Führen Sie das Skript folgendermaßen aus:

python ./metadata_writer_for_image_classifier.py \
    --model_file=./model_without_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --label_file=./model_without_metadata/labels.txt \
    --export_directory=model_with_metadata

So füllen Sie Metadaten für andere Bildklassifizierungsmodelle, fügen Sie die Modelldaten wie diese in das Skript. Der Rest dieses Handbuchs hebt einige der Schlüsselabschnitte im Bildklassifizierungsbeispiel hervor, um die Schlüsselelemente zu veranschaulichen.

Tauchen Sie tief in das Bildklassifizierungsbeispiel ein

Modellinformationen

Metadaten beginnen mit dem Erstellen einer neuen Modellinformation:

from tflite_support import flatbuffers
from tflite_support import metadata as _metadata
from tflite_support import metadata_schema_py_generated as _metadata_fb

""" ... """
"""Creates the metadata for an image classifier."""

# Creates model info.
model_meta = _metadata_fb.ModelMetadataT()
model_meta.name = "MobileNetV1 image classifier"
model_meta.description = ("Identify the most prominent object in the "
                          "image from a set of 1,001 categories such as "
                          "trees, animals, food, vehicles, person etc.")
model_meta.version = "v1"
model_meta.author = "TensorFlow"
model_meta.license = ("Apache License. Version 2.0 "
                      "http://www.apache.org/licenses/LICENSE-2.0.")

Eingabe- / Ausgabeinformationen

In diesem Abschnitt erfahren Sie, wie Sie die Eingabe- und Ausgabesignatur Ihres Modells beschreiben. Diese Metadaten können von automatischen Codegeneratoren verwendet werden, um Code vor und nach der Verarbeitung zu erstellen. So erstellen Sie Eingabe- oder Ausgabeinformationen zu einem Tensor:

# Creates input info.
input_meta = _metadata_fb.TensorMetadataT()

# Creates output info.
output_meta = _metadata_fb.TensorMetadataT()

Bildeingabe

Bild ist ein gängiger Eingabetyp für maschinelles Lernen. TensorFlow Lite-Metadaten unterstützen Informationen wie den Farbraum und Vorverarbeitungsinformationen wie die Normalisierung. Die Abmessung des Bildes erfordert keine manuelle Angabe, da sie bereits durch die Form des Eingangstensors bereitgestellt wird und automatisch abgeleitet werden kann.

input_meta.name = "image"
input_meta.description = (
    "Input image to be classified. The expected image is {0} x {1}, with "
    "three channels (red, blue, and green) per pixel. Each value in the "
    "tensor is a single byte between 0 and 255.".format(160, 160))
input_meta.content = _metadata_fb.ContentT()
input_meta.content.contentProperties = _metadata_fb.ImagePropertiesT()
input_meta.content.contentProperties.colorSpace = (
    _metadata_fb.ColorSpaceType.RGB)
input_meta.content.contentPropertiesType = (
    _metadata_fb.ContentProperties.ImageProperties)
input_normalization = _metadata_fb.ProcessUnitT()
input_normalization.optionsType = (
    _metadata_fb.ProcessUnitOptions.NormalizationOptions)
input_normalization.options = _metadata_fb.NormalizationOptionsT()
input_normalization.options.mean = [127.5]
input_normalization.options.std = [127.5]
input_meta.processUnits = [input_normalization]
input_stats = _metadata_fb.StatsT()
input_stats.max = [255]
input_stats.min = [0]
input_meta.stats = input_stats

Beschriftungsausgabe

Das Label kann mit TENSOR_AXIS_LABELS über eine zugehörige Datei einem TENSOR_AXIS_LABELS .

# Creates output info.
output_meta = _metadata_fb.TensorMetadataT()
output_meta.name = "probability"
output_meta.description = "Probabilities of the 1001 labels respectively."
output_meta.content = _metadata_fb.ContentT()
output_meta.content.content_properties = _metadata_fb.FeaturePropertiesT()
output_meta.content.contentPropertiesType = (
    _metadata_fb.ContentProperties.FeatureProperties)
output_stats = _metadata_fb.StatsT()
output_stats.max = [1.0]
output_stats.min = [0.0]
output_meta.stats = output_stats
label_file = _metadata_fb.AssociatedFileT()
label_file.name = os.path.basename("your_path_to_label_file")
label_file.description = "Labels for objects that the model can recognize."
label_file.type = _metadata_fb.AssociatedFileType.TENSOR_AXIS_LABELS
output_meta.associatedFiles = [label_file]

Erstellen Sie die Metadaten Flatbuffers

Der folgende Code kombiniert die Modellinformationen mit den Eingabe- und Ausgabeinformationen:

# Creates subgraph info.
subgraph = _metadata_fb.SubGraphMetadataT()
subgraph.inputTensorMetadata = [input_meta]
subgraph.outputTensorMetadata = [output_meta]
model_meta.subgraphMetadata = [subgraph]

b = flatbuffers.Builder(0)
b.Finish(
    model_meta.Pack(b),
    _metadata.MetadataPopulator.METADATA_FILE_IDENTIFIER)
metadata_buf = b.Output()

Packen Sie Metadaten und zugehörige Dateien in das Modell

Sobald die Metadaten Flatbuffers erstellt wurden, werden die Metadaten und die Beschriftungsdatei über die Methode populate in die TFLite-Datei geschrieben:

populator = _metadata.MetadataPopulator.with_model_file(model_file)
populator.load_metadata_buffer(metadata_buf)
populator.load_associated_files(["your_path_to_label_file"])
populator.populate()

Sie können über load_associated_files so viele zugehörige Dateien in das Modell load_associated_files wie Sie möchten. Es ist jedoch erforderlich, mindestens die in den Metadaten dokumentierten Dateien zu packen. In diesem Beispiel ist das Packen der Etikettendatei obligatorisch.

Visualisieren Sie die Metadaten

Sie können Netron verwenden , um Ihre Metadaten zu visualisieren, oder Sie können die Metadaten eines TensorFlow Lite-Modells mithilfe des MetadataDisplayer in ein JSON-Format lesen:

displayer = _metadata.MetadataDisplayer.with_model_file(export_model_path)
export_json_file = os.path.join(FLAGS.export_directory,
                    os.path.splitext(model_basename)[0] + ".json")
json_file = displayer.get_metadata_json()
# Optional: write out the metadata as a json file
with open(export_json_file, "w") as f:
  f.write(json_file)

Android Studio unterstützt auch die Anzeige von Metadaten über die Android Studio ML-Bindungsfunktion .

Versionierung von Metadaten

Das Metadatenschema wird sowohl durch die semantische Versionsnummer, die die Änderungen der Schemadatei verfolgt, als auch durch die Flatbuffers-Dateikennung versioniert, die die tatsächliche Versionskompatibilität angibt.

Die semantische Versionsnummer

Das Metadatenschema wird durch die semantische Versionsnummer wie MAJOR.MINOR.PATCH versioniert. Es verfolgt Schemaänderungen gemäß den hier angegebenen Regeln. Siehe den Verlauf der Felder, die nach Version 1.0.0 hinzugefügt wurden.

Die Flatbuffers-Dateiidentifikation

Die semantische Versionierung garantiert die Kompatibilität, wenn die Regeln befolgt werden, impliziert jedoch nicht die tatsächliche Inkompatibilität. Wenn Sie die MAJOR-Nummer erhöhen, bedeutet dies nicht unbedingt, dass die Abwärtskompatibilität unterbrochen ist. Daher verwenden wir die Flatbuffers-Dateikennung file_identifier , um die wahre Kompatibilität des Metadatenschemas zu kennzeichnen. Die Dateikennung ist genau 4 Zeichen lang. Es ist auf ein bestimmtes Metadatenschema festgelegt und kann von den Benutzern nicht geändert werden. Wenn die Abwärtskompatibilität des Metadatenschemas aus irgendeinem Grund unterbrochen werden muss, wird der file_identifier beispielsweise von "M001" auf "M002" erhöht. Es wird erwartet, dass File_identifier viel seltener geändert wird als die metadata_version.

Die minimal erforderliche Metadaten-Parser-Version

Die minimal erforderliche Metadaten-Parser-Version ist die Mindestversion des Metadaten-Parsers (der von Flatbuffers generierte Code), der die Metadaten-Flatbuffer vollständig lesen kann. Die Version ist effektiv die größte Versionsnummer unter den Versionen aller ausgefüllten Felder und die kleinste kompatible Version, die durch die Dateikennung angegeben wird. Die minimal erforderliche Metadaten-Parser-Version wird automatisch vom MetadataPopulator ausgefüllt, wenn die Metadaten in ein TFLite-Modell eingefügt werden. Weitere Informationen zur Verwendung der mindestens erforderlichen Metadaten-Parser-Version finden Sie im Metadaten-Extraktor .

Lesen Sie die Metadaten von Modellen

Die Metadata Extractor-Bibliothek ist ein praktisches Tool zum Lesen der Metadaten und zugehörigen Dateien aus einem Modell auf verschiedenen Plattformen (siehe Java-Version und C ++ - Version ). Mit der Flatbuffers-Bibliothek können Sie Ihr eigenes Metadaten-Extraktions-Tool in anderen Sprachen erstellen.

Lesen Sie die Metadaten in Java

Um die Metadata Extractor-Bibliothek in Ihrer Android-App zu verwenden, empfehlen wir die Verwendung des im JCenter gehosteten TensorFlow Lite-Metadaten-AAR . Es enthält die MetadataExtractor Klasse sowie die FlatBuffers-Java-Bindungen für das Metadatenschema und das Modellschema .

Sie können dies in Ihren build.gradle Abhängigkeiten wie folgt angeben:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite-metadata:0.0.0-nightly'
}

Sie können ein MetadataExtractor Objekt mit einem ByteBuffer , der auf das Modell verweist:

public MetadataExtractor(ByteBuffer buffer);

Der ByteBuffer muss während der gesamten Lebensdauer des MetadataExtractor Objekts unverändert bleiben. Die Initialisierung kann fehlschlagen, wenn die Flatbuffers-Dateikennung der Modellmetadaten nicht mit der des Metadatenparsers übereinstimmt. Weitere Informationen finden Sie unter Metadatenversionierung .

Mit übereinstimmenden Dateikennungen liest der Metadatenextraktor erfolgreich Metadaten, die aufgrund des Vorwärts- und Rückwärtskompatibilitätsmechanismus der Flatbuffer aus allen vergangenen und zukünftigen Schemata generiert wurden. Felder aus zukünftigen Schemata können jedoch nicht von älteren Metadatenextraktoren extrahiert werden. Die minimal erforderliche Parser-Version der Metadaten gibt die minimale Version des Metadaten-Parsers an, die die Metadaten-Flatbuffer vollständig lesen kann. Mit der folgenden Methode können Sie überprüfen, ob die mindestens erforderliche Parser-Versionsbedingung erfüllt ist:

public final boolean isMinimumParserVersionSatisfied();

Die Übergabe eines Modells ohne Metadaten ist zulässig. Das Aufrufen von Methoden, die aus den Metadaten lesen, führt jedoch zu Laufzeitfehlern. Sie können überprüfen, ob ein Modell Metadaten enthält, indem Sie die Methode hasMetadata :

public boolean hasMetadata();

MetadataExtractor bietet praktische Funktionen zum Abrufen der Metadaten der Eingabe- / Ausgabe-Tensoren. Zum Beispiel,

public int getInputTensorCount();
public TensorMetadata getInputTensorMetadata(int inputIndex);
public QuantizationParams getInputTensorQuantizationParams(int inputIndex);
public int[] getInputTensorShape(int inputIndex);
public int getoutputTensorCount();
public TensorMetadata getoutputTensorMetadata(int inputIndex);
public QuantizationParams getoutputTensorQuantizationParams(int inputIndex);
public int[] getoutputTensorShape(int inputIndex);

Obwohl das TensorFlow Lite-Modellschema mehrere Untergraphen unterstützt, unterstützt der TFLite-Interpreter derzeit nur einen einzigen Untergraphen. Daher lässt MetadataExtractor Subgraph-Index als Eingabeargument in seinen Methoden weg.

Lesen Sie die zugehörigen Dateien aus Modellen

Das TensorFlow Lite-Modell mit Metadaten und zugehörigen Dateien ist im Wesentlichen eine Zip-Datei, die mit gängigen Zip-Tools entpackt werden kann, um die zugehörigen Dateien abzurufen. Beispielsweise können Sie mobilet_v1_0.75_160_quantized entpacken und die Etikettendatei im Modell wie folgt extrahieren:

$ unzip mobilenet_v1_0.75_160_quantized_1_metadata_1.tflite
Archive:  mobilenet_v1_0.75_160_quantized_1_metadata_1.tflite
 extracting: labels.txt

Sie können zugehörige Dateien auch über die Metadata Extractor-Bibliothek lesen.

Übergeben Sie in Java den Dateinamen an die MetadataExtractor.getAssociatedFile Methode:

public InputStream getAssociatedFile(String fileName);

ModelMetadataExtractor::GetAssociatedFile kann dies in C ++ mit der Methode ModelMetadataExtractor::GetAssociatedFile :

tflite::support::StatusOr<absl::string_view> GetAssociatedFile(
      const std::string& filename) const;