Integração do Apple Core AI#

Core AI é o novo framework da Apple para executar redes neuronais diretamente em Apple silicon. Introduz o formato de modelo .aimodel, uma API moderna de inferência em Swift, ferramentas de conversão baseadas em PyTorch, compilação antecipada, especialização de modelos e ferramentas dedicadas de depuração e criação de perfis.

A Apple descreve o Core AI como a próxima evolução da execução de IA no dispositivo e como o framework de inferência subjacente ao Apple Intelligence no dispositivo. Foi concebido para arquiteturas de redes neuronais atuais, desde modelos compactos de visão até grandes modelos generativos, e pode agendar trabalho entre a CPU, a GPU e o Neural Engine da Apple (ANE).

O Core AI é uma nova via de implementação, e não um novo nome para o Core ML. Os frameworks utilizam formatos de modelo, ferramentas de conversão, APIs de runtime e padrões de integração com aplicações diferentes.

Comparação entre Core AI e Core ML#

O Core ML continua a ser a escolha adequada quando uma aplicação necessita de ampla cobertura de dispositivos, integração com o framework Vision ou tipos de modelos como árvores de decisão e pipelines tabulares. A Apple continua a oferecer suporte ao Core ML e encaminha para ele os programadores que utilizam tipos de modelos não neuronais.

Como funciona o formato Core AI#

O fluxo de criação do Core AI começa com um modelo PyTorch:

PyTorch model
    ↓ torch.export
ExportedProgram
    ↓ coreai-torch
Core AI program
    ↓ optimize and save
.aimodel
    ↓ specialize or compile ahead of time
Apple silicon executable

O pacote coreai-torch da Apple converte um torch.export.ExportedProgram, transformando as operações ATen do PyTorch em operações Core AI. As operações não suportadas podem ser implementadas com um lowering personalizado ou um kernel Metal personalizado.

O .aimodel resultante é um ativo de modelo não especializado. Quando uma aplicação prepara o modelo, o Core AI especializa-o para o dispositivo de destino. As aplicações podem permitir que isso aconteça na primeira utilização, solicitar a especialização antecipadamente ou distribuir um modelo compilado antecipadamente para reduzir o tempo de carregamento inicial.

Em Swift, as aplicações carregam o ativo com o framework Core AI, selecionam uma função de inferência, fornecem entradas NDArray tipadas e recebem saídas nomeadas. Isto é diferente de encapsular um modelo Core ML num pedido Vision, por isso a adoção do Core AI requer um runtime de aplicação concebido para ativos .aimodel.

Para obter detalhes de implementação, consulta a documentação da Apple sobre AIModel, especialização e colocação em cache de modelos e compilação antecipada.

Exportar modelos YOLO26 para Core AI#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="coreai")  # creates 'yolo26n.aimodel'
model.export(format="coreai", quantize=16)  # FP16 asset

# Run the exported model
coreai_model = YOLO("yolo26n.aimodel")
results = coreai_model("https://ultralytics.com/images/bus.jpg")

Para obter a lista completa de argumentos, consulta o modo de exportação. O grafo é estático: é traçado no imgsz fornecido a export, por isso faz previsões com esse mesmo tamanho. Os metadados do Ultralytics são transportados dentro do próprio metadata.json do ativo, por isso os nomes das classes, o stride e a tarefa sobrevivem à conversão de ida e volta.

Escolher a head#

Com nms=False, o YOLO26 exporta sua cabeça de ponta a ponta, que seleciona detecções dentro do grafo. O Core AI não tem nenhuma primitiva top-k, portanto essa seleção é convertida em uma ordenação completa e gera um custo fixo no limite da partição da Apple Neural Engine — cerca de 1,7 ms, independentemente de max_det. Exportar com nms=None emite as previsões brutas de (1, 84, 8400) em vez disso e deixa a supressão de não máximos para o preditor:

yolo export model=yolo26n.pt format=coreai nms=None quantize=16

Em um iPhone 17 Pro rodando o iOS 27.0, o YOLO26n em 640 mede 3,01 ms com a cabeça no grafo e 1,28 ms sem ela (FP16, compilado antecipadamente, três blocos intercalados de 50 iterações). Ambos passam por YOLO(...) para inferência. Usa nms=False quando uma única chamada de grafo precisar retornar detecções finalizadas, ou mantém o padrão nms=None para NMS externo.

No iOS 27 ou macOS 27, uma aplicação carregaria e executaria o ativo exportado através da API Swift Core AI da Apple. Os ativos exportados utilizam o ponto de entrada main, aceitam uma única entrada images com a forma [batch, 3, imgsz, imgsz] e devolvem output0:

import CoreAI

let modelURL = Bundle.main.url(forResource: "yolo26n", withExtension: "aimodel")!
let model = try await AIModel(contentsOf: modelURL)
guard let function = try model.loadFunction(named: "main") else {
    throw AppError.missingInferenceFunction
}

let outputs = try await function.run(inputs: ["images": imageTensor])

Ao contrário do fluxo atual com Core ML e Vision, a futura via Core AI terá de definir o pré-processamento de imagens, a construção de NDArray, os metadados do modelo e a descodificação das saídas no SDK Ultralytics para iOS. A Apple fornece detalhes atuais da API na documentação do framework Core AI e exemplos funcionais de modelos no repositório de modelos Core AI.

Vantagens do Core AI#

O Core AI oferece várias vantagens promissoras para futuras implementações do Ultralytics:

• Via moderna de exportação do PyTorch: A conversão começa com torch.export, preservando um grafo PyTorch mais expressivo do que o fluxo de tracing utilizado por muitos exportadores existentes.
• Controlo de runtime granular: As aplicações podem gerir a especialização, as caches de modelos compilados, as funções de inferência, a memória e a distribuição da computação.
• Suporte avançado a modelos: A execução com estado, formas dinâmicas, múltiplas funções num único artefacto e kernels Metal personalizados foram concebidos para arquiteturas modernas de visão e generativas.
• Ferramentas dedicadas para programadores: O Core AI Debugger pode inspecionar grafos e valores de tensores e rastreá-los até ao código Python de origem. O Xcode e o Instruments fornecem criação de perfis de runtime.
• Oportunidades de cópia zero: O Core AI expõe controlos de armazenamento e buffers destinados a reduzir cópias entre cargas de trabalho da câmara, dos gráficos e da inferência.
• Otimização para Apple silicon: A especialização no dispositivo permite à Apple otimizar um modelo para a CPU, a GPU e o Neural Engine disponíveis no dispositivo específico.
• Compressão flexível: As ferramentas Core AI Optimization da Apple suportam quantização, paletização e pruning, incluindo formatos de pesos com poucos bits.

Estas capacidades podem ser particularmente úteis para futuros modelos YOLO com execução dinâmica, componentes multimodais maiores ou operações personalizadas que não correspondam adequadamente às operações Core ML existentes.

Desvantagens e limitações atuais#

Atualmente, o Core AI não substitui a via Core ML de produção:

• São necessários sistemas operativos novos: O framework público destina-se à geração do iOS 27 e macOS 27, enquanto o Core ML suporta uma base instalada muito maior.
• Software beta: O framework Core AI da Apple e partes da sua toolchain Python ainda são preliminares e podem mudar antes dos lançamentos estáveis.
• Ambiente de exportação mais restrito: coreai-torch requer atualmente Python 3.11 ou posterior, mas inferior a 3.14, além de versões recentes do PyTorch, o que é muito mais restrito do que o intervalo de Python e PyTorch suportado pelo Ultralytics.
• A exportação é executada apenas no macOS: coreai-core publica apenas wheels macosx_26_0_arm64, por isso format=coreai requer um Mac com Apple silicon e macOS 26 ou posterior.
• Ainda não existe um runtime de aplicação Ultralytics: A aplicação YOLO oficial para iOS e o plugin Flutter carregam atualmente artefactos Core ML através de MLModel e do Vision.
• É necessária uma migração da aplicação: Não é possível substituir um .aimodel por um .mlpackage; o carregamento do modelo, o pré-processamento, as chamadas de inferência, o tratamento dos metadados e a descodificação das saídas requerem uma implementação Core AI.
• Evidência de produção limitada: O desempenho, o consumo de energia, o tempo de especialização na primeira execução, a precisão e a compressão precisam de ser validados em toda a matriz de tarefas YOLO e dispositivos suportados.
• Pipeline sem NMS: O CoreML pode empacotar um estágio de NMS para modelos de detecção YOLO mais antigos. O Core AI exporta previsões brutas de um para muitos por padrão; usa nms=False para a cabeça sem NMS do YOLO26. NMS embutido (nms=True) e dynamic=True não são suportados. coreai-torch não possui conversão para torchvision::nms, portanto o NMS permanece no host.
• Tamanho de entrada fixo: O grafo exportado é traçado num único imgsz e não tem formas dinâmicas, por isso faz previsões com o tamanho utilizado na exportação.
• Os ativos FP16 podem abortar durante o carregamento: Alguns ativos FP16 .aimodel não conseguem carregar o seu programa do Neural Engine da Apple e o MPSGraph gera uma asserção falhada, o que encerra o processo em vez de fazer fallback. Isto acontece dentro do runtime da Apple, antes de qualquer código do Ultralytics ser executado, e o mesmo ativo é carregado com uma especialização apenas para CPU. Prefere FP32 até que o problema seja corrigido a montante.

Que formato Apple deves utilizar?#

Utiliza Core ML hoje quando precisares de:

• Implementação em sistemas operativos Apple atuais e mais antigos
• Integração com o SDK Ultralytics para iOS ou Flutter
• Gestão de imagens através do framework Vision
• Implementação YOLO FP16 e INT8 testada
• NMS incorporado para modelos de deteção legados compatíveis

Avalia o Core AI quando puderes exigir iOS 27 ou macOS 27 e precisares de:

• O mais recente runtime de redes neuronais da Apple no dispositivo
• Gestão explícita da especialização e da cache
• Execução avançada de modelos dinâmicos ou com estado
• Operações Core AI personalizadas ou kernels Metal
• Depuração detalhada de grafos Core AI e criação de perfis de runtime

É esperado que o Core ML e o Core AI coexistam enquanto as aplicações fazem a transição. O suporte ao Core AI não elimina imediatamente a necessidade do Core ML, porque os seus destinos de implementação e contratos de aplicação são diferentes.

Roteiro do Ultralytics#

O destino de exportação dedicado coreai está implementado: a exportação e a validação numérica abrangem os modelos de tarefas YOLO26 suportados e são executadas continuamente no CI do Ultralytics no macOS 26, enquanto a latência FP16 é medida no dispositivo. O roteiro restante antes de o Core AI alcançar paridade com a via Core ML:

1. Carregamento de modelos Core AI e pré-processamento no SDK Ultralytics para iOS.
2. Integração com Flutter e uma estratégia de compatibilidade para dispositivos abaixo do iOS 27.
3. Lançamentos estáveis do framework Apple e das ferramentas de conversão (a geração do iOS 27 e macOS 27 está atualmente em beta).
4. Benchmarks de memória, energia e especialização em toda a matriz de dispositivos suportados.

O Core ML continua a ser o destino recomendado para aplicações que necessitam do SDK Ultralytics para iOS ou Flutter ou de cobertura abaixo do iOS 27; acompanha o roteiro do Ultralytics e as notas de lançamento para os itens restantes.

Recursos adicionais#

• Visão geral do Apple Core AI
• Documentação do framework Core AI
• Extensões Core AI para PyTorch
• Core AI Optimization
• Repositório de modelos Apple Core AI
• Integração do Ultralytics Core ML

Perguntas frequentes#