Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Ajouter des métadonnées aux modèles TensorFlow Lite

Les métadonnées TensorFlow Lite fournissent une norme pour les descriptions de modèles. Les métadonnées sont une source importante de connaissances sur ce que fait le modèle et ses informations d'entrée/sortie. Les métadonnées se composent à la fois

Tous les modèles d'image publiés sur tensorflow Lite modèles hébergés et tensorflow Hub ont été renseignés avec des métadonnées.

Modèle avec format de métadonnées

model_with_metadata
Figure 1. Modèle TFLite avec métadonnées et fichiers associés.

Métadonnées modèle est défini dans metadata_schema.fbs , un FlatBuffer fichier. Comme le montre la Figure 1, il est stocké dans le méta champ du schéma de modèle TFLite , sous le nom, "TFLITE_METADATA" . Certains modèles peuvent venir avec les fichiers associés, tels que les fichiers d'étiquettes de classement . Ces fichiers sont concaténés à la fin du fichier modèle original comme ZIP en utilisant le ZipFile mode « append » ( 'a' mode). TFLite Interpreter peut utiliser le nouveau format de fichier de la même manière qu'auparavant. Voir Emballez les fichiers associés pour plus d' informations.

Consultez les instructions ci-dessous pour savoir comment remplir, visualiser et lire les métadonnées.

Configurer les outils de métadonnées

Avant d'ajouter des métadonnées à votre modèle, vous aurez besoin d'une configuration d'environnement de programmation Python pour exécuter TensorFlow. Il y a un guide détaillé sur la façon de mettre en place ici .

Après avoir configuré l'environnement de programmation Python, vous devrez installer des outils supplémentaires :

pip install tflite-support

Les outils de métadonnées TensorFlow Lite sont compatibles avec Python 3.

Ajout de métadonnées à l'aide de l'API Python Flatbuffers

Il y a trois parties les métadonnées du modèle dans le schéma :

  1. Informations du modèle - Description générale du modèle ainsi que des éléments tels que les conditions de licence. Voir ModelMetadata .
  2. Informations d' entrée - Description des entrées et pré-traitement nécessaire telles que la normalisation. Voir SubGraphMetadata.input_tensor_metadata .
  3. Des informations de sortie - Description de la sortie et de post-traitement nécessaire comme la cartographie d'étiquettes. Voir SubGraphMetadata.output_tensor_metadata .

Depuis tensorflow Lite ne supporte que seul sous - graphe à ce point, le générateur de code tensorflow Lite et la fonctionnalité de ModelMetadata.name ModelMetadata.description SubGraphMetadata.name SubGraphMetadata.description liaison studio Android ML utilisera ModelMetadata.name et ModelMetadata.description , au lieu de SubGraphMetadata.name et SubGraphMetadata.description , lors de l' affichage des métadonnées et de génération de code.

Types d'entrée/sortie pris en charge

Les métadonnées TensorFlow Lite pour l'entrée et la sortie ne sont pas conçues pour des types de modèles spécifiques, mais plutôt pour des types d'entrée et de sortie. Peu importe ce que le modèle fait fonctionnellement, tant que les types d'entrée et de sortie se composent des éléments suivants ou d'une combinaison des éléments suivants, ils sont pris en charge par les métadonnées TensorFlow Lite :

  • Fonctionnalité - Nombres qui sont des entiers non signés ou float32.
  • Image - Les métadonnées prennent actuellement en charge les images RVB et en niveaux de gris.
  • Boîte englobante - Boîtes englobantes de forme rectangulaire. Le schéma prend en charge une variété de systèmes de numérotation .

Pack des fichiers associés

Les modèles TensorFlow Lite peuvent être livrés avec différents fichiers associés. Par exemple, les modèles de langage naturel ont généralement des fichiers de vocabulaire qui mappent des fragments de mots aux identifiants de mots ; les modèles de classification peuvent avoir des fichiers d'étiquettes qui indiquent des catégories d'objets. Sans les fichiers associés (s'il y en a), un modèle ne fonctionnera pas bien.

Les fichiers associés peuvent désormais être regroupés avec le modèle via la bibliothèque de métadonnées Python. Le nouveau modèle TensorFlow Lite devient un fichier zip contenant à la fois le modèle et les fichiers associés. Il peut être déballé avec des outils zip courants. Ce nouveau format de modèle continue d' utiliser la même extension de fichier, .tflite . Il est compatible avec le framework et l'interprète TFLite existants. Voir métadonnées Pack et les fichiers associés au modèle pour plus de détails.

Les informations de fichier associées peuvent être enregistrées dans les métadonnées. Selon le type de fichier et dans lequel le fichier est attaché à (c. -à- ModelMetadata , SubGraphMetadata et TensorMetadata ), le générateur de code applications tensorflow Lite peut appliquer un traitement de pré / post automatiquement en fonction de l'objet. Voir la section de chaque type de fichier associé <d'utilisation Codegen> dans le schéma pour plus de détails.

Paramètres de normalisation et de quantification

La normalisation est une technique courante de prétraitement des données en apprentissage automatique. Le but de la normalisation est de changer les valeurs à une échelle commune, sans fausser les différences dans les plages de valeurs.

Quantification du modèle est une technique qui permet une réduction de précision des représentations de poids et le cas échéant, pour les deux activations de stockage et de calcul.

En termes de prétraitement et de post-traitement, la normalisation et la quantification sont deux étapes indépendantes. Voici les détails.

Normalisation Quantification

Un exemple des valeurs de paramètre de l'image d'entrée dans MobileNet pour les modèles float et quant, respectivement.
Modèle de flotteur:
- moyenne : 127,5
- standard : 127,5
Modèle quantitatif:
- moyenne : 127,5
- standard : 127,5
Modèle de flotteur:
- point zéro : 0
- échelle : 1.0
Modèle quantitatif:
- point zéro : 128,0
- échelle:0.0078125f




Quand invoquer ?


Entrées: Si les données d'entrée est normalisée dans la formation, les données d'entrée des besoins d'inférence à normaliser en conséquence.
Sorties: données de sortie ne seront pas normalisées en général.
Modèles de flotteur ne quantification pas besoin.
Modèle Quantifié ou non besoin d'une quantification dans le pré / post traitement. Cela dépend du type de données des tenseurs d'entrée/sortie.
- tenseurs flottants : aucune quantification en pré/post traitement nécessaire. Quant op et dequant op sont ancrés dans le graphe du modèle.
- Tenseurs int8/uint8 : ont besoin d'une quantification en pré/post traitement.


Formule


entrée_normalisée = (entrée - moyenne) / std
Quantifier pour les entrées:
q = f / échelle + zeroPoint
Déquantifier pour les sorties:
f = (q - zeroPoint) * échelle

Où sont les paramètres
Rempli par le créateur de modèle et les métadonnées stockées dans le modèle, comme NormalizationOptions Rempli automatiquement par le convertisseur TFLite et stocké dans le fichier modèle tflite.
Comment obtenir les paramètres ? Grâce à l' MetadataExtractor API [2] Grâce à l'TFLite Tensor API [1] ou par l' MetadataExtractor API [2]
Les modèles float et quant partagent-ils la même valeur ? Oui, les modèles float et quant ont les mêmes paramètres de normalisation Non, le modèle flottant n'a pas besoin de quantification.
Le générateur de code TFLite ou la liaison Android Studio ML le génère-t-il automatiquement dans le traitement des données ?
Oui

Oui

[1] Le tensorflow Lite API Java et l' API de tensorflow Lite C .
[2] La bibliothèque d'extraction des métadonnées

Lors du traitement des données d'image pour les modèles uint8, la normalisation et la quantification sont parfois ignorées. C'est bien de le faire lorsque les valeurs de pixel sont dans la plage de [0, 255]. Mais en général, vous devez toujours traiter les données en fonction des paramètres de normalisation et de quantification, le cas échéant.

Tensorflow Library Task Lite peut gérer la normalisation pour vous si vous configurez NormalizationOptions dans les métadonnées. Les traitements de quantification et de déquantification sont toujours encapsulés.

Exemples

Vous pouvez trouver des exemples sur la façon dont les métadonnées doivent être renseignées pour différents types de modèles ici :

Classification des images

Télécharger le script ici , qui métadonnées Remplit à mobilenet_v1_0.75_160_quantized.tflite . Exécutez le script comme ceci :

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

Pour les métadonnées Populate pour d' autres modèles de classification des images, ajoutez les spécifications du modèle comme cela dans le script. Le reste de ce guide mettra en évidence certaines des sections clés de l'exemple de classification d'images pour illustrer les éléments clés.

Plongez dans l'exemple de classification d'images

Informations sur le modèle

Les métadonnées commencent par créer de nouvelles informations sur le modèle :

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

Informations d'entrée/sortie

Cette section vous montre comment décrire la signature d'entrée et de sortie de votre modèle. Ces métadonnées peuvent être utilisées par des générateurs de code automatiques pour créer du code de pré- et post-traitement. Pour créer des informations d'entrée ou de sortie sur un tenseur :

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

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

Saisie d'images

L'image est un type d'entrée courant pour l'apprentissage automatique. Les métadonnées TensorFlow Lite prennent en charge des informations telles que l'espace colorimétrique et les informations de prétraitement telles que la normalisation. La dimension de l'image ne nécessite pas de spécification manuelle puisqu'elle est déjà fournie par la forme du tenseur d'entrée et peut être déduite automatiquement.

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

Sortie d'étiquette

Étiquette peut être mis en correspondance avec un tenseur de sortie via un fichier associé à l' aide 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]

Créer les métadonnées Flatbuffers

Le code suivant combine les informations du modèle avec les informations d'entrée et de sortie :

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

Emballer les métadonnées et les fichiers associés dans le modèle

Une fois que les Flatbuffers de métadonnées est créée, les métadonnées et le fichier d'étiquettes sont écrites dans le fichier TFLite via la populate méthode:

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

Vous pouvez emballer autant de fichiers associés que vous voulez dans le modèle par load_associated_files . Cependant, il est nécessaire de compresser au moins les fichiers documentés dans les métadonnées. Dans cet exemple, l'emballage du fichier d'étiquettes est obligatoire.

Visualiser les métadonnées

Vous pouvez utiliser Netron pour visualiser vos métadonnées, ou vous pouvez lire les métadonnées d'un modèle tensorflow Lite dans un format JSON en utilisant la 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 prend en charge également l' affichage des métadonnées par la fonctionnalité de liaison studio Android ML .

Gestion des versions des métadonnées

Le schéma de métadonnées est versionné à la fois par le nombre de versionnage sémantique, qui permet de suivre les modifications du fichier de schéma, et par l'identification de fichier Flatbuffers, ce qui indique la véritable compatibilité de version.

Le numéro de version sémantique

Le schéma de métadonnées est versionné par le numéro de version sémantique , comme MAJOR.MINOR.PATCH. Il suit les changements de schéma selon les règles ici . Voir l' historique des champs ajoutés après la version 1.0.0 .

L'identification du fichier Flatbuffers

Le versioning sémantique garantit la compatibilité en suivant les règles, mais il n'implique pas la véritable incompatibilité. Lorsque vous augmentez le numéro MAJEUR, cela ne signifie pas nécessairement que la compatibilité descendante est rompue. Nous utilisons donc l' identification du fichier Flatbuffers , file_identifier , pour indiquer la vraie compatibilité du schéma de métadonnées. L'identifiant du fichier comporte exactement 4 caractères. Il est fixé à un certain schéma de métadonnées et n'est pas sujet à modification par les utilisateurs. Si la compatibilité descendante du schéma de métadonnées doit être rompue pour une raison quelconque, le file_identifier passera, par exemple, de "M001" à "M002". File_identifier devrait être modifié beaucoup moins fréquemment que metadata_version.

La version minimale de l'analyseur de métadonnées nécessaire

La version analyseur de métadonnées minimum nécessaire est la version minimale de l' analyseur métadonnées (les Flatbuffers code généré) qui peut lire les Flatbuffers de métadonnées dans son intégralité. La version est effectivement le plus grand numéro de version parmi les versions de tous les champs renseignés et la plus petite version compatible indiquée par l'identifiant de fichier. La version de l' analyseur de métadonnées minimum nécessaire est automatiquement par le MetadataPopulator lorsque les métadonnées sont renseignées dans un modèle de TFLite. Voir l' extracteur de métadonnées pour plus d' informations sur la version de l' analyseur de métadonnées minimum nécessaire est utilisé.

Lire les métadonnées des modèles

La bibliothèque est un outil extracteur métadonnées pratique pour lire les métadonnées et les fichiers associés à partir d' un modèle à travers différentes plates - formes (voir la version Java et la version C de ). Vous pouvez créer votre propre outil d'extraction de métadonnées dans d'autres langues à l'aide de la bibliothèque Flatbuffers.

Lire les métadonnées en Java

Pour utiliser la bibliothèque Extractor dans votre application des métadonnées Android, nous vous recommandons d' utiliser le AAR Lite métadonnées tensorflow hébergé chez MavenCentral . Il contient la MetadataExtractor classe, ainsi que les liaisons FlatBuffers Java pour le schéma de métadonnées et le schéma du modèle .

Vous pouvez spécifier dans vos build.gradle dépendances comme suit:

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

Pour utiliser des instantanés de nuit, assurez - vous que vous avez ajouté le dépôt de Sonatype .

Vous pouvez initialiser un MetadataExtractor objet avec un ByteBuffer qui pointe vers le modèle:

public MetadataExtractor(ByteBuffer buffer);

Le ByteBuffer doit rester inchangé pendant toute la durée de vie du MetadataExtractor objet. L'initialisation peut échouer si l'identifiant de fichier Flatbuffers des métadonnées du modèle ne correspond pas à celui de l'analyseur de métadonnées. Voir les métadonnées versioning pour plus d' informations.

Avec des identifiants de fichiers correspondants, l'extracteur de métadonnées lira avec succès les métadonnées générées à partir de tous les schémas passés et futurs grâce au mécanisme de compatibilité ascendante et descendante des Flatbuffers. Cependant, les champs des futurs schémas ne peuvent pas être extraits par les anciens extracteurs de métadonnées. La version analyseur minimum nécessaire des métadonnées indique la version minimale de l' analyseur des métadonnées qui peuvent lire les Flatbuffers de métadonnées dans leur intégralité. Vous pouvez utiliser la méthode suivante pour vérifier si la condition de version minimale de l'analyseur est remplie :

public final boolean isMinimumParserVersionSatisfied();

La transmission d'un modèle sans métadonnées est autorisée. Cependant, l'appel de méthodes qui lisent à partir des métadonnées provoquera des erreurs d'exécution. Vous pouvez vérifier si un modèle de métadonnées a en invoquant la hasMetadata méthode:

public boolean hasMetadata();

MetadataExtractor offre des fonctions pratiques pour vous d'obtenir les métadonnées des tenseurs d' entrée / sortie. Par exemple,

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);

Bien que le schéma du modèle Lite tensorflow prend en charge les sous - graphes multiples, l'interprète TFLite prend actuellement en charge qu'un seul sous - graphe. Par conséquent, MetadataExtractor de l'indice de sous - graphe comme argument d'entrée dans ses méthodes.

Lire les fichiers associés des modèles

Le modèle TensorFlow Lite avec les métadonnées et les fichiers associés est essentiellement un fichier zip qui peut être décompressé avec des outils zip courants pour obtenir les fichiers associés. Par exemple, vous pouvez dézipper mobilenet_v1_0.75_160_quantized et extraire le fichier d'étiquette dans le modèle comme suit:

$ 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

Vous pouvez également lire les fichiers associés via la bibliothèque Metadata Extractor.

En Java, passez le nom de fichier dans la MetadataExtractor.getAssociatedFile méthode:

public InputStream getAssociatedFile(String fileName);

Similairement, en C ++, cela peut être fait avec la méthode, ModelMetadataExtractor::GetAssociatedFile :

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