Integrare le categorie di classificazione delle immagini

La classificazione delle immagini è un uso comune del machine learning per identificare l'immagine rappresenta. Ad esempio, potremmo voler sapere che tipo di animale compare in una determinata immagine. L'attività di prevedere ciò che un'immagine rappresenta si chiama classificazione delle immagini. Un classificatore di immagini viene addestrato a riconoscere classi di immagini. Ad esempio, un modello potrebbe essere addestrato a riconoscere le foto che rappresentano tre tipi diversi di animali: conigli, criceti e cani. Consulta: il esempio di classificazione delle immagini per ulteriori informazioni sui classificatori di immagini.

Utilizza l'API ImageClassifier della libreria di attività per eseguire il deployment dell'immagine personalizzata di classificazione o preaddestrati nelle tue app mobile.

Funzionalità chiave dell'API ImageClassifier

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

  • Regione di interesse dell'immagine di input.

  • Assegna un'etichetta alle impostazioni internazionali della mappa.

  • Soglia di punteggio per filtrare i risultati.

  • Risultati della classificazione Top-K.

  • Lista consentita e lista bloccata di etichette.

Modelli di classificatori di immagini supportati

La compatibilità dei seguenti modelli è garantita con ImageClassifier tramite Google Cloud CLI o tramite l'API Compute Engine.

Esegui l'inferenza in Java

Consulta le 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 da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo per Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso. 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: utilizzo del 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);

Consulta le codice sorgente e javadoc per altre opzioni di configurazione di ImageClassifier.

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installata sul sistema. Consulta le Guida all'installazione di CocoaPods per istruzioni.

Consulta le Guida di CocoaPods per dettagli sull'aggiunta di pod a un progetto Xcode.

Aggiungi il pod TensorFlowLiteTaskVision al podfile.

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

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

Passaggio 2: utilizzo del 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 le 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: utilizzo del 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 le 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 le codice sorgente per altre opzioni di configurazione di ImageClassifier.

Risultati di esempio

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

passero

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 la semplice Strumento dimostrativo dell'interfaccia a riga di comando per ImageClassifier con il tuo modello e dati di test.

Requisiti di compatibilità del modello

L'API ImageClassifier prevede un modello TFLite con requisiti obbligatori Metadati del modello TFLite. Consulta esempi di creazione di metadati per classificatori di immagini utilizzando il metodo API TensorFlow Lite Metadata Writer.

I modelli di classificatori 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 (è necessario che i valori channels siano 3).
    • se il tipo è kTfLiteFloat32, è necessario che le NormalizationOptions allegati ai metadati per la normalizzazione degli input.

  • Tensore del punteggio di output (kTfLiteUInt8/kTfLiteFloat32)

    • con classi N e di 2 o 4 dimensioni, ad esempio [1 x N] o [1 x 1 x 1 x N]
    • mappe di etichette facoltative (ma consigliate) come AssociatedFile-s con tipo TENSOR_AXIS_LABELS, contenente un'etichetta per riga. Consulta le file di etichette di esempio. Il primo di questo AssociatedFile (se presente) viene utilizzato per compilare il campo label (denominato class_name in C++) dei risultati. Il campo display_name viene compilato dall'elemento AssociatedFile (se presente) le cui impostazioni internazionali corrispondono Campo display_names_locale di ImageClassifierOptions utilizzato alle data e ora di creazione ("en" per impostazione predefinita, ad es. inglese). Se nessuna di queste opzioni disponibile, verrà compilato solo il campo index dei risultati.