# CPU

Las CPU ejecutan modelos de Transformers con la cadena de dispositivo `cpu`, sin un acelerador. Funcionan para inferencia y entrenamiento cuando no hay GPUs disponibles, o cuando se desea una configuración rentable.

## Ejecutar inferencia

Los modelos se cargan en la CPU de forma predeterminada si no se pasa `device_map`, y [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utiliza la CPU cuando no hay un acelerador disponible. Pasa `device_map="cpu"` o `device="cpu"` para usar la CPU en una máquina que también cuenta con un acelerador.

```py
from transformers import pipeline

generator = pipeline("text-generation", model="Qwen/Qwen3-0.6B", device="cpu")
print(generator("CPUs are", max_new_tokens=50, do_sample=False)[0]["generated_text"])
```

## Entrenar con Trainer

Las CPU con soporte para bf16, como los procesadores recientes de Intel y AMD, pueden usar el entrenamiento de precisión mixta bf16 con [AMP de PyTorch](https://docs.pytorch.org/docs/stable/amp), lo que reduce el uso de memoria y acelera el entrenamiento.

Los ejemplos a continuación cubren tres configuraciones, desde una sola CPU hasta varios equipos cuando una sola CPU es demasiado lenta:

- una sola CPU
- varios procesos en una máquina (uno por cada socket de CPU)
- varios procesos en varias máquinas

Los ejemplos de nodo único y multinodo inician procesos con `mpirun` de [Intel MPI](https://www.intel.com/content/www/us/en/developer/tools/oneapi/mpi-library.html), parte del [Intel oneAPI HPC Toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/hpc-toolkit.html), y [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) ejecuta DDP sobre el backend `gloo`.

Establezca `bf16=True` y `use_cpu=True` en [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments), o pase `--bf16` y `--use_cpu` a un script de entrenamiento. Prefiera bf16 sobre fp16 en CPU porque es más estable numéricamente.

```py
from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="./outputs",
    bf16=True,
    use_cpu=True,
)
```

En un CPU de doble socket, ejecute un proceso por socket. Mantener los accesos a la memoria locales a cada socket mejora el rendimiento. El ejemplo siguiente inicia dos procesos en una sola máquina, con un proceso por socket, donde `train.py` es su script de entrenamiento de `Trainer`.

> [!TIP]
> Establezca `OMP_NUM_THREADS` en el número de núcleos físicos de un socket, menos un núcleo reservado para el sistema operativo. Por ejemplo, en un socket de 24 núcleos, establezca `OMP_NUM_THREADS=23`.

```bash
export MASTER_ADDR=127.0.0.1
mpirun -n 2 -genv OMP_NUM_THREADS=23 \
python3 train.py \
 --output_dir ./outputs \
 --use_cpu \
 --bf16
```

Escale el entrenamiento a cuatro procesos en dos máquinas (`node0` y `node1`) usando un `hostfile` que enumera la dirección IP de cada nodo. La bandera `-n 4` establece el número total de procesos. `-ppn 2` establece dos procesos por nodo (uno por socket).

Ejecuta este script desde `node0`, que actúa como el proceso principal.

> [!TIP]
> Establezca `OMP_NUM_THREADS` en el número de núcleos físicos de un socket, menos un núcleo reservado para el sistema operativo. Por ejemplo, en un socket de 24 núcleos, establezca `OMP_NUM_THREADS=23`.

Cree un hostfile con la dirección IP de cada nodo.

```bash
cat hostfile
xxx.xxx.xxx.xxx #node0 ip
xxx.xxx.xxx.xxx #node1 ip
```

Luego, ejecuta el script de entrenamiento.

```bash
export MASTER_ADDR=xxx.xxx.xxx.xxx #node0 ip
mpirun -f hostfile -n 4 -ppn 2 \
 -genv OMP_NUM_THREADS=23 \
python3 train.py \
 --output_dir ./outputs \
 --use_cpu \
 --bf16
```

## Ajustar el rendimiento de la CPU

Precargue un asignador de memoria más rápido y el tiempo de ejecución OpenMP de Intel para reducir la sobrecarga en el entrenamiento en CPU. Instale `google-perftools` (para `libtcmalloc`) y el paquete de Python `intel-openmp` (para `libiomp5`), y luego agregue ambas bibliotecas a la variable de entorno `LD_PRELOAD` antes de iniciar el entrenamiento.

Establezca `OMP_NUM_THREADS` en el número de núcleos que cada proceso puede utilizar. En un contenedor o un trabajo de clúster con límites de CPU, ese es el número de unidades de CPU asignadas, por lo que deje algunos núcleos sin asignar para los procesos del sistema.

## Próximos pasos

- Lea el artículo de blog [Accelerating PyTorch Transformers with Intel Sapphire Rapids](https://huggingface.co/blog/intel-sapphire-rapids) para una mirada más profunda al rendimiento de BF16 en el hardware moderno de Intel.
- Lea [DDP](./ddp) para obtener más información sobre la estrategia distribuida que utilizan los ejemplos de multiproceso.
- Lea las notas de [hilos de CPU](https://docs.pytorch.org/docs/stable/notes/cpu_threading_torchscript_inference.html) de PyTorch para aprender cómo `OMP_NUM_THREADS` afecta el rendimiento.
- Lea la [guía de PyTorchJob de Kubeflow](https://www.kubeflow.org/docs/components/training/user-guides/pytorch/) para ejecutar entrenamiento distribuido de CPU en Kubernetes.

