Integrare le categorie di classificazione delle immagini

La classificazione delle immagini è un uso comune del machine learning per identificare cosa rappresenta un'immagine. Ad esempio, potremmo voler sapere che tipo di animale appare in una determinata immagine. L'attività di prevedere cosa rappresenta un'immagine è chiamata classificazione delle immagini. Un classificatore di immagini viene addestrato a riconoscere varie classi di immagini. Ad esempio, un modello potrebbe essere addestrato a riconoscere foto che rappresentano tre diversi tipi di animali: conigli, criceti e cani. Per saperne di più sui classificatori di immagini, consulta l'esempio di classificazione delle immagini.

Utilizza l'API Task Library ImageClassifier per eseguire il deployment dei classificatori di immagini personalizzati o preaddestrati nelle tue app mobile.

Funzionalità chiave dell'API ImageClassifier

  • Elaborazione dell'immagine di input, inclusi rotazione, ridimensionamento e conversione dello spazio colore.

  • Regione di interesse dell'immagine di input.

  • Etichetta della località sulla mappa.

  • Soglia di punteggio per filtrare i risultati.

  • Risultati della classificazione top-k.

  • Liste consentite e bloccate di etichette.

Modelli di classificazione delle immagini supportati

I seguenti modelli sono garantiti per essere compatibili con l'API ImageClassifier.

Esegui l'inferenza in Java

Consulta l'app di riferimento per la classificazione delle immagini per un esempio di come utilizzare ImageClassifier in un'app per Android.

Passaggio 1: importa la dipendenza Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso e aggiungi la libreria TensorFlow Lite al file build.gradle del modulo:

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'
}

Passaggio 2: utilizza il modello

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

Per altre opzioni di configurazione di ImageClassifier, consulta il codice sorgente e javadoc.

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La libreria delle attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Per istruzioni, consulta la guida all'installazione di CocoaPods.

Per informazioni dettagliate sull'aggiunta di pod a un progetto Xcode, consulta la guida CocoaPods.

Aggiungi il pod TensorFlowLiteTaskVision nel podfile.

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

Assicurati che il modello .tflite che utilizzerai per l'inferenza sia presente nel bundle dell'app.

Passaggio 2: utilizza il modello

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

Consulta il codice sorgente per altre opzioni di configurazione di TFLImageClassifier.

Esegui l'inferenza in Python

Passaggio 1: installa il pacchetto pip

pip install tflite-support

Passaggio 2: utilizza il modello

# 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)

Consulta il codice sorgente per altre opzioni di configurazione di ImageClassifier.

Esegui l'inferenza in 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();

Consulta il codice sorgente per altre opzioni di configurazione di ImageClassifier.

Risultati di esempio

Ecco un esempio dei risultati della classificazione di un classificatore di uccelli.

sparrow

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

Prova il semplice strumento demo della CLI per ImageClassifier con il tuo modello e i tuoi dati di test.

Requisiti di compatibilità del modello

L'API ImageClassifier prevede un modello TFLite con metadati del modello TFLite obbligatori. Consulta gli esempi di creazione di metadati per i classificatori di immagini utilizzando l'API TensorFlow Lite Metadata Writer.

I modelli di classificazione delle immagini compatibili devono soddisfare i seguenti requisiti:

  • Tensore immagine di input (kTfLiteUInt8/kTfLiteFloat32)

    • input immagine di dimensioni [batch x height x width x channels].
    • L'inferenza batch non è supportata (batch deve essere 1).
    • sono supportati solo gli input RGB (channels deve essere 3).
    • Se il tipo è kTfLiteFloat32, è necessario allegare NormalizzazioneOptions ai metadati per la normalizzazione dell'input.

  • Tensore del punteggio di output (kTfLiteUInt8/kTfLiteFloat32)

    • con N classi e 2 o 4 dimensioni, ovvero [1 x N] o [1 x 1 x 1 x N]
    • mappa o mappe di etichette facoltative (ma consigliate) come AssociatedFile-s con tipo TENSOR_AXIS_LABELS, contenente un'etichetta per riga. Vedi il file di etichette di esempio. Il primo AssociatedFile (se presente) viene utilizzato per compilare il campo label (denominato class_name in C++) dei risultati. Il campo display_name viene compilato dal campo AssociatedFile (se presente) le cui impostazioni internazionali corrispondono al campo display_names_locale di ImageClassifierOptions utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà compilato solo il campo index dei risultati.