Apple Silicon

Los chips Apple Silicon (serie M) ejecutan PyTorch a través del backend Metal Performance Shaders (MPS), con la cadena de dispositivo mps. La CPU y la GPU comparten un único pool de memoria unificada.

MPS funciona con la instalación estándar de torch. Las versiones actuales de PyTorch para Apple Silicon requieren macOS 14 o posterior. Comprueba que PyTorch se haya compilado con MPS y que pueda ver la GPU.

import torch

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

Imprime True cuando MPS está listo para usarse.

Elegir un backend de atención

Establece el backend de atención con attn_implementation al cargar un modelo, y se aplica tanto a la inferencia como al entrenamiento. Los modelos usan SDPA de forma predeterminada. Con PyTorch 2.13 o posterior, SDPA en MPS maneja la atención de consulta agrupada directamente, sin repetir primero las cabeceras de clave y valor.

Use SDPA para el entrenamiento.

• kernels-community/metal-flash-sdpa solo admite entradas de longitud variable, como secuencias empaquetadas o un lote cuya máscara de atención contiene relleno. Un lote sin relleno, como un único prompt, genera un error. No calcula gradientes para las proyecciones de query, key y value. gpt-oss cambia a él automáticamente cuando solicitas flash attention en MPS.
• ggml-org/ggml-attn es el predeterminado para transformers serve y para los modelos GGUF cuando kernels está instalado.

Install the kernels extra to use either kernel. It installs a version that Transformers supports.

pip install "transformers[kernels]"

Ejecutar inferencia

Pasa device_map="mps" a from_pretrained(). pipeline() elige MPS automáticamente cuando no pasas 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))

Con un device_map que apunta a MPS, Transformers carga los pesos de safetensors directamente en el dispositivo MPS.

Servir un modelo

transformers serve inicia un servidor compatible con OpenAI. Su opción --device tiene auto como valor predeterminado, por lo que carga los modelos en MPS sin necesidad de banderas adicionales. Instale las dependencias de servicio e inicie el servidor.

pip install "transformers[serving]"
transformers serve

El servidor carga un modelo la primera vez que una solicitud lo menciona. Envía una solicitud de chat a 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}}

Cuando kernels está instalado, transformers serve usa ggml-org/ggml-attn por defecto en MPS y registra una advertencia al inicio. Pasa --attn-implementation sdpa para usar SDPA en su lugar.

Cuantizar modelos

Los pesos del modelo comparten memoria unificada con macOS y todo lo demás que se ejecuta en la Mac, por lo que cuantizarlos permite que un modelo más grande quepa para inferencia o ajuste fino. Metal cuantiza un modelo al cargarlo, mientras que GGUF ejecuta puntos de control que ya están cuantizados. Ambos son solo para inferencia.

• Metal cuantiza a 2, 4 u 8 bits con kernels de Metal del Hub.
• GGUF mantiene los pesos empaquetados en MPS cuando el kernel ggml-org/ggml-quantization está disponible.
• bitsandbytes cuantiza a 4 bits con kernels nativos de MPS.

Para ajustar un modelo que no cabe en la memoria, cárgalo en 4 bits con bitsandbytes y entrena adaptadores LoRA con PEFT.

Entrenar con Trainer

TrainingArguments detecta MPS y establece el dispositivo en mps, por lo que Trainer entrena en él sin ninguna configuración de dispositivo. Tanto la precisión mixta bf16 como la fp16 funcionan. Carga el modelo con la atención SDPA predeterminada, porque metal-flash-sdpa no calcula gradientes para las proyecciones de atención.

from transformers import TrainingArguments

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

Imprime mps cuando Trainer entrenará en la GPU.

En macOS, Python inicia los procesos de trabajo con spawn de forma predeterminada, lo que vuelve a importar tu script y requiere un dataset y una collate_fn que puedan serializarse con pickle. Cuando dataloader_num_workers es mayor que 1, TrainingArguments establece dataloader_multiprocessing_context="fork" en MPS, de modo que los procesos de trabajo se inician a partir de una copia del proceso de entrenamiento. Establece "spawn" si una fuente de datos no es segura para fork.

Limitar el crecimiento de la caché de grafos

MPS compila un kernel de Metal para cada forma de tensor que detecta y los mantiene en una caché de grafos que nunca se expulsa. El entrenamiento con entradas de longitud variable añade un kernel para cada nueva forma y puede agotar la memoria unificada.

Reduzca el número de formas rellenando cada lote hasta un múltiplo de una longitud fija con el argumento pad_to_multiple_of de DataCollatorWithPadding.

from transformers import AutoTokenizer, DataCollatorWithPadding

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

Pásalo a Trainer con data_collator=data_collator.

Limitaciones

• device_map="auto" no puede descargar capas a la CPU, porque MPS y la CPU comparten la misma memoria. El desbordamiento se envía al disco.
• Los puntos de control FP8 de compressed-tensors se cargan en MPS, pero sus pesos se descomprimen en la primera pasada hacia adelante, por lo que no reducen la memoria durante la inferencia.
• El paralelismo de tensores no se admite porque un Mac solo tiene un dispositivo.
• Algunas operaciones de PyTorch aún no tienen una implementación en MPS. Establezca PYTORCH_ENABLE_MPS_FALLBACK=1 para ejecutarlas en la CPU en lugar de generar un error.

Próximos pasos

• Lea las notas del backend MPS de PyTorch para conocer las operaciones admitidas y los problemas conocidos.
• Lee la guía de Backends de atención para aprender cómo attn_implementation selecciona una función de atención.
• Comprueba la columna Metal en el resumen de cuantización para encontrar todos los métodos de cuantización que se ejecutan en MPS.