Opsætning af Træning, Finjustering og Inferens af LLM’er med NVIDIA GPU’er og CUDA

Området for kunstig intelligens (AI) har oplevet bemærkelsesværdige fremskridt i de seneste år, og i hjertet af det ligger den kraftfulde kombination af grafikprocessorer (GPU’er) og parallel computing-platform.

Modeller som f.eks. GPT, BERT, og mere nylig Llama, Mistral er i stand til at forstå og generere menneske-lignende tekst med en hidtil uset flydende og sammenhængende karakter. Men træning af disse modeller kræver enorme mængder af data og beregningsressourcer, hvilket gør GPU’er og CUDA uundværlige værktøjer i denne proces.

Denne omfattende vejledning vil guide dig gennem processen med at opsætte en NVIDIA GPU på Ubuntu, herunder installation af essentielle softwarekomponenter som NVIDIA-driver, CUDA Toolkit, cuDNN, PyTorch og mere.

Opkomsten af CUDA-Accelererede AI-Rammer

GPU-accelereret dyb læring er blevet fremmet af udviklingen af populære AI-rammer, der udnytter CUDA til effektiv beregning. Rammer som f.eks. TensorFlow, PyTorch og MXNet har indbygget support for CUDA, hvilket muliggør en nærmest uden problemer integration af GPU-acceleration i dyb læring-pipelines.

Ifølge NVIDIA Data Center Deep Learning Product Performance Study, kan CUDA-accelererede dyb læring-modeller opnå en hastighed på op til 100 gange hurtigere end CPU-baserede implementationer.

NVIDIA’s Multi-Instance GPU (MIG)-teknologi, introduceret med Ampere-arkitekturen, tillader en enkelt GPU at blive opdelt i multiple sikre instanser, hver med deres egne dedikerede ressourcer. Denne funktion muliggør en effektiv deling af GPU-ressourcer mellem multiple brugere eller workloads, hvilket maksimerer udnyttelsen og reducerer de samlede omkostninger.

Accelerering af LLM-Inferens med NVIDIA TensorRT

Mens GPU’er har været afgørende for træning af LLM’er, er effektiv inferens lige så vigtig for at implementere disse modeller i produktionsmiljøer. NVIDIA TensorRT, en høj-ydelses dyb læring-inferens-optimizer og runtime, spiller en vital rol i accelerering af LLM-inferens på CUDA-aktiverede GPU’er.

Ifølge NVIDIA’s benchmarks kan TensorRT give op til 8 gange hurtigere inferens-ydelse og 5 gange lavere samlede ejeromkostninger i forhold til CPU-baseret inferens for store sprogmodeller som GPT-3.

NVIDIA’s engagement i open-source-initiativer har været en drivende kraft bag den bredt accepterede anvendelse af CUDA i AI-forskningsfællesskabet. Projekter som f.eks. cuDNN, cuBLAS og NCCL er tilgængelige som open-source-biblioteker, hvilket muliggør for forskere og udviklere at udnytte det fulde potentiale i CUDA til deres dyb læring.

Installation

Når det kommer til AI-udvikling, kan det ikke altid være det bedste valg at bruge de seneste drivere og biblioteker. For eksempel understøtter den seneste NVIDIA-driver (545.xx) CUDA 12.3, men PyTorch og andre biblioteker kan måske ikke endnu understøtte denne version. Derfor vil vi bruge driver version 535.146.02 med CUDA 12.2 for at sikre kompatibilitet.

Installations-Trin

1. Installér NVIDIA-Driver

Først skal du identificere dit GPU-model. I denne vejledning bruger vi NVIDIA GPU. Besøg NVIDIA Driver Download-side, vælg den passende driver til dit GPU og notér driver-versionen.

For at tjekke for forudbyggede GPU-pakker på Ubuntu, køres:

sudo ubuntu-drivers list --gpgpu

Genstart din computer og verificér installationen:

nvidia-smi

2. Installér CUDA Toolkit

CUDA Toolkit leverer udviklingsmiljøet for at oprette høj-ydelses GPU-accelererede applikationer.

Til en non-LLM/dyb læring opsætning kan du bruge:

sudo apt install nvidia-cuda-toolkit

Men for at sikre kompatibilitet med BitsAndBytes, følger vi disse trin:

[code language="BASH"]

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

Verificér installationen:

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

Angiv miljøvariabler:

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. Installér cuDNN

Download cuDNN-pakken fra NVIDIA Developer-websted. Installér den med:

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

Følg instruktionerne for at tilføje nøgle-ringen:

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

Installér cuDNN-biblioteker:

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

4. Opsæt Python-Virtuel Miljø

Ubuntu 22.04 kommer med Python 3.10. Installér venv:

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

Opret og aktiver det virtuelle miljø:

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

5. Installér BitsAndBytes fra Kilde

Navigér til BitsAndBytes-mappen og byg fra kilde:

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. Installér PyTorch

Installér PyTorch med følgende kommando:

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

7. Installér Hugging Face og Transformers

Installér transformers og accelerate-biblioteker:

pip install transformers
pip install accelerate

Kraften af Parallel-Processing

I deres kerne er GPU’er højtydelses parallel-processorer designet til at håndtere tusinder af samtidige tråde effektivt. Denne arkitektur gør dem velegnede til de beregningsintensive opgaver, der er involveret i træning af dyb læring-modeller, herunder LLM’er. CUDA-platformen, udviklet af NVIDIA, leverer et software-miljø, der tillader udviklere at udnytte det fulde potentiale i disse GPU’er, hvilket muliggør, at de kan skrive kode, der kan udnytte parallel-processing-kapaciteterne i hardwaren.
Accelerering af LLM-Træning med GPU’er og CUDA.

Træning af store sprogmodeller er en beregningskrævende opgave, der kræver behandling af enorme mængder af tekstdata og udførelse af talrige matrix-operationer. GPU’er med deres tusinder af kerner og højhastigheds hukommelsesbåndbredder er ideelt egnet til disse opgaver. Ved at udnytte CUDA kan udviklere optimere deres kode til at udnytte parallel-processing-kapaciteterne i GPU’er, hvilket kan reducere den tid, der kræves til at træne LLM’er, betydeligt.

For eksempel blev træningen af GPT-3, en af de største sprogmodeller hidtil, muliggjort gennem brug af tusinder af NVIDIA GPU’er, der kørte CUDA-optimiseret kode. Dette tillod, at modellen blev trænet på en hidtil uset mængde data, hvilket førte til dens imponerende præstation i naturlige sprogopgaver.

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

# Indlæs fortrænet GPT-2-model og tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Flyt model til GPU, hvis tilgængelig
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Definér træningsdata og hyperparametre
train_data = [...] # Din træningsdata
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Definér tab-funktion og optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Trænings-løkke
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Forbered input- og target-secvenser
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Forward-pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Backward-pass og optimisering
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

I dette eksempel demonstrerer vi træning af en GPT-2-sprogmodel med PyTorch og CUDA-aktiverede GPU’er. Modellen indlæses på GPU’en (hvis tilgængelig), og trænings-løkken udnytter parallelismen i GPU’er til at udføre effektive forward- og backward-passer, hvilket accelererer træningsprocessen.

CUDA-Accelererede Biblioteker til Dyb Læring

Ud over CUDA-platformen selv har NVIDIA og open-source-fællesskabet udviklet en række CUDA-accellererede biblioteker, der muliggør effektiv implementering af dyb læring-modeller, herunder LLM’er. Disse biblioteker leverer optimerede implementationer af almindelige operationer, såsom matrix-multiplicationer, convolutioner og aktiveringsfunktioner, hvilket tillader udviklere at fokusere på model-arkitekturen og træningsprocessen i stedet for lav-niveau-optimering.

Et sådant bibliotek er cuDNN (CUDA Deep Neural Network bibliotek), der leverer højtydelses implementationer af standard-rutiner, der bruges i dybe neurale netværk. Ved at udnytte cuDNN kan udviklere accelerere træning og inferens af deres modeller betydeligt, opnående ydelsesforbedringer på op til flere størrelsesordener i forhold til CPU-baserede implementationer.

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

I dette kode-eksempel definerer vi en residual-blok til en convolutional neural network (CNN) med PyTorch. Autocast-kontekst-manageren fra PyTorch’s Automatic Mixed Precision (AMP) bruges til at aktivere mixed-precision-træning, hvilket kan give betydelige ydelsesforbedringer på CUDA-aktiverede GPU’er, mens det opretholder høj nøjagtighed. F.relu-funktionen er optimeret af cuDNN, hvilket sikrer effektiv udførelse på GPU’er.

Multi-GPU og Distribueret Træning til Skalbarhed

Da LLM’er og dyb læring-modeller fortsat vokser i størrelse og kompleksitet, stiger også de beregningskrævende krav til træning af disse modeller. For at imødekomme denne udfordring har forskere og udviklere vendt sig til multi-GPU og distribueret træningsteknikker, der tillader dem at udnytte den kombinerede beregningskraft af multiple GPU’er på tværs af multiple maskiner.

CUDA og tilhørende biblioteker, såsom NCCL (NVIDIA Collective Communications Library), leverer effektive kommunikations-primitiver, der muliggør nærmest uden problemer data-overførsel og synkronisering på tværs af multiple GPU’er, hvilket muliggør distribueret træning i en hidtil uset skala.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialiser distribueret træning
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Opret model og flyt til GPU
model = MyModel().cuda()

# Indpak model med DDP
model = DDP(model, device_ids=[local_rank])

# Trænings-løkke (distribueret)
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()

I dette eksempel demonstrerer vi distribueret træning med PyTorch’s DistributedDataParallel (DDP)-modul. Modellen indpakkes med DDP, der automatisk håndterer data-parallellisering, gradient-synkronisering og kommunikation på tværs af multiple GPU’er med NCCL. Denne tilgang muliggør effektiv skalering af træningsprocessen på tværs af multiple maskiner, hvilket tillader forskere og udviklere at træne større og mere komplekse modeller på en rimelig tid.

Implementering af Dyb Læring-Modeller med CUDA

Mens GPU’er og CUDA primært er blevet brugt til træning af dyb læring-modeller, er de også afgørende for effektiv implementering og inferens. Da dyb læring-modeller bliver mere komplekse og ressource-krævende, er GPU-acceleration essentiel for at opnå real-tid-præstation i produktionsmiljøer.

NVIDIA’s TensorRT er en høj-ydelses dyb læring-inferens-optimizer og runtime, der giver lav-forsinkelse og høj-gennemstrømning inferens på CUDA-aktiverede GPU’er. TensorRT kan optimere og accelerere modeller trænet i rammer som TensorFlow, PyTorch og MXNet, hvilket muliggør effektiv implementering på forskellige platforme, fra indlejrede systemer til datacentre.

import tensorrt as trt

# Indlæs fortrænet model
model = load_model(...)

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

# Pars og optimér model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Kør inferens på GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Indstil input-data og kør inferens
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Behandl output
# ...

I dette eksempel demonstrerer vi brugen af TensorRT til at implementere en fortrænet dyb læring-model på en CUDA-aktiveret GPU. Modellen indlæses og optimeres af TensorRT, der genererer en højtydelses optimeret inferens-motor tilpasset til den specifikke model og hardware. Denne motor kan derefter bruges til at udføre effektiv inferens på GPU’en, hvilket udnytter CUDA til accelereret beregning.

Konklusion

Kombinationen af GPU’er og CUDA har været afgørende for fremgangen i store sprogmodeller, computer-vision, tale-genkendelse og andre områder af dyb læring. Ved at udnytte parallel-processing-kapaciteterne i GPU’er og de optimerede biblioteker leveret af CUDA kan forskere og udviklere træne og implementere stadig mere komplekse modeller med høj effektivitet.

Da AI-feltet fortsat udvikler sig, vil betydningen af GPU’er og CUDA kun vokse. Med endnu mere kraftfuld hardware og software-optimering kan vi forvente at se yderligere gennembrud i udvikling og implementering af AI-systemer, der udvider grænserne for, hvad der er muligt.