Conheça o LiteRT: o ambiente de execução de alto desempenho do Google para IA no dispositivo, antes conhecido como TensorFlow Lite.

Esta página foi traduzida pela API Cloud Translation.

Integrar detectores de objetos

Os detectores de objetos podem identificar quais objetos de um conjunto conhecido podem estar presentes e fornecem informações sobre suas posições na imagem ou em um vídeo riacho. Um detector de objetos é treinado para detectar a presença e a localização várias classes de objetos. Por exemplo, um modelo pode ser treinado com imagens que contêm vários pedaços de fruta, junto com um rótulo que especifica o classe de fruta que representam (por exemplo, uma maçã, uma banana ou um morango) e dados que especificam onde cada objeto aparece na imagem. Consulte a exemplo de detecção de objetos para mais informações sobre detectores de objetos.

Use a API Task Library ObjectDetector para implantar seus detectores de objetos personalizados ou pré-treinados aos seus apps para dispositivos móveis.

Principais recursos da API ObjectDetector

Processamento de imagens de entrada, incluindo rotação, redimensionamento e espaço de cores e conversão em massa.
Localidade do mapa do rótulo.
Limite de pontuação para filtrar os resultados.
Resultados da detecção do Top-K.
Lista de permissões de rótulos e lista de bloqueio.

Modelos de detector de objetos compatíveis

Os modelos a seguir têm a garantia de compatibilidade com o ObjectDetector API.

A modelos pré-treinados de detecção de objetos no TensorFlow Hub.
Modelos criados pela Detecção de objetos do AutoML Vision Edge.
Modelos criados pela TensorFlow Lite Model Maker para detector de objetos.
Modelos personalizados que atendem aos requisitos de compatibilidade do modelo.

Executar inferência em Java

Consulte a App de referência de detecção de objetos para conferir um exemplo de como usar ObjectDetector em um app Android.

Etapa 1: importar a dependência do Gradle e outras configurações

Copie o arquivo modelo .tflite para o diretório de assets do módulo Android. em que o modelo será executado. Especifique que o arquivo não deve ser compactado. Adicione a biblioteca do TensorFlow Lite ao arquivo build.gradle do módulo:

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'
}

Etapa 2: uso do modelo

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

Consulte a código-fonte e o javadoc (em inglês) para mais opções de configuração do ObjectDetector.

Executar inferência no iOS

Etapa 1: instalar as dependências

A biblioteca de tarefas oferece suporte à instalação usando o CocoaPods. Verifique se o CocoaPods está instalado no seu sistema. Consulte a Guia de instalação do CocoaPods para obter instruções.

Consulte a Guia de CocoaPods para detalhes sobre como adicionar pods a um projeto do Xcode.

Adicione o pod TensorFlowLiteTaskVision ao Podfile.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskVision'
end

O modelo .tflite que você vai usar para inferência precisa estar presente seu pacote de apps.

Etapa 2: uso do modelo

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

Consulte a código-fonte para mais opções de configuração do TFLObjectDetector.

Executar inferência em Python

Etapa 1: instalar o pacote pip

pip install tflite-support

Etapa 2: uso do modelo

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

Consulte a código-fonte para mais opções de configuração do ObjectDetector.

Executar inferência em 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();

Consulte a código-fonte para mais opções de configuração do ObjectDetector.

Resultados de exemplo

Este é um exemplo dos resultados da detecção ssd mobilenet v1 (link em inglês) usando o TensorFlow Hub.

cães

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

Renderize as caixas delimitadoras na imagem de entrada:

saída da detecção

Teste a funcionalidade Ferramenta de demonstração da CLI para o ObjectDetector com seu próprio modelo e dados de teste.

Requisitos de compatibilidade do modelo

A API ObjectDetector espera um modelo TFLite com valores obrigatórios Metadados de modelo do TFLite. Veja exemplos de criação de metadados para detectores de objetos usando o API TensorFlow Lite Metadata Writer

Os modelos de detector de objetos compatíveis precisam atender aos seguintes requisitos:

Tensor da imagem de entrada: (kTfLiteUInt8/kTfLiteFloat32)
- entrada de imagem de tamanho [batch x height x width x channels].
- A inferência em lote não é compatível (batch precisa ser 1).
- somente entradas RGB são compatíveis (channels precisa ser 3).
- se o tipo for kTfLiteFloat32, as NormalizationOptions devem ser anexada aos metadados para normalização de entrada.
Os tensores de saída precisam ser as quatro saídas de uma operação DetectionPostProcess, ou seja:
- Tensor de locais (kTfLiteFloat32)
  - de tamanho [1 x num_results x 4], a matriz interna que representa caixas delimitadoras no formato [top, left, right, bottom].
  - BoundingBoxProperties precisa ser anexada aos metadados e precisa especificar type=BOUNDARIES e `coordinate_type=RATIO.
- Tensor de classes (kTfLiteFloat32)
  - de tamanho [1 x num_results], cada valor representando o índice inteiro de uma classe.
  - mapas de marcadores opcionais (mas recomendados) podem ser anexados como AssociatedFile-s com tipo TENSOR_VALUE_LABELS, contendo um rótulo por linha. Consulte a exemplo de arquivo de rótulo. O primeiro AssociatedFile (se houver) é usado para preencher o class_name dos resultados. O campo display_name é preenchido a partir de AssociatedFile (se houver) cuja localidade corresponde ao Campo display_names_locale do ObjectDetectorOptions usado em hora de criação ("en" por padrão, isto é, inglês). Se nenhuma delas for disponível, apenas o campo index dos resultados será preenchido.
- Tensor de pontuações (kTfLiteFloat32)
  - de tamanho [1 x num_results], cada valor representando pontuação do objeto detectado.
- Número do tensor de detecção (kTfLiteFloat32)
  - num_results de números inteiros como um tensor de tamanho [1].