Intégrer des classificateurs d'images

La classification d'images est une utilisation courante du machine learning pour identifier ce qu'une image représente. Par exemple, nous pouvons vouloir savoir quel type d'animal apparaît sur une image donnée. La tâche consistant à prédire ce qu'une image représente est appelée classification d'images. Un classificateur d'images est entraîné à reconnaître différentes 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. Pour en savoir plus sur les classificateurs d'images, consultez l'exemple de classification d'images.

Utilisez l'API Task Library ImageClassifier pour déployer vos classificateurs d'images personnalisés ou préentraînés dans vos applications mobiles.

Principales fonctionnalités de l'API ImageClassifier

Traitement des images 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.
Paramètres régionaux de la carte des libellés.
Seuil de score permettant de filtrer les résultats.
Résultats de classification top-k.
Listes d'autorisation et de blocage de libellés.

Modèles de classification d'images compatibles

Les modèles suivants sont garantis d'être compatibles avec l'API ImageClassifier.

Modèles créés par TensorFlow Lite Model Maker pour la classification d'images.
Les modèles de classification d'images pré-entraînés sur TensorFlow Hub.
Modèles créés par AutoML Vision Edge Image Classification.
Des modèles personnalisés qui répondent aux exigences de compatibilité des modèles.

Exécuter une inférence en Java

Consultez l'application de référence pour la classification d'images pour obtenir un exemple d'utilisation de ImageClassifier dans une application Android.

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

Copiez le fichier de modèle .tflite dans le répertoire des éléments du module Android dans lequel le modèle sera exécuté. Spécifiez que le fichier ne doit pas être compressé et ajoutez la bibliothèque TensorFlow Lite au fichier build.gradle du module :

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'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Étape 2 : Utiliser le modèle

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

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

Consultez le code source et le Javadoc pour découvrir d'autres options de configuration de ImageClassifier.

Exécuter l'inférence dans iOS

Étape 1 : Installez les dépendances

La bibliothèque de tâches est compatible avec l'installation à l'aide de CocoaPods. Assurez-vous que CocoaPods est installé sur votre système. Pour obtenir des instructions, consultez le guide d'installation de CocoaPods.

Pour savoir comment ajouter des pods à un projet Xcode, consultez le guide CocoaPods.

Ajoutez le pod TensorFlowLiteTaskVision dans le fichier Podfile.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskVision'
end

Assurez-vous que le modèle .tflite que vous utiliserez pour l'inférence est présent dans votre package d'application.

Étape 2 : Utiliser le modèle

Swift

// Imports
import TensorFlowLiteTaskVision

// Initialization
guard let modelPath = Bundle.main.path(forResource: "birds_V1",
                                            ofType: "tflite") else { return }

let options = ImageClassifierOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let classifier = try ImageClassifier.classifier(options: options)

// Convert the input image to MLImage.
// There are other sources for MLImage. For more details, please see:
// https://developers.google.com/ml-kit/reference/ios/mlimage/api/reference/Classes/GMLImage
guard let image = UIImage (named: "sparrow.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let classificationResults = try classifier.classify(mlImage: mlImage)

Objective-C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"birds_V1" ofType:@"tflite"];

TFLImageClassifierOptions *options =
    [[TFLImageClassifierOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLImageClassifier *classifier = [TFLImageClassifier imageClassifierWithOptions:options
                                                                          error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"sparrow.jpg"];

// There are other sources for GMLImage. For more details, please see:
// https://developers.google.com/ml-kit/reference/ios/mlimage/api/reference/Classes/GMLImage
GMLImage *gmlImage = [[GMLImage alloc] initWithImage:image];

// Run inference
TFLClassificationResult *classificationResult =
    [classifier classifyWithGMLImage:gmlImage error:nil];

Pour découvrir d'autres options de configuration de TFLImageClassifier, consultez le code source.

Exécuter l'inférence en Python

Étape 1 : Installez le package pip

pip install tflite-support

Étape 2 : Utiliser le modèle

# Imports
from tflite_support.task import vision
from tflite_support.task import core
from tflite_support.task import processor

# Initialization
base_options = core.BaseOptions(file_name=model_path)
classification_options = processor.ClassificationOptions(max_results=2)
options = vision.ImageClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = vision.ImageClassifier.create_from_options(options)

# Alternatively, you can create an image classifier in the following manner:
# classifier = vision.ImageClassifier.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

Pour découvrir d'autres options de configuration de ImageClassifier, consultez le code source.

Exécuter une inférence en C++

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

// Create input frame_buffer from your inputs, `image_data` and `image_dimension`.
// See more information here: tensorflow_lite_support/cc/task/vision/utils/frame_buffer_common_utils.h

std::unique_ptr<FrameBuffer> frame_buffer = CreateFromRgbRawBuffer(
      image_data, image_dimension);

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

Pour découvrir d'autres options de configuration de ImageClassifier, consultez le code source.

Exemples de résultats

Voici un exemple de résultats de 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 l'outil de démonstration simple de la CLI pour ImageClassifier avec votre propre modèle et vos données de test.

Exigences de compatibilité des modèles

L'API ImageClassifier attend un modèle TFLite avec des métadonnées de modèle TFLite obligatoires. Consultez des exemples de création de métadonnées pour les classificateurs d'images à l'aide de l'API TensorFlow Lite Metadata Writer.

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

Tenseur d'image d'entrée (kTfLiteUInt8/kTfLiteFloat32)
- image d'entrée de taille [batch x height x width x channels].
- L'inférence par lots n'est pas acceptée (batch doit être défini sur 1).
- Seules les entrées RVB sont acceptées (channels doit être égal à 3).
- Si le type est kTfLiteFloat32, des options de normalisation doivent être associé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, c'est-à-dire [1 x N] ou [1 x 1 x 1 x N]
- Cartes de libellés facultatives (mais recommandées) en tant que fichiers associés de type TENSOR_AXIS_LABELS, contenant un libellé par ligne. Consultez l'exemple de fichier de libellés. Le premier AssociatedFile de ce type (le cas échéant) est utilisé pour remplir le champ label (nommé class_name en C++). Le champ display_name est rempli à partir du champ AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champ display_names_locale du ImageClassifierOptions utilisé au moment de la création ("en" par défaut, c'est-à-dire l'anglais). Si aucune de ces informations n'est disponible, seul le champ index des résultats sera renseigné.