Aplicaciones y Guías

Intel Habana Gaudí 2: instalación y prueba

Antes de empezar a instalar el software de los aceleradores Gaudí 2, hay una característica importante que merece la pena mencionar. Estamos acostumbrados a que el entrenamiento y la inferencia de redes neuronales se realicen utilizando GPUs. Sin embargo, Intel Habana Gaudi 2 es muy diferente de las GPU y representa una clase diferente de dispositivos que están diseñados exclusivamente para la aceleración de tareas de IA.

Muchas aplicaciones y marcos de trabajo conocidos no funcionarán sin preparar primero el sistema operativo y, en algunos casos, sin un kit de herramientas especial para la migración a la GPU. Esto explica el gran número de pasos preparatorios que describimos en este artículo. Empecemos por orden.

Paso 1. Instala SynapseAI Software Stack

Para empezar a trabajar con los aceleradores Intel Habana Gaudi 2, es necesario instalar la pila SynapseAI. Incluye un compilador de gráficos especial que transforma la topología del modelo de red neuronal para optimizar eficazmente la ejecución en la arquitectura Gaudí, bibliotecas API para el escalado horizontal, así como un SDK independiente para crear algoritmos de alto rendimiento y modelos de aprendizaje automático.

Por otra parte, cabe destacar que SynapseAI es la parte que permite crear un puente entre marcos de trabajo populares como PyTorch/TensorFlow y los aceleradores de IA de Gaudi 2. Esto permite trabajar con abstracciones conocidas, y Gaudi 2 optimiza de forma independiente los cálculos Los operadores específicos para los que los aceleradores no tienen soporte de hardware se ejecutan en la CPU.

Para simplificar la instalación de los componentes individuales de SynapseAI, se ha creado un cómodo script de shell. Vamos a descargarlo:

wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.sh

Haga el archivo ejecutable:

chmod +x habanalabs-installer.sh

Ejecuta el script:

./habanalabs-installer.sh install --type base

Siga las instrucciones del sistema durante la instalación. Encontrarás un informe detallado en el archivo de registro. En él podrás ver qué paquetes se instalaron, así como si los aceleradores se encontraron e inicializaron correctamente.

Registros aquí: /var/log/habana_logs/install-YYYY-MM-DD-HH-MM-SS.log

[  +3.881647] habanalabs hl5: Found GAUDI2 device with 96GB DRAM
[  +0.008145] habanalabs hl0: Found GAUDI2 device with 96GB DRAM
[  +0.032034] habanalabs hl3: Found GAUDI2 device with 96GB DRAM
[  +0.002376] habanalabs hl4: Found GAUDI2 device with 96GB DRAM
[  +0.005174] habanalabs hl1: Found GAUDI2 device with 96GB DRAM
[  +0.000390] habanalabs hl2: Found GAUDI2 device with 96GB DRAM
[  +0.007065] habanalabs hl7: Found GAUDI2 device with 96GB DRAM
[  +0.006256] habanalabs hl6: Found GAUDI2 device with 96GB DRAM

Al igual que la utilidad nvidia-smi proporciona información sobre las GPUs instaladas y los procesos de computación en ejecución, SynapseAI tiene un programa similar. Puedes ejecutarlo para obtener un informe sobre el estado actual de los aceleradores de IA Gaudí 2:

hl-smi

Paso 2. Prueba TensorFlow

TensorFlow es una de las plataformas más populares para el aprendizaje automático. Usando el mismo script de instalación, puedes instalar una versión pre-construida de TensorFlow con soporte para los aceleradores Gaudi 2. Empecemos instalando las dependencias generales:

./habanalabs-installer.sh install -t dependencies

A continuación, instalaremos las dependencias para TensorFlow:

./habanalabs-installer.sh install -t dependencies-tensorflow

Instalar la plataforma TensorFlow dentro de un entorno virtual implementado mediante el mecanismo Python Virtual Environment (venv):

./habanalabs-installer.sh install --type tensorflow --venv

Activemos el entorno virtual creado:

source habanalabs-venv/bin/activate

Crear un sencillo ejemplo de código Python que utilizará las capacidades de los aceleradores Gaudí 2:

nano example.py


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import os
# Import Habana Torch Library
import habana_frameworks.torch.core as htcore
class SimpleModel(nn.Module):
   def __init__(self):
       super(SimpleModel, self).__init__()
       self.fc1   = nn.Linear(784, 256)
       self.fc2   = nn.Linear(256, 64)
       self.fc3   = nn.Linear(64, 10)
   def forward(self, x):
       out = x.view(-1,28*28)
       out = F.relu(self.fc1(out))
       out = F.relu(self.fc2(out))
       out = self.fc3(out)
       return out
def train(net,criterion,optimizer,trainloader,device):
   net.train()
   train_loss = 0.0
   correct = 0
   total = 0
   for batch_idx, (data, targets) in enumerate(trainloader):
       data, targets = data.to(device), targets.to(device)
       optimizer.zero_grad()
       outputs = net(data)
       loss = criterion(outputs, targets)
       loss.backward()
       # API call to trigger execution
       htcore.mark_step()
       optimizer.step()
       # API call to trigger execution
       htcore.mark_step()
       train_loss += loss.item()
       _, predicted = outputs.max(1)
       total += targets.size(0)
       correct += predicted.eq(targets).sum().item()
   train_loss = train_loss/(batch_idx+1)
   train_acc = 100.0*(correct/total)
   print("Training loss is {} and training accuracy is {}".format(train_loss,train_acc))
def test(net,criterion,testloader,device):
   net.eval()
   test_loss = 0
   correct = 0
   total = 0
   with torch.no_grad():
       for batch_idx, (data, targets) in enumerate(testloader):
           data, targets = data.to(device), targets.to(device)
           outputs = net(data)
           loss = criterion(outputs, targets)
           # API call to trigger execution
           htcore.mark_step()
           test_loss += loss.item()
           _, predicted = outputs.max(1)
           total += targets.size(0)
           correct += predicted.eq(targets).sum().item()
   test_loss = test_loss/(batch_idx+1)
   test_acc = 100.0*(correct/total)
   print("Testing loss is {} and testing accuracy is {}".format(test_loss,test_acc))
def main():
   epochs = 20
   batch_size = 128
   lr = 0.01
   milestones = [10,15]
   load_path = './data'
   save_path = './checkpoints'
   if(not os.path.exists(save_path)):
       os.makedirs(save_path)
   # Target the Gaudi HPU device
   device = torch.device("hpu")
   # Data
   transform = transforms.Compose([
       transforms.ToTensor(),
   ])
   trainset = torchvision.datasets.MNIST(root=load_path, train=True,
                                           download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
   testset = torchvision.datasets.MNIST(root=load_path, train=False,
                                       download=True, transform=transform)
   testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
   net = SimpleModel()
   net.to(device)
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(net.parameters(), lr=lr,
                       momentum=0.9, weight_decay=5e-4)
   scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
   for epoch in range(1, epochs+1):
       print("=====================================================================")
       print("Epoch : {}".format(epoch))
       train(net,criterion,optimizer,trainloader,device)
       test(net,criterion,testloader,device)
       torch.save(net.state_dict(), os.path.join(save_path,'epoch_{}.pth'.format(epoch)))
       scheduler.step()
if __name__ == '__main__':
   main()

Por último, ejecute la aplicación:

python3 example.py

Para salir del entorno virtual, ejecute el siguiente comando:

deactivate

Paso 3. Clonar el repositorio de formación

Clone el repositorio con el código MLperf:

git clone https://github.com/mlcommons/training_results_v3.0

Crear un directorio separado que será utilizado por el contenedor Docker con MLperf:

mkdir -p mlperf

Cambia el directorio:

cd mlperf

Exportemos algunas variables de entorno:

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Cree nuevos directorios utilizando las variables creadas:

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Copia la aplicación de benchmark a $MLPERF_DIR/Habana:

cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/Habana

Exporta otra variable que almacenará un enlace para descargar la versión deseada del contenedor Docker:

export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41

Paso 4. Instalar Docker

Nuestra instancia ejecuta Ubuntu Linux 22.04 LTS y no soporta Docker por defecto. Por lo tanto, antes de descargar y ejecutar contenedores, es necesario instalar el soporte para Docker. Actualicemos la caché de paquetes e instalemos algunos paquetes básicos que necesitaremos más adelante:

sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Para instalar Docker, necesitas añadir un repositorio de proyecto firmado digitalmente. Descarga la clave de firma digital y añádela al almacén de claves del sistema operativo:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Docker puede ejecutarse en plataformas con diversas arquitecturas. El siguiente comando detectará la arquitectura de su servidor y añadirá la línea del repositorio correspondiente a la lista del gestor de paquetes de APT:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualice la caché de paquetes y las políticas e instale docker-ce (Docker Community Edition):

sudo apt update && apt-cache policy docker-ce && sudo apt install docker-ce

Por último, compruebe que el demonio Docker está en funcionamiento:

sudo systemctl status docker

Paso 5. Ejecutar el contenedor Docker

Vamos a lanzar el contenedor en modo privilegiado utilizando las variables especificadas anteriormente:

sudo docker run --privileged --security-opt seccomp=unconfined \
  --name mlperf3.0 -td                    \
  -v /dev:/dev                            \
  --device=/dev:/dev                      \
  -e LOG_LEVEL_ALL=6                      \
  -v /sys/kernel/debug:/sys/kernel/debug  \
  -v /tmp:/tmp                            \
  -v $MLPERF_DIR:/root/MLPERF             \
  -v $SCRATCH_DIR:/root/scratch           \
  -v $DATASETS_DIR:/root/datasets/        \
  --cap-add=sys_nice --cap-add=SYS_PTRACE \
  --user root --workdir=/root --net=host  \
  --ulimit memlock=-1:-1 $MLPERF_DOCKER_IMAGE

Para mayor comodidad, puedes acceder al terminal dentro del contenedor a través de SSH:

sudo docker exec mlperf3.0 bash -c "service ssh start"

Para abrir un shell de comandos (bash) en la sesión actual, ejecute el siguiente comando:

sudo docker exec -it mlperf3.0 bash

Paso 6. Preparar un conjunto de datos

Para ejecutar las pruebas de implementación de Bert desde MLperf, necesita un conjunto de datos preparado. El método óptimo es generar un conjunto de datos a partir de datos precargados. El repositorio MLperf incluye un script especial, prepare_data.sh, que requiere un conjunto específico de paquetes para funcionar. Naveguemos hasta el siguiente directorio:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorch

Instale todos los paquetes necesarios utilizando la lista pregenerada y el gestor de paquetes pip:

pip install -r requirements.txt

Establezca la variable PYTORCH_BERT_DATA para indicar al script dónde almacenar los datos:

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Ejecute el script:

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

El procedimiento de generación es bastante largo y puede durar varias horas. Por favor, sea paciente y no interrumpa el proceso. Si tiene previsto desconectarse de la sesión SSH, se recomienda utilizar la utilidad de pantalla inmediatamente antes de iniciar el contenedor Docker.

Paso 7. Empaquetar el conjunto de datos

El siguiente paso es "cortar" el conjunto de datos en trozos iguales para el posterior lanzamiento de MLperf. Vamos a crear el directorio separado para los datos empaquetados:

mkdir $PYTORCH_BERT_DATA/packed

Ejecute el script de empaquetado:

python3 pack_pretraining_data_pytorch.py \
  --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
  --output_dir=$PYTORCH_BERT_DATA/packed \
  --max_predictions_per_seq=76

Paso 8. Ejecute una prueba

Ahora que el conjunto de datos está preparado, es el momento de ejecutar la prueba. Sin embargo, es imposible hacerlo sin una preparación previa. Los autores de la prueba Bert dejaron algunos valores codificados en el script, que interferirán con la ejecución de la prueba. En primer lugar, cambie el nombre del siguiente directorio

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Cambia el directorio:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PT

Como el editor GNU Nano no está instalado dentro del contenedor, debe instalarse por separado. Como alternativa, puede utilizar el editor Vi integrado:

apt update && apt -y install nano

Ahora, edita el script de lanzamiento de la prueba:

nano launch_bert_pytorch.sh

Encuentra la primera línea:

DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_data

Sustitúyela por lo siguiente:

DATA_ROOT=/root/datasets/pytorch_bert

Encuentra la segunda línea:

INPUT_DIR=$DATA_ROOT/packed

Sustitúyela por lo siguiente:

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Guarde el archivo y salga.

El código de la prueba incluye una función limitadora que restringe el gradiente para que no exceda ciertos valores, previniendo un potencial crecimiento exponencial. Por razones que desconocemos, esta función está ausente en la versión de PyTorch utilizada en el contenedor, causando que la prueba termine anormalmente durante la etapa de calentamiento.

Una posible solución podría ser eliminar temporalmente esta función del código en el archivo fastddp.py. Para ello, abra el archivo:

nano ../PyTorch/fastddp.py

Busque y comente las siguientes tres líneas de código utilizando el símbolo # (símbolo shebang) para que tengan este aspecto:

#from habana_frameworks.torch import _hpex_C
#    clip_global_grad_norm = _hpex_C.fused_lamb_norm(grads, 1.0)
#    _fusion_buffer.div_((clip_global_grad_norm * _all_reduce_group_size).to(_fusion_buffer.dtype))

Además, guarda el archivo y sal. Cambia el directorio:

cd ../HLS-Gaudi2-PT

Por último, ejecute el script. Tardará aproximadamente 20 minutos en completarse:

./launch_bert_pytorch.sh

Ver también:

Actualizado: 12.08.2025

Publicado: 23.01.2025