Ti presentiamo Google AI Edge Portal: esegui il benchmarking dell'IA di Edge su larga scala. Registrati per richiedere l'accesso durante l'anteprima privata.

Questa pagina è stata tradotta dall'API Cloud Translation.

Integra rilevatori di oggetti

I rilevatori di oggetti possono identificare quali di un insieme noto di oggetti potrebbero essere presenti e fornire informazioni sulle loro posizioni all'interno dell'immagine o del flusso video fornito. Un rilevatore di oggetti è addestrato a rilevare la presenza e la posizione di più classi di oggetti. Ad esempio, un modello potrebbe essere addestrato con immagini che contengono vari tipi di frutta, insieme a un'etichetta che specifica la classe di frutta che rappresentano (ad es. una mela, una banana o una fragola) e dati che specificano dove compare ogni oggetto nell'immagine. Per saperne di più sui rilevatori di oggetti, consulta l'esempio di rilevamento di oggetti.

Utilizza l'API Task Library ObjectDetector per eseguire il deployment dei rilevatori di oggetti personalizzati o preaddestrati nelle tue app mobile.

Funzionalità principali dell'API ObjectDetector

Elaborazione dell'immagine di input, inclusi rotazione, ridimensionamento e conversione dello spazio colore.
Etichetta della località sulla mappa.
Soglia di punteggio per filtrare i risultati.
I primi k risultati del rilevamento.
Liste consentite e bloccate di etichette.

Modelli di rilevatore 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 detector di oggetti.
Modelli personalizzati che soddisfano i requisiti di compatibilità dei modelli.

Esegui l'inferenza in Java

Consulta l'app di riferimento per il rilevamento di oggetti per un esempio di come utilizzare ObjectDetector 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
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);

Per altre opzioni di configurazione di ObjectDetector, 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: "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)

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

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

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

Consulta il codice sorgente per altre opzioni di configurazione di 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();

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

Risultati di esempio

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

cani

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

Esegui il rendering dei riquadri di delimitazione sull'immagine di input:

output del rilevamento

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

Requisiti di compatibilità del modello

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

I modelli di rilevamento degli oggetti 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.
I tensori di output devono essere i quattro output 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 selezione nel formato [alto, sinistra, destra, basso].
- Le proprietà BoundingBoxProperties devono essere allegate ai metadati e devono specificare type=BOUNDARIES e `coordinate_type=RATIO.
- Tensore delle classi (kTfLiteFloat32)
- tensore di dimensione [1 x num_results], ogni valore rappresenta l'indice intero di una classe.
- Le mappe delle etichette facoltative (ma consigliate) possono essere allegate come AssociatedFile-s di tipo TENSOR_VALUE_LABELS, contenenti un'etichetta per riga. Vedi il file di etichette di esempio. Il primo AssociatedFile (se presente) viene utilizzato per compilare il campo class_name dei risultati. Il campo display_name viene compilato a partire dal campo AssociatedFile (se presente) la cui impostazione locale corrisponde al campo display_names_locale del ObjectDetectorOptions utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà compilato 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 di tensori di rilevamento (kTfLiteFloat32)
- integer num_results come tensore di dimensione [1].