Konfigurasjon av trenings-, finjustering og inferens av LLM med NVIDIA-GPU og CUDA

Feltet kunstig intelligens (AI) har vært vitne til bemerkelsesverdige fremgang i de siste årene, og i hjertet av det ligger den kraftfulle kombinasjonen av grafikkprosessorer (GPU) og parallell databehandlingplattform.

Modeller som GPT, BERT, og mer nylig Llama, Mistral er i stand til å forstå og generere menneske-lignende tekst med utenforliggende flyt og sammenheng. Men å trene disse modellene krever enorme mengder data og beregningsressurser, noe som gjør GPU og CUDA til uunnværlige verktøy i dette foretaket.

Denne omfattende guiden vil føre deg gjennom prosessen med å konfigurere en NVIDIA-GPU på Ubuntu, med dekning av installasjon av essensielle programvarekomponenter som NVIDIA-driver, CUDA Toolkit, cuDNN, PyTorch og mer.

Oppsvinget av CUDA-akselererte AI-rammeverk

GPU-akselerert dyp læring har blitt drivende av utviklingen av populære AI-rammeverk som utnytter CUDA for effektiv beregning. Rammeverk som TensorFlow, PyTorch, og MXNet har innebygget støtte for CUDA, som muliggjør sømløs integrering av GPU-akselerasjon i dyp læring-pipelines.

Ifølge NVIDIA Data Center Deep Learning Product Performance Study, kan CUDA-akselererte dyp læring-modeller oppnå opptil 100 ganger raskere ytelse sammenlignet med CPU-baserte implementeringer.

NVIDIA’s Multi-Instance GPU (MIG)-teknologi, introdusert med Ampere-arkitekturen, tillater en enkelt GPU å deles inn i flere sikre instanser, hver med sine egne dedikerte ressurser. Denne funksjonen muliggjør effektiv deling av GPU-ressurser blant flere brukere eller arbeidsbyrder, maksimerer utnyttelse og reduserer samlede kostnader.

Akselerering av LLM-inferens med NVIDIA TensorRT

Mens GPU har vært instrumentale i trening av LLM, er effektiv inferens like viktig for å distribuere disse modellene i produksjonsmiljøer. NVIDIA TensorRT, en høy-ytelses dyp læring-inferens-optimizer og kjøretid, spiller en vital rolle i akselerering av LLM-inferens på CUDA-aktiverede GPU.

Ifølge NVIDIA’s benchmark, kan TensorRT gi opptil 8 ganger raskere inferens-ytelse og 5 ganger lavere samlet eierkostnad sammenlignet med CPU-basert inferens for store språkmodeller som GPT-3.

NVIDIA’s forpliktelse til åpne kilde-initiativer har vært en drivende kraft bak den omfattende aksepten av CUDA i AI-forskningsmiljøet. Prosjekter som cuDNN, cuBLAS, og NCCL er tilgjengelige som åpne kildebiblioteker, som muliggjør at forskere og utviklere kan utnytte det fulle potensialet av CUDA for sine dyp læring-modeller.

Installasjon

Når det gjelder AI-utvikling, kan det å bruke de nyeste drivere og bibliotekene ikke alltid være det beste valget. For eksempel, mens den nyeste NVIDIA-drivere (545.xx) støtter CUDA 12.3, kan PyTorch og andre biblioteker ikke ennå støtte denne versjonen. Derfor vil vi bruke driver-versjon 535.146.02 med CUDA 12.2 for å sikre kompatibilitet.

Installasjonsprosedyre

1. Installer NVIDIA-driver

Først, identifiser din GPU-modell. For denne guiden, bruker vi NVIDIA-GPU. Besøk NVIDIA Driver Download-side, velg den riktige drivere for din GPU, og noter driver-versjonen.

Sjekk for forhåndsbygde GPU-pakker på Ubuntu, kjør:

sudo ubuntu-drivers list --gpgpu

Start om datamaskinen og verifiser installasjonen:

nvidia-smi

2. Installer CUDA Toolkit

CUDA Toolkit gir utviklingsmiljøet for å lage høy-ytelses GPU-akselererte applikasjoner.

For en ikke-LLM/dyp læring-oppsättning, kan du bruke:

sudo apt install nvidia-cuda-toolkit

Men for å sikre kompatibilitet med BitsAndBytes, vil vi følge disse trinnene:

[code language="BASH"]

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

Verifiser installasjonen:

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

Sett 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. Installer cuDNN

Last ned cuDNN-pakken fra NVIDIA Developer-nettsiden. Installer den med:

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

Følg instruksjonene for å legge til nøkleringen:

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

Installer cuDNN-bibliotekene:

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

4. Konfigurer Python-virtuelt miljø

Ubuntu 22.04 kommer med Python 3.10. Installer venv:

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

Opprett og aktiver det virtuelle miljøet:

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

5. Installer BitsAndBytes fra kilde

Naviger til BitsAndBytes-katalogen og bygg 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. Installer PyTorch

Installer PyTorch med følgende kommando:

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

7. Installer Hugging Face og Transformers

Installer transformers og accelerate-bibliotekene:

pip install transformers
pip install accelerate

Kraften av parallell prosessering

I kjernen er GPU-er høytt parallell prosessorer designet for å håndtere tusenvis av samtidige tråder effektivt. Denne arkitekturen gjør dem godt egnet for de beregningsintensive oppgavene involvert i trening av dyp læring-modeller, inkludert LLM.

CUDA-plattformen, utviklet av NVIDIA, gir et programvare-miljø som tillater utviklere å utnytte det fulle potensialet av disse GPU-ene, muliggjører skriving av kode som kan utnytte parallell prosessering-kapasiteten til maskinvaren.
Akselerering av LLM-trening med GPU og CUDA.

Trening av store språkmodeller er en beregningskrevende oppgave som krever prosessering av enorme mengder tekstdata og utføring av tallrike matriser-operasjoner. GPU-er, med sine tusenvis av kerner og høy minnehastighet, er ideelt egnet for disse oppgavene. Ved å utnytte CUDA, kan utviklere optimere sin kode for å utnytte parallell prosessering-kapasiteten til GPU-ene, noe som betyr at tiden som kreves for å trene LLM-er kan reduseres betydelig.

For eksempel, var treningen av GPT-3, en av de største språkmodellene til dato, mulig gjennom bruk av tusenvis av NVIDIA-GPU-er som kjører CUDA-optimert kode. Dette tillot modellen å bli trenet på en utenforliggende mengde data, noe som ledet til dens imponerende ytelse i naturlige språk-oppgaver.

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

# Last inn forhånds-trent GPT-2-modell og tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Flytt modell til GPU hvis tilgjengelig
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Definer treningdata og hyperparametere
train_data = [...] # Din treningdata
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Definer tap-funksjon og optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Trening-løkke
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Forbered inndata og mål-sekvenser
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Fremover-passering
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Bakover-passering og optimisering
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

I dette eksempelet demonstrerer vi trening av en GPT-2-språkmodell med PyTorch og CUDA-aktiverede GPU-er. Modellen lastes inn på GPU-en (hvis tilgjengelig), og trening-løkken utnytter parallellheten til GPU-ene for å utføre effektive fremover- og bakover-passeringer, akselererende treningen.

CUDA-akselererte biblioteker for dyp læring

I tillegg til CUDA-plattformen selv, har NVIDIA og åpne kilde-samfunnet utviklet en rekke CUDA-akselererte biblioteker som muliggjør effektiv implementering av dyp læring-modeller, inkludert LLM. Disse bibliotekene gir optimerte implementeringer av vanlige operasjoner, som matrisemultiplikasjon, konvolusjon og aktiveringsfunksjoner, og tillater utviklere å fokusere på modell-arkitekturen og trening-prosessen i stedet for lav-nivå-optimisering.

Et slikt bibliotek er cuDNN (CUDA Deep Neural Network-bibliotek), som gir høytt justerte implementeringer av standard-rutiner brukt i dyp neural nettverk. Ved å utnytte cuDNN, kan utviklere akselerere trening og inferens av sine modeller betydelig, og oppnå ytelsesforbedringer på opptil flere størrelsesordener sammenlignet med CPU-baserte implementeringer.

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-eksempelet definerer vi en residual-blokk for et konvolusjons-neural nettverk (CNN) med PyTorch. Autocast-kontekst-håndtereren fra PyTorch’s Automatic Mixed Precision (AMP) brukes til å aktivere blandet-presisjon-trening, som kan gi betydelige ytelsesforbedringer på CUDA-aktiverede GPU-er samtidig som høy nøyaktighet opprettholdes. F.relu-funksjonen er optimert av cuDNN, som sikrer effektiv utføring på GPU-er.

Multi-GPU og distribuert trening for skalerbarhet

Ettersom LLM-er og dyp læring-modeller fortsetter å vokse i størrelse og kompleksitet, øker også de beregningsmessige kravene for å trene disse modellene. For å møte denne utfordringen, har forskere og utviklere vendt seg til multi-GPU og distribuert treningsteknikker, som tillater dem å utnytte den kombinerte prosesseringskraften til flere GPU-er over flere maskiner.

CUDA og tilhørende biblioteker, som NCCL (NVIDIA Collective Communications Library), gir effektive kommunikasjonsprimitiver som muliggjør sømløs dataoverføring og synkronisering over flere GPU-er, og muliggjør distribuert trening i en tidligere uoppnåelig skala.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialiser distribuert trening
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Opprett modell og flytt til GPU
model = MyModel().cuda()

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

# Trening-løkke (distribuert)
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 eksempelet demonstrerer vi distribuert trening med PyTorch’s DistributedDataParallel (DDP)-modul. Modellen pakkes inn i DDP, som automatisk håndterer data-parallellitet, gradient-synkronisering og kommunikasjon over flere GPU-er med NCCL. Denne tilnærmingen muliggjør effektiv skalering av trening-prosessen over flere maskiner, og tillater forskere og utviklere å trene større og mer komplekse modeller på en rimelig tid.

Distribusjon av dyp læring-modeller med CUDA

Mens GPU-er og CUDA hovedsakelig har blitt brukt til trening av dyp læring-modeller, er de også avgjørende for effektiv distribusjon og inferens. Ettersom dyp læring-modeller blir mer komplekse og ressurskrevende, er GPU-akselerasjon essensiell for å oppnå sanntids-ytelse i produksjonsmiljøer.

NVIDIA’s TensorRT er en høy-ytelses dyp læring-inferens-optimizer og kjøretid som gir lav-forsinkelse og høy-gjennomstrømming på CUDA-aktiverede GPU-er. TensorRT kan optimere og akselerere modeller trenet i rammeverk som TensorFlow, PyTorch og MXNet, og muliggjør effektiv distribusjon på ulike plattformer, fra innebygde systemer til datasentre.

import tensorrt as trt

# Last inn forhånds-trent modell
model = load_model(...)

# Opprett 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 modell
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

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

# Sett inndata og kjør inferens
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Behandle utdata
# ...

I dette eksempelet demonstrerer vi bruk av TensorRT for å distribuere en forhånds-trent dyp læring-modell på en CUDA-aktiveret GPU. Modellen pars og optimeres av TensorRT, som genererer en høytt optimert inferens-motor tilpasset for den spesifikke modellen og maskinvaren. Denne motoren kan deretter brukes til å utføre effektiv inferens på GPU-en, og utnytte CUDA for akselerert beregning.

Konklusjon

Kombinasjonen av GPU-er og CUDA har vært avgjørende i å drive fremgangen i store språkmodeller, datavisning, talegjenkjenning og andre områder av dyp læring. Ved å utnytte parallell prosessering-kapasiteten til GPU-er og de optimerte bibliotekene som følger med CUDA, kan forskere og utviklere trene og distribuere stadig mer komplekse modeller med høy effektivitet.

Ettersom AI-feltet fortsetter å utvikle seg, vil betydningen av GPU-er og CUDA bare øke. Med enda kraftigere maskinvare og programvare-optimiseringer, kan vi forvente å se ytterligere gjennombrudd i utvikling og distribusjon av AI-systemer, og presse grensene for hva som er mulig.