Vision Framework da Apple: O que já vem pronto e que a maioria dos devs busca em APIs na nuvem

O framework Vision da Apple, aquele sem o sufixo “OS”, oferece mais de duas dúzias de operações de visão computacional executadas no próprio dispositivo. A maioria dos desenvolvedores iOS recorre por padrão à API OpenAI Vision, ao Google Cloud Vision ou ao AWS Rekognition para tarefas que o framework executa em microssegundos no Neural Engine do dispositivo. Esse padrão reflete mais um viés do que uma avaliação: APIs na nuvem parecem “IA moderna” e o Vision parece “encanamento de plataforma”, então a plataforma é deixada de lado. Esse viés interpreta mal o que a plataforma agora contém.

O Vision é o framework de CV local-first. Ele roda no Neural Engine quando disponível, na GPU quando não, e na CPU como último recurso. A inferência acontece em poucos milissegundos para a maioria das operações. O framework não custa nada por chamada. Os dados nunca saem do dispositivo. A chave de API não existe porque nenhuma API existe. Para a maior parte do trabalho de visão computacional que um app iOS faz, esta é a ferramenta certa.

TL;DR

• O Apple Vision oferece mais de duas dúzias de operações de CV no dispositivo: reconhecimento de texto, detecção de rostos e marcos faciais, estimativa de pose corporal e de mãos, leitura de códigos de barras, segmentação de documentos, embeddings de imagem, saliência, detecção de animais, contornos, trajetórias, fluxo óptico e um runner para qualquer modelo Core ML.
• Cada operação roda em milissegundos no Neural Engine, não custa nada por chamada, não exige rede e não produz telemetria de terceiros.
• APIs na nuvem ganham em um caso específico: raciocínio semântico complexo sobre uma imagem (um LLM multimodal entendendo um gráfico, um meme ou a intenção de um documento). Para operações em nível de pixel (encontrar rostos, ler texto, detectar uma mão), o Vision ganha em custo, latência e privacidade.
• A conexão com workflows de agentes: os resultados do Vision alimentam App Intents e chamadas de LLM no dispositivo via Foundation Models sem um round-trip de rede. Toda a pipeline roda localmente.

O que o Vision realmente contém

O Vision agrupa suas operações como tipos VNRequest. Uma request é criada, configurada com parâmetros, alimentada com uma imagem (ou CVPixelBuffer, ou CIImage, ou CGImage, ou URL) e executada. Os resultados retornam como observações anexadas à request. As categorias abaixo cobrem o território do framework no iOS 26.

Reconhecimento de texto

VNRecognizeTextRequest realiza OCR. A request suporta recognitionLevel (.fast para streams de câmera ao vivo, .accurate para digitalização de documentos), dicas de idioma, listas de palavras personalizadas e confiança da bounding-box. O caminho accurate no iOS 18+ rivaliza com APIs comerciais de OCR em recibos, placas e documentos impressos; o reconhecimento de escrita à mão é suportado em vários idiomas.

let request = VNRecognizeTextRequest { request, error in
    guard let observations = request.results as? [VNRecognizedTextObservation] else { return }
    let lines = observations.compactMap { $0.topCandidates(1).first?.string }
    print(lines.joined(separator: "\n"))
}
request.recognitionLevel = .accurate
request.usesLanguageCorrection = true
request.recognitionLanguages = ["en-US"]

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

A mesma operação pela API OpenAI Vision custa aproximadamente uma fração de centavo por chamada no modo low-detail e significativamente mais no modo high-detail, leva de 1 a 3 segundos round-trip e envia a imagem para os servidores da OpenAI. O Vision retorna resultados em 100-300 ms localmente, gratuitamente, sem exfiltração de dados.

Detecção de rostos e marcos faciais

Três camadas de análise facial vêm no Vision:

• VNDetectFaceRectanglesRequest retorna bounding boxes para cada rosto no quadro.
• VNDetectFaceLandmarksRequest retorna regiões de marcos estruturados por rosto (linha do queixo, boca, olhos, sobrancelhas, nariz, pupilas), cada uma com vários keypoints.
• VNDetectFaceCaptureQualityRequest retorna uma pontuação de qualidade que o app Câmera usa para temporizar a captura de selfies.

Para a maioria dos apps que precisam encontrar rostos, recortar para rostos, desfocar rostos ou contar rostos, a request de retângulos é a ferramenta certa. Para apps que animam algo no rosto do usuário (filtros, máscaras, tracking), os marcos mais o tracking de pupilas são a ferramenta certa. Nada disso exige um arquivo de modelo ou uma chamada de rede.

Pose corporal e de mãos

VNDetectHumanBodyPoseRequest retorna as 19 articulações nomeadas em VNHumanBodyPoseObservation.JointName⁴ (nariz, pescoço, ombros, cotovelos, pulsos, quadris, joelhos, tornozelos, orelhas, olhos, raiz) com coordenadas 2D e confiança por articulação. VNDetectHumanBodyPose3DRequest estende a topologia para o espaço 3D em dispositivos com LiDAR Scanner. VNDetectHumanHandPoseRequest retorna 21 marcos da mão na resolução de articulações dos dedos.

A pose corporal é o que apps fitness usam para contar repetições sem um wearable, o que apps AR usam para anexar conteúdo virtual às mãos do usuário e o que apps de postura usam para avaliar a forma. A pose das mãos alimenta o reconhecimento de gestos (o usuário levanta dois dedos, o app vê dois dedos). Ambas rodam a 60 fps em um Neural Engine de iPhone recente. Os equivalentes na nuvem são o Google MediaPipe ou APIs proprietárias de fitness-tech, que o framework substitui.

Códigos de barras e QR

VNDetectBarcodesRequest lê as simbologias que a maioria dos workflows de varejo e inventário precisa (QR, PDF417, Aztec, Code 128, Code 39, EAN-13, ITF14, Data Matrix, GS1 DataBar e mais) e retorna o payload bruto mais o retângulo delimitador. A detecção roda em milissegundos e funciona em condições de baixa luminosidade que o app Câmera da Apple já valida.

Segmentação de documentos

VNDetectDocumentSegmentationRequest encontra documentos retangulares em um quadro e retorna seus pontos de canto, levando em conta a perspectiva. A request é o que apps scanner de documentos usam para recortar e retificar o documento em uma imagem plana. O próprio framework VisionKit da Apple envolve a request mais uma UI, mas a operação subjacente pode ser chamada diretamente quando um app precisa de UI personalizada.

Saliência e estética

VNGenerateAttentionBasedSaliencyImageRequest retorna um heatmap de onde a atenção do espectador provavelmente vai focar em uma imagem. VNGenerateObjectnessBasedSaliencyImageRequest retorna um heatmap de onde os objetos estão. VNCalculateImageAestheticsScoresRequest, adicionada como API pública no iOS 18¹, retorna pontuações de qualidade estética incluindo uma classificação de utilidade (memos, capturas de tela) e um valor estético. As pontuações são o que o Fotos usa para destacar candidatos a “Memória” e o que alimenta decisões de auto-recorte.

Classificação de imagem e embeddings

VNClassifyImageRequest retorna os top-N rótulos de categoria para uma imagem usando um classificador interno (mais de 1.000 categorias de um modelo treinado em dados em escala web). VNGenerateImageFeaturePrintRequest retorna um vetor de features (o embedding do modelo) adequado para busca de similaridade de imagens.

Embeddings são como um app de Fotos, o “encontre pratos similares” de um app de receitas ou a deduplicação por similaridade de um app de moodboard realmente funcionam. O equivalente na nuvem é embeddings da OpenAI CLIP ou o Vertex AI do Google; o Vision os retorna localmente e de graça.

Tracking de objetos e trajetórias

VNDetectTrajectoriesRequest rastreia objetos em movimento entre quadros e retorna ajustes de trajetória parabólica (uma bola lançada, uma flecha disparada). VNTrackObjectRequest segue um objeto delimitado manualmente ao longo de uma sequência de vídeo.

Trajetórias são a primitiva subjacente para apps esportivos (rastrear uma bola de baseball, basquete, tênis). A detecção funciona em um stream AVFoundation ao vivo e retorna resultados em tempo real.

Modelos personalizados via VNCoreMLRequest

VNCoreMLRequest roda qualquer modelo Core ML pela pipeline do Vision. A request lida com preprocessamento (redimensionamento da imagem, conversão de espaço de cores, normalização) automaticamente com base na descrição de entrada do modelo. Um app treina um classificador personalizado no Create ML (algumas categorias, cem imagens de amostra por categoria, dez minutos de treinamento) ou baixa um modelo publicado, coloca o .mlpackage no bundle do app e o roda pelo Vision com três linhas de código.

let model = try VNCoreMLModel(for: MyClassifier(configuration: .init()).model)
let request = VNCoreMLRequest(model: model) { request, error in
    let results = request.results as? [VNClassificationObservation]
    print(results?.first?.identifier, results?.first?.confidence)
}
let handler = VNImageRequestHandler(cgImage: image, options: [:])
try handler.perform([request])

O equivalente na nuvem para um classificador personalizado é hospedar o modelo em um servidor, pagar pela computação de inferência, gerenciar a API e aceitar a latência da rede. O Vision transforma isso em um .mlpackage no bundle do app e um request handler.

Onde APIs na nuvem realmente ganham

O território do Vision são operações em nível de pixel: encontrar essa coisa, classificar essa imagem, reconhecer esse texto. O framework não fornece raciocínio semântico complexo sobre o significado de uma imagem. Três casos onde APIs na nuvem são a escolha certa:

Compreensão de LLM multimodal. “O que essa pessoa está fazendo nessa imagem?” “Esse gráfico é enganoso?” “Traduza esse cardápio e me diga quais itens são vegetarianos.” Nenhuma dessas é uma pergunta em nível de pixel. Elas exigem um grande modelo multimodal para combinar percepção visual com conhecimento de mundo e linguagem. O Foundation Models da Apple (o LLM no dispositivo, abordado em Foundation Models on-device LLM) está começando a lidar com parte disso no dispositivo, mas para raciocínio complexo, GPT-4o, Claude Sonnet ou Gemini ainda ganham.

Tarefas personalizadas one-shot sem dados de treinamento. O modelo de classificação do Vision é fixo; modelos Core ML personalizados exigem dados de treinamento. Um LLM multimodal pode responder “isso é uma foto de um gato com gravata-borboleta?” sem ver um único exemplo de treinamento rotulado. Para prototipagem ou tarefas pontuais onde coletar dados de treinamento é caro demais, LLMs na nuvem são a ferramenta certa.

Inteligência de documentos além do OCR. O OCR do Vision retorna texto. Uma API de inteligência de documentos (AWS Textract, Google Document AI, Azure Form Recognizer) retorna campos estruturados: número da nota, data, itens, totais. A estruturação é o valor agregado, não o OCR. Para workflows de documentos de alto valor, as APIs na nuvem geralmente são as certas; para “leia esse recibo e despeje o texto”, o Vision é.

O padrão: a nuvem ganha em raciocínio e em APIs verticais altamente especializadas; o Vision ganha em primitivas de percepção.

Comparação honesta de latência e custo

Uma pipeline de inferência representativa rodando em iPhone 16 Pro (chip A18 Pro):

Os números acima são derivados de benchmarks públicos da Apple e medições reportadas por desenvolvedores; a mensagem é a ordem de magnitude, não o número exato. As vitórias do Vision estão em custo (zero por chamada), em latência de cauda (sem jitter de rede) e em privacidade (os dados nunca saem do dispositivo).

O custo se acumula quando um app chama operações de visão com frequência. Um app de edição de fotos processando 100 imagens por sessão custa na ordem de dólares por sessão via APIs na nuvem e zero via Vision.

A conexão com workflows de agentes

O Vision combina perfeitamente com duas ideias do cluster já lançadas:

App Intents tools para Apple Intelligence. Quando o app expõe uma capacidade “Encontrar rostos nas minhas fotos” ou “Ler texto da captura de tela” através de um AppIntent, o método perform da intent roda o Vision localmente e retorna um resultado estruturado. O orquestrador da Apple Intelligence pode chamar a intent sem enviar a foto do usuário para um servidor. O post sobre App Intents percorre o contrato de superfície.

Foundation Models on-device LLM. Uma pipeline que precisa tanto de percepção quanto de raciocínio roda primeiro o Vision (extrai texto, encontra rostos, localiza objetos) e depois o Foundation Models (raciocina sobre o que foi encontrado, gera um resumo). Ambos os estágios rodam no dispositivo. Total de chamadas de rede: zero. O post sobre Foundation Models explica como chamar o LLM; este post argumenta que o Vision é o que o alimenta sem um round-trip pela nuvem.

let textRequest = VNRecognizeTextRequest()
textRequest.recognitionLevel = .accurate

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

let extractedText = (textRequest.results ?? [])
    .compactMap { ($0 as? VNRecognizedTextObservation)?.topCandidates(1).first?.string }
    .joined(separator: "\n")

let llmResponse = await foundationModel.generate(
    "Summarize this receipt as JSON with merchant, total, and date fields:\n\(extractedText)"
)

Toda a pipeline roda no dispositivo. Sem chave de API. Sem chamada de rede. Sem exposição de dados a terceiros.

O que amadureceu nos últimos dois lançamentos

Três adições que valem ser nomeadas, com datação conservadora contra as release notes da Apple²:

Pontuação estética como API pública (iOS 18). VNCalculateImageAestheticsScoresRequest retorna pontuações incluindo classificação de utilidade e valor estético, substituindo o que apps de curadoria de fotos antes tinham que aproximar com modelos Core ML personalizados.

OCR multilíngue aprimorado. VNRecognizeTextRequest expandiu seu suporte a scripts não-latinos ao longo dos lançamentos recentes, estreitando a distância em relação a serviços de OCR na nuvem que historicamente tinham cobertura multilíngue mais forte. A documentação de reconhecimento de texto da Apple lista o suporte de idiomas atual³.

Segmentação de documentos com integração VisionKit. VNDetectDocumentSegmentationRequest encontra documentos retangulares e retorna pontos de canto; o DataScannerViewController do VisionKit envolve a request com uma UI projetada para digitalização ao vivo de documentos.

As capacidades principais do framework (rosto, texto, pose, código de barras, embeddings) estão maduras há vários lançamentos do iOS. O padrão: estender em vez de reinventar.

Por que a maioria dos desenvolvedores ignora o Vision

Três razões pelas quais o framework é ignorado apesar de o caso ser claro:

Hábito cloud-first. A maior parte do desenvolvimento moderno de IA acontece primeiro contra APIs na nuvem. Os desenvolvedores sabem chamar a OpenAI; a área de superfície de VNRecognizeTextRequest mais VNImageRequestHandler mais VNRecognizedTextObservation parece mais API a aprender pelo que é, na prática, menos linhas de código.

Avaliação errada da capacidade. Desenvolvedores que não conferiram o framework recentemente assumem que ele cobre apenas OCR e códigos de barras. A lista de categorias acima é mais de uma dúzia de capacidades, várias das quais não têm equivalente cloud-native e várias das quais igualam APIs comerciais sem o custo.

Divergência entre protótipo e produção. APIs na nuvem ganham na prototipagem inicial (um comando curl para obter um resultado), e o protótipo é transformado em pipeline de produção sem uma reavaliação. O movimento certo é prototipar com o que for mais rápido e reavaliar a camada de percepção quando o workflow for real.

A correção não é recusar APIs na nuvem; a correção é saber o que a plataforma contém para que a escolha seja real.

O que esse padrão significa para apps iOS 26+

Três conclusões.

1. Use Vision por padrão para primitivas de percepção. Encontrar rostos, ler texto, detectar códigos de barras, rodar estimativa de pose, obter embeddings de imagem. O framework roda em microssegundos no Neural Engine, custa zero, não deixa rastro de dados a terceiros. Para operações de CV em nível de pixel, o framework é o ponto de partida certo.

2. Use APIs na nuvem para raciocínio, não percepção. Um LLM multimodal entendendo o significado de uma imagem, uma API vertical de inteligência de documentos extraindo campos estruturados, uma tarefa personalizada one-shot sem dados de treinamento. Esse é o território da nuvem; cedê-lo à nuvem está correto.

3. Combine Vision com Foundation Models para pipelines totalmente no dispositivo. Percepção (Vision) alimenta raciocínio (LLM no dispositivo). A pipeline roda localmente de ponta a ponta, sem chaves de API, sem jitter de rede e sem telemetria saindo do dispositivo. O post de Foundation Models do cluster cobre a metade do LLM; o Vision é a metade da entrada.

O cluster completo do Apple Ecosystem: App Intents tipados; servidores MCP; a questão do roteamento; Foundation Models; a distinção runtime vs tooling LLM; três superfícies; o padrão single source of truth; Two MCP Servers; hooks para desenvolvimento Apple; Live Activities; o contrato de runtime do watchOS; internals do SwiftUI; o modelo mental espacial do RealityKit; disciplina de schema do SwiftData; padrões Liquid Glass; shipping multiplataforma; a matriz da plataforma; sobre o que me recuso a escrever. O hub está na Série Apple Ecosystem. Para o contexto mais amplo de iOS-com-AI-agents, veja o guia iOS Agent Development.

FAQ

Qual é a diferença entre Apple Vision e visionOS?

O framework Vision é a API de visão computacional no dispositivo para iOS, macOS e visionOS. visionOS é o sistema operacional do Apple Vision Pro. A sobreposição de nomenclatura é infeliz. O Vision (o framework) roda em todo dispositivo Apple moderno; o visionOS (o SO) roda especificamente no hardware do Vision Pro.

Quando devo usar o Vision em vez da API OpenAI Vision ou do Google Cloud Vision?

Para tarefas de percepção em nível de pixel (encontrar rostos, ler texto, detectar objetos, contar itens, estimar pose, gerar embeddings de imagem), o Vision quase sempre é a escolha certa. Ele roda em milissegundos, não custa nada por inferência e mantém os dados do usuário no dispositivo. APIs na nuvem são certas quando a tarefa exige raciocínio semântico complexo sobre o significado de uma imagem, ou quando uma API vertical de inteligência de documentos fornece campos estruturados além da extração de texto.

Posso rodar meu próprio modelo Core ML pelo Vision?

Sim. VNCoreMLRequest envolve qualquer modelo Core ML e lida com o preprocessamento automaticamente. Coloque o arquivo .mlpackage no bundle do app, instancie o modelo, envolva-o em um VNCoreMLModel e rode-o por um request handler. O mesmo handler pode rodar várias requests em paralelo, incluindo as requests embutidas do Vision e o modelo Core ML personalizado.

Como funciona o dispatch do Vision no Apple Silicon?

O Vision (e os modelos Core ML que ele roda) faz dispatch automaticamente para o Neural Engine quando disponível, recorre à GPU quando não, e à CPU como último recurso. O framework escolhe o caminho mais rápido para o dispositivo e a operação. Para a maioria dos iPhones modernos (A12 Bionic e posteriores), o Neural Engine lida com o grosso da inferência; o desenvolvedor não configura o dispatch manualmente.

O que foi adicionado recentemente?

O resumo conservador, datado contra as release notes da Apple: VNCalculateImageAestheticsScoresRequest foi adicionada como API pública no iOS 18; VNRecognizeTextRequest expandiu o suporte multilíngue ao longo de lançamentos recentes; o DataScannerViewController do VisionKit envolve a digitalização de documentos em uma UI projetada. As capacidades principais (texto, rosto, pose, códigos de barras, embeddings) estão maduras há vários lançamentos do iOS.

Referências