Einrichten von Training, Feinabstimmung und Inferenz von LLMs mit NVIDIA-GPUs und CUDA

Das Feld der künstlichen Intelligenz (KI) hat in den letzten Jahren bemerkenswerte Fortschritte erlebt, und im Herzen davon liegt die leistungsstarke Kombination aus Grafikprozessoren (GPUs) und der parallelen Rechenplattform.

Modelle wie GPT, BERT und mehr recently Llama, Mistral sind in der Lage, menschliche Texte mit unvergleichlicher Flüssigkeit und Kohärenz zu verstehen und zu generieren. Allerdings erfordert das Training dieser Modelle enorme Mengen an Daten und Rechenressourcen, wodurch GPUs und CUDA unverzichtbare Werkzeuge in diesem Unterfangen sind.

Dieser umfassende Leitfaden wird Sie durch den Prozess der Einrichtung einer NVIDIA-GPU auf Ubuntu führen, einschließlich der Installation von wesentlichen Softwarekomponenten wie dem NVIDIA-Treiber, dem CUDA-Toolkit, cuDNN, PyTorch und mehr.

Der Aufstieg von CUDA-beschleunigten KI-Frameworks

GPU-beschleunigtes Deep Learning wurde durch die Entwicklung von beliebten KI-Frameworks vorangetrieben, die CUDA für effiziente Berechnungen nutzen. Frameworks wie TensorFlow, PyTorch und MXNet haben eine integrierte Unterstützung für CUDA, was eine nahtlose Integration von GPU-Beschleunigung in Deep-Learning-Pipelines ermöglicht.

Laut der NVIDIA Data Center Deep Learning Product Performance Study können CUDA-beschleunigte Deep-Learning-Modelle bis zu 100-mal schnellere Leistung im Vergleich zu CPU-basierten Implementierungen erreichen.

NVIDIA’s Multi-Instance-GPU- (MIG-) Technologie, die mit der Ampere-Architektur eingeführt wurde, ermöglicht es, eine einzelne GPU in mehrere sichere Instanzen aufzuteilen, von denen jede ihre eigenen dedizierten Ressourcen hat. Diese Funktion ermöglicht eine effiziente Aufteilung von GPU-Ressourcen unter mehreren Benutzern oder Workloads, wodurch die Auslastung maximiert und die Gesamtkosten reduziert werden.

Beschleunigung von LLM-Inferenz mit NVIDIA TensorRT

Während GPUs bei der Ausbildung von LLMs instrumental waren, ist eine effiziente Inferenz ebenso wichtig für die Bereitstellung dieser Modelle in Produktionsumgebungen. NVIDIA TensorRT, ein Hochleistungs-Deep-Learning-Inferenz-Optimierer und Laufzeitumgebung, spielt eine wichtige Rolle bei der Beschleunigung von LLM-Inferenz auf CUDA-fähigen GPUs.

Laut NVIDIA’s Benchmarks kann TensorRT bis zu 8-mal schnellere Inferenzleistung und 5-mal geringere Gesamtkosten im Vergleich zu CPU-basierten Inferenz für große Sprachmodelle wie GPT-3 bieten.

NVIDIA’s Engagement für Open-Source-Initiativen war ein treibender Faktor bei der weitverbreiteten Akzeptanz von CUDA in der KI-Forschungsgemeinschaft. Projekte wie cuDNN, cuBLAS und NCCL sind als Open-Source-Bibliotheken verfügbar, wodurch Forscher und Entwickler die volle Leistungsfähigkeit von CUDA für ihre Deep-Learning-Anwendungen nutzen können.

Installation

Wenn Sie AI-Entwicklung betreiben, ist es nicht immer ratsam, die neuesten Treiber und Bibliotheken zu verwenden. Zum Beispiel unterstützt der neueste NVIDIA-Treiber (545.xx) CUDA 12.3, aber PyTorch und andere Bibliotheken unterstützen diese Version möglicherweise noch nicht. Daher werden wir den Treiber in der Version 535.146.02 mit CUDA 12.2 verwenden, um die Kompatibilität zu gewährleisten.

Installationschritte

1. Installation des NVIDIA-Treibers

Zuerst müssen Sie Ihr GPU-Modell identifizieren. Für diesen Leitfaden verwenden wir die NVIDIA-GPU. Besuchen Sie die NVIDIA-Treiber-Download-Seite, wählen Sie den entsprechenden Treiber für Ihre GPU aus und notieren Sie die Treiberversion.

Um vorgefertigte GPU-Pakete auf Ubuntu zu überprüfen, führen Sie den folgenden Befehl aus:

sudo ubuntu-drivers list --gpgpu

Starten Sie Ihren Computer neu und überprüfen Sie die Installation:

nvidia-smi

2. Installation des CUDA-Toolkits

Das CUDA-Toolkit bietet die Entwicklungsumgebung für die Erstellung von hochleistungsorientierten GPU-beschleunigten Anwendungen.

Für eine Nicht-LLM/Tiefenlern-Installation können Sie Folgendes verwenden:

sudo apt install nvidia-cuda-toolkit

Allerdings werden wir, um die Kompatibilität mit BitsAndBytes zu gewährleisten, die folgenden Schritte ausführen:

[code language="BASH"]

git clone https://github.com/TimDettmers/bitsandbytes.git
cd bitsandbytes/
bash install_cuda.sh 122 ~/local 1

Überprüfen Sie die Installation:

~/local/cuda-12.2/bin/nvcc --version

Setzen Sie die Umgebungsvariablen:

export CUDA_HOME=/home/roguser/local/cuda-12.2/
export LD_LIBRARY_PATH=/home/roguser/local/cuda-12.2/lib64
export BNB_CUDA_VERSION=122
export CUDA_VERSION=122

3. Installation von cuDNN

Laden Sie das cuDNN-Paket von der NVIDIA-Entwickler-Website herunter. Installieren Sie es mit:

sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb

Folgen Sie den Anweisungen, um den Schlüsselring hinzuzufügen:

sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/

Installieren Sie die cuDNN-Bibliotheken:

sudo apt update
sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples

4. Einrichten einer Python-Virtual-Umgebung

Ubuntu 22.04 kommt mit Python 3.10. Installieren Sie venv:

sudo apt-get install python3-pip
sudo apt install python3.10-venv

Erstellen und aktivieren Sie die virtuelle Umgebung:

cd
mkdir test-gpu
cd test-gpu
python3 -m venv venv
source venv/bin/activate

5. Installation von BitsAndBytes aus dem Quellcode

Navigieren Sie zum BitsAndBytes-Verzeichnis und bauen Sie es aus dem Quellcode:

cd ~/bitsandbytes
CUDA_HOME=/home/roguser/local/cuda-12.2/ \
LD_LIBRARY_PATH=/home/roguser/local/cuda-12.2/lib64 \
BNB_CUDA_VERSION=122 \
CUDA_VERSION=122 \
make cuda12x

CUDA_HOME=/home/roguser/local/cuda-12.2/ \
LD_LIBRARY_PATH=/home/roguser/local/cuda-12.2/lib64 \
BNB_CUDA_VERSION=122 \
CUDA_VERSION=122 \
python setup.py install

6. Installation von PyTorch

Installieren Sie PyTorch mit dem folgenden Befehl:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

7. Installation von Hugging Face und Transformers

Installieren Sie die Transformers- und Accelerate-Bibliotheken:

pip install transformers
pip install accelerate

Die Macht der parallelen Verarbeitung

Im Kern sind GPUs hochparallele Prozessoren, die darauf ausgelegt sind, Tausende von Threads gleichzeitig effizient zu verarbeiten. Diese Architektur macht sie ideal für die rechenintensiven Aufgaben, die bei der Ausbildung von Deep-Learning-Modellen, einschließlich LLMs, auftreten. Die CUDA-Plattform, die von NVIDIA entwickelt wurde, bietet eine Softwareumgebung, die es Entwicklern ermöglicht, das volle Potenzial dieser GPUs zu nutzen, indem sie Code schreiben können, der die parallele Verarbeitungsfähigkeiten der Hardware ausnutzt.
Beschleunigung von LLM-Training mit GPUs und CUDA.

Das Training von großen Sprachmodellen ist eine rechenintensive Aufgabe, die die Verarbeitung großer Mengen an Textdaten und die Durchführung zahlreicher Matrixoperationen erfordert. GPUs mit ihren Tausenden von Kernen und hoher Speicherbandbreite sind ideal für diese Aufgaben geeignet. Durch die Nutzung von CUDA können Entwickler ihren Code optimieren, um die parallele Verarbeitungsfähigkeiten von GPUs zu nutzen, wodurch die Zeit, die für die Ausbildung von LLMs benötigt wird, erheblich reduziert wird.

Zum Beispiel wurde das Training von GPT-3, einem der größten Sprachmodelle, durch die Verwendung von Tausenden von NVIDIA-GPUs mit CUDA-optimiertem Code ermöglicht. Dies ermöglichte es dem Modell, auf einer unvergleichlichen Menge an Daten trainiert zu werden, was zu seiner beeindruckenden Leistung in natürlichen Sprachaufgaben führte.

import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Laden Sie das vorgefertigte GPT-2-Modell und den Tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Verschieben Sie das Modell auf die GPU, wenn verfügbar
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Definieren Sie die Trainingsdaten und Hyperparameter
train_data = [...] # Ihre Trainingsdaten
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Definieren Sie die Verlustfunktion und den Optimierer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Trainingsloop
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Vorbereiten der Eingabe- und Zielsequenzen
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Vorwärtslauf
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Rückwärtslauf und Optimierung
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f'Epoch {epoch+1}/{num_epochs}, Verlust: {loss.item()}')

In diesem Codebeispiel demonstrieren wir die Ausbildung eines GPT-2-Sprachmodells mit PyTorch und CUDA-fähigen GPUs. Das Modell wird auf die GPU (wenn verfügbar) geladen, und die Trainingsloop nutzt die Parallelität von GPUs, um effiziente Vorwärts- und Rückwärtsläufe durchzuführen, wodurch die Ausbildung beschleunigt wird.

CUDA-beschleunigte Bibliotheken für Deep Learning

Zusätzlich zur CUDA-Plattform selbst haben NVIDIA und die Open-Source-Community eine Reihe von CUDA-beschleunigten Bibliotheken entwickelt, die eine effiziente Implementierung von Deep-Learning-Modellen, einschließlich LLMs, ermöglichen. Diese Bibliotheken bieten optimierte Implementierungen von gängigen Operationen wie Matrixmultiplikationen, Konvolutionen und Aktivierungsfunktionen, wodurch Entwickler sich auf die Modellarchitektur und den Trainingsprozess konzentrieren können, anstatt sich mit der Low-Level-Optimierung zu befassen.

Eine solche Bibliothek ist cuDNN (CUDA Deep Neural Network-Bibliothek), die hoch optimierte Implementierungen von Standardroutinen bietet, die in tiefen neuronalen Netzen verwendet werden. Durch die Nutzung von cuDNN können Entwickler die Ausbildung und Inferenz ihrer Modelle erheblich beschleunigen, wodurch Leistungssteigerungen von bis zu mehreren Größenordnungen im Vergleich zu CPU-basierten Implementierungen erreicht werden können.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.cuda.amp import autocast

class ResidualBlock(nn.Module):
def __init__(self, in_channels, out_channels, stride=1):
super().__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(out_channels)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != out_channels:
self.shortcut = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(out_channels))

def forward(self, x):
with autocast():
out = F.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
out += self.shortcut(x)
out = F.relu(out)
return out

In diesem Codebeispiel definieren wir einen Residualblock für ein konvolutionales neuronales Netzwerk (CNN) mit PyTorch. Der autocast-Kontextmanager von PyTorch’s Automatic Mixed Precision (AMP) wird verwendet, um gemischte Präzisionstraining zu ermöglichen, was auf CUDA-fähigen GPUs erhebliche Leistungssteigerungen bieten kann, während die Genauigkeit erhalten bleibt. Die F.relu-Funktion wird von cuDNN optimiert, um eine effiziente Ausführung auf GPUs zu gewährleisten.

Mehrgpu- und verteilte Ausbildung für Skalierbarkeit

Da LLMs und Deep-Learning-Modelle weiter an Größe und Komplexität zunehmen, steigen auch die Rechenanforderungen für die Ausbildung dieser Modelle. Um diese Herausforderung zu meistern, haben Forscher und Entwickler auf Mehrgpu- und verteilte Ausbildungstechniken zurückgegriffen, die es ermöglichen, die kombinierte Rechenleistung von mehreren GPUs über mehrere Maschinen hinweg zu nutzen.

CUDA und zugehörige Bibliotheken wie NCCL (NVIDIA Collective Communications Library) bieten effiziente Kommunikationsprimitiven, die eine nahtlose Datenübertragung und Synchronisation zwischen mehreren GPUs ermöglichen, wodurch verteilte Ausbildung im großen Maßstab ermöglicht wird.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialisieren Sie die verteilte Ausbildung
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Erstellen Sie das Modell und verschieben Sie es auf die GPU
model = MyModel().cuda()

# Umschließen Sie das Modell mit DDP
model = DDP(model, device_ids=[local_rank])

# Trainingsloop (verteilt)
for epoch in range(num_epochs):
for data in train_loader:
inputs, targets = data
inputs = inputs.cuda(non_blocking=True)
targets = targets.cuda(non_blocking=True)

outputs = model(inputs)
loss = criterion(outputs, targets)

optimizer.zero_grad()
loss.backward()
optimizer.step()

In diesem Beispiel demonstrieren wir verteilte Ausbildung mit PyTorch’s DistributedDataParallel (DDP)-Modul. Das Modell wird in DDP eingehüllt, das automatisch Datenparallelismus, Gradientensynchronisation und Kommunikation zwischen mehreren GPUs mit NCCL handhabt. Dieser Ansatz ermöglicht eine effiziente Skalierung des Trainingsprozesses über mehrere Maschinen hinweg, wodurch Forscher und Entwickler größere und komplexere Modelle in angemessener Zeit ausbilden können.

Bereitstellung von Deep-Learning-Modellen mit CUDA

Während GPUs und CUDA hauptsächlich für die Ausbildung von Deep-Learning-Modellen verwendet wurden, sind sie auch für die effiziente Bereitstellung und Inferenz unerlässlich. Da Deep-Learning-Modelle immer komplexer und ressourcenintensiver werden, ist GPU-Beschleunigung für die Erzielung von Echtzeitleistung in Produktionsumgebungen unerlässlich.

NVIDIA’s TensorRT ist ein Hochleistungs-Deep-Learning-Inferenz-Optimierer und Laufzeitumgebung, der niedrige Latenz und hohe Durchsatzleistung auf CUDA-fähigen GPUs bietet. TensorRT kann Modelle optimieren und beschleunigen, die in Frameworks wie TensorFlow, PyTorch und MXNet trainiert wurden, wodurch eine effiziente Bereitstellung auf verschiedenen Plattformen, von eingebetteten Systemen bis hin zu Rechenzentren, ermöglicht wird.

import tensorrt as trt

# Laden Sie das vorgefertigte Modell
model = load_model(...)

# Erstellen Sie den TensorRT-Motor
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Parsen und Optimieren des Modells
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Führen Sie die Inferenz auf der GPU aus
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Setzen Sie die Eingabedaten und führen Sie die Inferenz aus
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Verarbeiten Sie die Ausgabe
# ...

In diesem Beispiel demonstrieren wir die Verwendung von TensorRT für die Bereitstellung eines vorgefertigten Deep-Learning-Modells auf einer CUDA-fähigen GPU. Das Modell wird zuerst von TensorRT geparst und optimiert, was einen hoch optimierten Inferenz-Motor generiert, der auf die spezifische Hardware zugeschnitten ist. Dieser Motor kann dann verwendet werden, um effiziente Inferenz auf der GPU durchzuführen, wodurch CUDA für die beschleunigte Berechnung genutzt wird.

Zusammenfassung

Die Kombination aus GPUs und CUDA war maßgeblich an den Fortschritten bei großen Sprachmodellen, Computer-Vision, Spracherkennung und verschiedenen anderen Bereichen des Deep Learning beteiligt. Durch die Nutzung der parallelen Verarbeitungsfähigkeiten von GPUs und der optimierten Bibliotheken von CUDA können Forscher und Entwickler immer komplexere Modelle mit hoher Effizienz ausbilden und bereitstellen.

Da das Feld der KI weiterhin evolviert, wird die Bedeutung von GPUs und CUDA nur noch größer. Mit noch leistungsfähigerer Hardware und Softwareoptimierungen können wir weitere Durchbrüche in der Entwicklung und Bereitstellung von KI-Systemen erwarten, die die Grenzen dessen, was möglich ist, weiter verschieben.