Image Labeling: o que é, métodos e como funciona

O que é Image Labeling: fundamentos da classificação

Image Labeling é um subtipo de classificação de imagens onde o modelo recebe uma imagem como entrada e retorna probabilidades para cada classe do conjunto de treinamento. Ao contrário da detecção de objetos, o Image Labeling não determina a posição dos objetos na imagem — apenas sua presença ou ausência. Ao contrário da segmentação de imagem, não delineia o contorno do objeto. O Image Labeling responde à pergunta “o que está na foto?”, não “onde e o que está na foto?”

Arquitetura do classificador: uma backbone CNN (MobileNet, ResNet, EfficientNet) extrai um mapa de características da imagem, o Global Average Pooling colapsa as dimensões espaciais, e uma camada totalmente conectada (Dense) com ativação Softmax gera as probabilidades das classes. MobileNetV2 é a backbone mais popular para dispositivos móveis: 3,5M parâmetros, inferência de 0,5–2 ms no Pixel 6 via GPU. EfficientNet-Lite é uma alternativa com melhor relação precisão/parâmetros.

Precisão Top-1 vs Top-5: top-1 — o modelo prevê corretamente a classe principal (91% no ML Kit); top-5 — a classe correta está entre as cinco mais prováveis (98% no ML Kit). Para aplicações em produção, use top-5 e mostre ao usuário várias opções de rótulos. Para moderação de conteúdo, use top-1 com um limite de confiança >= 0,8 (reduz a taxa de falsos positivos em 40%).

On-device vs Nuvem: a classificação no dispositivo (ML Kit, Core ML) oferece latência de 1–20 ms com privacidade total dos dados. A API na nuvem (Google Cloud Vision, AWS Rekognition) tem latência de 500–2000 ms mais custo por solicitação, mas é mais precisa (97–99%) graças a modelos maiores (ViT, CLIP). Para aplicações em tempo real (câmera, RA), escolha a opção no dispositivo. Para cenários complexos (medicina, análise especializada), use a nuvem com fallback no dispositivo.

ML Kit Image Labeling no Android e iOS

ML Kit Image Labeling é uma biblioteca pronta do Google para classificação de imagens no dispositivo. Disponível em dois modos: no dispositivo (gratuito, mais de 400 rótulos, 10–20 ms) e na nuvem (pago, mais de 10.000 rótulos, mais de 500 ms). A versão no dispositivo usa MobileNetV3 com quantização INT8, ocupando 4 MB de espaço em disco. O ML Kit detecta automaticamente a orientação da imagem e otimiza o tamanho antes da classificação.

API do ML Kit: InputImage (de Bitmap, media.Image, filePath) → ImageLabeler → OnSuccessListener com uma lista de ImageLabel (rótulo, confiança, índice). O limite de confiança (padrão 0,5) é a confiança mínima para retornar um rótulo. Aumentar o limite para 0,7 reduz o número de rótulos por quadro, mas aumenta a precisão de cada um. Para moderação de conteúdo, defina o limite como 0,8.

val labeler = ImageLabeling.getClient(
    ImageLabelerOptions.DEFAULT_OPTIONS
)

labeler.process(inputImage)
    .addOnSuccessListener { labels ->
        labels
            .filter { it.confidence >= 0.7f }
            .forEach { label ->
                log("Label: ${label.label}")
                log("Confidence: ${label.confidence}")
            }
    }
    .addOnFailureListener { error -> handleError(error) }

ML Kit no iOS: a API é semelhante ao Android, usando UIImage ou CMSampleBuffer. O ML Kit usa automaticamente Core ML + ANE em dispositivos A12+. Para iOS 16+, o ML Kit Image Labeling oferece latência de 8–15 ms no iPhone 15 Pro. Para minimizar a latência, passe a menor resolução de imagem possível (224x224 para MobileNet) — o ML Kit a redimensiona automaticamente, mas converter imagens grandes adiciona 2–5 ms de overhead.

Core ML e Vision Framework no iOS

Core ML é o framework da Apple para executar modelos de ML no dispositivo. Combinado com o Vision Framework (VNCoreMLRequest), o Core ML permite a classificação de imagens com o mínimo de código. A Apple fornece modelos integrados: SqueezeNet (5 MB, 80,5% top-1), ResNet50 (98 MB, 95,2%), MobileNetV2 (14 MB, 90,2%). Modelos no formato .mlmodel ou .mlpackage são convertidos via coremltools a partir do TensorFlow ou PyTorch.

VNCoreMLRequest é uma API do Vision que cuida do pré-processamento da imagem (redimensionamento, crop-to-fill, conversão de espaço de cor) e passa o resultado para o modelo. O Vision retorna VNClassificationObservation com identifier (nome da classe) e confidence (0..1). MaxCandidates é o número máximo de rótulos retornados (padrão 1). Para classificação com seleção automática, use VNCoreMLRequest com imageCropAndScaleOption = .centerCrop.

guard let model = try? VNCoreMLModel(for: MobileNetV2().model) else { return }
let request = VNCoreMLRequest(model: model) { request, _ in
    guard let results = request.results as? [VNClassificationObservation] else { return }
    results.prefix(5).forEach { obs in
        print("Rótulo: \(obs.identifier), Confiança: \(obs.confidence)")
    }
}
request.imageCropAndScaleOption = .centerCrop

let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
try handler.perform([request])

Core ML vs ML Kit no iOS: Core ML é nativo, não requer SDKs adicionais e é melhor otimizado para ANE (Neural Engine da Apple). ML Kit é mais preciso em cenas complexas graças aos modelos do Google. Core ML suporta qualquer modelo (convertido via coremltools), enquanto ML Kit suporta apenas os seus. Para implementação rápida, use ML Kit. Para máximo controle sobre o modelo, use Core ML. Uma abordagem prática: use ambos os frameworks em um único aplicativo — ML Kit para rótulos padrão, Core ML para personalizados.

Treinamento e integração de modelos personalizados

Modelos personalizados de Image Labeling — treinar seu próprio classificador para uma tarefa específica: reconhecer qualidade de frutas, detectar defeitos em uma linha de produção, classificar raças de cães. O processo inclui coleta de dataset (mais de 1000 imagens por classe), anotação, treinamento via transfer learning em uma MobileNetV2 ou EfficientNet pré-treinada, e conversão para TFLite / Core ML.

Transfer Learning — o método principal para treinar classificadores móveis. Pega-se um modelo pré-treinado no ImageNet, congelam-se as camadas inferiores (backbone CNN) e retreinam-se as camadas superiores (fine-tuning). Isso requer apenas 100–500 imagens por classe e leva de 1 a 2 horas no Google Colab (GPU). Bibliotecas: TensorFlow Keras (Android), PyTorch + coremltools (iOS). Resultado: 95–98% de precisão nas classes alvo.

// Inferência de modelo personalizado TFLite
val interpreter = Interpreter(loadModelFile(context))
val inputImage = TensorImage.fromBitmap(bitmap)
    .apply { load(Bitmap.createScaledBitmap(bitmap, 224, 224, true)) }

val output = Array(1) { FloatArray(NUM_CLASSES) }
interpreter.run(inputImage.tensorBuffer, output)

val probabilities = TensorLabel.mapIndexToLabels(output[0])
val topClass = probabilities.maxByOrNull { it.value }

ML Kit Custom Model API — uma alternativa: não é necessário escrever código para TFLite Interpreter — o ML Kit carrega o modelo e lida com o pré-processamento automaticamente. O Image Labeler personalizado aceita um modelo TFLite com tamanho de entrada 224x224x3 e saída score float[NUM_CLASSES]. Basta fornecer o arquivo do modelo e obter rótulos padrão. O ML Kit Custom Model API é recomendado se o modelo corresponder ao formato TFLite. Se for necessário um controle mais preciso sobre a inferência (limiares por classe), use o TFLite Interpreter diretamente.

TFLite e Core ML: comparação de formatos

TFLite (TensorFlow Lite) é o formato de modelos do Google para dispositivos móveis e de borda. Suporta quantização (FP16, INT8), que reduz o tamanho do modelo em 4x e aumenta a velocidade em 2–3x com uma pequena perda de precisão (1–2%). O TFLite funciona no Android via GPU Delegate (OpenGL/OpenCL) e no iOS via Core ML Delegate. A TFLite Task API fornece uma interface unificada para Image Classifier, Object Detector e outras tarefas.

Core ML é o formato da Apple (.mlpackage — novo, .mlmodel — legado). Suporta quantização (FP16) e paletização de pesos (até 1/2/4/6/8 bits), alcançando até 80% de compressão do modelo. O Core ML usa ANE (Neural Engine), GPU e CPU — o sistema seleciona automaticamente o motor ideal. Conversão do PyTorch via torch.onnx.export + coremltools, do TensorFlow via tf-keras + coremltools. O iOS 18+ suporta treinamento no dispositivo via Core ML Training API.

ONNX como formato intermediário: converta modelos para ONNX (PyTorch → ONNX, TensorFlow → ONNX) e depois para TFLite / Core ML via onnx2tf ou onnx2coreml. ONNX é um formato unificado suportado por mais de 70 frameworks. Isso simplifica o pipeline: um modelo treinado → ONNX → formatos nativos para ambas as plataformas. Treinamento em PyTorch + conversão para ONNX → TFLite (Android) / Core ML (iOS) é o pipeline recomendado para projetos multiplataforma.

Aplicações do Image Labeling em apps mobile

Marcação automática de fotos — aplicativos de galeria (Google Fotos, Apple Photos) atribuem automaticamente rótulos às imagens: “praia”, “pôr do sol”, “cachorro”, “comida”. O ML Kit Image Labeling processa cada foto da galeria em segundo plano — 1–2 segundos para 100 fotos (lote). O usuário obtém pesquisa por rótulos sem classificação manual. O Google Fotos usa classificação no dispositivo com verificação posterior no servidor para cenas complexas.

Moderação de conteúdo — detecção automática de imagens indesejadas em conteúdo gerado pelo usuário (redes sociais, marketplaces, plataformas UGC). O ML Kit Custom Model detecta conteúdo NSFW, violência e propaganda com 92–96% de precisão. O limite de acionamento é confiança 0,8. Para reduzir falsos positivos (imagens médicas legítimas), use um comitê de classificadores: Image Labeling + Object Detection + Blur Detection. A moderação no dispositivo é mais rápida e protege a privacidade do usuário.

Busca visual de produtos — um usuário fotografa um produto (tênis, bolsa, móvel), o aplicativo determina o rótulo e encontra produtos similares no catálogo. O Image Labeling reduz a busca a uma categoria, então descritores de características (vetores de características) encontram itens visualmente semelhantes. Pinterest Lens, Google Lens e Amazon StyleSnap usam essa abordagem. A classificação no dispositivo oferece resultados em 10–30 ms, a busca na nuvem em 200–500 ms.

// Image Labeling com Core ML para busca visual
let request = VNCoreMLRequest(model: productClassifier) { req, _ in
    guard let result = req.results?.first as? VNClassificationObservation,
          result.confidence > 0.6 else { return }
    SearchService.findSimilarProducts(
        category: result.identifier,
        image: capturedPhoto,
        limit: 10
    ) { products in
        DispatchQueue.main.async {
            self.showResults(products)
        }
    }
}

Aplicativos de RA e educacionais — o Image Labeling classifica objetos em tempo real através da câmera. Um usuário aponta o telefone para uma planta — o aplicativo mostra o nome, cuidados e rega. Aponta para uma peça mecânica — explica sua função. Requisito: latência inferior a 30 ms. O EfficientNet-Lite em dispositivos flagship oferece 15–25 ms. Com pouca luz, a precisão diminui — use um limite de confiança adaptativo (reduza o limite em condições de baixa iluminação para compensar a qualidade degradada da entrada).