Apple Silicon

Os chips Apple Silicon (série M) executam o PyTorch por meio do backend Metal Performance Shaders (MPS), com a string de dispositivo mps. A CPU e a GPU compartilham um único pool de memória unificada.

O MPS funciona com a instalação padrão do torch. As versões atuais do PyTorch para Apple Silicon exigem o macOS 14 ou posterior. Verifique se o PyTorch foi compilado com suporte a MPS e se consegue detectar a GPU.

import torch

print(torch.backends.mps.is_available())

Ele imprime True quando o MPS está pronto para uso.

Escolha um backend de atenção

Defina o backend de atenção com attn_implementation ao carregar um modelo, e ele será aplicado tanto para inferência quanto para treinamento. Os modelos usam SDPA por padrão. Com o PyTorch 2.13 ou posterior, o SDPA no MPS lida diretamente com a atenção de consulta agrupada, sem precisar repetir as cabeças de chave e valor antes.

Use SDPA para treinamento.

• kernels-community/metal-flash-sdpa suporta apenas entradas de comprimento variável, como sequências empacotadas ou um lote cuja máscara de atenção contém preenchimento. Um lote sem preenchimento, como um único prompt, gera um erro. Ele não calcula gradientes para as projeções de query, key e value. gpt-oss passa a usá-lo automaticamente quando você solicita flash attention no MPS.
• ggml-org/ggml-attn é o padrão para transformers serve e para modelos GGUF quando kernels está instalado.

Instale o extra kernels para usar qualquer kernel. Ele instala uma versão que o Transformers suporta.

pip install "transformers[kernels]"

Executar inferência

Passe device_map="mps" para from_pretrained(). O pipeline() seleciona o MPS automaticamente quando você não passa device.

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", device_map="mps")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

inputs = tokenizer("Apple Silicon is", return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=50, do_sample=False)
print(tokenizer.decode(output[0], skip_special_tokens=True))

Com um device_map que aponta para o MPS, o Transformers carrega os pesos em safetensors diretamente no dispositivo MPS.

Servir um modelo

transformers serve inicia um servidor compatível com a OpenAI. A opção --device tem como padrão auto, de modo que ele carrega os modelos no MPS sem a necessidade de flags adicionais. Instale as dependências de serving e inicie o servidor.

pip install "transformers[serving]"
transformers serve

O servidor carrega um modelo na primeira vez que uma solicitação o especifica. Envie uma solicitação de chat para http://localhost:8000.

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen2.5-0.5B-Instruct",
    "messages": [{"role": "user", "content": "What is Apple Silicon? Answer in one sentence."}],
    "max_tokens": 64,
    "temperature": 0
  }'

{"id":"b48e84c1-b3c6-484d-b781-4c9ce8022dff","choices":[{"finish_reason":"stop","index":0,"message":{"content":"Apple Silicon is a type of processor technology developed and manufactured by Apple Inc., designed to offer faster performance and lower power consumption compared to traditional silicon-based processors. This technology allows for the creation of more efficient and energy-efficient devices, such as high-performance computers, smartphones, and other Apple products.","role":"assistant"}}],"created":1791843839,"model":"Qwen/Qwen2.5-0.5B-Instruct@main","object":"chat.completion","usage":{"completion_tokens":59,"prompt_tokens":39,"total_tokens":98}}

Quando kernels está instalado, transformers serve usa ggml-org/ggml-attn por padrão no MPS e registra um aviso na inicialização. Passe --attn-implementation sdpa para usar SDPA em vez disso.

Quantizar modelos

Os pesos do modelo compartilham a memória unificada com o macOS e com tudo o mais que está em execução no Mac, de modo que a quantização permite que um modelo maior caiba para inferência ou ajuste fino. O Metal quantiza um modelo quando ele é carregado, enquanto o GGUF executa checkpoints que já estão quantizados. Ambos são exclusivos para inferência.

• Metal quantiza para 2, 4 ou 8 bits com kernels Metal do Hub.
• GGUF mantém os pesos compactados no MPS quando o kernel ggml-org/ggml-quantization está disponível.
• bitsandbytes quantiza para 4 bits com kernels nativos de MPS.

Para ajustar um modelo que não cabe na memória, carregue-o em 4 bits com bitsandbytes e treine adaptadores LoRA com PEFT.

Treinar com o Trainer

TrainingArguments detecta o MPS e define o dispositivo como mps, de modo que o Trainer treina nele sem nenhuma configuração de dispositivo. Tanto a precisão mista bf16 quanto a fp16 funcionam. Carregue o modelo com a atenção SDPA padrão, pois o metal-flash-sdpa não calcula gradientes para as projeções de atenção.

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="./outputs",
    bf16=True,
)
print(training_args.device)

Ele exibe mps quando o Trainer vai treinar na GPU.

No macOS, o Python inicia processos de worker com spawn por padrão, o que reimporta seu script e exige um dataset picklable e collate_fn. Quando dataloader_num_workers é maior que 1, o TrainingArguments define dataloader_multiprocessing_context="fork" no MPS, de modo que os workers são iniciados a partir de uma cópia do processo de treinamento. Defina-o como "spawn" se uma fonte de dados não for segura para fork.

Limitar o crescimento do cache de grafos

O MPS compila um kernel Metal para cada forma de tensor que encontra e os mantém em um cache de grafo que nunca é descartado. O treinamento com entradas de comprimento variável adiciona um kernel para cada nova forma e pode esgotar a memória unificada.

Reduza o número de formas ao preencher cada lote até um múltiplo de um comprimento fixo usando o argumento pad_to_multiple_of do DataCollatorWithPadding.

from transformers import AutoTokenizer, DataCollatorWithPadding

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
data_collator = DataCollatorWithPadding(tokenizer, pad_to_multiple_of=64)

Passe para o Trainer com data_collator=data_collator.

Limitações

• device_map="auto" não consegue descarregar camadas para a CPU, pois o MPS e a CPU compartilham a mesma memória. O estouro é enviado para o disco.
• Os checkpoints FP8 do compressed-tensors são carregados no MPS, mas seus pesos são descomprimidos pela primeira passagem de frente, de modo que não reduzem a memória durante a inferência.
• O paralelismo de tensor não é suportado porque um Mac possui apenas um dispositivo.
• Algumas operações do PyTorch ainda não possuem uma implementação para MPS. Defina PYTORCH_ENABLE_MPS_FALLBACK=1 para executá-las na CPU em vez de gerar um erro.

Próximas etapas

• Leia as notas do backend MPS do PyTorch para as operações suportadas e os problemas conhecidos.
• Leia o guia Backends de atenção para aprender como attn_implementation seleciona uma função de atenção.
• Verifique a coluna Metal na visão geral de quantização para encontrar todos os métodos de quantização que rodam em MPS.