La journée communautaire ML est le 9 novembre ! Rejoignez - nous pour les mises à jour de tensorflow, JAX et plus En savoir plus

Intégrer des classificateurs d'images

La classification d'images est une utilisation courante de l'apprentissage automatique pour identifier ce qu'une image représente. Par exemple, nous pourrions vouloir savoir quel type d'animal apparaît dans une image donnée. La tâche de prédire ce que représente une image est appelée classification d'image. Un classificateur d'images est entraîné à reconnaître diverses classes d'images. Par exemple, un modèle peut être entraîné à reconnaître des photos représentant trois types d'animaux différents : des lapins, des hamsters et des chiens. Voir l' introduction de la classification d'images pour plus d' informations sur classificateurs d'image.

Utilisez la bibliothèque de tâches ImageClassifier API pour déployer votre classificateurs d'image personnalisés ou les dans vos applications pré - entraîné mobiles.

Principales fonctionnalités de l'API ImageClassifier

  • Traitement de l'image d'entrée, y compris la rotation, le redimensionnement et la conversion de l'espace colorimétrique.

  • Région d'intérêt de l'image d'entrée.

  • Étiquette locale de la carte.

  • Seuil de score pour filtrer les résultats.

  • Résultats du classement Top-k.

  • Libellé liste d'autorisation et liste de refus.

Modèles de classificateur d'images pris en charge

Les modèles suivants sont garantis pour être compatibles avec la ImageClassifier API.

Exécuter l'inférence en Java

Voir l' application de référence Classification des images pour un exemple de la façon d'utiliser ImageClassifier dans une application Android.

Étape 1 : Importer la dépendance Gradle et d'autres paramètres

Copiez le .tflite fichier modèle dans le répertoire actif du module Android où le modèle sera exécuté. Spécifiez que le fichier ne doit pas être compressé, et ajoutez la bibliothèque Lite tensorflow du module à build.gradle fichier:

android {
    // Other settings

    // Specify tflite file should not be compressed for the app apk
    aaptOptions {
        noCompress "tflite"
    }

}

dependencies {
    // Other dependencies

    // Import the Task Vision Library dependency
    implementation 'org.tensorflow:tensorflow-lite-task-vision:0.2.0'
}

Étape 2 : Utilisation du modèle

// Initialization
ImageClassifierOptions options = ImageClassifierOptions.builder().setMaxResults(1).build();
ImageClassifier imageClassifier = ImageClassifier.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Classifications> results = imageClassifier.classify(image);

Voir le code source et javadoc pour plus d' options pour configurer ImageClassifier .

Exécuter l'inférence en C++

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Voir le code source pour plus d' options pour configurer ImageClassifier .

Exemple de résultats

Voici un exemple des résultats de la classification d'un classificateur d'oiseaux .

moineau

Results:
  Rank #0:
   index       : 671
   score       : 0.91406
   class name  : /m/01bwb9
   display name: Passer domesticus
  Rank #1:
   index       : 670
   score       : 0.00391
   class name  : /m/01bwbt
   display name: Passer montanus
  Rank #2:
   index       : 495
   score       : 0.00391
   class name  : /m/0bwm6m
   display name: Passer italiae

Essayez simple outil de démonstration de CLI pour ImageClassifier avec vos propres données de modèle et de test.

Exigences de compatibilité des modèles

Le ImageClassifier API attend un modèle TFLite avec obligatoire TFLite modèle de métadonnées . Voir des exemples de création de métadonnées pour les classificateurs d'image en utilisant l' API Lite tensorflow métadonnées Writer .

Les modèles de classificateur d'images compatibles doivent répondre aux exigences suivantes :

  • Tenseur d'image d'entrée (kTfLiteUInt8/kTfLiteFloat32)

    • entrée d'image de taille [batch x height x width x channels] .
    • inférence par lots ne sont pas pris en charge ( batch doit être 1).
    • que les entrées RVB sont pris en charge ( channels est requis pour être 3).
    • si le type est kTfLiteFloat32, les NormalizationOptions doivent être attachées aux métadonnées pour la normalisation des entrées.
  • Tenseur de score de sortie (kTfLiteUInt8/kTfLiteFloat32)

    • avec N classes et 2 ou 4 dimensions, à savoir [1 x N] ou [1 x 1 x 1 x N]

    • map(s) d'étiquettes facultatives (mais recommandées) comme AssociatedFile-s avec le type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Voir l' exemple de fichier d'étiquette . Le premier de ces AssociatedFile ( le cas échéant) est utilisé pour remplir l' label champ (nommé class_name en C ++) des résultats. Le display_name champ est rempli du AssociatedFile ( le cas échéant) dont le lieu correspond au display_names_locale champ des ImageClassifierOptions utilisés au moment de la création ( « fr » par défaut, à savoir l' anglais). Si aucun d' entre eux sont disponibles, seul l' index champ des résultats sera rempli.