Intel Habana Gaudi 2: installieren und testen
Bevor Sie mit der Installation der Gaudi 2 Accelerators Software beginnen, sollten Sie eine wichtige Funktion erwähnen. Wir sind daran gewöhnt, dass das Training und die Inferenz von neuronalen Netzen mit GPUs durchgeführt werden können. Intel Habana Gaudi 2 unterscheidet sich jedoch stark von GPUs und stellt eine andere Klasse von Geräten dar, die ausschließlich für die Beschleunigung von KI-Aufgaben konzipiert sind.
Viele bekannte Anwendungen und Frameworks funktionieren nicht ohne vorherige Vorbereitung des Betriebssystems und in einigen Fällen auch nicht ohne ein spezielles GPU Migration Toolkit. Dies erklärt die große Anzahl von Vorbereitungsschritten, die wir in diesem Artikel beschreiben. Beginnen wir der Reihe nach.
Schritt 1. SynapseAI Software Stack installieren
Um mit Intel Habana Gaudi 2 Beschleunigern arbeiten zu können, müssen Sie den SynapseAI Stack installieren. Er umfasst einen speziellen Graphen-Compiler, der die Topologie des neuronalen Netzwerkmodells umwandelt, um die Ausführung auf der Gaudi-Architektur effektiv zu optimieren, API-Bibliotheken für die horizontale Skalierung sowie ein separates SDK für die Erstellung von Hochleistungsalgorithmen und maschinellen Lernmodellen.
Unabhängig davon ist SynapseAI der Teil, der es Ihnen ermöglicht, eine Brücke zwischen beliebten Frameworks wie PyTorch/TensorFlow und den Gaudi 2 AI-Beschleunigern zu schlagen. Dadurch können Sie mit vertrauten Abstraktionen arbeiten, und Gaudi 2 optimiert unabhängig Berechnungen. Spezifische Operatoren, für die Beschleuniger keine Hardwareunterstützung haben, werden auf der CPU ausgeführt.
Um die Installation der einzelnen SynapseAI-Komponenten zu vereinfachen, wurde ein praktisches Shell-Skript erstellt. Lassen Sie es uns herunterladen:
wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.shMachen Sie die Datei ausführbar:
chmod +x habanalabs-installer.shFühren Sie das Skript aus:
./habanalabs-installer.sh install --type baseFolgen Sie den Anweisungen des Systems während der Installation. Sie finden einen detaillierten Bericht in der Protokolldatei. Darin können Sie sehen, welche Pakete installiert wurden, und ob die Beschleuniger erfolgreich gefunden und initialisiert wurden.
Protokolle hier: /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
Genauso wie das nvidia-smi-Dienstprogramm Informationen über installierte GPUs und laufende Rechenprozesse liefert, hat SynapseAI ein ähnliches Programm. Sie können es ausführen, um einen Bericht über den aktuellen Zustand der Gaudi 2 AI-Beschleuniger zu erhalten:
hl-smi
Schritt 2. TensorFlow-Test
TensorFlow ist eine der beliebtesten Plattformen für maschinelles Lernen. Mit dem gleichen Installationsskript können Sie eine vorgefertigte Version von TensorFlow mit Unterstützung für Gaudi 2 Beschleuniger installieren. Lassen Sie uns mit der Installation der allgemeinen Abhängigkeiten beginnen:
./habanalabs-installer.sh install -t dependenciesAls nächstes werden wir die Abhängigkeiten für TensorFlow installieren:
./habanalabs-installer.sh install -t dependencies-tensorflowInstallieren Sie die TensorFlow Plattform innerhalb einer virtuellen Umgebung, die mit dem Python Virtual Environment (venv) Mechanismus implementiert wurde:
./habanalabs-installer.sh install --type tensorflow --venvLassen Sie uns die erstellte virtuelle Umgebung aktivieren:
source habanalabs-venv/bin/activateErstellen Sie ein einfaches Python-Codebeispiel, das die Fähigkeiten der Gaudi 2-Beschleuniger nutzt:
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()Führen Sie schließlich die Anwendung aus:
python3 example.pyUm die virtuelle Umgebung zu beenden, führen Sie den folgenden Befehl aus:
deactivateSchritt 3. Trainings-Repository klonen
Klonen Sie das Repository mit dem MLperf-Code:
git clone https://github.com/mlcommons/training_results_v3.0Erstellen Sie ein separates Verzeichnis, das vom Docker-Container mit MLperf verwendet werden soll:
mkdir -p mlperfWechseln Sie das Verzeichnis:
cd mlperfLassen Sie uns einige Umgebungsvariablen exportieren:
export MLPERF_DIR=/home/usergpu/mlperfexport SCRATCH_DIR=/home/usergpu/mlperf/scratchexport DATASETS_DIR=/home/usergpu/mlperf/datasetsErstellen Sie neue Verzeichnisse unter Verwendung der erstellten Variablen:
mkdir -p $MLPERF_DIR/Habanamkdir -p $SCRATCH_DIRmkdir -p $DATASETS_DIRKopieren Sie die Benchmark-Anwendung nach $MLPERF_DIR/Habana:
cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/HabanaExportieren Sie eine weitere Variable, in der ein Link zum Herunterladen der gewünschten Version des Docker-Containers gespeichert wird:
export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41Schritt 4. Docker installieren
Unsere Instanz läuft unter Ubuntu Linux 22.04 LTS und unterstützt Docker standardmäßig nicht. Bevor Sie also Container herunterladen und ausführen können, müssen Sie die Docker-Unterstützung installieren. Aktualisieren Sie den Paket-Cache und installieren Sie einige grundlegende Pakete, die Sie später benötigen werden:
sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-commonUm Docker zu installieren, müssen Sie ein digital signiertes Projekt-Repository hinzufügen. Laden Sie den Schlüssel für die digitale Signatur herunter und fügen Sie ihn dem Schlüsselspeicher des Betriebssystems hinzu:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpgDocker kann auf Plattformen mit verschiedenen Architekturen ausgeführt werden. Der folgende Befehl erkennt die Architektur Ihres Servers und fügt die entsprechende Repository-Zeile in die Liste des APT-Paketmanagers ein:
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/nullAktualisieren Sie den Paket-Cache und die Richtlinien und installieren Sie docker-ce (Docker Community Edition):
sudo apt update && apt-cache policy docker-ce && sudo apt install docker-cePrüfen Sie abschließend, ob der Docker-Daemon läuft und funktioniert:
sudo systemctl status dockerSchritt 5. Docker-Container starten
Starten wir den Container im privilegierten Modus unter Verwendung der zuvor angegebenen Variablen:
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_IMAGEDer Einfachheit halber können Sie über SSH auf das Terminal innerhalb des Containers zugreifen:
sudo docker exec mlperf3.0 bash -c "service ssh start"Um eine Befehlsshell (bash) in der aktuellen Sitzung zu öffnen, führen Sie den folgenden Befehl aus:
sudo docker exec -it mlperf3.0 bashSchritt 6. Vorbereiten eines Datensatzes
Um Bert-Implementierungstests mit MLperf durchzuführen, benötigen Sie einen vorbereiteten Datensatz. Die optimale Methode ist die Erzeugung eines Datensatzes aus vorgeladenen Daten. Das MLperf-Repository enthält ein spezielles Skript, prepare_data.sh, das eine bestimmte Anzahl von Paketen benötigt, um zu funktionieren. Wechseln wir in das folgende Verzeichnis:
cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorchInstallieren Sie alle erforderlichen Pakete mit Hilfe der vorbereiteten Liste und dem pip-Paketmanager:
pip install -r requirements.txtSetzen Sie die Variable PYTORCH_BERT_DATA, um dem Skript mitzuteilen, wo es Daten speichern soll:
export PYTORCH_BERT_DATA=/root/datasets/pytorch_bertFühren Sie das Skript aus:
bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATADas Generierungsverfahren ist recht langwierig und kann mehrere Stunden dauern. Bitte haben Sie Geduld und unterbrechen Sie den Vorgang nicht. Wenn Sie vorhaben, die SSH-Sitzung zu beenden, empfiehlt es sich, das Bildschirmdienstprogramm unmittelbar vor dem Start des Docker-Containers zu verwenden.
Schritt 7. Packen des Datensatzes
Der nächste Schritt besteht darin, den Datensatz für den anschließenden Start von MLperf in gleiche Teile zu "schneiden". Erstellen wir ein separates Verzeichnis für die gepackten Daten:
mkdir $PYTORCH_BERT_DATA/packedFühren Sie das Packing-Skript aus:
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=76Schritt 8. Einen Test durchführen
Nun, da der Datensatz vorbereitet ist, ist es an der Zeit, den Test durchzuführen. Dies ist jedoch ohne vorherige Vorbereitung nicht möglich. Die Autoren des Bert-Tests haben einige fest kodierte Werte im Skript hinterlassen, die die Ausführung des Tests beeinträchtigen werden. Benennen Sie zunächst das folgende Verzeichnis um:
mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_ptÄndern Sie das Verzeichnis:
cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PTDa der GNU Nano-Editor nicht im Container installiert ist, muss er separat installiert werden. Alternativ können Sie auch den eingebauten Vi-Editor verwenden:
apt update && apt -y install nanoBearbeiten Sie nun das Teststartskript:
nano launch_bert_pytorch.shSuchen Sie die erste Zeile:
DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_dataErsetzen Sie sie durch die folgende:
DATA_ROOT=/root/datasets/pytorch_bertSuchen Sie die zweite Zeile:
INPUT_DIR=$DATA_ROOT/packedErsetzen Sie sie durch die folgende:
INPUT_DIR=$DATA_ROOT/packed_data_500_ptSpeichern Sie die Datei und beenden Sie sie.
Der Testcode enthält eine Begrenzerfunktion, die den Gradienten daran hindert, bestimmte Werte zu überschreiten, um ein mögliches exponentielles Wachstum zu verhindern. Aus uns unbekannten Gründen fehlt diese Funktion in der im Container verwendeten PyTorch-Version, was dazu führt, dass der Test während der Aufwärmphase abnormal beendet wird.
Eine mögliche Abhilfe könnte darin bestehen, diese Funktion vorübergehend aus dem Code in der Datei fastddp.py zu entfernen. Dazu öffnen Sie die Datei:
nano ../PyTorch/fastddp.pySuchen Sie die folgenden drei Codezeilen und kommentieren Sie sie mit dem Symbol # (shebang) aus, so dass sie wie folgt aussehen:
#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))Speichern Sie außerdem die Datei und beenden Sie sie. Wechseln Sie das Verzeichnis:
cd ../HLS-Gaudi2-PTFühren Sie schließlich das Skript aus. Die Ausführung wird etwa 20 Minuten dauern:
./launch_bert_pytorch.shSiehe auch:
Aktualisiert: 12.08.2025
Veröffentlicht: 23.01.2025
