Integração com o Apple Core AI#

Core AI é a nova 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 a framework de inferência subjacente ao Apple Intelligence no dispositivo. Foi concebido para arquiteturas de redes neuronais atuais, desde modelos de visão compactos a grandes modelos generativos, e pode agendar trabalho entre a CPU, a GPU e o Apple Neural Engine (ANE).

O Core AI é uma nova opção de implementação, não um novo nome para o Core ML. As frameworks usam 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 precisa de ampla compatibilidade com dispositivos, integração com a framework Vision ou tipos de modelos como árvores de decisão e pipelines tabulares. A Apple continua a dar suporte ao Core ML e encaminha para ele os programadores que usam 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 operações PyTorch ATen 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 recurso 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 deixar que isso aconteça na primeira utilização, pedir a especialização com antecedência ou distribuir um modelo compilado antecipadamente para reduzir o tempo de carregamento inicial.

Em Swift, as aplicações carregam o recurso com a framework Core AI, selecionam uma função de inferência, fornecem entradas NDArray tipadas e recebem saídas nomeadas. Isto difere 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 recursos .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")  # cria 'yolo26n.aimodel'
model.export(format="coreai", quantize=16)  # FP16 asset

# Executar o modelo exportado
coreai_model = YOLO("yolo26n.aimodel")
results = coreai_model("https://ultralytics.com/images/bus.jpg")

Para ver a lista completa de argumentos, consulta o modo de exportação. O grafo é estático: é rastreado com o imgsz fornecido a export, por isso faz previsões com esse mesmo tamanho. Os metadados da Ultralytics são incluídos no próprio metadata.json do recurso, para que os nomes das classes, o stride e a tarefa sejam preservados na conversão de ida e volta.

Escolher a head#

Com nms=False, o YOLO26 exporta a sua head end-to-end, que seleciona as deteções dentro do grafo. O Core AI não tem uma primitiva top-k, pelo que essa seleção é convertida numa ordenação completa e tem um custo fixo na fronteira da partição do Apple Neural Engine — cerca de 1,7 ms, independentemente de max_det. A exportação com nms=None emite, em vez disso, as previsões (1, 84, 8400) em bruto e deixa a supressão não máxima a cargo do preditor:

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

Num iPhone 17 Pro com iOS 27.0, o YOLO26n a 640 mede 3,01 ms com a head no grafo e 1,28 ms sem ela (FP16, compilado antecipadamente, três blocos intercalados de 50 iterações). Em ambos os casos, a inferência faz a conversão de ida e volta através de YOLO(...). Usa nms=False quando uma única chamada ao grafo tiver de devolver deteções finalizadas, ou mantém o nms=None predefinido para NMS externa.

No iOS 27 ou macOS 27, uma aplicação carregaria e executaria o recurso exportado através da API Swift Core AI da Apple. Os recursos exportados usam o ponto de entrada main, recebem uma única entrada images com a forma [batch, 3, imgsz, imgsz] e devolvem output0 (os modelos de segmentação de instâncias também devolvem output1):

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 de trabalho atual com Core ML e Vision, a opção Core AI no SDK para iOS da Ultralytics executa o pré-processamento letterbox e a criação de NDArray, lê os mesmos metadados da Ultralytics em metadata.json do recurso e reutiliza os descodificadores de saída do Core ML. O carregamento é ativado quando uma aplicação fornece um caminho .aimodel ou um URL .aimodel.zip. A Apple disponibiliza detalhes atuais da API na documentação da framework Core AI e exemplos funcionais de modelos no repositório de modelos Core AI.

Desempenho medido#

Inferência de ponta a ponta de uma única imagem para as exportações YOLO26n FP16 (quantize=16) Core ML e Core AI com o cabeçalho bruto padrão (nms=None) em um Mac mini com Apple M4 (4 núcleos de CPU de desempenho e 6 de eficiência, GPU de 10 núcleos, Neural Engine de 16 núcleos), 16 GB de memória e macOS 27.0, usando ultralytics 8.4.168, coremltools 9.0 para inferência Core ML e coreai-torch 0.4.3 com coreai-core 1.0.0b3 para inferência Core AI em Python 3.13. Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento), com a divisão por etapa logo abaixo.

• Os valores de velocidade são latências de rajada para uma única imagem: a média de 15 chamadas predict após 3 chamadas de aquecimento em bus.jpg, por meio da API Python da Ultralytics, com cada modelo e unidade de computação em um processo novo. A ordem entre CPU e acelerador foi alternada entre as tarefas em uma única execução sequencial. As linhas Core ML carregam com coremltools.ComputeUnit.CPU_ONLY ou CPU_AND_NE; as linhas Core AI são especializadas com SpecializationOptions.cpu_only() ou SpecializationOptions.from_preferred_compute_unit_kind(ComputeUnitKind.neural_engine()), e o posicionamento final das operações é controlado por cada framework.
• Detecção, segmentação, classificação, pose e OBB retornaram as mesmas previsões nos dois formatos em todas as unidades de computação. Neste Mac, o modelo semântico FP16 Core ML é mais lento com o Neural Engine como opção preferencial do que somente com a CPU, e o pós-processamento semântico do Core AI leva de 6.4 a 7.4 ms, contra 0.4 ms do Core ML.
• Compare os resultados no dispositivo do iPhone 17 Pro na integração CoreML.

Vantagens do Core AI#

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

• Fluxo moderno de exportação PyTorch: A conversão começa em torch.export, preservando um grafo PyTorch mais expressivo do que o fluxo de rastreamento usado por muitos exportadores existentes.
• Controlo granular do runtime: As aplicações podem gerir a especialização, as caches de modelos compilados, as funções de inferência, a memória e a alocação de computação.
• Suporte avançado a modelos: A execução com estado, as formas dinâmicas, várias funções num único artefacto e os 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 permitem criar perfis de runtime.
• Possibilidades de cópia zero: O Core AI disponibiliza controlos de armazenamento e buffers concebidos para reduzir cópias entre cargas de trabalho de câmara, gráficos e 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 nesse 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 se adaptem bem às operações Core ML existentes.

Desvantagens e limitações atuais#

Atualmente, o Core AI não substitui o fluxo de produção com Core ML:

• Requer sistemas operativos novos: A framework pública destina-se à geração iOS 27 e macOS 27, enquanto o Core ML é compatível com uma base instalada muito maior.
• Software beta: A framework Core AI da Apple e partes da sua cadeia de ferramentas Python ainda são preliminares e podem mudar antes das versões estáveis.
• Ambiente de exportação mais restrito: Atualmente, coreai-torch requer Python 3.11 a 3.14, além de versões recentes do PyTorch, o que é muito mais restrito do que o intervalo de versões de Python e PyTorch suportado pela Ultralytics.
• Plataformas de exportação limitadas: coreai-core publica apenas wheels macosx_26_0_arm64 e manylinux_2_34_x86_64, então format=coreai requer um Mac com Apple silicon executando macOS 26 ou posterior, ou Linux x86_64 com glibc 2.34 ou posterior (por exemplo, Ubuntu 22.04+). Para executar um .aimodel, ainda é necessário ter hardware da Apple.
• Opção disponível, mas não predefinida, nos SDKs da Ultralytics: Num iPhone 17 Pro, a comparação no dispositivo mostra que o Core AI está ao nível do Core ML no pipeline completo, e não à frente; a inferência semântica, de profundidade e apenas com CPU é mais lenta, e os recursos FP16 têm um tamanho de transferência cerca do dobro. Por isso, o SDK para iOS e o plugin Flutter mantêm o Core ML como opção predefinida.
• Usa a head em bruto nos SDKs: Com nms=False, o YOLO26n demora cerca do dobro no Core AI em comparação com o Core ML (3,06 contra 1,53 ms numa execução de comparação), e o modelo de pose end-to-end FP16 não deteta nada com a alocação predefinida do Core AI no iOS 27.0 (apple/coreai-torch#115). A head em bruto (nms=None, a opção predefinida) evita ambos os problemas, e os SDKs executam NMS em Swift. Consulta Escolher a head.
• Sem runtime do iOS Simulator: O SDK do iOS Simulator não inclui o Core AI.
• É necessária a 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 de metadados e a descodificação da saída requerem uma implementação Core AI fora dos SDKs da Ultralytics, que já disponibilizam uma.
• Evidências de produção limitadas: É necessário validar o desempenho, o consumo de energia, o tempo de especialização na primeira execução, a precisão e a compressão em toda a matriz de dispositivos e tarefas YOLO suportadas.
• Sem pipeline NMS: O Core ML pode incluir uma etapa NMS para modelos de deteção YOLO antigos. Por predefinição, as exportações Core AI produzem previsões em bruto de um para muitos; usa nms=False para a head sem NMS do YOLO26. NMS integrada (nms=True) e dynamic=True não são suportados. coreai-torch não tem lowering para torchvision::nms, pelo que a NMS é executada no host.
• Tamanho de entrada fixo: O grafo exportado é rastreado com um único imgsz e não tem formas dinâmicas; por isso, faz previsões com o tamanho usado na exportação.
• Os recursos FP16 podem provocar uma falha ao carregar: Alguns recursos .aimodel FP16 não conseguem carregar o respetivo programa Apple Neural Engine, e o MPSGraph gera uma asserção falhada que termina o processo em vez de recorrer a uma alternativa. Isto acontece dentro do runtime da Apple, antes de qualquer código da Ultralytics ser executado, e o mesmo recurso carrega com uma especialização apenas para CPU. Usa FP32 como alternativa se isto acontecer com um recurso; os recursos FP16 do SDK testados num iPhone 17 Pro (todos os modelos nano, deteção em todos os tamanhos e o maior modelo de cada tarefa) foram carregados sem falhas.

Que formato Apple deves usar?#

Usa Core ML hoje quando precisares de:

• Implementação em sistemas operativos Apple atuais e antigos
• A opção predefinida do SDK para iOS ou Flutter da Ultralytics
• Tratamento de imagens com a framework Vision
• Implementação YOLO FP16 e INT8 testada
• NMS integrada para modelos de deteção antigos compatíveis

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

• O runtime mais recente da Apple para redes neuronais no dispositivo
• Gestão explícita da especialização e das caches
• 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

Espera-se que Core ML e Core AI coexistam durante a transição das aplicações. O suporte ao Core AI não elimina imediatamente a necessidade do Core ML, porque os respetivos destinos de implementação e contratos de aplicação são diferentes.

Roteiro da 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 na CI da Ultralytics em macOS 26; a latência FP16 é medida no dispositivo. O que falta no roteiro para que o Core AI alcance a paridade com o fluxo Core ML:

1. Reduzir a diferença de latência da head end-to-end no Apple Neural Engine (apple/coreai-torch#66) e resolver os problemas de correção do Neural Engine (apple/coreai-torch#115, #116).
2. Recursos Core AI INT8 e paletizados; os recursos do SDK são FP16 e têm um tamanho de transferência cerca do dobro dos recursos Core ML INT8.
3. Versões estáveis da framework e das ferramentas de conversão da Apple (a geração iOS 27 e macOS 27 está atualmente em beta).
4. Benchmarks de memória, consumo de energia e especialização em toda a matriz de dispositivos suportados.

O SDK para iOS da Ultralytics e o plugin Flutter carregam Core AI como opção no iOS 27 e posteriores; o Core ML continua a ser a opção predefinida e o destino recomendado para compatibilidade com versões anteriores ao iOS 27. Acompanha o roteiro da Ultralytics e as notas de versão para ver os itens que faltam.

Recursos adicionais#

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

Perguntas frequentes#