La clasificación de imágenes es un uso común del aprendizaje automático para identificar lo que representa una imagen. Por ejemplo, podríamos querer saber qué tipo de animal aparece en una imagen determinada. La tarea de predecir lo que representa una imagen se llama clasificación de imágenes . Un clasificador de imágenes está capacitado para reconocer varias clases de imágenes. Por ejemplo, se podría entrenar a un modelo para que reconozca fotografías que representen tres tipos diferentes de animales: conejos, hámsteres y perros. Consulte la descripción general de la clasificación de imágenes para obtener más información sobre los clasificadores de imágenes.
Utilice la API ImageClassifier
de la biblioteca de tareas para implementar sus clasificadores de imágenes personalizados o previamente entrenados en sus aplicaciones móviles.
Características clave de la API ImageClassifier
Procesamiento de imágenes de entrada, incluida la rotación, el cambio de tamaño y la conversión del espacio de color.
Región de interés de la imagen de entrada.
Localización del mapa de etiquetas.
Umbral de puntuación para filtrar resultados.
Resultados de la clasificación top-k.
Etiquetar lista permitida y lista denegada.
Modelos de clasificador de imágenes compatibles
Se garantiza que los siguientes modelos serán compatibles con la API ImageClassifier
.
Modelos creados por TensorFlow Lite Model Maker para clasificación de imágenes .
Los modelos de clasificación de imágenes previamente entrenados en TensorFlow Hub .
Modelos creados por AutoML Vision Edge Image Classification .
Modelos personalizados que cumplen con los requisitos de compatibilidad de modelos .
Ejecutar inferencia en Java
Consulte la aplicación de referencia de Clasificación de imágenes para ver un ejemplo de cómo usar ImageClassifier
en una aplicación de Android.
Paso 1: importar la dependencia de Gradle y otras configuraciones
Copie el archivo del modelo .tflite
en el directorio de activos del módulo de Android donde se ejecutará el modelo. Especifique que el archivo no debe comprimirse y agregue la biblioteca TensorFlow Lite al archivo build.gradle
del módulo:
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'
}
Paso 2: usar el modelo
// 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);
Consulte el código fuente y javadoc para obtener más opciones para configurar ImageClassifier
.
Ejecutar inferencia en iOS
Paso 1: instalar las dependencias
La biblioteca de tareas admite la instalación mediante CocoaPods. Asegúrese de que CocoaPods esté instalado en su sistema. Consulte la guía de instalación de CocoaPods para obtener instrucciones.
Consulte la guía CocoaPods para obtener detalles sobre cómo agregar pods a un proyecto Xcode.
Agregue el pod TensorFlowLiteTaskVision
en el Podfile.
target 'MyAppWithTaskAPI' do
use_frameworks!
pod 'TensorFlowLiteTaskVision'
end
Asegúrese de que el modelo .tflite
que utilizará para la inferencia esté presente en el paquete de su aplicación.
Paso 2: usar el modelo
Rápido
// 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)
C objetivo
// 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];
Consulte el código fuente para obtener más opciones para configurar TFLImageClassifier
.
Ejecutar inferencia en Python
Paso 1: instale el paquete pip
pip install tflite-support
Paso 2: usar el modelo
# 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)
Consulte el código fuente para obtener más opciones para configurar ImageClassifier
.
Ejecutar inferencia 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();
Consulte el código fuente para obtener más opciones para configurar ImageClassifier
.
Resultados de ejemplo
A continuación se muestra un ejemplo de los resultados de clasificación de un clasificador de aves .
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
Pruebe la sencilla herramienta de demostración CLI para ImageClassifier con su propio modelo y datos de prueba.
Requisitos de compatibilidad del modelo
La API ImageClassifier
espera un modelo TFLite con metadatos del modelo TFLite obligatorios. Vea ejemplos de creación de metadatos para clasificadores de imágenes utilizando la API de escritura de metadatos de TensorFlow Lite .
Los modelos de clasificador de imágenes compatibles deben cumplir los siguientes requisitos:
Tensor de imagen de entrada (kTfLiteUInt8/kTfLiteFloat32)
- entrada de imagen de tamaño
[batch x height x width x channels]
. - No se admite la inferencia por lotes (se requiere que
batch
sea 1). - Solo se admiten entradas RGB (se requieren 3
channels
). - si el tipo es kTfLiteFloat32, es necesario adjuntar NormalizationOptions a los metadatos para la normalización de la entrada.
- entrada de imagen de tamaño
Tensor de puntuación de salida (kTfLiteUInt8/kTfLiteFloat32)
- con
N
clases y 2 o 4 dimensiones, es decir,[1 x N]
o[1 x 1 x 1 x N]
- Mapas de etiquetas opcionales (pero recomendados) como AssociatedFile-s con tipo TENSOR_AXIS_LABELS, que contienen una etiqueta por línea. Vea el archivo de etiqueta de ejemplo . El primer AssociatedFile (si lo hay) se utiliza para completar el campo
label
(denominadoclass_name
en C++) de los resultados. El campodisplay_name
se completa desde AssociatedFile (si lo hay) cuya configuración regional coincide con el campodisplay_names_locale
deImageClassifierOptions
utilizado en el momento de la creación ("en" de forma predeterminada, es decir, inglés). Si ninguno de estos está disponible, solo se completará el campoindex
de los resultados.
- con