Scopri di più sui nostri annunci di Google AI Edge da I/O

Questa pagina è stata tradotta dall'API Cloud Translation.

Integra rilevatori di oggetti

I rilevatori di oggetti possono identificare quale di un insieme noto di oggetti potrebbe essere presente e fornisci informazioni sulla loro posizione all'interno dell'immagine o del video. flusso di dati. Un rilevatore di oggetti è addestrato per rilevare la presenza e la posizione più classi di oggetti. Ad esempio, un modello potrebbe essere addestrato con immagini contenenti vari pezzi di frutta, insieme a un'etichetta che specifica classe di frutta che rappresentano (ad es. una mela, una banana o una fragola); e che specificano la posizione di ciascun oggetto nell'immagine. Consulta le esempio di rilevamento di oggetti per ulteriori informazioni sui rilevatori di oggetti.

Utilizza l'API ObjectDetector della libreria di attività per eseguire il deployment dei rilevatori di oggetti personalizzati o preaddestrati nelle tue app mobile.

Funzionalità chiave dell'API ObjectDetector

Elaborazione dell'immagine di input, inclusi rotazione, ridimensionamento e spazio colore e conversione in blocco.
Assegna un'etichetta alle impostazioni internazionali della mappa.
Soglia di punteggio per filtrare i risultati.
Risultati del rilevamento top-k.
Lista consentita e lista bloccata di etichette.

Modelli di rilevamento di oggetti supportati

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

La modelli di rilevamento degli oggetti preaddestrati su TensorFlow Hub.
Modelli creati da Rilevamento di oggetti periferici di AutoML Vision.
Modelli creati da Model Maker di TensorFlow Lite per il rilevatore di oggetti.
Modelli personalizzati che soddisfano requisiti di compatibilità dei modelli.

Esegui l'inferenza in Java

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

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

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installata nel 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: "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 le 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: 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)

Consulta le 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 le codice sorgente per altre opzioni di configurazione di ObjectDetector.

Risultati di esempio

Ecco un esempio dei risultati del rilevamento 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

Visualizza i riquadri di delimitazione nell'immagine di input:

output di rilevamento

Prova la semplice Strumento dimostrativo dell'interfaccia a riga di comando per ObjectDetector con il tuo modello e dati di test.

Requisiti di compatibilità del modello

L'API ObjectDetector prevede un modello TFLite con requisiti obbligatori Metadati del modello TFLite. Visualizza esempi di creazione e metadati per i rilevatori di oggetti, API TensorFlow Lite Metadata Writer.

I modelli di rilevamento di 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 (è necessario che i valori channels siano 3).
- se il tipo è kTfLiteFloat32, è necessario che le NormalizationOptions allegati ai metadati per la normalizzazione degli input.
I tensori di output devono essere i 4 output di un'operazione DetectionPostProcess, ad esempio:
- Tensore posizioni (kTfLiteFloat32)
  - tensore della dimensione [1 x num_results x 4], l'array interno che rappresenta riquadri di delimitazione [in alto, a sinistra, a destra, in basso].
  - È necessario collegare i valori BoundingBoxProperties ai metadati e deve specificare type=BOUNDARIES e "coordinate_type=RATIO.
- Tensore delle classi (kTfLiteFloat32)
  - tensore di dimensione [1 x num_results], ogni valore che rappresenta il l'indice intero di una classe.
  - le mappe delle etichette facoltative (ma consigliate) possono essere allegate File associati di tipo TENSOR_VALUE_LABELS, contenenti un'etichetta per riga. Consulta le file di etichette di esempio. Il primo AssociatedFile (se presente) viene utilizzato per riempire Campo class_name dei risultati. Il campo display_name è compilato dall'AssociatedFile (se presente) le cui impostazioni internazionali corrispondono alla Campo display_names_locale di ObjectDetectorOptions 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.
- Tensore dei punteggi (kTfLiteFloat32)
  - tensore di dimensione [1 x num_results], ogni valore che rappresenta il dell'oggetto rilevato.
- Numero di tensori di rilevamento (kTfLiteFloat32)
  - numero intero num_results come tensore di dimensione [1].