Integra rilevatori di oggetti

I rilevatori di oggetti possono identificare quale di un insieme noto di oggetti potrebbe essere presente e fornire informazioni sulla loro posizione all'interno dell'immagine data o di un flusso video. Un rilevatore di oggetti viene addestrato per rilevare la presenza e la posizione di più classi di oggetti. Ad esempio, un modello potrebbe essere addestrato con immagini che contengono vari pezzi di frutta, insieme a un'etichetta che specifica la classe di frutta che rappresentano (ad esempio una mela, una banana o una fragola) e dati che specificano dove ogni oggetto appare in l'immagine. Vedere l' introduzione del rilevamento di oggetti per ulteriori informazioni sui rilevatori di oggetti.

Utilizza l'API ObjectDetector della Libreria attività per distribuire i rilevatori di oggetti personalizzati o quelli preaddestrati nelle tue app mobili.

Caratteristiche principali dell'API ObjectDetector

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

• Etichettare la localizzazione della mappa.

• Soglia di punteggio per filtrare i risultati.

• Risultati di rilevamento top-k.

• Etichetta lista consentita e lista negata.

Modelli di rilevatori di oggetti supportati

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

• I modelli di rilevamento degli oggetti preaddestrati su TensorFlow Hub .

• Modelli creati da AutoML Vision Edge Object Detection .

• Modelli creati da TensorFlow Lite Model Maker per il rilevatore di oggetti .

• Modelli personalizzati che soddisfano i requisiti di compatibilità del modello .

Esegui l'inferenza in Java

Vedere l' app di riferimento di Object Detection per un esempio di come utilizzare ObjectDetector 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
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

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

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: "ssd_mobilenet_v1",
                                            ofType: "tflite") else { return }

let options = ObjectDetectorOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let detector = try ObjectDetector.detector(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: "cats_and_dogs.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let detectionResult = try detector.detect(mlImage: mlImage)

Obiettivo C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"ssd_mobilenet_v1" ofType:@"tflite"];

TFLObjectDetectorOptions *options = [[TFLObjectDetectorOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLObjectDetector *detector = [TFLObjectDetector objectDetectorWithOptions:options
                                                                     error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"dogs.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
TFLDetectionResult *detectionResult = [detector detectWithGMLImage:gmlImage error:nil];

Vedere il codice sorgente per ulteriori opzioni per configurare TFLObjectDetector .

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)
detection_options = processor.DetectionOptions(max_results=2)
options = vision.ObjectDetectorOptions(base_options=base_options, detection_options=detection_options)
detector = vision.ObjectDetector.create_from_options(options)

# Alternatively, you can create an object detector in the following manner:
# detector = vision.ObjectDetector.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
detection_result = detector.detect(image)

Vedere il codice sorgente per ulteriori opzioni per configurare ObjectDetector .

Esegui l'inferenza in C++

// Initialization
ObjectDetectorOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ObjectDetector> object_detector = ObjectDetector::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 DetectionResult result = object_detector->Detect(*frame_buffer).value();

Vedere il codice sorgente per ulteriori opzioni per configurare ObjectDetector .

Risultati di esempio

Ecco un esempio dei risultati del rilevamento di ssd mobilenet v1 da TensorFlow Hub.

Results:
 Detection #0 (red):
  Box: (x: 355, y: 133, w: 190, h: 206)
  Top-1 class:
   index       : 17
   score       : 0.73828
   class name  : dog
 Detection #1 (green):
  Box: (x: 103, y: 15, w: 138, h: 369)
  Top-1 class:
   index       : 17
   score       : 0.73047
   class name  : dog

Rendering dei riquadri di delimitazione sull'immagine di input:

Prova il semplice strumento demo CLI per ObjectDetector con il tuo modello e i tuoi dati di prova.

Requisiti di compatibilità del modello

L'API ObjectDetector prevede un modello TFLite con metadati del modello TFLite obbligatori. Vedere esempi di creazione di metadati per rilevatori di oggetti utilizzando l' API di scrittura di metadati TensorFlow Lite .

I modelli di rilevatori di oggetti 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.

• I tensori di uscita devono essere le 4 uscite di un'operazione DetectionPostProcess , ovvero:

  • Tensore delle posizioni (kTfLiteFloat32)
    • tensore di dimensione [1 x num_results x 4] , l'array interno che rappresenta i riquadri di delimitazione nella forma [in alto, a sinistra, a destra, in basso].
    • Le BoundingBoxProperties devono essere allegate ai metadati e devono specificare type=BOUNDARIES e `coordinate_type=RATIO.

  • Tensore di classi (kTfLiteFloat32)

    • tensore di size [1 x num_results] , ogni valore rappresenta l'indice intero di una classe.
    • Le mappe di etichette opzionali (ma consigliate) possono essere allegate come AssociatedFile-s con tipo TENSOR_VALUE_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 class_name dei risultati. Il campo display_name viene compilato dall'AssociatedFile (se presente) la cui locale corrisponde al campo display_names_locale di ObjectDetectorOptions utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà riempito solo il campo index dei risultati.

  • Tensore dei punteggi (kTfLiteFloat32)

    • tensore di dimensione [1 x num_results] , ogni valore rappresenta il punteggio dell'oggetto rilevato.

  • Numero del tensore di rilevamento (kTfLiteFloat32)

    • intero num_results come tensore di dimensione [1] .

I rilevatori di oggetti possono identificare quale di un insieme noto di oggetti potrebbe essere presente e fornire informazioni sulla loro posizione all'interno dell'immagine data o di un flusso video. Un rilevatore di oggetti viene addestrato per rilevare la presenza e la posizione di più classi di oggetti. Ad esempio, un modello potrebbe essere addestrato con immagini che contengono vari pezzi di frutta, insieme a un'etichetta che specifica la classe di frutta che rappresentano (ad esempio una mela, una banana o una fragola) e dati che specificano dove ogni oggetto appare in l'immagine. Vedere l' introduzione del rilevamento di oggetti per ulteriori informazioni sui rilevatori di oggetti.

Utilizza l'API ObjectDetector della Libreria attività per distribuire i rilevatori di oggetti personalizzati o quelli preaddestrati nelle tue app mobili.

Caratteristiche principali dell'API ObjectDetector

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

• Etichettare la localizzazione della mappa.

• Soglia di punteggio per filtrare i risultati.

• Risultati di rilevamento top-k.

• Etichetta lista consentita e lista negata.

Modelli di rilevatori di oggetti supportati

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

• I modelli di rilevamento degli oggetti preaddestrati su TensorFlow Hub .

• Modelli creati da AutoML Vision Edge Object Detection .

• Modelli creati da TensorFlow Lite Model Maker per il rilevatore di oggetti .

• Modelli personalizzati che soddisfano i requisiti di compatibilità del modello .

Esegui l'inferenza in Java

Vedere l' app di riferimento di Object Detection per un esempio di come utilizzare ObjectDetector 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
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

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

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: "ssd_mobilenet_v1",
                                            ofType: "tflite") else { return }

let options = ObjectDetectorOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let detector = try ObjectDetector.detector(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: "cats_and_dogs.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let detectionResult = try detector.detect(mlImage: mlImage)

Obiettivo C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"ssd_mobilenet_v1" ofType:@"tflite"];

TFLObjectDetectorOptions *options = [[TFLObjectDetectorOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLObjectDetector *detector = [TFLObjectDetector objectDetectorWithOptions:options
                                                                     error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"dogs.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
TFLDetectionResult *detectionResult = [detector detectWithGMLImage:gmlImage error:nil];

Vedere il codice sorgente per ulteriori opzioni per configurare TFLObjectDetector .

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)
detection_options = processor.DetectionOptions(max_results=2)
options = vision.ObjectDetectorOptions(base_options=base_options, detection_options=detection_options)
detector = vision.ObjectDetector.create_from_options(options)

# Alternatively, you can create an object detector in the following manner:
# detector = vision.ObjectDetector.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
detection_result = detector.detect(image)

Vedere il codice sorgente per ulteriori opzioni per configurare ObjectDetector .

Esegui l'inferenza in C++

// Initialization
ObjectDetectorOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ObjectDetector> object_detector = ObjectDetector::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 DetectionResult result = object_detector->Detect(*frame_buffer).value();

Vedere il codice sorgente per ulteriori opzioni per configurare ObjectDetector .

Risultati di esempio

Ecco un esempio dei risultati del rilevamento di ssd mobilenet v1 da TensorFlow Hub.

Results:
 Detection #0 (red):
  Box: (x: 355, y: 133, w: 190, h: 206)
  Top-1 class:
   index       : 17
   score       : 0.73828
   class name  : dog
 Detection #1 (green):
  Box: (x: 103, y: 15, w: 138, h: 369)
  Top-1 class:
   index       : 17
   score       : 0.73047
   class name  : dog

Rendering dei riquadri di delimitazione sull'immagine di input:

Prova il semplice strumento demo CLI per ObjectDetector con il tuo modello e i tuoi dati di prova.

Requisiti di compatibilità del modello

L'API ObjectDetector prevede un modello TFLite con metadati del modello TFLite obbligatori. Vedere esempi di creazione di metadati per rilevatori di oggetti utilizzando l' API di scrittura di metadati TensorFlow Lite .

I modelli di rilevatori di oggetti 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.

• I tensori di uscita devono essere le 4 uscite di un'operazione DetectionPostProcess , ovvero:

  • Tensore delle posizioni (kTfLiteFloat32)
    • tensore di dimensione [1 x num_results x 4] , l'array interno che rappresenta i riquadri di delimitazione nella forma [in alto, a sinistra, a destra, in basso].
    • Le BoundingBoxProperties devono essere allegate ai metadati e devono specificare type=BOUNDARIES e `coordinate_type=RATIO.

  • Tensore di classi (kTfLiteFloat32)

    • tensore di size [1 x num_results] , ogni valore rappresenta l'indice intero di una classe.
    • Le mappe di etichette opzionali (ma consigliate) possono essere allegate come AssociatedFile-s con tipo TENSOR_VALUE_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 class_name dei risultati. Il campo display_name viene compilato dall'AssociatedFile (se presente) la cui locale corrisponde al campo display_names_locale di ObjectDetectorOptions utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà riempito solo il campo index dei risultati.

  • Tensore dei punteggi (kTfLiteFloat32)

    • tensore di dimensione [1 x num_results] , ogni valore rappresenta il punteggio dell'oggetto rilevato.

  • Numero del tensore di rilevamento (kTfLiteFloat32)

    • intero num_results come tensore di dimensione [1] .