Het opzetten van een trainings-, fine-tunings- en inferentieproces van LLM’s met NVIDIA-GPU’s en CUDA

Het veld van kunstmatige intelligentie (AI) heeft de afgelopen jaren een opmerkelijke vooruitgang geboekt, en het krachtige combinatie van graphics processing units (GPU’s) en parallelle verwerking is hierin een belangrijke factor.

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

Deze uitgebreide gids zal u door het proces leiden van het opzetten van een NVIDIA (NVDA ) -GPU op Ubuntu, met inbegrip van de installatie van essentiële softwarecomponenten zoals de NVIDIA-stuurprogramma’s, 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 sneller presteren in vergelijking met CPU-gebaseerde implementaties.

NVIDIA’s Multi-Instance GPU (MIG) technologie, geïntroduceerd met de Ampere-architectuur, maakt het mogelijk om één GPU te partitioneren in meerdere beveiligde instanties, elk met zijn eigen toegewezen resources. Deze functie maakt een efficiënte deling van GPU-resources onder meerdere gebruikers of workloads mogelijk, waardoor de algehele kosten worden verlaagd.

LLM-inferentie versnellen met NVIDIA TensorRT

Terwijl GPU’s essentieel zijn geweest bij het trainen van LLM’s, is efficiënte inferentie eveneens cruciaal voor het in productie brengen van deze modellen. NVIDIA TensorRT, een high-performance diepe leren inferentie-optimalisator en runtime, speelt een vitale rol bij het versnellen van LLM-inferentie 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 inferentie voor grote taalmodellen zoals GPT-3.

NVIDIA’s toewijding aan open-source-initiatieven is een belangrijke drijfveer 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 is het niet altijd de beste keuze om de laatste stuurprogramma’s en bibliotheken te gebruiken. 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.

Installatiestappen

1. Installeer NVIDIA-stuurprogramma

Eerst moet u uw GPU-model identificeren. Voor deze gids gebruiken we de NVIDIA GPU. Bezoek de NVIDIA-stuurprogramma downloadpagina, selecteer de juiste stuurprogramma voor uw GPU en noteer de stuurprogramma-versie.

Controleer of er vooraf gebouwde GPU-pakketten op Ubuntu zijn, 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 maken van high-performance GPU-geaccelereerde toepassingen.

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

sudo apt install nvidia-cuda-toolkit

<p>Echter, om compatibiliteit met BitsAndBytes te garanderen, zullen we deze stappen volgen:</p>

[code language=&amp;quot;BASH&amp;quot;]

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

Verifieer de installatie:

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

Stel de omgevingsvariabelen in:

<p>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</p>

3. Installeer cuDNN

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

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

Volg de instructies om de keyring toe te voegen:

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

Installeer de cuDNN-bibliotheken:

<p>sudo apt update
sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>

4. Stel een Python-virtuele omgeving in

Ubuntu 22.04 komt met Python 3.10. Installeer venv:

<p>sudo apt-get install python3-pip
sudo apt install python3.10-venv</p>

Maak en activeer de virtuele omgeving:

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

5. Installeer BitsAndBytes vanuit de bron

Navigeer naar de BitsAndBytes-map en bouw vanuit de bron:

<p>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</p>

<p>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</p>

6. Installeer PyTorch

Installeer PyTorch met de volgende opdracht:

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

7. Installeer Hugging en Transformers

Installeer de transformers en accelerate bibliotheken:

<p>pip install transformers
pip install accelerate</p>

De kracht van parallelle verwerking

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

Het trainen van grote taalmodellen is een rekenintensieve taak die het verwerken van enorme hoeveelheden tekstgegevens en het uitvoeren van talloze matrixoperaties vereist. GPU’s, met hun duizenden kernen en hoge geheugensnelheid, 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, werd 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 gegevens, wat leidde tot zijn indrukwekkende prestaties in natuurlijke taaltaken.

<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>

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

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

<p># Definieer trainingsgegevens en hyperparameters
train_data = [...] # Uw trainingsgegevens
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>

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

<p># 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)</p>

<p># Voorwaartse pas
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>

<p># Achterwaartse pas en optimalisatie
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

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

In deze codefragment demonsteren 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 verwerking 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, waaronder LLM’s. Deze bibliotheken bieden geoptimaliseerde implementaties van gemeenschappelijke operaties, zoals matrixvermenigvuldigingen, convoluties en activatiefuncties, waardoor ontwikkelaars zich kunnen concentreren op de modelarchitectuur en het trainingsproces in plaats van lage optimalisatie.

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

<p>import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.cuda.amp import autocast</p>

<p>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))</p>

<p>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</p>

In dit codefragment definiëren we een residu-blok voor een convolutioneel neuronaal netwerk (CNN) met PyTorch. De autocast-contextmanager van PyTorch’s Automatic Mixed Precision (AMP) wordt gebruikt om gemengde precisietraining mogelijk te maken, wat aanzienlijke prestatieverbeteringen kan bieden op CUDA-geactiveerde GPU’s terwijl hoge nauwkeurigheid wordt behouden. De F.relu-functie wordt geoptimaliseerd door cuDNN, waardoor efficiënte uitvoering op GPU’s wordt gegarandeerd.

Multi-GPU en gedistribueerde training voor schaalbaarheid

Naarmate LLM’s en diepe leren modellen groter en complexer worden, 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, waardoor ze de gecombineerde verwerkingskracht van meerdere GPU’s over meerdere machines kunnen benutten.

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

</pre>
import torch.distributed as dist

<p>from torch.nn.parallel import DistributedDataParallel as DDP</p>

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

<p># Maak model en verplaats naar GPU
model = MyModel().cuda()</p>

<p># Wikkel model in DDP
model = DDP(model, device_ids=[local_rank])</p>

<p># 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)</p>

<p>outputs = model(inputs)
loss = criterion(outputs, targets)</p>

<p>optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

In dit voorbeeld demonstreren we gedistribueerde training met PyTorch’s DistributedDataParallel (DDP) module. Het model wordt gewikkeld in DDP, waardoor data-parallellisme, gradient-synchronisatie en communicatie over meerdere GPU’s automatisch worden afgehandeld met behulp van NCCL. Deze aanpak maakt een efficiënte schaalvergroting van het trainingsproces over meerdere machines mogelijk, waardoor onderzoekers en ontwikkelaars grotere en complexere modellen in een redelijke tijd kunnen trainen.

Diepe leren modellen implementeren met CUDA

Terwijl GPU’s en CUDA voornamelijk zijn gebruikt voor het trainen van diepe leren modellen, zijn ze ook cruciaal voor efficiënte implementatie en inferentie. Naarmate diepe leren modellen complexer en rekenintensiever worden, is GPU-versnelling essentieel voor het behalen van real-time prestaties in productieomgevingen.

NVIDIA’s TensorRT is een high-performance diepe leren inferentie-optimalisator en runtime die lage latentie en hoge doorvoer inferentie op CUDA-geactiveerde GPU’s biedt. TensorRT kan modellen die zijn getraind in frameworks zoals TensorFlow, PyTorch en MXNet optimaliseren en versnellen, waardoor efficiënte implementatie op verschillende platforms mogelijk wordt, van ingebedde systemen tot datacenters.

import tensorrt as trt

<p># Laad voorgetraind model
model = load_model(...)</p>

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

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

<p># Voer inferentie uit op GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)</p>

<p># Stel invoergegevens in en voer inferentie uit
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p>

# 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 geparsed en geoptimaliseerd door TensorRT, waardoor een hoogwaardige inferentie-engine wordt gegenereerd die is afgestemd op het specifieke model en de hardware. Deze engine kan vervolgens worden gebruikt om efficiënte inferentie uit te voeren op de GPU, waardoor CUDA wordt gebruikt voor versnelde berekening.

Conclusie

De combinatie van GPU’s en CUDA is een belangrijke factor geweest bij 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 complexe modellen trainen en implementeren met hoge efficiëntie.

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