# Apple Silicon

Los chips Apple Silicon (serie M) ejecutan PyTorch a través del backend [Metal Performance Shaders (MPS)](https://docs.pytorch.org/docs/stable/notes/mps.html), 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.

```py
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](./attention_interface) 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](https://huggingface.co/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](./model_doc/gpt_oss) cambia a él automáticamente cuando solicitas flash attention en MPS.
- [ggml-org/ggml-attn](https://huggingface.co/kernels/ggml-org/ggml-attn) es el predeterminado para `transformers serve` y para los modelos [GGUF](./quantization/gguf#attention) cuando `kernels` está instalado.

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

```bash
pip install "transformers[kernels]"
```

## Ejecutar inferencia

Pasa `device_map="mps"` a [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained). [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) selecciona MPS automáticamente si no pasas `device`.

```py
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](./serve-cli/serving) 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.

```bash
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`.

```bash
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
  }'
```

```json
{"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](https://huggingface.co/kernels/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](./quantization/metal) cuantiza a 2, 4 u 8 bits con kernels de Metal del Hub.
- [GGUF](./quantization/gguf) mantiene los pesos empaquetados en MPS cuando el kernel `ggml-org/ggml-quantization` está disponible.
- [bitsandbytes](./quantization/bitsandbytes) cuantiza a 4 bits con kernels nativos de MPS.

Para ajustar un modelo que no cabe en memoria, cárgalo en 4 bits con bitsandbytes y entrena adaptadores LoRA con [PEFT](./peft).

## Entrenar con Trainer

[TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) detecta MPS y establece el dispositivo en `mps`, por lo que [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.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](#choose-an-attention-backend) no calcula gradientes para las proyecciones de atención.

```py
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 se puedan serializar con pickle. Cuando `dataloader_num_workers` es mayor que 1, [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.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 mediante el argumento `pad_to_multiple_of` de [DataCollatorWithPadding](/docs/transformers/v5.23.0/es/main_classes/data_collator#transformers.DataCollatorWithPadding).

```py
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, ya que MPS y la CPU comparten la misma memoria. El desbordamiento se envía al disco.
- Los puntos de control FP8 de [compressed-tensors](./quantization/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](https://docs.pytorch.org/docs/stable/notes/mps.html) de PyTorch para conocer las operaciones admitidas y los problemas conocidos.
- Lee la guía de [Backends de atención](./attention_interface) para aprender cómo `attn_implementation` selecciona una función de atención.
- Comprueba la columna Metal en el [resumen de cuantización](./quantization/overview) para encontrar todos los métodos de cuantización que se ejecutan en MPS.

