Guia de classificação de imagens para iOS

A tarefa "Classificador de imagens" permite realizar a classificação de imagens. É possível usar essa tarefa para identificar o que uma imagem representa entre um conjunto de categorias definidas no momento do treinamento. Estas instruções mostram como usar o classificador de imagens em apps para iOS. O exemplo de código descrito nestas instruções está disponível no GitHub.

Confira esta demonstração na Web para ver essa tarefa em ação. Para mais informações sobre os recursos, modelos e opções de configuração desta tarefa, consulte a Visão geral.

Exemplo de código

O código de exemplo do MediaPipe Tasks é uma implementação básica de um app de classificador de imagem para iOS. O exemplo usa a câmera em um dispositivo iOS físico para classificar objetos continuamente e também pode usar imagens e vídeos da galeria do dispositivo para classificar objetos de forma estática.

Você pode usar o app como ponto de partida para seu próprio app iOS ou se referir a ele ao modificar um app existente. O código de exemplo do Classificador de imagens está hospedado no GitHub.

Fazer o download do código

As instruções a seguir mostram como criar uma cópia local do exemplo de código usando a ferramenta de linha de comando git.

Para fazer o download do código de exemplo:

  1. Clone o repositório do Git usando o seguinte comando:

    git clone https://github.com/google-ai-edge/mediapipe-samples

  2. Como opção, configure sua instância git para usar a finalização de compra esparsa, de modo que você tenha apenas os arquivos do app de exemplo do Image Classifier:

    cd mediapipe
git sparse-checkout init --cone
git sparse-checkout set examples/image_classification/ios/

Depois de criar uma versão local do código de exemplo, instale a biblioteca de tarefas MediaPipe, abra o projeto usando o Xcode e execute o app. Para instruções, consulte o Guia de configuração para iOS.

Principais componentes

Os arquivos a seguir contêm o código crucial para o aplicativo de exemplo do Classificador de imagens:

Configuração

Esta seção descreve as principais etapas para configurar seu ambiente de desenvolvimento e projetos de código para usar o Classificador de imagens. Para informações gerais sobre como configurar seu ambiente de desenvolvimento para usar tarefas do MediaPipe, incluindo os requisitos de versão da plataforma, consulte o Guia de configuração para iOS.

Dependências

O classificador de imagens usa a biblioteca MediaPipeTasksVision, que precisa ser instalada usando o CocoaPods. A biblioteca é compatível com apps Swift e Objective-C e não requer outras configurações específicas da linguagem.

Para instruções sobre como instalar o CocoaPods no macOS, consulte o Guia de instalação do CocoaPods. Para instruções sobre como criar um Podfile com os pods necessários para seu app, consulte Como usar CocoaPods.

Adicione o pod MediaPipeTasksVision no Podfile usando o seguinte código:

target 'MyImageClassifierApp' do
  use_frameworks!
  pod 'MediaPipeTasksVision'
end

Se o app incluir destinos de teste de unidade, consulte o guia de configuração para iOS para mais informações sobre como configurar o Podfile.

Modelo

A tarefa do classificador de imagens do MediaPipe exige um modelo treinado compatível com essa tarefa. Para mais informações sobre os modelos treinados disponíveis para o classificador de imagem, consulte a visão geral da tarefa seção Modelos.

Selecione e faça o download de um modelo e adicione-o ao diretório do projeto usando o Xcode. Para instruções sobre como adicionar arquivos ao projeto do Xcode, consulte Como gerenciar arquivos e pastas no projeto do Xcode.

Use a propriedade BaseOptions.modelAssetPath para especificar o caminho para o modelo no app bundle. Para conferir um exemplo de código, consulte a próxima seção.

Criar a tarefa

É possível criar a tarefa de classificador de imagens chamando um dos inicializadores dela. O inicializador ImageClassifier(options:) define valores para opções de configuração, incluindo modo de execução, localidade de nomes de exibição, número máximo de resultados, limite de confiança, lista de permissões e de bloqueio de categorias.

Se você não precisa que um classificador de imagem seja inicializado com opções de configuração personalizadas, use o inicializador ImageClassifier(modelPath:) para criar um classificador de imagem com as opções padrão. Para mais informações sobre as opções de configuração, consulte Visão geral da configuração.

A tarefa Classificador de imagem é compatível com três tipos de dados de entrada: imagens estáticas, arquivos de vídeo e streams de vídeo ao vivo. Por padrão, ImageClassifier(modelPath:) inicializa uma tarefa de imagens estáticas. Se você quiser que a tarefa seja inicializada para processar arquivos de vídeo ou transmissões de vídeo ao vivo, use ImageClassifier(options:) para especificar o modo de execução do vídeo ou da transmissão ao vivo. O modo de transmissão ao vivo também exige a opção de configuração imageClassifierLiveStreamDelegate adicional, que permite que o classificador de imagens envie resultados de classificação de imagens para o delegado de forma assíncrona.

Escolha a guia correspondente ao modo de execução para saber como criar a tarefa e executar a inferência.

Swift

Imagem

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "tflite")

let options = ImageClassifierOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .image
options.maxResults = 5

let imageClassifier = try ImageClassifier(options: options)

Vídeo

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "tflite")

let options = ImageClassifierOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .video
options.maxResults = 5

let imageClassifier = try ImageClassifier(options: options)

Transmissão ao vivo

import MediaPipeTasksVision

// Class that conforms to the `ImageClassifierLiveStreamDelegate` protocol and
// implements the method that the image classifier calls once it
// finishes performing classification on each input frame.
class ImageClassifierResultProcessor: NSObject, ImageClassifierLiveStreamDelegate {

   func imageClassifier(
    _ imageClassifier: ImageClassifier,
    didFinishClassification result: ImageClassifierResult?,
    timestampInMilliseconds: Int,
    error: Error?) {

    // Process the image classifier result or errors here.

  }
}

let modelPath = Bundle.main.path(
  forResource: "model",
  ofType: "tflite")

let options = ImageClassifierOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .liveStream
options.maxResults = 5

// Assign an object of the class to the `imageClassifierLiveStreamDelegate`
// property.
let processor = ImageClassifierResultProcessor()
options.imageClassifierLiveStreamDelegate = processor

let imageClassifier = try ImageClassifier(options: options)

Objective-C

Imagem

@import MediaPipeTasksVision;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPImageClassifierOptions *options = [[MPPImageClassifierOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeImage;
options.maxResults = 5;

MPPImageClassifier *imageClassifier =
      [[MPPImageClassifier alloc] initWithOptions:options error:nil];

Vídeo

@import MediaPipeTasksVision;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPImageClassifierOptions *options = [[MPPImageClassifierOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeVideo;
options.maxResults = 5;

MPPImageClassifier *imageClassifier =
      [[MPPImageClassifier alloc] initWithOptions:options error:nil];

Transmissão ao vivo

@import MediaPipeTasksVision;

// Class that conforms to the `MPPImageClassifierLiveStreamDelegate` protocol
// and implements the method that the image classifier calls once it finishes
// performing classification on each input frame.

@interface APPImageClassifierResultProcessor : NSObject 

@end

@implementation APPImageClassifierResultProcessor

-   (void)imageClassifier:(MPPImageClassifier *)imageClassifier
    didFinishClassificationWithResult:(MPPImageClassifierResult *)imageClassifierResult
              timestampInMilliseconds:(NSInteger)timestampInMilliseconds
                                error:(NSError *)error {

    // Process the image classifier result or errors here.

}

@end

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPImageClassifierOptions *options = [[MPPImageClassifierOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeLiveStream;
options.maxResults = 5;

// Assign an object of the class to the `imageClassifierLiveStreamDelegate`
// property.
APPImageClassifierResultProcessor *processor = [APPImageClassifierResultProcessor new];
options.imageClassifierLiveStreamDelegate = processor;

MPPImageClassifier *imageClassifier =
      [[MPPImageClassifier alloc] initWithOptions:options error:nil];

Opções de configuração

Esta tarefa tem as seguintes opções de configuração para apps iOS:

Nome da opção Descrição Intervalo de valor Valor padrão
runningMode Define o modo de execução para a tarefa. Há três modos:

IMAGE: o modo para entradas de imagem única.

VÍDEO: o modo para quadros decodificados de um vídeo.

LIVE_STREAM: o modo de uma transmissão ao vivo de dados de entrada, como de uma câmera. Nesse modo, o resultListener precisa ser chamado para configurar um listener para receber resultados de forma assíncrona.		 {RunningMode.image, RunningMode.video, RunningMode.liveStream} RunningMode.image
displayNamesLocale Define o idioma dos rótulos a serem usados para os nomes de exibição fornecidos nos metadados do modelo da tarefa, se disponível. O padrão é en para o inglês. É possível adicionar rótulos localizados aos metadados de um modelo personalizado usando a API Writer de metadados do TensorFlow Lite. Código de localidade en
maxResults Define o número máximo opcional de resultados de classificação com a maior pontuação a serem retornados. Se for < 0, todos os resultados disponíveis serão retornados. Qualquer número positivo -1
scoreThreshold Define o limite de pontuação de previsão que substitui o fornecido nos metadados do modelo (se houver). Resultados abaixo desse valor são rejeitados. Qualquer flutuação Não definido
categoryAllowlist Define a lista opcional de nomes de categorias permitidos. Se não estiver vazio, os resultados da classificação com nome de categoria que não estiver nesse conjunto serão filtrados. Nomes de categorias duplicados ou desconhecidos são ignorados. Essa opção é mutuamente exclusiva com categoryDenylist, e o uso de ambas resulta em um erro. Qualquer string Não definido
categoryDenylist Define a lista opcional de nomes de categorias não permitidos. Se não estiver vazio, os resultados de classificação cujo nome de categoria estiver neste conjunto serão filtrados. Nomes de categorias duplicados ou desconhecidos são ignorados. Essa opção é mutuamente exclusiva de categoryAllowlist, e o uso das duas resulta em um erro. Qualquer string Não definido
resultListener Define o listener de resultados para receber os resultados de classificação de forma assíncrona quando o classificador de imagens está no modo de transmissão ao vivo. Só pode ser usado quando o modo de execução está definido como LIVE_STREAM. N/A Não definido

Configuração de transmissão ao vivo

Quando o modo de execução é definido como transmissão ao vivo, o classificador de imagens exige a opção de configuração imageClassifierLiveStreamDelegate adicional, que permite que o classificador forneça resultados de classificação de forma assíncrona. O delegado implementa o método imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:), que o classificador de imagem chama depois de processar os resultados da classificação de cada frame.

Nome da opção Descrição Intervalo de valor Valor padrão
imageClassifierLiveStreamDelegate Permite que o Image Classifier receba resultados de classificação de maneira assíncrona no modo de transmissão ao vivo. A classe com a instância definida para essa propriedade precisa implementar o método imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:). Não relevante Não definido

Preparar dados

É necessário converter a imagem de entrada ou o frame em um objeto MPImage antes de transmiti-lo ao classificador de imagem. MPImage oferece suporte a diferentes tipos de formatos de imagem do iOS e pode usá-los em qualquer modo em execução para inferência. Para mais informações sobre MPImage, consulte a API MPImage.

Escolha um formato de imagem do iOS com base no seu caso de uso e no modo de execução exigido pelo aplicativo.MPImage aceita os formatos de imagem UIImage, CVPixelBuffer e CMSampleBuffer do iOS.

UIImage

O formato UIImage é adequado para os seguintes modos de execução:

  • Imagens: as imagens de um pacote de apps, galeria de usuários ou sistema de arquivos formatadas como UIImage podem ser convertidas em um objeto MPImage.

  • Vídeos: use AVAssetImageGenerator para extrair frames de vídeo no formato CGImage e converta-os em imagens UIImage.

Swift

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(uiImage: image)

Objective-C

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];

O exemplo inicializa um MPImage com a orientação padrão UIImage.Orientation.Up. É possível inicializar uma MPImage com qualquer um dos valores UIImage.Orientation compatíveis. O classificador de imagens não oferece suporte a orientações espelhadas, como .upMirrored, .downMirrored, .leftMirrored e .rightMirrored.

Para mais informações sobre UIImage, consulte a documentação para desenvolvedores da Apple de UIImage (em inglês).

CVPixelBuffer

O formato CVPixelBuffer é adequado para aplicativos que geram frames e usam o framework CoreImage do iOS para processamento.

O formato CVPixelBuffer é adequado para os seguintes modos de execução:

  • Imagens: aplicativos que geram imagens CVPixelBuffer após algum processamento usando o framework CoreImage do iOS podem ser enviados ao classificador de imagem no modo de execução de imagem.

  • Vídeos: os frames de vídeo podem ser convertidos para o formato CVPixelBuffer para processamento e, em seguida, enviados ao classificador de imagem no modo de vídeo.

  • Transmissão ao vivo: os apps que usam uma câmera do iOS para gerar frames podem ser convertidos no formato CVPixelBuffer para processamento antes de serem enviados ao classificador de imagens no modo de transmissão ao vivo.

Swift

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(pixelBuffer: pixelBuffer)

Objective-C

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];

Para mais informações sobre CVPixelBuffer, consulte a Documentação do desenvolvedor da Apple CVPixelBuffer (em inglês).

CMSampleBuffer

O formato CMSampleBuffer armazena amostras de mídia de um tipo uniforme e é adequado para o modo de execução de transmissões ao vivo. Os frames ao vivo das câmeras do iOS são enviados de forma assíncrona no formato CMSampleBuffer pelo AVCaptureVideoDataOutput do iOS.

Swift

// Obtain a CMSampleBuffer.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(sampleBuffer: sampleBuffer)

Objective-C

// Obtain a `CMSampleBuffer`.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithSampleBuffer:sampleBuffer error:nil];

Para mais informações sobre CMSampleBuffer, consulte a documentação para desenvolvedores da Apple CMSampleBuffer (em inglês).

Executar a tarefa

Para executar o classificador de imagens, use o método classify() específico para o modo de execução atribuído:

  • Imagem estática: classify(image:)
  • Vídeo: classify(videoFrame:timestampInMilliseconds:)
  • transmissão ao vivo: classifyAsync(image:timestampInMilliseconds:)

O classificador de imagens retorna as categorias possíveis para o objeto na imagem ou frame de entrada.

Os exemplos de código abaixo mostram exemplos básicos de como executar o classificador de imagem nesses diferentes modos de execução:

Swift

Imagem

let result = try imageClassifier.classify(image: image)

Vídeo

let result = try imageClassifier.classify(
  videoFrame: image,
  timestampInMilliseconds: timestamp)

Transmissão ao vivo

try imageClassifier.classifyAsync(
  image: image,
  timestampInMilliseconds: timestamp)

Objective-C

Imagem

MPPImageClassifierResult *result = [imageClassifier classifyImage:image
                                                            error:nil];

Vídeo

MPPImageClassifierResult *result = [imageClassifier classifyVideoFrame:image
                                               timestampInMilliseconds:timestamp
                                                                 error:nil];

Transmissão ao vivo

BOOL success = [imageClassifier classifyAsyncImage:image
                          timestampInMilliseconds:timestamp
                                            error:nil];

O exemplo de código do classificador de imagens mostra as implementações de cada um desses modos com mais detalhes classify(image:), classify(videoFrame:timestampInMilliseconds:) e classifyAsync(image:timestampInMilliseconds:). O código de exemplo permite que o usuário alterne entre os modos de processamento que podem não ser necessários para seu caso de uso.

Observe o seguinte:

  • Ao executar no modo de vídeo ou de transmissão ao vivo, você também precisa fornecer o carimbo de data/hora do frame de entrada para a tarefa do classificador de imagens.

  • Quando executada no modo de imagem ou vídeo, a tarefa do classificador de imagens bloqueia a linha de execução atual até que ela termine de processar a imagem ou o frame de entrada. Para evitar o bloqueio da linha de execução atual, execute o processamento em uma linha de execução em segundo plano usando os frameworks Dispatch ou NSOperation do iOS.

  • Quando executada no modo de transmissão ao vivo, a tarefa do classificador de imagem retorna imediatamente e não bloqueia a linha de execução atual. Ele invoca o método imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:) com o resultado da classificação após o processamento de cada frame de entrada. O classificador de imagem invoca esse método de forma assíncrona em uma fila de envio em série dedicada. Para mostrar os resultados na interface do usuário, envie os resultados para a fila principal depois de processá-los. Se a função classifyAsync for chamada quando a tarefa do classificador de imagem estiver ocupada processando outro frame, o classificador de imagem vai ignorar o novo frame de entrada.

Processar e mostrar resultados

Ao executar a inferência, a tarefa do classificador de imagens retorna um objeto ImageClassifierResult que contém a lista de categorias possíveis para os objetos na imagem ou frame de entrada.

Confira a seguir um exemplo dos dados de saída desta tarefa:

ImageClassifierResult:
 Classifications #0 (single classification head):
  head index: 0
  category #0:
   category name: "/m/01bwb9"
   display name: "Passer domesticus"
   score: 0.91406
   index: 671
  category #1:
   category name: "/m/01bwbt"
   display name: "Passer montanus"
   score: 0.00391
   index: 670

Esse resultado foi obtido executando o Bird Classifier em:

O código de exemplo do classificador de imagem demonstra como exibir os resultados de classificação retornados da tarefa. Consulte o exemplo de código para mais detalhes.