La classification des 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 qu'une image représente est appelée classification d'image . Un classificateur d'images est formé pour 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. Consultez la vue d'ensemble de la classification d'images pour plus d'informations sur les classificateurs 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 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.
Étiqueter les paramètres régionaux de la carte.
Seuil de score pour filtrer les résultats.
Résultats de la classification Top-k.
Étiquetez la liste d'autorisation et la liste de refus.
Modèles de classificateurs d'images pris en charge
Les modèles suivants sont garantis 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 .
Modèles personnalisés qui répondent aux exigences de compatibilité des modèles .
Exécuter l'inférence en Java
Voir l' application de référence Image Classification pour un exemple d'utilisation 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 assets 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 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 (NNAPI is included)
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 : Utilisation du 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);
Voir le code source et javadoc pour plus d'options pour configurer ImageClassifier
.
Exécuter l'inférence dans iOS
Étape 1 : Installer 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. Veuillez consulter le guide d'installation de CocoaPods pour obtenir des instructions.
Veuillez consulter le guide CocoaPods pour plus de détails 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 : Utilisation du modèle
Rapide
// 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)
Objectif 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 plus d'options pour configurer TFLImageClassifier
.
Exécuter l'inférence en Python
Étape 1 : Installez le package pip
pip install tflite-support
Étape 2 : Utilisation du 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)
Voir le code source 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_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();
Voir le code source pour plus d'options pour configurer ImageClassifier
.
Exemples de résultats
Voici un exemple des résultats de classification d'un classificateur d'oiseaux .
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 CLI simple 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 classificateurs 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]
. - l'inférence par lot n'est pas prise en charge (
batch
doit être égal à 1). - seules les entrées RVB sont prises en charge (
channels
doivent être 3). - si le type est kTfLiteFloat32, NormalizationOptions doit être joint aux métadonnées pour la normalisation des entrées.
- entrée d'image de taille
Tenseur de score de sortie (kTfLiteUInt8/kTfLiteFloat32)
- avec
N
classes et soit 2 soit 4 dimensions, soit[1 x N]
ou[1 x 1 x 1 x N]
- carte(s) d'étiquettes facultative (mais recommandée) en tant qu'AssociatedFile-s avec le type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Voir l' exemple de fichier d'étiquette . Le premier AssociatedFile (le cas échéant) est utilisé pour remplir le champ
label
(nomméclass_name
en C++) des résultats. Le champdisplay_name
est renseigné à partir de l'AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champdisplay_names_locale
desImageClassifierOptions
utilisé au moment de la création ("en" par défaut, c'est-à-dire l'anglais). Si aucun de ceux-ci n'est disponible, seul le champindex
des résultats sera rempli.
- avec