Intel Gaudi

Los aceleradores Intel Gaudi ejecutan PyTorch en el stack Intel Gaudi, con la cadena de dispositivo hpu. Gaudi ejecuta PyTorch en modo eager de forma predeterminada. El modo eager ejecuta cada operación en cuanto se llama, de la misma manera que PyTorch se ejecuta en una CPU o GPU, por lo que los modelos de Transformers se ejecutan en Gaudi sin cambios específicos de Gaudi. Para capturar el modelo en un grafo en su lugar, compílelo con torch.compile.

Instalación

Instale el software de Intel Gaudi y su paquete de PyTorch (habana-torch-plugin, importado como habana_frameworks) con la guía de instalación de Intel Gaudi, además de Accelerate 1.5.0 o posterior.

Transformers usa tensores int64 para los IDs de tokens, por lo que debe habilitar el soporte de int64 en Gaudi. La CI de Gaudi de Transformers se ejecuta con la misma configuración.

export PT_ENABLE_INT64_SUPPORT=1

Comprueba que Transformers puede ver el dispositivo.

from transformers import is_torch_hpu_available

print(is_torch_hpu_available())

Imprime True cuando Gaudi está listo para usarse, y False con Accelerate anterior a la 1.5.0, incluso si hay un dispositivo Gaudi presente.

Seleccionar dispositivos

Elija qué dispositivos Gaudi puede utilizar un contenedor de Docker al iniciarlo. Establezca HABANA_VISIBLE_MODULES en los IDs de módulo, que permanecen iguales entre reinicios y reinstalaciones de controladores, o HABANA_VISIBLE_DEVICES en los índices de dispositivo, que pueden cambiar. Si no establece ninguno, PyTorch utiliza cualquier dispositivo Gaudi disponible en el servidor.

docker run --runtime=habana -e HABANA_VISIBLE_MODULES=0,1,2,3 ...

Ejecute hl-smi -Q index,module_id -f csv para mapear los índices de dispositivo a los IDs de módulo. Para una carga de trabajo distribuida en parte de un servidor, Intel solo admite grupos de 2 y 4 dispositivos. Consulte Varios Dockers, cada uno con una única carga de trabajo para las combinaciones de ID de módulo admitidas.

Ejecutar inferencia

Pasa device_map="hpu" a from_pretrained(). pipeline() selecciona Gaudi automáticamente cuando no pasas device.

from transformers import AutoModelForCausalLM, AutoTokenizer

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

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

Cuantizar modelos

bitsandbytes cuantiza los modelos a 4 u 8 bits en Gaudi 2 y Gaudi 3. Si no se pasa device_map, coloca el modelo en el dispositivo Gaudi actual.

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

Entrenar con Trainer

TrainingArguments detecta Gaudi y establece el dispositivo en hpu, por lo que Trainer entrena en él sin ninguna configuración de dispositivo. Todas las generaciones de Gaudi admiten bf16.

from transformers import TrainingArguments

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

Imprime un dispositivo hpu cuando Trainer entrenará en Gaudi.

Compilar el modelo

Transformers envuelve torch.compile en Gaudi, por lo que cualquier llamada con un backend distinto de hpu_backend o eager, incluido un decorador @torch.compile en el código de modelado, cambia a hpu_backend y registra una advertencia. El envoltorio se aplica a cada llamada de torch.compile, ya sea para inferencia o entrenamiento.

Para compilar un modelo para entrenamiento, establezca torch_compile=True en TrainingArguments, lo que establece torch_compile_backend en "hpu_backend".

from transformers import TrainingArguments

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

Entrenamiento distribuido

El entrenamiento distribuido utiliza el backend colectivo HCCL. Transformers lo selecciona en Gaudi, y también puedes configurarlo explícitamente con ddp_backend="hccl".

training_args = TrainingArguments(
    output_dir="./outputs",
    bf16=True,
    ddp_backend="hccl",
)

Inicie un proceso por dispositivo Gaudi con torchrun o accelerate launch, después de seleccionar los dispositivos. accelerate launch establece el número de procesos en el número de dispositivos Gaudi cuando no se pasa --num_processes.

accelerate launch train.py

Próximos pasos

• Consulte la documentación de Intel Gaudi para obtener detalles sobre el hardware, el stack de software y la arquitectura de Gaudi.
• Pruebe Optimum for Intel Gaudi para obtener implementaciones de modelos optimizadas para Gaudi, tanto para entrenamiento como para inferencia.