Integração com Apple Core AI#

O Core AI é o novo framework da Apple para executar redes neurais diretamente no Apple silicon. Ele introduz o formato de modelo .aimodel, uma moderna API 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 por trás do Apple Intelligence no dispositivo. Ele foi projetado para arquiteturas de redes neurais atuais, desde modelos de visão compactos até grandes modelos generativos, e pode distribuir a carga de trabalho entre a CPU, a GPU e o Apple Neural Engine (ANE).

O Core AI é uma nova opção de implantação, não um novo nome para o Core ML. Os frameworks usam formatos de modelo, ferramentas de conversão, APIs de execução e padrões de integração com aplicativos diferentes.

Comparação entre Core AI e Core ML#

O Core ML continua sendo a opção adequada quando um aplicativo precisa oferecer ampla compatibilidade com dispositivos, integração com o framework Vision ou suporte a tipos de modelo como árvores de decisão e pipelines tabulares. A Apple continua oferecendo suporte ao Core ML e direciona para ele os desenvolvedores que trabalham com tipos de modelos não neurais.

Como funciona o formato Core AI#

O fluxo de autoria 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 reduzindo operações PyTorch ATen a operações Core AI. As operações sem suporte podem ser implementadas com um lowering personalizado ou um kernel Metal personalizado.

O .aimodel resultante é um recurso de modelo não especializado. Quando um aplicativo prepara o modelo, o Core AI o especializa para o dispositivo de destino. Os aplicativos podem deixar que isso aconteça no primeiro uso, solicitar a especialização com antecedência ou distribuir um modelo compilado antecipadamente para reduzir o tempo de carregamento inicial.

Em Swift, os aplicativos carregam o recurso com o framework Core AI, selecionam uma função de inferência, fornecem entradas NDArray tipadas e recebem saídas nomeadas. Isso é diferente de encapsular um modelo Core ML em uma solicitação do Vision; portanto, a adoção do Core AI exige um ambiente de execução de aplicativo projetado para recursos .aimodel.

Para ver os detalhes de implementação, consulte a documentação da Apple sobre AIModel, especialização e armazenamento em cache de modelos e compilação antecipada.

Exportação de 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

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

Para ver a lista completa de argumentos, consulte o modo de exportação. O grafo é estático: ele é rastreado com o tamanho imgsz fornecido a export, então faça previsões usando esse mesmo tamanho. Os metadados da Ultralytics são armazenados no próprio metadata.json do recurso, preservando os nomes das classes, o stride e a tarefa na conversão de ida e volta.

Escolha do cabeçalho#

Com nms=False, o YOLO26 exporta seu cabeçalho de ponta a ponta, que seleciona as detecções dentro do grafo. O Core AI não tem uma primitiva top-k, então essa seleção é convertida em uma ordenação completa e tem um custo fixo na fronteira de particionamento do Apple Neural Engine — cerca de 1,7 ms, independentemente de max_det. Ao exportar com nms=None, as previsões brutas (1, 84, 8400) são emitidas, e a supressão não máxima fica a cargo do preditor:

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

Em um iPhone 17 Pro com iOS 27.0, o YOLO26n a 640 leva 3.01 ms com o cabeçalho no grafo e 1.28 ms sem ele (FP16, compilado antecipadamente, três blocos intercalados de 50 iterações). Em ambos os casos, a inferência é feita por meio de YOLO(...). Use nms=False quando uma única chamada ao grafo precisar retornar detecções prontas, ou mantenha o nms=None padrão para aplicar NMS externamente.

No iOS 27 ou macOS 27, o aplicativo carregaria e executaria o recurso exportado por meio da API Swift Core AI da Apple. Os recursos exportados usam o ponto de entrada main, recebem uma única entrada images com formato [batch, 3, imgsz, imgsz] e retornam output0 (modelos de segmentação de instâncias também retornam 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 atual do Core ML e do Vision, o caminho do Core AI no SDK para iOS da Ultralytics realiza o pré-processamento letterbox e a construção de NDArray por conta própria, lê os mesmos metadados da Ultralytics no metadata.json do recurso e reutiliza os decodificadores de saída do Core ML. O carregamento ocorre quando um aplicativo recebe um caminho .aimodel ou uma URL .aimodel.zip. A Apple fornece os detalhes atuais da API na documentação do framework Core AI e exemplos funcionais de modelos no repositório de modelos Core AI.

Desempenho medido#

Inferência de ponta a ponta em uma única imagem para exportações YOLO26n FP16 (quantize=16) do Core ML e do 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 no Python 3.13. Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento), com o detalhamento 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 pela 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 tarefas em uma única execução sequencial. As linhas do Core ML carregam com coremltools.ComputeUnit.CPU_ONLY ou CPU_AND_NE; as linhas do Core AI fazem a especialização 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.
• Detect, segment, classify, 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 do Core ML é mais lento com o Neural Engine como opção preferencial do que usando apenas a CPU, e o pós-processamento semântico do Core AI leva de 6.4 a 7.4 ms, contra 0.4 ms no Core ML.
• Compara os resultados no dispositivo do iPhone 17 Pro na integração com CoreML.

Vantagens do Core AI#

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

• Caminho moderno de exportação do PyTorch: a conversão começa em torch.export, preservando um grafo PyTorch mais expressivo do que o fluxo de trabalho de rastreamento usado por muitos exportadores existentes.
• Controle de execução detalhado: os aplicativos podem gerenciar a especialização, os caches de modelos compilados, as funções de inferência, a memória e o posicionamento da computação.
• Suporte avançado a modelos: a execução com estado, as formas dinâmicas, várias funções em um único artefato e os kernels Metal personalizados foram projetados para arquiteturas modernas de visão computacional e generativas.
• Ferramentas dedicadas para desenvolvedores: o Core AI Debugger pode inspecionar grafos e valores de tensores e rastreá-los até o código Python de origem. O Xcode e o Instruments oferecem criação de perfis de execução.
• Possibilidades de cópia zero: o Core AI expõe controles de armazenamento e buffer destinados a reduzir as cópias entre cargas de trabalho de câmera, gráficos e inferência.
• Otimização para Apple silicon: a especialização para o dispositivo permite que a Apple otimize um modelo para a CPU, a GPU e o Neural Engine disponíveis no dispositivo específico.
• Compactação flexível: as ferramentas Core AI Optimization da Apple oferecem suporte a quantização, paletização e poda, incluindo formatos de pesos com poucos bits.

Esses recursos podem ser particularmente úteis para futuros modelos YOLO com execução dinâmica, componentes multimodais maiores ou operações personalizadas que não se mapeiam bem às operações existentes do Core ML.

Desvantagens e limitações atuais#

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

• Requer sistemas operacionais novos: o framework público tem como alvo a geração iOS 27 e macOS 27, enquanto o Core ML é compatível com uma base instalada muito maior.
• Software beta: o framework Core AI da Apple e partes da sua cadeia de ferramentas 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 a 3.14, além de versões recentes do PyTorch, o que é muito mais restrito do que o intervalo de versões do Python e do PyTorch compatível com a Ultralytics.
• Plataformas de exportação limitadas: coreai-core publica apenas wheels macosx_26_0_arm64 e manylinux_2_34_x86_64; por isso, format=coreai requer um Mac com Apple silicon e 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 Apple.
• Opcional nos SDKs da Ultralytics, não padrão: no iPhone 17 Pro, a comparação no dispositivo mostra que o Core AI está no mesmo 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 cerca do dobro do tamanho de download. Por isso, o SDK para iOS e o plugin Flutter mantêm o Core ML como padrão.
• Usa a head bruta 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 em uma execução de comparação), e o modelo de pose FP16 de ponta a ponta não retorna detecções com o posicionamento padrão do Core AI no iOS 27.0 (apple/coreai-torch#115). A head bruta (nms=None, o padrão) evita os dois problemas, e os SDKs executam NMS em Swift. Consulta Escolher a head.
• Sem ambiente de execução do Simulador do iOS: o SDK do Simulador do iOS não inclui o Core AI.
• É necessário migrar o aplicativo: um .aimodel não pode substituir um .mlpackage; o carregamento do modelo, o pré-processamento, as chamadas de inferência, o tratamento de metadados e a decodificação da saída precisam de uma implementação do Core AI fora dos SDKs da Ultralytics, que oferecem uma.
• Evidências limitadas em produção: o desempenho, o consumo de energia, o tempo de especialização na primeira execução, a precisão e a compactação precisam ser validados em toda a matriz de tarefas YOLO e dispositivos compatíveis.
• Sem pipeline NMS: o Core ML pode incluir uma etapa NMS para modelos de detecção YOLO legados. Por padrão, as exportações do Core AI retornam previsões brutas one-to-many; usa nms=False para a head sem NMS do YOLO26. O NMS incorporado (nms=True) e dynamic=True não são compatíveis. coreai-torch não tem uma conversão de nível inferior para torchvision::nms, por isso o NMS continua sendo executado no host.
• Tamanho de entrada fixo: o grafo exportado é rastreado em um único imgsz e não tem formas dinâmicas; por isso, faz previsões no tamanho usado na exportação.
• Recursos FP16 podem interromper o carregamento: alguns recursos .aimodel FP16 não conseguem carregar o programa do Apple Neural Engine, e o MPSGraph gera uma asserção falhada, encerrando o processo em vez de usar uma alternativa. Isso acontece dentro do ambiente de execução 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 isso acontecer com um recurso; os recursos FP16 do SDK testados em um iPhone 17 Pro (todos os modelos nano, detecção em todos os tamanhos e o maior modelo de cada tarefa) carregaram sem interromper o processo.

Qual formato Apple deves usar?#

Usa o Core ML hoje quando precisares de:

• Implantação em sistemas operacionais Apple atuais e antigos
• O caminho padrão do SDK para iOS ou Flutter da Ultralytics
• Tratamento de imagens com o framework Vision
• Implantação YOLO FP16 e INT8 testada
• NMS incorporado para modelos de detecção legados compatíveis

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

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

É esperado que Core ML e Core AI coexistam durante a transição dos aplicativos. O suporte ao Core AI não elimina imediatamente a necessidade do Core ML, pois os alvos de implantação e os contratos dos aplicativos 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 YOLO26 compatíveis e são executadas continuamente no CI da Ultralytics no macOS 26; a latência FP16 é medida no dispositivo. O que falta no roteiro para o Core AI alcançar paridade com o fluxo do Core ML:

1. Reduzir a diferença de latência da head de ponta a ponta no Apple Neural Engine (apple/coreai-torch#66) e resolver os problemas de precisã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 cerca do dobro do tamanho de download dos recursos Core ML INT8.
3. Lançamentos estáveis dos frameworks Apple e das ferramentas de conversão (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 compatíveis.

O SDK para iOS e o plugin Flutter da Ultralytics carregam o Core AI como opção em iOS 27 e posterior; o Core ML continua sendo o padrão e o destino recomendado para compatibilidade com versões anteriores ao iOS 27. Acompanha o roteiro da Ultralytics e as notas de lançamento para saber o que ainda falta.

Recursos adicionais#

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

Perguntas frequentes#