Partecipa al simposio Women in ML il 7 dicembre Registrati ora

Integra i classificatori di immagini

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

La classificazione delle immagini è un uso comune dell'apprendimento automatico per identificare ciò che rappresenta un'immagine. Ad esempio, potremmo voler sapere quale tipo di animale appare in una determinata immagine. Il compito di prevedere cosa rappresenta un'immagine è chiamato classificazione delle immagini. Un classificatore di immagini è addestrato a riconoscere varie classi di immagini. Ad esempio, un modello potrebbe essere addestrato per riconoscere le foto che rappresentano tre diversi tipi di animali: conigli, criceti e cani. Per ulteriori informazioni sui classificatori di immagini, vedere la panoramica della classificazione delle immagini.

Usa l'API ImageClassifier della libreria delle attività per distribuire i tuoi classificatori di immagini personalizzati o quelli preaddestrati nelle tue app mobili.

Caratteristiche principali dell'API ImageClassifier

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

  • Regione di interesse dell'immagine di input.

  • Etichettare la localizzazione della mappa.

  • Soglia di punteggio per filtrare i risultati.

  • Risultati della classifica Top-k.

  • Etichetta lista consentita e lista negata.

Modelli di classificatori di immagini supportati

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

Esegui l'inferenza in Java

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

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo Android in cui verrà eseguito il modello. Specificare che il file non deve essere compresso e aggiungere 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 (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'
}

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

Vedere il codice sorgente e javadoc per ulteriori opzioni per configurare ImageClassifier .

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La Libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Consulta la guida all'installazione di CocoaPods per le istruzioni.

Consulta la guida CocoaPods per i dettagli sull'aggiunta di pod a un progetto Xcode.

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 tuo app bundle.

Passaggio 2: utilizzo del modello

Veloce

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

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

Vedere il codice sorgente per ulteriori opzioni per configurare 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)

Vedere il codice sorgente per ulteriori opzioni per configurare 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();

Vedere il codice sorgente per ulteriori opzioni per configurare ImageClassifier .

Risultati di esempio

Ecco un esempio dei risultati di classificazione di un 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 il semplice strumento demo CLI per ImageClassifier con il tuo modello e i tuoi dati di prova.

Requisiti di compatibilità del modello

L'API ImageClassifier prevede un modello TFLite con metadati del modello TFLite obbligatori. Vedere esempi di creazione di metadati per classificatori di immagini utilizzando l' API di scrittura di metadati TensorFlow Lite .

I modelli di classificatori di immagini compatibili devono soddisfare i seguenti requisiti:

  • Tensore dell'immagine di ingresso (kTfLiteUInt8/kTfLiteFloat32)

    • input dell'immagine della dimensione [batch x height x width x channels] .
    • l'inferenza batch non è supportata ( batch deve essere 1).
    • sono supportati solo gli ingressi RGB (i channels devono essere 3).
    • se il tipo è kTfLiteFloat32, NormalizationOptions deve essere allegato ai metadati per la normalizzazione dell'input.
  • Tensore del punteggio di uscita (kTfLiteUInt8/kTfLiteFloat32)

    • con N classi e 2 o 4 dimensioni, cioè [1 x N] o [1 x 1 x 1 x N]
    • mappe di etichette opzionali (ma consigliate) come AssociatedFile-s con tipo TENSOR_AXIS_LABELS, contenente un'etichetta per riga. Vedere il file di etichetta di esempio . Il primo di tali AssociatedFile (se presente) viene utilizzato per riempire il campo label (denominato class_name in C++) dei risultati. Il campo display_name viene compilato dall'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à riempito solo il campo index dei risultati.
,

La classificazione delle immagini è un uso comune dell'apprendimento automatico per identificare ciò che rappresenta un'immagine. Ad esempio, potremmo voler sapere quale tipo di animale appare in una determinata immagine. Il compito di prevedere cosa rappresenta un'immagine è chiamato classificazione delle immagini. Un classificatore di immagini è addestrato a riconoscere varie classi di immagini. Ad esempio, un modello potrebbe essere addestrato per riconoscere le foto che rappresentano tre diversi tipi di animali: conigli, criceti e cani. Per ulteriori informazioni sui classificatori di immagini, vedere la panoramica della classificazione delle immagini.

Usa l'API ImageClassifier della libreria delle attività per distribuire i tuoi classificatori di immagini personalizzati o quelli preaddestrati nelle tue app mobili.

Caratteristiche principali dell'API ImageClassifier

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

  • Regione di interesse dell'immagine di input.

  • Etichettare la localizzazione della mappa.

  • Soglia di punteggio per filtrare i risultati.

  • Risultati della classifica Top-k.

  • Etichetta lista consentita e lista negata.

Modelli di classificatori di immagini supportati

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

Esegui l'inferenza in Java

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

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo Android in cui verrà eseguito il modello. Specificare che il file non deve essere compresso e aggiungere 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 (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'
}

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

Vedere il codice sorgente e javadoc per ulteriori opzioni per configurare ImageClassifier .

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La Libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Consulta la guida all'installazione di CocoaPods per le istruzioni.

Consulta la guida CocoaPods per i dettagli sull'aggiunta di pod a un progetto Xcode.

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 tuo app bundle.

Passaggio 2: utilizzo del modello

Veloce

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

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

Vedere il codice sorgente per ulteriori opzioni per configurare 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)

Vedere il codice sorgente per ulteriori opzioni per configurare 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();

Vedere il codice sorgente per ulteriori opzioni per configurare ImageClassifier .

Risultati di esempio

Ecco un esempio dei risultati di classificazione di un 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 il semplice strumento demo CLI per ImageClassifier con il tuo modello e i tuoi dati di prova.

Requisiti di compatibilità del modello

L'API ImageClassifier prevede un modello TFLite con metadati del modello TFLite obbligatori. Vedere esempi di creazione di metadati per classificatori di immagini utilizzando l' API di scrittura di metadati TensorFlow Lite .

I modelli di classificatori di immagini compatibili devono soddisfare i seguenti requisiti:

  • Tensore dell'immagine di ingresso (kTfLiteUInt8/kTfLiteFloat32)

    • input dell'immagine della dimensione [batch x height x width x channels] .
    • l'inferenza batch non è supportata ( batch deve essere 1).
    • sono supportati solo gli ingressi RGB (i channels devono essere 3).
    • se il tipo è kTfLiteFloat32, NormalizationOptions deve essere allegato ai metadati per la normalizzazione dell'input.
  • Tensore del punteggio di uscita (kTfLiteUInt8/kTfLiteFloat32)

    • con N classi e 2 o 4 dimensioni, cioè [1 x N] o [1 x 1 x 1 x N]
    • mappe di etichette opzionali (ma consigliate) come AssociatedFile-s con tipo TENSOR_AXIS_LABELS, contenente un'etichetta per riga. Vedere il file di etichetta di esempio . Il primo di tali AssociatedFile (se presente) viene utilizzato per riempire il campo label (denominato class_name in C++) dei risultati. Il campo display_name viene compilato dall'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à riempito solo il campo index dei risultati.