Apresentação do Google AI Edge Portal: compare a IA Edge em escala. Inscrição para solicitar acesso durante a visualização particular.

Esta página foi traduzida pela API Cloud Translation.

Integrar detectores de objetos

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

Use a API da biblioteca de tarefas ObjectDetector para implantar detectores de objetos personalizados ou pré-treinados nos seus apps para dispositivos móveis.

Principais recursos da API ObjectDetector

Processamento de imagens de entrada, incluindo rotação, redimensionamento e conversão de espaço de cores.
Localidade do mapa de rótulos.
Limite de pontuação para filtrar resultados.
Principais resultados de detecção k.
Lista de permissões e de bloqueio de rótulos.

Modelos de detectores de objetos compatíveis

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

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

Executar inferência em Java

Consulte o app de referência de detecção de objetos para ver 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 de modelo .tflite para o diretório de recursos do módulo Android em que o modelo será executado. Especifique que o arquivo não deve ser compactado e 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: usar o 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 o código-fonte e o javadoc 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 o guia de instalação do CocoaPods para instruções.

Consulte o guia do CocoaPods (em inglês) para saber como adicionar pods a um projeto do Xcode.

Adicione o pod TensorFlowLiteTaskVision ao Podfile.

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

Verifique se o modelo .tflite que você vai usar para inferência está presente no pacote do app.

Etapa 2: usar o 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 o 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: usar o 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 o 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 o código-fonte para mais opções de configuração do ObjectDetector.

Resultados de exemplo

Confira um exemplo dos resultados da detecção de ssd mobilenet v1 do 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 de detecção

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

Requisitos de compatibilidade de modelo

A API ObjectDetector espera um modelo do TFLite com metadados do modelo do TFLite obrigatórios. Confira exemplos de como criar metadados para detectores de objetos usando a API TensorFlow Lite Metadata Writer.

Os modelos de detecção de objetos compatíveis precisam atender aos seguintes requisitos:

Tensor de 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 aceitas (channels precisa ser 3).
- Se o tipo for kTfLiteFloat32, NormalizationOptions precisará ser anexado 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)
- tensor de tamanho [1 x num_results x 4], a matriz interna que representa caixas delimitadoras no formato [parte de cima, esquerda, direita, parte de baixo].
- BoundingBoxProperties precisam ser anexadas aos metadados e especificar type=BOUNDARIES e "coordinate_type=RATIO".
- Tensor de classes (kTfLiteFloat32)
- Tensor de tamanho [1 x num_results], em que cada valor representa o índice inteiro de uma classe.
- É possível anexar mapas de identificadores opcionais (mas recomendados) como AssociatedFile-s com o tipo TENSOR_VALUE_LABELS, contendo um identificador por linha. Confira o arquivo de exemplo de rótulo. O primeiro AssociatedFile (se houver) é usado para preencher o campo class_name dos resultados. O campo display_name é preenchido com o AssociatedFile (se houver) cuja localidade corresponde ao campo display_names_locale do ObjectDetectorOptions usado no momento da criação ("en" por padrão, ou seja, inglês). Se nenhuma delas estiver disponível, apenas o campo index dos resultados será preenchido.
- Tensor de pontuações (kTfLiteFloat32)
- Tensor de tamanho [1 x num_results], em que cada valor representa a pontuação do objeto detectado.
- Número de tensores de detecção (kTfLiteFloat32)
- inteiro num_results como um tensor de tamanho [1].