Intégrer des classificateurs d'images

La classification d'images est une utilisation courante du machine learning pour identifier représente. Par exemple, nous pouvons vouloir savoir quel type d’animal apparaît dans une image donnée. La tâche de prédiction de la représentation d'une image s'appelle classification d'images. Un classificateur d'images est entraîné à reconnaître d'images. Par exemple, un modèle peut être entraîné à reconnaître des photos représentant trois types d'animaux différents: les lapins, les hamsters et les chiens. Voir la exemple de classification d'images pour en savoir plus sur les classificateurs d'images.

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

Principales fonctionnalités de l'API ImageClassifier

Traitement de l'image d'entrée, y compris la rotation, le redimensionnement et l'espace colorimétrique la conversion.
Région d'intérêt de l'image d'entrée.
Paramètres régionaux de la carte de libellés.
Seuil de score pour filtrer les résultats.
Top K des résultats de classification.
Liste d'autorisation et liste de blocage d'étiquettes.

Modèles de classificateur d'images compatibles

La compatibilité des modèles suivants avec ImageClassifier est garantie. API.

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

Exécuter une inférence en Java

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

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

Copiez le fichier de modèle .tflite dans le répertoire d'éléments du module Android. où le modèle sera exécuté. Spécifier que le fichier ne doit pas être compressé 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 Javadoc pour afficher d'autres options de configuration de ImageClassifier.

Exécuter une inférence sous iOS

Étape 1: Installez les dépendances

La bibliothèque de tâches prend en charge l'installation à l'aide de CocoaPods. Assurez-vous que CocoaPods est installé sur votre système. Consultez les Guide d'installation de CocoaPods pour obtenir des instructions.

Consultez les Guide CocoaPods pour pour en savoir plus sur l'ajout de pods à un projet Xcode.

Ajoutez le pod TensorFlowLiteTaskVision dans le 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 app bundle.

É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];

Consultez le code source pour afficher d'autres options de configuration de TFLImageClassifier.

Exécuter une 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)

Consultez le code source pour afficher d'autres options de configuration de ImageClassifier.

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

Consultez le code source pour afficher d'autres options de configuration de ImageClassifier.

Exemples de résultats

Voici un exemple de résultats de classification classificateur oiseau.

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 la méthode la plus simple Outil de démonstration 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 du modèle TFLite. Découvrez des exemples de création de métadonnées pour des classificateurs d'images à l'aide de API TensorFlow Lite Metadata Writer.

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

Tensor d'image d'entrée (kTfLiteUInt8/kTfLiteFloat32)
- Entrée d'image de taille [batch x height x width x channels].
- l'inférence par lot n'est pas acceptée (batch doit être défini sur 1).
- Seules les entrées RVB sont acceptées (la valeur de channels doit être 3).
- Si le type est kTfLiteFloat32, les options de normalisation doivent être aux métadonnées pour la normalisation des entrées.
Tensor de score de sortie (kTfLiteUInt8/kTfLiteFloat32)
- avec des classes N et 2 ou 4 dimensions (par exemple, [1 x N] ou [1 x 1 x 1 x N]) ;
- des mappages d'étiquettes facultatives (mais recommandés) en tant que AssociatedFiles de type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Consultez le exemple de fichier d'étiquettes. Le premier fichier AssociatedFile de ce type (le cas échéant) est utilisé pour remplir le champ label. (nommée class_name en C++) des résultats. Le champ display_name est renseigné à partir de l'élément AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent à Champ display_names_locale de l'ImageClassifierOptions utilisé à date et heure de création ("en" par défaut, c'est-à-dire anglaise). Si aucune de ces options ne correspond disponible, seul le champ index des résultats sera rempli.