Configurarea unui mediu de antrenare, reglare fină și inferență a LLM cu GPU-uri NVIDIA și CUDA

Domeniul inteligenței artificiale (IA) a cunoscut progrese remarcabile în ultimii ani, iar la baza acestor progrese se află combinația puternică a unităților de procesare grafică (GPU) și a platformei de calcul paralel.

Modele precum GPT, BERT și, mai recent, Llama, Mistral sunt capabile să înțeleagă și să genereze text umanoid cu o fluență și coerență fără precedent. Cu toate acestea, antrenarea acestor modele necesită cantități imense de date și resurse computaționale, făcând GPU-urile și CUDA instrumente indispensabile în acest efort.

Acest ghid cuprinzător vă va conduce prin procesul de configurare a unui GPU NVIDIA (NVDA ) pe Ubuntu, acoperind instalarea componentelor software esențiale, cum ar fi driverul NVIDIA, Kitul de dezvoltare CUDA, cuDNN, PyTorch și multe altele.

Apariția cadrelor de lucru AI accelerate de CUDA

Învățarea profundă accelerată de GPU a fost alimentată de dezvoltarea cadrelor de lucru AI populare care folosesc CUDA pentru calcul eficient. Cadre precum TensorFlow, PyTorch și MXNet au suport încorporat pentru CUDA, permițând integrarea fără efort a accelerării GPU în fluxurile de lucru de învățare profundă.

Conform Studiului de performanță al produselor de învățare profundă NVIDIA Data Center, modelele de învățare profundă accelerate de CUDA pot atinge până la 100 de ori mai multă performanță comparativ cu implementările bazate pe CPU.

Tehnologia Multi-Instance GPU (MIG) a NVIDIA, introdusă odată cu arhitectura Ampere, permite împărțirea unei singure GPU în multiple instanțe securizate, fiecare cu resurse dedicate. Această funcție permite partajarea eficientă a resurselor GPU între multiple utilizatori sau sarcini de lucru, maximizând utilizarea și reducând costurile totale.

Accelerarea inferenței LLM cu NVIDIA TensorRT

În timp ce GPU-urile au fost instrumentale în antrenarea LLM, inferența eficientă este la fel de crucială pentru implementarea acestor modele în medii de producție. NVIDIA TensorRT, un optimizator și runtime de inferență de învățare profundă de înaltă performanță, joacă un rol vital în accelerarea inferenței LLM pe GPU-uri compatibile cu CUDA.

Conform benchmark-urilor NVIDIA, TensorRT poate oferi până la 8 ori mai multă performanță de inferență și 5 ori mai mic cost total de proprietate comparativ cu inferența bazată pe CPU pentru modele de limbaj mari, cum ar fi GPT-3.

Angajamentul NVIDIA față de inițiativele open-source a fost o forță motrice în spatele adoptării pe scară largă a CUDA în comunitatea de cercetare IA. Proiecte precum cuDNN, cuBLAS și NCCL sunt disponibile ca biblioteci open-source, permițând cercetătorilor și dezvoltatorilor să valorifice pe deplin potențialul CUDA pentru învățarea profundă.

Instalare

La configurarea mediului de dezvoltare IA, utilizarea celor mai recente drivere și biblioteci nu este întotdeauna cea mai bună alegere. De exemplu, în timp ce cel mai recent driver NVIDIA (545.xx) suportă CUDA 12.3, PyTorch și alte biblioteci nu pot suporta încă această versiune. Prin urmare, vom utiliza driverul versiunii 535.146.02 cu CUDA 12.2 pentru a asigura compatibilitatea.

Pașii de instalare

1. Instalarea driverului NVIDIA

Mai întâi, identificați modelul dvs. de GPU. Pentru acest ghid, vom folosi GPU-ul NVIDIA. Vizitați pagina de descărcare a driverului NVIDIA, selectați driverul adecvat pentru GPU-ul dvs. și notați versiunea driverului.

Pentru a verifica pachetele precompilate GPU pe Ubuntu, rulați:

sudo ubuntu-drivers list --gpgpu

Reîncărcați computerul și verificați instalarea:

nvidia-smi

2. Instalarea Kitului de dezvoltare CUDA

Kitul de dezvoltare CUDA oferă mediul de dezvoltare pentru crearea de aplicații accelerate de GPU de înaltă performanță.

Pentru o configurare non-LLM/dezvoltare de învățare profundă, puteți utiliza:

sudo apt install nvidia-cuda-toolkit

<p>Însă, pentru a asigura compatibilitatea cu BitsAndBytes, vom urma pașii următori:</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>

Verificați instalarea:

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

Setați variabilele de mediu:

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

Descărcați pachetul cuDNN de pe site-ul NVIDIA Developer. Instalați-l cu:

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

Urmați instrucțiunile pentru a adăuga cheia:

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

Instalați bibliotecile cuDNN:

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

4. Configurarea mediului virtual Python

Ubuntu 22.04 vine cu Python 3.10. Instalați venv:

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

Creați și activați mediul virtual:

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

5. Instalarea BitsAndBytes din sursă

Navigați către directorul BitsAndBytes și construiți din sursă:

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

Instalați PyTorch cu următoarea comandă:

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

7. Instalarea Hugging și Transformers

Instalați bibliotecile transformers și accelerate:

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

Puterea procesării paralele

La baza lor, GPU-urile sunt procesori paraleli de înaltă performanță, concepuți pentru a gestiona mii de fire de execuție concurentă. Această arhitectură le face potrivite pentru sarcinile computaționale intensive implicate în antrenarea modelelor de învățare profundă, inclusiv LLM. Platforma CUDA, dezvoltată de NVIDIA, oferă un mediu software care permite dezvoltatorilor să valorifice pe deplin potențialul acestor GPU-uri, permițându-le să scrie cod care să poată valorifica capacitățile de procesare paralelă ale hardware-ului.
Accelerarea antrenării LLM cu GPU-uri și CUDA.

Antrenarea modelelor de limbaj mari este o sarcină computațională solicitantă care necesită procesarea unor cantități imense de date text și efectuarea numeroaselor operații matriciale. GPU-urile, cu miile lor de nuclee și banda lor largă de memorie, sunt ideal potrivite pentru aceste sarcini. Prin valorificarea CUDA, dezvoltatorii pot optimiza codul lor pentru a valorifica capacitățile de procesare paralelă ale GPU-urilor, reducând semnificativ timpul necesar pentru antrenarea LLM.

De exemplu, antrenarea GPT-3, unul dintre cele mai mari modele de limbaj până în prezent, a fost posibilă prin utilizarea a mii de GPU-uri NVIDIA care rulează cod optimizat CUDA. Acest lucru a permis modelului să fie antrenat pe o cantitate fără precedent de date, ducând la performanța sa impresionantă în sarcinile de limbaj natural.

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

<p># Încărcați modelul preantrenat GPT-2 și tokenizer-ul
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')</p>

<p># Mută modelul pe GPU, dacă este disponibil
dispozitiv = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(dispozitiv)</p>

<p># Definiți datele de antrenare și hiperparametrii
date_antrenare = [...] # Datele dvs. de antrenare
marime_lot = 32
numar_epoci = 10
rata_invatarii = 5e-5</p>

<p># Definiți funcția de pierdere și optimizerul
criteriu = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=rata_invatarii)</p>

<p># Buclă de antrenare
for epoca in range(numar_epoci):
for i in range(0, len(date_antrenare), marime_lot):
# Pregătiți secvențele de intrare și țintă
intrari, tinte = date_antrenare[i:i+marime_lot]
intrari = tokenizer(intrari, return_tensors="pt", padding=True)
intrari = intrari.to(dispozitiv)
tinte = tinte.to(dispozitiv)</p>

<p># Trecere înainte
ieșiri = model(**intrari, labels=tinte)
pierdere = ieșiri.loss</p>

<p># Trecere înapoi și optimizare
optimizer.zero_grad()
pierdere.backward()
optimizer.step()</p>

<p>print(f'Epocă {epoca+1}/{numar_epoci}, Pierdere: {pierdere.item()}')</p>

În acest exemplu de cod, demonstrăm antrenarea unui model de limbaj GPT-2 utilizând PyTorch și GPU-urile compatibile cu CUDA. Modelul este încărcat pe GPU (dacă este disponibil), iar bucla de antrenare valorifică paralelismul GPU-urilor pentru a efectua treceri înainte și înapoi eficiente, accelerând procesul de antrenare.

Biblioteci accelerate de CUDA pentru învățare profundă

În plus față de platforma CUDA însăși, NVIDIA și comunitatea open-source au dezvoltat o serie de biblioteci accelerate de CUDA care permit implementarea eficientă a modelelor de învățare profundă, inclusiv LLM. Aceste biblioteci oferă implementări optimizate ale operațiunilor comune, cum ar fi multiplicarea matricelor, convoluțiile și funcțiile de activare, permițând dezvoltatorilor să se concentreze asupra arhitecturii modelului și procesului de antrenare, mai degrabă decât asupra optimizării de nivel scăzut.

Una dintre aceste biblioteci este cuDNN (biblioteca de rețele neuronale profunde CUDA), care oferă implementări de înaltă calitate ale rutinelor standard utilizate în rețelele neuronale profunde. Prin valorificarea cuDNN, dezvoltatorii pot accelera semnificativ antrenarea și inferența modelelor lor, obținând câștiguri de performanță de până la mai multe ordine de mărime comparativ cu implementările bazate pe CPU.

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

<p>class BlocResidual(nn.Module):
def __init__(self, canale_intrare, canale_iesire, pas=1):
super().__init__()
self.conv1 = nn.Conv2d(canale_intrare, canale_iesire, kernel_size=3, stride=pas, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(canale_iesire)
self.conv2 = nn.Conv2d(canale_iesire, canale_iesire, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(canale_iesire)
self.scurtătură = nn.Sequential()
if pas != 1 or canale_intrare != canale_iesire:
self.scurtătură = nn.Sequential(
nn.Conv2d(canale_intrare, canale_iesire, kernel_size=1, stride=pas, bias=False),
nn.BatchNorm2d(canale_iesire))</p>

<p>def forward(self, x):
cu autocast():
iesiri = F.relu(self.bn1(self.conv1(x)))
iesiri = self.bn2(self.conv2(iesiri))
iesiri += self.scurtătură(x)
iesiri = F.relu(iesiri)
return iesiri</p>

În acest exemplu de cod, definim un bloc residual pentru o rețea neuronală convoluvională (CNN) utilizând PyTorch. Managerul de context autocast din PyTorch permite antrenarea cu precizie mixtă, care poate oferi câștiguri semnificative de performanță pe GPU-urile compatibile cu CUDA, menținând în același timp o acuratețe ridicată. Funcția F.relu este optimizată de cuDNN, asigurând o execuție eficientă pe GPU.

Antrenare multi-GPU și distribuită pentru scalabilitate

Pe măsură ce modelele LLM și de învățare profundă continuă să crească în dimensiune și complexitate, cerințele computaționale pentru antrenarea acestor modele cresc și ele. Pentru a aborda această provocare, cercetătorii și dezvoltatorii s-au orientat spre tehnici de antrenare multi-GPU și distribuită, care le permit să valorifice puterea de procesare combinată a mai multor GPU-uri de pe mai multe mașini.

CUDA și bibliotecile asociate, cum ar fi NCCL (Biblioteca de comunicații colective NVIDIA), oferă primitive de comunicare eficiente care permit transferul și sincronizarea datelor între mai multe GPU-uri, permițând antrenarea distribuită la o scară fără precedent.

import torch.distributed as dist

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

<p># Inițializați antrenarea distribuită
dist.init_process_group(backend='nccl', init_method='...')
rang_local = dist.get_rank()
torch.cuda.set_device(rang_local)</p>

<p># Creați modelul și mutați-l pe GPU
model = MyModel().cuda()</p>

<p># Înveliți modelul cu DDP
model = DDP(model, device_ids=[rang_local])</p>

<p># Buclă de antrenare (distribuită)
for epocă in range(număr_epoci):
for date in încărcător_date:
intrări, ținte = date
intrări = intrări.cuda(non_blocking=True)
ținte = ținte.cuda(non_blocking=True)</p>

<p>ieșiri = model(intrări)
pierdere = criteriu(ieșiri, ținte)</p>

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

În acest exemplu, demonstrăm antrenarea distribuită utilizând modulul DistributedDataParallel (DDP) din PyTorch. Modelul este învelit în DDP, care gestionează automat paralelismul datelor, sincronizarea gradientului și comunicarea între mai multe GPU-uri utilizând NCCL. Acest abordare permite scalarea eficientă a procesului de antrenare pe mai multe mașini, permițând cercetătorilor și dezvoltatorilor să antreneze modele mai mari și mai complexe într-un timp rezonabil.

Implementarea modelelor de învățare profundă cu CUDA

În timp ce GPU-urile și CUDA au fost utilizate în principal pentru antrenarea modelelor de învățare profundă, ele sunt, de asemenea, esențiale pentru implementarea și inferența eficientă. Pe măsură ce modelele de învățare profundă devin tot mai complexe și consumatoare de resurse, accelerarea GPU este esențială pentru atingerea performanței în timp real în mediile de producție.

NVIDIA TensorRT este un optimizator și runtime de inferență de învățare profundă de înaltă performanță care oferă inferență cu latență scăzută și debit ridicat pe GPU-urile compatibile cu CUDA. TensorRT poate optimiza și accelera modele antrenate în cadre precum TensorFlow, PyTorch și MXNet, permițând implementarea eficientă pe diverse platforme, de la sisteme înglobate la centre de date.

import tensorrt as trt

<p># Încărcați modelul preantrenat
model = load_model(...)</p>

<p># Creați motorul TensorRT
logger = trt.Logger(trt.Logger.INFO)
constructor = trt.Builder(logger)
rețea = constructor.create_network()
parser = trt.OnnxParser(rețea, logger)</p>

<p># Parsează și optimizează modelul
succes = parser.parse_from_file(model_path)
motor = constructor.build_cuda_engine(rețea)</p>

<p># Rulează inferența pe GPU
context = motor.create_execution_context()
intrări, ieșiri, legături, flux = alocați_bufer(motor)</p>

<p># Setează datele de intrare și rulează inferența
setați_datele_intrare(intrări, date_intrare)
context.execute_async_v2(legături=legături, flux=flux.ptr)</p>

# Procesați ieșirile
# ...

În acest exemplu, demonstrăm utilizarea TensorRT pentru implementarea unui model de învățare profundă preantrenat pe un GPU compatibil cu CUDA. Modelul este parsat și optimizat de TensorRT, care generează un motor de inferență de înaltă performanță, personalizat pentru modelul și hardware-ul specific. Acest motor poate fi utilizat pentru a efectua inferența eficientă pe GPU, valorificând CUDA pentru calcul accelerat.

Concluzie

Combinația dintre GPU-uri și CUDA a fost instrumentală în impulsionează progresele în modelele de limbaj mari, învățarea profundă și alte domenii ale inteligenței artificiale. Prin valorificarea capacităților de procesare paralelă ale GPU-urilor și a bibliotecilor optimizate oferite de CUDA, cercetătorii și dezvoltatorii pot antrena și implementa modele tot mai complexe cu eficiență ridicată.

Pe măsură ce domeniul inteligenței artificiale continuă să evolueze, importanța GPU-urilor și a CUDA va crește și mai mult. Cu hardware și optimizări software și mai puternice, putem aștepta să vedem progrese suplimentare în dezvoltarea și implementarea sistemelor de inteligență artificială, împingând limitele a ceea ce este posibil.