Metadaten zu LiteRT-Modellen hinzufügen

LiteRT-Metadaten bieten einen Standard für Modellbeschreibungen. Die Metadaten sind eine wichtige Wissensquelle darüber, was das Modell tut und was Eingabe-/Ausgabeinformationen. Die Metadaten umfassen sowohl

• menschenlesbare Teile, die die Best Practice bei der Verwendung des Modells vermitteln. und
• maschinenlesbare Teile, die von Codegeneratoren wie dem LiteRT-Android-Code Generator und die Android Studio ML Binding

Alle auf Kaggle veröffentlichte Bildmodelle Modelle wurden mit Metadaten.

Modell mit Metadatenformat

Modellmetadaten werden definiert in metadata_schema.fbs eine FlatBuffer -Datei. Wie in Abbildung 1 gezeigt, werden die Daten im Metadaten des TFLite-Modells Schema unter dem Namen "TFLITE_METADATA". Einige Modelle haben möglicherweise verknüpfte Dateien, wie z. B. Klassifizierungslabel Dateien. Diese Dateien werden am Ende der ursprünglichen Modelldatei als ZIP-Datei verkettet. mithilfe der ZipFile-Datei "append" Modus ('a'-Modus) eingestellt. TFLite Der Interpreter kann das neue Dateiformat auf dieselbe Weise wie zuvor verarbeiten. Paket ansehen in den zugehörigen Dateien.

In der folgenden Anleitung erfahren Sie, wie Sie Metadaten füllen, visualisieren und lesen.

Metadatentools einrichten

Bevor Sie Ihrem Modell Metadaten hinzufügen, müssen Sie mit einer Python-Programmierung zum Ausführen von TensorFlow einrichten. Hier finden Sie eine ausführliche Anleitung richten Sie dies hier ein.

Nach der Einrichtung der Python-Programmierumgebung müssen Sie zusätzliche Tools:

pip install tflite-support

LiteRT-Metadatentools unterstützen Python 3.

Metadaten mithilfe der Flatbuffers Python API hinzufügen

Die Modellmetadaten bestehen aus drei Teilen im Schema:

1. Modellinformationen: Gesamtbeschreibung des Modells und der Artikel wie Lizenzbedingungen. Weitere Informationen finden Sie unter ModelMetadata angegeben.
   1. Eingabeinformationen: Beschreibung der Eingaben und der Vorverarbeitung wie Normalisierung. Weitere Informationen finden Sie unter SubGraphMetadata.input_tensor_metadata:
      1. Ausgabeinformationen: Beschreibung der Ausgabe und ist eine Nachbearbeitung erforderlich, z. B. die Zuordnung zu Labels. Weitere Informationen finden Sie unter SubGraphMetadata.output_tensor_metadata:

Da LiteRT derzeit nur einzelne Teilgraphen unterstützt, wird der LiteRT-Codegenerator und die Android Studio ML Binding Funktion werden ModelMetadata.name und ModelMetadata.description anstelle von SubGraphMetadata.name und SubGraphMetadata.description, bei Anzeige und Generieren von Code.

Unterstützte Eingabe-/Ausgabetypen

LiteRT-Metadaten für Ein- und Ausgabe sind nicht mit spezifischen berücksichtigen, sondern eher Eingabe- und Ausgabetypen. Es spielt keine Rolle, was wie das Modell funktioniert, solange die Eingabe- und Ausgabetypen aus die folgenden oder eine Kombination aus Folgendem verwenden, wird sie von TensorFlow unterstützt: Lite-Metadaten:

• Merkmal: Zahlen, die als Ganzzahlen ohne Vorzeichen oder als Gleitkommazahl (FLOAT32) formatiert sind.
• Bild: Metadaten unterstützen derzeit RGB- und Graustufenbilder.
• Begrenzungsrahmen - Begrenzungsrahmen in rechteckiger Form. Das Schema unterstützt a Vielfalt der Nummerierung .

Verknüpfte Dateien packen

LiteRT-Modelle können mit verschiedenen verknüpften Dateien geliefert werden. Beispiel: Natural Language Models haben in der Regel Vokabulardateien, in denen Wortteile einzelnen Wörtern zugeordnet werden. IDs: Klassifizierungsmodelle können Labeldateien haben, die Objektkategorien angeben. Ohne verknüpfte Dateien (falls vorhanden) funktioniert ein Modell nicht gut.

Die verknüpften Dateien können jetzt über die Metadaten mit dem Modell gebündelt werden. Python-Bibliothek. Das neue LiteRT-Modell wird zu einer ZIP-Datei, die das Modell und die zugehörigen Dateien. Es kann mit einem gewöhnlichen Zip entpackt werden. Werkzeuge. Das neue Modellformat hat weiterhin dieselbe Dateiendung – .tflite. Es ist mit dem vorhandenen TFLite-Framework und Interpreter kompatibel. Paketmetadaten ansehen und zugehörige Dateien im finden Sie weitere Informationen.

Die zugehörigen Dateiinformationen können in den Metadaten aufgezeichnet werden. Je nach Den Dateityp und den Speicherort der Datei (z.B. ModelMetadata, SubGraphMetadata und TensorMetadata), den LiteRT-Android-Code Generator können entsprechende Vorher-/Nachher-Vergleiche automatisch an das Objekt übergeben. Siehe <Codegen-Nutzung> Abschnitt von jede verknüpfte Datei Typ im Schema.

Normalisierungs- und Quantisierungsparameter

Die Normalisierung ist eine gängige Methode der Datenvorverarbeitung im maschinellen Lernen. Die Ziel der Normalisierung ist es, die Werte in eine gemeinsame Skala zu ändern, verzerrte Differenzen in den Wertebereichen.

Die Modellquantisierung ist eine Technik mit der Gewichtungen mit geringerer Genauigkeit dargestellt werden können. Optional Aktivierungen für Speicher und Berechnung.

Im Hinblick auf die Vorverarbeitung und Nachverarbeitung, Normalisierung und Quantisierung sind zwei unabhängige Schritte. Ausführliche Informationen zum Problem:

[1] Das LiteRT Java API und die LiteRT C++- API
[2] Die Metadaten-Extraktorbibliothek

Bei der Verarbeitung von Bilddaten für uint8-Modelle werden Normalisierung und Quantisierung manchmal übersprungen. Dies ist kein Problem, wenn die Pixelwerte im Bereich [0, 255]. Aber im Allgemeinen sollten Sie die Daten immer gemäß den Normalisierungs- und Quantisierungsparameter.

Beispiele

Es gibt Beispiele dafür, wie die Metadaten für verschiedene Modelltypen verwenden:

Bildklassifizierung

Script herunterladen hier , mit der Metadaten in mobilenet_v1_0.75_160_quantized.tflite. Führen Sie das Skript so 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

Fügen Sie die Modellspezifikationen hinzu, um Metadaten für andere Bildklassifizierungsmodelle zu füllen „Mag ich“-Bewertung dieser in das Skript ein. Im weiteren Verlauf dieses Leitfadens werden einige der wichtigsten Abschnitte erläutert. im Beispiel für die Bildklassifizierung zur Veranschaulichung der wichtigsten Elemente.

Beispiel für die Bildklassifizierung im Detail

Modellinformationen

Metadaten beginnen damit, dass neue Modellinformationen erstellt werden:

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.")

Ein-/Ausgabeinformationen

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

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

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

Bildeingabe

Bilder sind ein gängiger Eingabetyp für maschinelles Lernen. LiteRT-Metadaten unterstützt Informationen wie Farbraum und Vorverarbeitungsinformationen wie Normalisierung. Die Abmessungen des Bildes müssen nicht manuell angegeben werden. da er bereits von der Form des Eingabetensors bereitgestellt wird und automatisch abgeleitet wird.

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

Labelausgabe

Label kann einem Ausgabetensor über eine verknüpfte Datei mithilfe von 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]

Metadaten-Flatbuffer erstellen

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

# 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()

Metadaten und zugehörige Dateien in das Modell packen

Nachdem die Flatbuffers für Metadaten erstellt wurden, werden die Metadaten und die Labeldatei mit der 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 beliebig viele verknüpfte Dateien in das Modell packen, load_associated_files Es ist jedoch erforderlich, mindestens diese Dateien zu verpacken. die in den Metadaten dokumentiert sind. In diesem Beispiel wird die Labeldatei obligatorisch.

Metadaten visualisieren

Sie können Netron verwenden, um Ihre Metadaten oder Sie lesen die Metadaten aus einem LiteRT-Modell in eine JSON-Datei. Format mit dem MetadataDisplayer:

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 Android Studio ML. Bindung .

Versionsverwaltung für Metadaten

Die Metadaten Schema wird sowohl mit der semantischen Versionsnummerierung versioniert, die die Änderungen der und anhand der Identifizierung der Flatbuffers-Datei, die den echte Versionskompatibilität.

Semantische Versionsnummer

Das Metadatenschema wird durch die semantische Versionsverwaltung versioniert. Nummer, wie MAJOR.MINOR.PATCH. Schemaänderungen werden gemäß den Regeln erfasst. hier. Sehen Sie sich den Verlauf von Felder nach Version 1.0.0 hinzugefügt.

Identifizierung der Flatbuffers-Datei

Die semantische Versionsverwaltung garantiert die Kompatibilität, wenn die Regeln eingehalten werden, impliziert nicht die tatsächliche Inkompatibilität. Wenn man die MAJOR-Nummer hochfährt, bedeutet nicht unbedingt, dass die Abwärtskompatibilität beeinträchtigt ist. Aus diesem Grund die Flatbuffers-Datei Identifikation, file_identifier, um die tatsächliche Kompatibilität des Metadatenschemas anzugeben. Die Dateikennung lautet genau 4 Zeichen lang ist. Sie ist auf ein bestimmtes Metadatenschema festgelegt Änderungen durch Nutzer vorbehalten. Wenn die Abwärtskompatibilität des Metadatenschemas defekt sein muss, stößt das Feld "file_identifier" zum Beispiel nach oben von "M001" in "M002" ändern. Das Feld "file_identifier" wird voraussichtlich deutlich seltener geändert. als „metadata_version“.

Die mindestens erforderliche Version des Metadatenparsers

Der mindestens erforderliche Metadatenparser Version ist die Mindestversion des Metadatenparsers (der von Flatbuffers generierte Code), der kann die Metadaten-Flatbuffer vollständig lesen. Die Version ist effektiv die höchste Versionsnummer unter den Versionen aller ausgefüllten Felder und der die kleinste kompatible Version, die in der Datei-ID angegeben ist. Das Minimum Die erforderliche Version des Metadatenparsers wird automatisch vom MetadataPopulator, wenn die Metadaten in ein TFLite-Modell eingefügt werden. Weitere Informationen finden Sie in der Metadaten-Extraktor finden Sie weitere Informationen dazu, wie Sie wird die mindestens erforderliche Version des Metadatenparsers verwendet.

Metadaten aus Modellen lesen

Die Metadata Extractor-Bibliothek ist ein praktisches Tool, verknüpfte Dateien eines Modells auf verschiedenen Plattformen (siehe Java- Version und die C++- Version. Mit dem Tool für Metadatenextraktoren in anderen Sprachen können Sie Flatbuffers-Bibliothek.

Metadaten in Java lesen

Um die Metadata Extractor-Bibliothek in deiner Android-App zu verwenden, empfehlen wir Folgendes: der LiteRT Metadata AAR gehostet unter MavenCentral. Sie enthält die Klasse MetadataExtractor und die FlatBuffers Java Bindungen für die Metadaten Schema und das Modell Schema.

Sie können dies so in Ihren build.gradle-Abhängigkeiten angeben:

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

Wenn Sie nächtliche Momentaufnahmen verwenden möchten, achten Sie darauf, dass Sie einen Sonatype-Snapshot hinzugefügt haben. .

Sie können ein MetadataExtractor-Objekt mit einer ByteBuffer initialisieren, die auf auf das Modell:

public MetadataExtractor(ByteBuffer buffer);

ByteBuffer darf für die gesamte Lebensdauer des Elements unverändert bleiben. MetadataExtractor-Objekt. Die Initialisierung kann fehlschlagen, wenn die Flatbuffers-Datei Die Kennzeichnung der Modellmetadaten stimmt nicht mit der des Metadaten-Parsers überein. Weitere Informationen finden Sie unter Metadatenversionsverwaltung.

Mit übereinstimmenden Datei-IDs kann der Metadatenextraktor den Inhalt lesen. Metadaten, die aufgrund der Flatbuffers aus allen vergangenen und zukünftigen Schemas generiert wurden der Vorwärts- und Rückwärtskompatibilität. Felder aus zukünftigen Schemas können nicht von älteren Metadatenextraktoren extrahiert werden. Das erforderliche Minimum Parserversion der Metadaten. gibt die Mindestversion des Metadatenparsers an, der die Metadaten lesen kann Flatbuffers komplett. Mit der folgenden Methode können Sie überprüfen, ob das Minimum Die erforderliche Bedingung für die Parserversion ist erfüllt:

public final boolean isMinimumParserVersionSatisfied();

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

public boolean hasMetadata();

MetadataExtractor bietet praktische Funktionen zum Abrufen des Eingabe-/Ausgabetensoren Metadaten. 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 LiteRT-Modell Schema unterstützt mehrere Teildiagramme, der TFLite Interpreter unterstützt derzeit nur eine Teildiagramm zu erstellen. Daher lässt MetadataExtractor den Teilgraphenindex als Eingabe weg -Argument in seinen Methoden.

Verknüpfte Dateien aus Modellen lesen

Das LiteRT-Modell mit Metadaten und den zugehörigen Dateien ist im Wesentlichen ein ZIP-Datei, die mit gängigen ZIP-Tools entpackt werden kann, um die zugehörigen Dateien abzurufen. Sie können zum Beispiel mobilenet_v1_0.75_160_quantized und extrahieren Sie die Labeldatei im Modell wie folgt:

$ 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 verknüpfte Dateien auch über die Metadata Extractor-Bibliothek lesen.

In Java übergeben Sie den Dateinamen an den MetadataExtractor.getAssociatedFile. :

public InputStream getAssociatedFile(String fileName);

In C++ können Sie dies mithilfe der Methode ModelMetadataExtractor::GetAssociatedFile:

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