Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Integrar classificadores de imagem

A classificação de imagens é um uso comum do aprendizado de máquina para identificar o que uma imagem representa. Por exemplo, podemos querer saber que tipo de animal aparece em uma determinada imagem. A tarefa de prever o que uma imagem representa é chamado 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 cães. Veja a introdução de classificação de imagens para mais informações sobre classificadores de imagens.

Use a tarefa Biblioteca ImageClassifier API para implantar seus classificadores de imagens personalizadas ou os pré-treinado em seus aplicativos móveis.

Principais recursos da API ImageClassifier

  • Processamento de imagem de entrada, incluindo rotação, redimensionamento e conversão de espaço de cores.

  • Região de interesse da imagem de entrada.

  • Rotular a localidade do mapa.

  • Limite de pontuação para filtrar os resultados.

  • Resultados da classificação Top-k.

  • Lista de permissões de etiqueta e denylist.

Modelos de classificadores de imagem suportados

Os seguintes modelos são garantidos para ser compatível com o ImageClassifier API.

Executar inferência em Java

Veja a Imagem aplicativo de referência de Classificação para um exemplo de como usar ImageClassifier em um aplicativo Android.

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

Copie o .tflite arquivo de modelo para o diretório ativo do módulo Android onde o modelo será executado. Especificar que o arquivo não deve ser comprimido, e adicione a biblioteca TensorFlow Lite ao módulo build.gradle arquivo:

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:0.3.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.3.0'
}

Etapa 2: usando 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);

Ver o código-fonte e javadoc para mais opções para configurar ImageClassifier .

Executar inferência em C ++

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Ver o código-fonte para mais opções para configurar ImageClassifier .

Resultados de exemplo

Aqui está um exemplo dos resultados da classificação de um classificador de aves .

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

Experimente o simples ferramenta CLI demo para ImageClassifier com seus próprios dados do modelo e teste.

Requisitos de compatibilidade de modelo

O ImageClassifier API espera um modelo TFLite com obrigatório TFLite modelo de metadados . Veja exemplos de criação de metadados para classificadores de imagens usando o escritor API TensorFlow Lite Metadados .

Os modelos de classificadores de imagem compatíveis devem atender aos seguintes requisitos:

  • Tensor de imagem de entrada (kTfLiteUInt8 / kTfLiteFloat32)

    • de entrada de imagem de tamanho [batch x height x width x channels] .
    • inferência lote não está suportado ( batch é requerido para ser 1).
    • única entradas RGB são suportados ( channels é necessário ser 3).
    • se o tipo for kTfLiteFloat32, NormalizationOptions deve 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, isto é, [1 x N] ou [1 x 1 x 1 x N]
    • mapa (s) de rótulo opcional (mas recomendado) como AssociatedFile-s com tipo TENSOR_AXIS_LABELS, contendo um rótulo por linha. Veja o exemplo de arquivo de etiqueta . O primeiro tal AssociatedFile (se houver) é usado para encher o label campo (denominado como class_name em C ++) dos resultados. O display_name campo é preenchido a partir do AssociatedFile (se houver), cujo local corresponde ao display_names_locale campo das ImageClassifierOptions utilizados no momento da criação ( "en" por padrão, ou seja, em Inglês). Se nenhum destes estão disponíveis, apenas o index campo dos resultados será preenchido.