AI-verktøy 101
Konfigurasjon av trening, finjustering og inferens av LLM med NVIDIA-GPU og CUDA
Feltet kunstig intelligens (AI) har sett bemerkelsesverdige fremgang i de senere årene, og i hjertet av det ligger den kraftfulle kombinasjonen av grafikkprosessorer (GPUs) og parallellprosesseringsplattform.
Modeller som GPT, BERT, og mer nylig Llama, Mistral er i stand til å forstå og generere menneskelignende tekst med utenforliggende flyt og kohensjon. Men å trene disse modellene krever enorme mengder data og beregningsressurser, og gjør GPUs og CUDA uunnværlige verktøy i dette foretaket.
Denne omfattende guiden vil føre deg gjennom prosessen med å sette opp en NVIDIA-GPU på Ubuntu, og dekker installasjonen av essensielle programvarekomponenter som NVIDIA-drivere, 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 innebygd støtte for CUDA, og muliggjør enkel integrasjon 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, og maksimerer utnyttelsen og reduserer de totale kostnadene.
Akselerering av LLM-inferens med NVIDIA TensorRT
Mens GPUs har vært instrumentale i trening av LLM, er effektiv inferens like viktig for å deployere disse modellene i produksjonsmiljøer. NVIDIA TensorRT, en høy-ytelses dyp læring-inferens-optimizer og runtime, spiller en vital rolle i å akselerere LLM-inferens på CUDA-aktiverede GPUs.
Ifølge NVIDIA’s benchmark, kan TensorRT gi opptil 8 ganger raskere inferens-ytelse og 5 ganger lavere total kostnad sammenlignet med CPU-basert inferens for store språkmodeller som GPT-3.
NVIDIA’s forpliktelse til åpen 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 åpen kilde-biblioteker, og muliggjør at forskere og utviklere kan utnytte fullt potensialet av CUDA for sine dyp læring-modeller.
Installasjon
Når du setter opp 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.
Installasjonssteg
1. Installer NVIDIA-drivere
Først, identifiser din GPU-modell. For denne guiden, vil vi bruke 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 <p>Men for å sikre kompatibilitet med BitsAndBytes, vil vi følge disse stegene:</p> [code language=&quot;BASH&quot;] <p>git clone https://github.com/TimDettmers/bitsandbytes.git cd bitsandbytes/ bash install_cuda.sh 122 ~/local 1</p>
Verifiser installasjonen:
~/local/cuda-12.2/bin/nvcc --version
Sett miljøvariabler:
<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. Installer cuDNN
Last ned cuDNN-pakken fra NVIDIA Developer-nettstedet. Installer den med:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Følg instruksjonene for å legge til nøkleringen:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Installer cuDNN-bibliotekene:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Sett opp Python-virtuelt miljø
Ubuntu 22.04 kommer med Python 3.10. Installer venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Opprett og aktiver virtuelt miljø:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Installer BitsAndBytes fra kilde
Naviger til BitsAndBytes-katalogen og bygg fra kilde:
<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. Installer PyTorch
Installer PyTorch med følgende kommando:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Installer Hugging Face og Transformers
Installer transformers- og accelerate-bibliotekene:
<p>pip install transformers pip install accelerate</p>
Kraften av parallellprosesserings
I kjernen er GPU-er høytt parallellprosessorer 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.
Akselerering av LLM-trening med GPU-er og CUDA.
Trening av store språkmodeller er en beregningskrevende oppgave som krever prosessering av enorme mengder tekstdata og utføring av tallrike matriseregnskaper. 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 parallellprosesseringskapasiteten til GPU-er, og redusere tiden det tar å trene LLM-er betydelig.
For eksempel, treningen av GPT-3, en av de største språkmodellene til dags dato, ble mulig gjennom bruk av tusenvis av NVIDIA-GPU-er som kjørte CUDA-optimert kode. Dette tillot modellen å bli trent på en utenforliggende mengde data, og ledet til dens imponerende ytelse i naturlige språkoppdrag.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Last inn forhånds-trent GPT-2-modell og tokenizer
model = GPT2LMHeadModel.from_pretrained(&#039;gpt2&#039;)
tokenizer = GPT2Tokenizer.from_pretrained(&#039;gpt2&#039;)</p>
<p># Flytt modell til GPU hvis tilgjengelig
device = torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
model = model.to(device)</p>
<p># Definer treningdata og hyperparametere
train_data = [...] # Din treningdata
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>
<p># Definer tap-funksjon og optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>
<p># Treningssyklus
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Preparér inndata og målsekvenser
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors=&quot;pt&quot;, padding=True)
inputs = inputs.to(device)
targets = targets.to(device)</p>
<p># Fremover-pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>
<p># Bakover-pass og optimalisering
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>
<p>print(f&#039;Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}&#039;)</p>
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 treningssyklusen utnytter parallellheten til GPU-er for å utføre effektive fremover- og bakover-passer, og akselerer treningprosessen.
CUDA-akselererte biblioteker for dyp læring
I tillegg til CUDA-plattformen selv, har NVIDIA og åpen 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å modellarkitektur og treningprosess i stedet for lav-nivå-optimering.
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 modellene sine, og oppnå ytelsesforbedringer på opptil flere størrelsesordener sammenlignet med CPU-baserte implementeringer.
<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>
I dette kode-eksempelet definerer vi en residual-blokk for et konvolusjons-neuralt nettverk (CNN) med PyTorch. Autocast-kontekst-håndtereren fra PyTorch’s Automatic Mixed Precision (AMP) brukes til å aktivere blandet-presisjonstrening, som kan gi betydelige ytelsesforbedringer på CUDA-aktiverede GPU-er samtidig som den opprettholder høy nøyaktighet. F.relu-funksjonen er optimert av cuDNN, og sikrer effektiv kjøring på GPU-er.
Flere-GPU-er 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 flere-GPU-er 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 enkel dataoverføring og synkronisering over flere GPU-er, og muliggjør distribuert trening i en utenforliggende skala.
&lt;/pre&gt; import torch.distributed as dist <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Initialiser distribuert trening dist.init_process_group(backend=&#039;nccl&#039;, init_method=&#039;...&#039;) local_rank = dist.get_rank() torch.cuda.set_device(local_rank)</p> <p># Opprett modell og flytt til GPU model = MyModel().cuda()</p> <p># Omgi modell med DDP model = DDP(model, device_ids=[local_rank])</p> <p># Treningssyklus (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)</p> <p>outputs = model(inputs) loss = criterion(outputs, targets)</p> <p>optimizer.zero_grad() loss.backward() optimizer.step()</p>
I dette eksempelet demonstrerer vi distribuert trening med PyTorch’s DistributedDataParallel (DDP)-modul. Modellen er omgitt av DDP, som automatisk håndterer data-parallellitet, gradient-synkronisering og kommunikasjon over flere GPU-er med NCCL. Denne tilnærmingen muliggjør effektiv skalerbarhet av treningprosessen over flere maskiner, og tillater forskere og utviklere å trene større og mer komplekse modeller på en rimelig tid.
Deployering 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 deployering og inferens. Ettersom dyp læring-modeller blir stadig 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 runtime som gir lav-forsinkelse og høy-gjennomstrømming inferens på CUDA-aktiverede GPU-er. TensorRT kan optimere og akselerere modeller trent i rammeverk som TensorFlow, PyTorch og MXNet, og muliggjør effektiv deployering på ulike plattformer, fra innbygde systemer til data-sentere.
import tensorrt as trt <p># Last inn forhånds-trent modell model = load_model(...)</p> <p># Opprett TensorRT-motor logger = trt.Logger(trt.Logger.INFO) builder = trt.Builder(logger) network = builder.create_network() parser = trt.OnnxParser(network, logger)</p> <p># Pars og optimér modell success = parser.parse_from_file(model_path) engine = builder.build_cuda_engine(network)</p> <p># Kjør inferens på GPU context = engine.create_execution_context() inputs, outputs, bindings, stream = allocate_buffers(engine)</p> <p># Sett inndata og kjør inferens set_input_data(inputs, input_data) context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p> # Behandle utdata # ...
I dette eksempelet demonstrerer vi bruk av TensorRT for å deployere en forhånds-trent dyp læring-modell på en CUDA-aktiveret GPU. Modellen lastes inn og optimiseres av TensorRT, som genererer en høytt optimert inferens-motor tilpasset den spesifikke modellen og hårdwaren. 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 instrumentell i å drive fremgangen i store språkmodeller, datamaskin-syn, tale-gjenkjenning og andre områder av dyp læring. Ved å utnytte parallellprosesseringskapasiteten til GPU-er og de optimerte bibliotekene som følger med CUDA, kan forskere og utviklere trene og deployere stadig mer komplekse modeller med høy effektivitet.
Som feltet AI fortsetter å utvikle seg, vil betydningen av GPU-er og CUDA bare øke. Med enda mer kraftfulle hårdware og programvare-optimaliseringer, kan vi forvente å se ytterligere gjennombrudd i utviklingen og deployeringen av AI-systemer, og å pusha grensene for hva som er mulig.
