Integrar classificadores de imagens

A classificação de imagens é um uso comum do machine learning para identificar o que uma imagem representa. Por exemplo, podemos querer saber que tipo de animal aparece em uma determinada foto. A tarefa de prever o que uma imagem representa é chamada de classificação de imagens. Um classificador de imagens é treinado para reconhecer várias classes de imagens. Por exemplo, um modelo pode ser treinado para reconhecer fotos que representam três tipos diferentes de animais: coelhos, hamsters e cachorros. Consulte o exemplo de classificação de imagens para mais informações sobre classificadores de imagens.

Use a API Task Library ImageClassifier para implantar classificadores de imagens personalizados ou pré-treinados nos seus apps para dispositivos móveis.

Principais recursos da API ImageClassifier

Processamento de imagens de entrada, incluindo rotação, redimensionamento e conversão de espaço de cores.
Região de interesse da imagem de entrada.
Localidade do mapa de rótulos.
Limite de pontuação para filtrar resultados.
Os principais resultados da classificação k.
Lista de permissões e de bloqueio de rótulos.

Modelos de classificação de imagens compatíveis

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

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

Executar inferência em Java

Consulte o app de referência de classificação de imagens para ver um exemplo de como usar ImageClassifier 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
ImageClassifierOptions options =
    ImageClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ImageClassifier imageClassifier =
    ImageClassifier.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Classifications> results = imageClassifier.classify(image);

Consulte o código-fonte e o javadoc para mais opções de configuração do ImageClassifier.

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: "birds_V1",
                                            ofType: "tflite") else { return }

let options = ImageClassifierOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let classifier = try ImageClassifier.classifier(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: "sparrow.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let classificationResults = try classifier.classify(mlImage: mlImage)

Objective-C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"birds_V1" ofType:@"tflite"];

TFLImageClassifierOptions *options =
    [[TFLImageClassifierOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLImageClassifier *classifier = [TFLImageClassifier imageClassifierWithOptions:options
                                                                          error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"sparrow.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
TFLClassificationResult *classificationResult =
    [classifier classifyWithGMLImage:gmlImage error:nil];

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

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)
classification_options = processor.ClassificationOptions(max_results=2)
options = vision.ImageClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = vision.ImageClassifier.create_from_options(options)

# Alternatively, you can create an image classifier in the following manner:
# classifier = vision.ImageClassifier.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

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

Executar inferência em C++

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::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 ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

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

Resultados de exemplo

Confira um exemplo dos resultados da classificação de um classificador de pássaros.

pardal

Results:
  Rank #0:
   index       : 671
   score       : 0.91406
   class name  : /m/01bwb9
   display name: Passer domesticus
  Rank #1:
   index       : 670
   score       : 0.00391
   class name  : /m/01bwbt
   display name: Passer montanus
  Rank #2:
   index       : 495
   score       : 0.00391
   class name  : /m/0bwm6m
   display name: Passer italiae

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

Requisitos de compatibilidade de modelo

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

Os modelos de classificação de imagens 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.
Tensor de pontuação de saída (kTfLiteUInt8/kTfLiteFloat32)
- com N classes e 2 ou 4 dimensões, ou seja, [1 x N] ou [1 x 1 x 1 x N]
- mapas de rótulos opcionais (mas recomendados) como AssociatedFile-s com o tipo TENSOR_AXIS_LABELS, contendo um rótulo por linha. Confira o arquivo de rótulos de exemplo. O primeiro AssociatedFile (se houver) é usado para preencher o campo label (chamado de class_name em C++) dos resultados. O campo display_name é preenchido com o AssociatedFile (se houver) cuja localidade corresponde ao campo display_names_locale do ImageClassifierOptions usado no momento da criação ("en" por padrão, ou seja, inglês). Se nenhum deles estiver disponível, apenas o campo index dos resultados será preenchido.