Het instellen van een training, fine-tuning en inferencing van LLM’s met NVIDIA GPU’s en CUDA

Het veld van kunstmatige intelligentie (AI) heeft in de afgelopen jaren een opmerkelijke vooruitgang geboekt, en het hart ervan ligt in de krachtige combinatie van graphics processing units (GPU’s) en parallelle rekenplatforms.

Modellen zoals GPT, BERT, en meer recent Llama, Mistral zijn in staat om menselijke tekst te begrijpen en te genereren met ongekende vloeiendheid en coherentie. Echter, het trainen van deze modellen vereist enorme hoeveelheden data en rekenbronnen, waardoor GPU’s en CUDA onmisbare instrumenten zijn in dit streven.

Deze uitgebreide gids zal u door het proces leiden van het instellen van een NVIDIA GPU op Ubuntu, met inbegrip van de installatie van essentiële softwarecomponenten zoals de NVIDIA-stuurprogramma, CUDA Toolkit, cuDNN, PyTorch en meer.

De opkomst van CUDA-geaccelereerde AI-frameworks

GPU-geaccelereerd diepe leren is aangewakkerd door de ontwikkeling van populaire AI-frameworks die CUDA gebruiken voor efficiënte berekening. Frameworks zoals TensorFlow, PyTorch, en MXNet hebben ingebouwde ondersteuning voor CUDA, waardoor een naadloze integratie van GPU-versnelling in diepe leren pipelines mogelijk is.

Volgens de NVIDIA Data Center Deep Learning Product Performance Study, kunnen CUDA-geaccelereerde diepe leren modellen tot 100 keer snellere prestaties bereiken in vergelijking met CPU-gebaseerde implementaties.

NVIDIA’s Multi-Instance GPU (MIG) technologie, geïntroduceerd met de Ampere architectuur, stelt één GPU in staat om te worden opgedeeld in meerdere beveiligde instanties, elk met zijn eigen toegewezen bronnen. Deze functie maakt een efficiënte sharing van GPU-bronnen onder meerdere gebruikers of workloads mogelijk, waardoor de benutting wordt gemaximaliseerd en de totale kosten worden verlaagd.

Versnellen van LLM-inferencing met NVIDIA TensorRT

Terwijl GPU’s instrumenteel zijn geweest bij het trainen van LLM’s, is efficiënte inferencing eveneens cruciaal voor het in productie nemen van deze modellen. NVIDIA TensorRT, een hoge-prestatie diepe leren inferencing optimizer en runtime, speelt een vitale rol bij het versnellen van LLM-inferencing op CUDA-geactiveerde GPU’s.

Volgens NVIDIA’s benchmarks kan TensorRT tot 8 keer snellere inferentieprestaties en 5 keer lagere totale eigendomskosten bieden in vergelijking met CPU-gebaseerde inferencing voor grote taalmodellen zoals GPT-3.

NVIDIA’s toewijding aan open-source initiatieven is een drijvende kracht geweest achter de wijdverbreide adoptie van CUDA in de AI-onderzoekscommunity. Projecten zoals cuDNN, cuBLAS, en NCCL zijn beschikbaar als open-source bibliotheken, waardoor onderzoekers en ontwikkelaars de volledige potentie van CUDA kunnen benutten voor hun diepe leren.

Installatie

Bij het opzetten van AI-ontwikkeling, kan het gebruik van de laatste stuurprogramma’s en bibliotheken niet altijd de beste keuze zijn. Bijvoorbeeld, terwijl de laatste NVIDIA-stuurprogramma (545.xx) CUDA 12.3 ondersteunt, kunnen PyTorch en andere bibliotheken deze versie nog niet ondersteunen. Daarom zullen we stuurprogramma versie 535.146.02 met CUDA 12.2 gebruiken om compatibiliteit te garanderen.

Installatie-stappen

1. Installeer NVIDIA-stuurprogramma

Identificeer eerst uw GPU-model. Voor deze gids gebruiken we de NVIDIA GPU. Bezoek de NVIDIA-stuurprogramma download pagina, selecteer de juiste stuurprogramma voor uw GPU en noteer de stuurprogramma versie.

Om te controleren op vooraf gebouwde GPU-pakketten op Ubuntu, voer uit:

sudo ubuntu-drivers list --gpgpu

Herstart uw computer en verifieer de installatie:

nvidia-smi

2. Installeer CUDA Toolkit

De CUDA Toolkit biedt de ontwikkelomgeving voor het creëren van high-performance GPU-geaccelereerde toepassingen.

Voor een niet-LLM/diepe leren setup, kunt u gebruiken:

sudo apt install nvidia-cuda-toolkit

Echter, om compatibiliteit met BitsAndBytes te garanderen, zullen we de volgende stappen volgen:

[code language="BASH"]

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

Verifieer de installatie:

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

Stel de omgevingsvariabelen in:

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. Installeer cuDNN

Download het cuDNN-pakket van de NVIDIA-ontwikkelaarswebsite. Installeer het met:

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

Volg de instructies om de keyring toe te voegen:

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

Installeer de cuDNN-bibliotheken:

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

4. Stel Python-virtuele omgeving in

Ubuntu 22.04 komt met Python 3.10. Installeer venv:

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

Maak en activeer de virtuele omgeving:

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

5. Installeer BitsAndBytes vanuit bron

Navigeer naar de BitsAndBytes-directory en bouw vanuit bron:

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. Installeer PyTorch

Installeer PyTorch met de volgende opdracht:

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

7. Installeer Hugging Face en Transformers

Installeer de transformers en accelerate bibliotheken:

pip install transformers
pip install accelerate

De kracht van parallelle verwerking

In hun kern zijn GPU’s hoogwaardige parallelle verwerkers ontworpen om duizenden gelijktijdige threads efficiënt te verwerken. Deze architectuur maakt hen zeer geschikt voor de rekenintensieve taken die betrokken zijn bij het trainen van diepe leren modellen, inclusief LLM’s. Het CUDA-platform, ontwikkeld door NVIDIA, biedt een softwareomgeving die ontwikkelaars in staat stelt om de volledige potentie van deze GPU’s te benutten, waardoor zij code kunnen schrijven die de parallelle verwerkingsmogelijkheden van de hardware kan benutten.
Versnellen van LLM training met GPU’s en CUDA.

Het trainen van grote taalmodellen is een rekenintensieve taak die het verwerken van enorme hoeveelheden tekstdata en het uitvoeren van talloze matrixoperaties vereist. GPU’s, met hun duizenden kernen en hoge geheugensbandbreedte, zijn ideaal geschikt voor deze taken. Door CUDA te gebruiken, kunnen ontwikkelaars hun code optimaliseren om de parallelle verwerkingsmogelijkheden van GPU’s te benutten, waardoor de tijd die nodig is om LLM’s te trainen aanzienlijk wordt verkort.

Bijvoorbeeld, het trainen van GPT-3, een van de grootste taalmodellen tot nu toe, was mogelijk gemaakt door het gebruik van duizenden NVIDIA GPU’s die CUDA-geoptimaliseerde code uitvoerden. Dit stelde het model in staat om getraind te worden op een ongekende hoeveelheid data, wat leidde tot zijn indrukwekkende prestaties in natuurlijke taaltaken.

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

# Laad voorgetraind GPT-2 model en tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Verplaats model naar GPU als beschikbaar
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Definieer trainingsdata en hyperparameters
train_data = [...] # Uw trainingsdata
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Definieer verliesfunctie en optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Trainingslus
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Bereid invoer- en doelsequenties voor
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Voorwaartse pas
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Achterwaartse pas en optimalisatie
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

In dit voorbeeld demonstreren we het trainen van een GPT-2 taalmodel met PyTorch en CUDA-geactiveerde GPU’s. Het model wordt geladen op de GPU (als beschikbaar), en de trainingslus benut de parallelle verwerkingsmogelijkheden van GPU’s om efficiënte voorwaartse en achterwaartse passes uit te voeren, waardoor het trainingsproces wordt versneld.

CUDA-geaccelereerde bibliotheken voor diepe leren

Naast het CUDA-platform zelf, hebben NVIDIA en de open-source gemeenschap een reeks CUDA-geaccelereerde bibliotheken ontwikkeld die efficiënte implementatie van diepe leren modellen mogelijk maken, inclusief LLM’s. Deze bibliotheken bieden geoptimaliseerde implementaties van veelvoorkomende operaties, zoals matrixvermenigvuldigingen, convoluties en activatiefuncties, waardoor ontwikkelaars zich kunnen concentreren op de modelarchitectuur en het trainingsproces in plaats van lage-niveau optimalisatie.

Een dergelijke bibliotheek is cuDNN (CUDA Deep Neural Network bibliotheek), die hoogwaardig getune implementaties van standaardroutines biedt die in diepe neurale netwerken worden gebruikt. Door cuDNN te gebruiken, kunnen ontwikkelaars hun modellen aanzienlijk versnellen, waardoor prestatiewinsten van tot enkele ordes van grootte kunnen worden behaald in vergelijking met CPU-gebaseerde implementaties.

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 dit codevoorbeeld definiëren we een residublok voor een convolutioneel neuronaal netwerk (CNN) met PyTorch. De autocast context manager van PyTorch’s Automatic Mixed Precision (AMP) wordt gebruikt om gemengde precisie training in te schakelen, wat aanzienlijke prestatiewinsten kan bieden op CUDA-geactiveerde GPU’s terwijl hoge nauwkeurigheid wordt behouden. De F.relu functie is geoptimaliseerd door cuDNN, waardoor efficiënte uitvoering op GPU’s wordt gegarandeerd.

Multi-GPU en gedistribueerde training voor schaalbaarheid

Aangezien LLM’s en diepe leren modellen continue groeien in grootte en complexiteit, nemen de rekenvereisten voor het trainen van deze modellen ook toe. Om deze uitdaging aan te pakken, zijn onderzoekers en ontwikkelaars overgestapt op multi-GPU en gedistribueerde trainingsmethoden, die het mogelijk maken om de gecombineerde verwerkingskracht van meerdere GPU’s over meerdere machines te benutten.

CUDA en verwante bibliotheken, zoals NCCL (NVIDIA Collective Communications Library), bieden efficiënte communicatieprimitieven die naadloze datatransfer en synchronisatie over meerdere GPU’s mogelijk maken, waardoor gedistribueerde training op een ongekende schaal mogelijk wordt.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialiseer gedistribueerde training
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Maak model en verplaats naar GPU
model = MyModel().cuda()

# Wrap model met DDP
model = DDP(model, device_ids=[local_rank])

# Trainingslus (gedistribueerd)
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 dit voorbeeld demonstreren we gedistribueerde training met PyTorch’s DistributedDataParallel (DDP) module. Het model wordt gewikkeld in DDP, dat automatisch data parallelisme, gradient synchronisatie en communicatie over meerdere GPU’s met NCCL afhandelt. Deze benadering stelt onderzoekers en ontwikkelaars in staat om het trainingsproces efficiënt over meerdere machines te schalen, waardoor zij grotere en complexere modellen in een redelijke tijd kunnen trainen.

Implementatie van diepe leren modellen met CUDA

Terwijl GPU’s en CUDA voornamelijk zijn gebruikt voor het trainen van diepe leren modellen, zijn zij eveneens cruciaal voor efficiënte implementatie en inferencing. Aangezien diepe leren modellen steeds complexer en rekenintensiever worden, is GPU-versnelling essentieel voor het bereiken van real-time prestaties in productieomgevingen.

NVIDIA’s TensorRT is een hoge-prestatie diepe leren inferencing optimizer en runtime die lage latentie en hoge doorvoer inferencing op CUDA-geactiveerde GPU’s biedt. TensorRT kan modellen geoptimaliseerd en versneld worden die zijn getraind in frameworks zoals TensorFlow, PyTorch en MXNet, waardoor efficiënte implementatie op verschillende platforms mogelijk wordt, van ingebedde systemen tot datacenters.

import tensorrt as trt

# Laad voorgetraind model
model = load_model(...)

# Maak TensorRT-engine
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Parse en optimaliseer model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Voer inferencing uit op GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Stel invoerdata in en voer inferencing uit
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Verwerk uitvoer
# ...

In dit voorbeeld demonstreren we het gebruik van TensorRT voor het implementeren van een voorgetraind diepe leren model op een CUDA-geactiveerde GPU. Het model wordt eerst geparst en geoptimaliseerd door TensorRT, dat een hoogwaardig geoptimaliseerde inferencing engine genereert die is afgestemd op het specifieke model en de hardware. Deze engine kan vervolgens worden gebruikt om efficiënte inferencing uit te voeren op de GPU, waardoor CUDA-geactiveerde berekening wordt benut.

Conclusie

De combinatie van GPU’s en CUDA is instrumenteel geweest bij het stimuleren van de vooruitgang in grote taalmodellen, computerzicht, spraakherkenning en diverse andere domeinen van diepe leren. Door de parallelle verwerkingsmogelijkheden van GPU’s en de geoptimaliseerde bibliotheken van CUDA te benutten, kunnen onderzoekers en ontwikkelaars steeds complexere modellen trainen en implementeren met hoge efficiëntie.

Aangezien het veld van AI continue evolueert, zal de belangrijkheid van GPU’s en CUDA alleen maar toenemen. Met nog krachtigere hardware en software optimalisaties, kunnen wij verwachten dat er verdere doorbraken zullen komen in de ontwikkeling en implementatie van AI-systemen, waardoor de grenzen van wat mogelijk is worden verlegd.