I rilevatori di oggetti possono identificare quale di un insieme noto di oggetti potrebbe essere presente e fornire informazioni sulla loro posizione all'interno di una determinata immagine o flusso video. 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 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 appare ciascun oggetto in l'immagine. Vedere l' introduzione al rilevamento degli oggetti per ulteriori informazioni sui rilevatori di oggetti.
Utilizza l'API ObjectDetector
della Task Library per distribuire i rilevatori di oggetti personalizzati o preaddestrati nelle tue app mobili.
Funzionalità principali dell'API ObjectDetector
Elaborazione delle immagini in ingresso, inclusa rotazione, ridimensionamento e conversione dello spazio colore.
Etichetta locale della mappa.
Soglia del punteggio per filtrare i risultati.
Risultati di rilevamento top-k.
Etichetta lista consentita e lista negata.
Modelli di rilevatori di oggetti supportati
È garantita la compatibilità dei seguenti modelli 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 rilevatore di oggetti .
Modelli personalizzati che soddisfano i requisiti di compatibilità del modello .
Esegui l'inferenza in Java
Consulta l' app di riferimento Object Detection per un esempio di come utilizzare ObjectDetector
in un'app Android.
Passaggio 1: importa la dipendenza Gradle e altre impostazioni
Copia il file del modello .tflite
nella directory 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 (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);
Consulta 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 utilizzando CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Per istruzioni, consultare la guida all'installazione di CocoaPods .
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 pacchetto dell'app.
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];
Consulta 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 dati di test.
Requisiti di compatibilità del modello
L'API ObjectDetector
prevede un modello TFLite con metadati del modello TFLite obbligatori. Guarda gli esempi di creazione di metadati per rilevatori di oggetti utilizzando l' API TensorFlow Lite Metadata Writer .
I modelli di rilevatori di oggetti compatibili devono soddisfare i seguenti requisiti:
Tensore immagine in ingresso: (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 ingressi RGB (
channels
devono essere 3). - se il tipo è kTfLiteFloat32, è necessario allegare NormalizationOptions ai metadati per la normalizzazione dell'input.
- input immagine di dimensioni
I tensori di output devono essere i 4 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 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 dimensione
Tensore delle classi (kTfLiteFloat32)
- tensore di dimensione
[1 x num_results]
, ogni valore rappresenta l'indice intero di una classe. - le mappe di etichette facoltative (ma consigliate) possono essere allegate come AssociatedFile con tipo TENSOR_VALUE_LABELS, contenenti un'etichetta per riga. Vedi il file di etichetta di esempio . Il primo AssociatedFile (se presente) viene utilizzato per riempire il campo
class_name
dei risultati. Il campodisplay_name
viene compilato da AssociatedFile (se presente) la cui locale corrisponde al campodisplay_names_locale
diObjectDetectorOptions
utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà compilato solo il campoindex
dei risultati.
- tensore di dimensione
Tensore dei punteggi (kTfLiteFloat32)
- tensore di dimensione
[1 x num_results]
, ciascun valore rappresenta il punteggio dell'oggetto rilevato.
- tensore di dimensione
Numero di tensore di rilevamento (kTfLiteFloat32)
- intero num_results come tensore di dimensione
[1]
.
- intero num_results come tensore di dimensione
- Tensore delle posizioni (kTfLiteFloat32)