A tarefa Image Classifier permite que você execute a classificação em imagens. É possível usar essa tarefa para identificar o que uma imagem representa entre um conjunto de categorias definidas no tempo de 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 no GitHub.
Para saber como funciona a tarefa, confira esta demonstração na Web. Para mais informações sobre os recursos, modelos e opções de configuração dessa 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 de um dispositivo iOS físico para classificar objetos continuamente, além de usar imagens e vídeos da galeria para classificar os objetos estaticamente.
É possível usar o app como ponto de partida para seu próprio app iOS ou consultá-lo ao modificar um app atual. O exemplo de código do Image Classifier 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:
Clone o repositório git usando o seguinte comando:
git clone https://github.com/google-ai-edge/mediapipe-samples
Como opção, configure sua instância git para usar o checkout esparso, 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 essencial para o aplicativo de exemplo Image Classifier:
- ImageClassifierService.swift: inicializa o classificador de imagem, processa a seleção do modelo e executa a inferência nos dados de entrada.
- CameraViewController.swift: implementa a IU para o modo de entrada de feed da câmera em tempo real e visualiza os resultados.
- MediaLibraryViewController.swift Implementa a IU para o modo de entrada de arquivo de imagem estática e de vídeo e visualiza os resultados.
Configuração
Nesta seção, descrevemos 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 seu ambiente de desenvolvimento para usar tarefas do MediaPipe, incluindo requisitos de versão da plataforma, consulte o Guia de configuração para iOS.
Dependências
O Image Classifier usa a biblioteca MediaPipeTasksVision
, que precisa ser instalada
com 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
o 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 para
iOS para mais informações sobre como configurar
o Podfile
.
Modelo
A tarefa do classificador de imagem do MediaPipe requer um modelo treinado que seja 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 Xcode, consulte Como gerenciar arquivos e pastas no projeto do Xcode.
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. O
inicializador ImageClassifier(options:)
define valores para as opções de configuração,
incluindo o modo de execução, a localidade dos nomes de exibição, o número máximo de resultados, o limite
de confiança, a lista de permissões de categorias e a lista de bloqueio.
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 sua tarefa seja inicializada para processar arquivos de vídeo ou streams de vídeo ao vivo, use ImageClassifier(options:)
para especificar o modo de execução de vídeo ou transmissão ao vivo. O modo de transmissão ao vivo também requer a
opção de configuração extra imageClassifierLiveStreamDelegate
, que
permite que o classificador de imagem forneça resultados de classificação de imagem ao
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ões 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ões 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 da tarefa. Há três
modos: IMAGEM: o modo para entradas de imagem única. VÍDEO: é o modo para frames 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, 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 nos nomes de exibição fornecidos nos
metadados do modelo da tarefa, se disponíveis. O padrão é en para
inglês. É possível adicionar rótulos localizados aos metadados de um modelo personalizado
usando a API TensorFlow Lite Metadata Writer. |
Código da localidade | en |
maxResults |
Define o número máximo opcional de resultados da classificação com maior pontuação a serem retornados. Se < 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 usar
os dois resulta em erro. |
Qualquer string | Não definido |
categoryDenylist |
Define a lista opcional de nomes de categorias que não são permitidos. Se não estiver vazio, os resultados da classificação com um nome de categoria nesse conjunto serão filtrados. Nomes de categorias duplicados ou desconhecidos são ignorados. Essa opção é mutuamente exclusiva com categoryAllowlist e usar os dois resulta em erro. |
Qualquer string | Não definido |
resultListener |
Define o listener de resultado para receber os resultados da classificação
de forma assíncrona quando o classificador de imagem estiver no modo de transmissão
ao vivo. Só pode ser usado quando o modo de corrida está definido como LIVE_STREAM |
N/A | Não definido |
Configuração da transmissão ao vivo
Quando o modo de execução é definido como transmissão ao vivo, o classificador de imagem exige a
opção de configuração imageClassifierLiveStreamDelegate
extra, 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 Classificador receba resultados de classificação de forma assíncrona
no modo de transmissão ao vivo. A classe que tem a instância definida para essa propriedade precisa implementar o método imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:) . |
Não relevante | Não definido |
preparar os 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 iOS com base no caso de uso e no modo de execução exigido pelo aplicativo.O MPImage
aceita os formatos de imagem do iOS UIImage
, CVPixelBuffer
e CMSampleBuffer
.
UIImage
O formato UIImage
é adequado para os seguintes modos de execução:
Imagens: imagens de um pacote de apps, uma galeria do usuário ou um sistema de arquivos formatadas como imagens
UIImage
podem ser convertidas em um objetoMPImage
.Vídeos: use o AVAssetImageGenerator para extrair frames de vídeo para o formato CGImage e os converter 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 uma MPImage
com a orientação
UIImage.Orientation.Up
padrão. É possível inicializar um MPImage
com qualquer um dos valores
UIImage.Orientation
compatíveis. O Image Classificador não oferece suporte a orientações espelhadas como .upMirrored
,
.downMirrored
, .leftMirrored
, .rightMirrored
.
Para mais informações sobre UIImage
, consulte a Documentação do desenvolvedor da Apple
UIImage.
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 frameworkCoreImage
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 imagem 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 da transmissão 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 do desenvolvedor da Apple
CMSampleBuffer (em inglês).
Executar a tarefa
Para executar o classificador de imagem, 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 imagem retorna as categorias possíveis para o objeto na imagem ou no 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ões 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ões ao vivo
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
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, também é necessário 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 do Classificador de imagem bloqueia a linha de execução atual até terminar 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 exibir resultados na interface do usuário, envie-os para a fila principal depois de processá-los. Se a funçãoclassifyAsync
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.
Gerenciar e exibir resultados
Ao executar a inferência, a tarefa do classificador de imagem retorna um
objeto ImageClassifierResult
que contém a lista de categorias possíveis
para os objetos na imagem de entrada ou no frame.
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 classificador de imagem demonstra como exibir os resultados de classificação retornados da tarefa. Consulte o exemplo de código para mais detalhes.