Guia de classificação de imagens para iOS

A tarefa Image Classifier permite que você execute a classificação em imagens. Você pode 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 imagem em Apps iOS. O exemplo de código descrito nestas instruções está disponível em GitHub.

Para saber como essa tarefa funciona, acesse este site demonstração. Para mais informações sobre os recursos, modelos e opções de configuração do para essa tarefa, consulte Visão geral.

Exemplo de código

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

Você pode usar o app como ponto de partida para seu próprio app iOS ou consultá-lo ao modificar um aplicativo existente. O exemplo de código do Image Classifier está hospedado GitHub.

Fazer o download do código

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

Para fazer o download do código de exemplo:

1. Clone o repositório git usando o seguinte comando:

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

2. Opcionalmente, configure sua instância git para usar a finalização esparsa. Assim, você terá 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, você pode instalar o MediaPipe, abrir o projeto usando Xcode e executar o app. Para instruções, consulte o Guia de configuração do iOS.

Principais componentes

Os arquivos a seguir contêm o código essencial para o exemplo do Image Classifier. aplicativo:

• ImageClassifierService.swift: Inicializa o classificador de imagem, processa a seleção de modelos e executa a inferência nos dados de entrada.
• CameraViewController.swift: Implementa a interface para o modo de entrada de transmissão da câmera em tempo real e visualiza os resultados.
• MediaLibraryViewController.swift Implementa a interface para o modo de entrada de arquivo de vídeo e imagem estática e visualiza os resultados.

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 imagem. Para informações gerais sobre como configurar sua ambiente de desenvolvimento para usar tarefas do MediaPipe, incluindo a versão da plataforma , consulte o Guia de configuração para iOS.

Dependências

O Image Classificador usa a biblioteca MediaPipeTasksVision, que precisa ser instalada usando o CocoaPods. A biblioteca é compatível com aplicativos Swift e Objective-C e não requer configuração específica do idioma.

Para instruções sobre como instalar o CocoaPods no macOS, consulte a documentação do CocoaPods guia de instalação (em inglês). Para instruções sobre como criar um Podfile com os pods necessários para aplicativo, consulte Usar CocoaPods.

Adicione o pod do 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 do iOS para mais informações sobre a configuração seu Podfile.

Modelo

A tarefa do classificador de imagem do MediaPipe requer um modelo treinado que seja compatível a essa tarefa. Para mais informações sobre os modelos treinados disponíveis para Classificador de imagem, consulte a visão geral da tarefa 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 seu projeto Xcode, consulte Como gerenciar arquivos e pastas no seu Xcode projeto.

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

Criar a tarefa

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

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

A tarefa Classificador de imagem oferece suporte a três tipos de dados de entrada: imagens estáticas e arquivos de vídeo e transmissões de vídeo ao vivo. Por padrão, ImageClassifier(modelPath:) inicializa uma para imagens estáticas. Se você quiser que sua tarefa seja inicializada para processar vídeos arquivos ou streams de vídeo ao vivo, use ImageClassifier(options:) para especificar vídeo ou transmissão ao vivo. O modo de transmissão ao vivo também requer opção de configuração imageClassifierLiveStreamDelegate extra, que permite que o Image Classificador forneça resultados de classificação de imagem para o delegar de maneira assíncrona.

Escolha a guia correspondente ao modo de corrida para saber como criar a tarefa e executar inferência.

Swift

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)
    

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)
    

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

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

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

@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:

Configuração da transmissão ao vivo

Quando o modo de execução é definido como transmissão ao vivo, o Classificador de imagem exige o opção de configuração imageClassifierLiveStreamDelegate extra, que permite que o classificador entregue resultados de classificação de forma assíncrona. A delegado implementa imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:) , que o classificador de imagem chama depois de processar a classificação resultados para cada frame.

Preparar dados

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

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

UIImage

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

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

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

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

// 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 o UIImage.Orientation.Up orientação. É possível inicializar um MPImage com qualquer um dos UIImage.Orientation e a distribuição dos valores dos dados. O Image Classificador não oferece suporte a orientações espelhadas como .upMirrored, .downMirrored, .leftMirrored e .rightMirrored.

Para mais informações sobre o UIImage, consulte a página do desenvolvedor de imagens de usuário Documentação.

CVPixelBuffer

O formato CVPixelBuffer é adequado para aplicativos que geram frames e usar a interface CoreImage do iOS para processamento.

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

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

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

• Transmissão ao vivo: apps que usam a câmera do iOS para gerar frames podem ser convertidos no formato CVPixelBuffer para processamento antes de ser enviado ao Classificador de imagem no modo de transmissão ao vivo.

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

// 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 o CVPixelBuffer, consulte a documentação da Apple CVPixelBuffer Desenvolvedor Documentação.

CMSampleBuffer

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

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

// 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 o CMSampleBuffer, consulte a documentação da Apple do CMSampleBuffer Desenvolvedor Documentação.

Executar a tarefa

Para executar o classificador de imagem, use o método classify() específico para o modo de corrida:

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

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

Os exemplos de código a seguir mostram exemplos básicos de como executar o classificador de imagem no estes diferentes modos de execução:

Swift

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

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

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

Objective-C

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

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

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

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

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 imagem.

• Quando executada no modo de imagem ou vídeo, a tarefa Classificador de imagem bloqueia o linha de execução atual até terminar de processar a imagem ou frame de entrada. Para evite o bloqueio da linha de execução atual, execute o processamento em segundo plano conversa usando iOS Dispatch ou NSOperation frameworks.

• Quando executada no modo de transmissão ao vivo, a tarefa Classificador de imagem retorna imediatamente e não bloqueia a linha de execução atual. Ele invoca imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:) com o resultado da classificação após o processamento de cada frame de entrada. A O Image Classifier invoca esse método de forma assíncrona em um número de série dedicado fila de despacho. Para exibir resultados na interface do usuário, envie o para a fila principal após o processamento dos resultados. Se o A função classifyAsync é chamada quando a tarefa do classificador de imagem está ocupada processar outro frame, o Image Classifier ignora o novo frame de entrada.

Gerenciar e exibir resultados

Ao executar a inferência, a tarefa Classificador de imagem retorna uma Objeto ImageClassifierResult que contém a lista de categorias possíveis para os objetos na imagem ou frame de entrada.

Confira abaixo 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 Image Classifier demonstra como exibir a classificação resultados retornados da tarefa, consulte o código exemplo para mais detalhes.