AI-værktøjer 101
Opsætning af Træning, Finjustering og Inferens af LLM’er med NVIDIA GPU’er og CUDA
Det kunstige intelligensfelt (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 GPT, BERT og mere nylig Llama, Mistral er i stand til at forstå og generere menneskelignende tekst med udenforliggende flydende og sammenhæng.
Dette omfattende vejledning vil føre dig gennem processen med at opsætte en NVIDIA GPU på Ubuntu, med dækning af installation af essentielle softwarekomponenter som NVIDIA-driver, CUDA Toolkit, cuDNN, PyTorch og mere.
CUDA-Accelerated AI-Rammernes Opkomst
GPU-accelerered dyb læring er blevet fremmet af udviklingen af populære AI-rammer, der udnytter CUDA til effektiv beregning. Rammer som TensorFlow, PyTorch og MXNet har indbygget support for CUDA, hvilket muliggør en nahtløs 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å op til 100 gange hurtigere performance i forhold til CPU-baserede implementationer.
NVIDIA’s Multi-Instance GPU (MIG)-teknologi, introduceret med Ampere-arkitekturen, tillader en enkelt GPU at blive partitioneret 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 samlede omkostninger.
Accelererende LLM-Inferens med NVIDIA TensorRT
Mens GPU’er har været afgørende for træning af LLM’er, er effektiv inferens lige så afgørende for at deployere disse modeller i produktionsmiljøer. NVIDIA TensorRT, en højpræstations dyb læring-inferens-optimizer og runtime, spiller en vital rol i at accelerere LLM-inferens på CUDA-aktiverede GPU’er.
Ifølge NVIDIA’s benchmarks kan TensorRT give op til 8 gange hurtigere inferens-performance og 5 gange lavere total omkostning 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 cuDNN, cuBLAS og NCCL er tilgængelige som open-source-biblioteker, hvilket muliggør, at forskere og udviklere kan udnytte det fulde potentiale af CUDA til deres dyb læring.
Installation
Når du sætter AI-udvikling, kan det at bruge de seneste drivere og biblioteker ikke altid være det bedste valg. For eksempel, mens den seneste NVIDIA-driver (545.xx) understøtter CUDA 12.3, kan PyTorch og andre biblioteker 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, identificér din GPU-model. For denne vejledning, bruger vi NVIDIA GPU. Besøg NVIDIA Driver Download-side, vælg den passende driver til din GPU og notér driver-versionen.
Tjek for forudbyggede GPU-pakker på Ubuntu, kørende:
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øjpræstations GPU-accelererede applikationer.
For en non-LLM/dyb læring opsætning, kan du bruge:
sudo apt install nvidia-cuda-toolkit <p>Men for at sikre kompatibilitet med BitsAndBytes, vil vi følge disse trin:</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>
Verificér installationen:
~/local/cuda-12.2/bin/nvcc --version
Sæt miljøvariablerne:
<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. Installér cuDNN
Download cuDNN-pakken fra NVIDIA Developer-webstedet. Installér det med:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Følg instruktionerne for at tilføje keyring:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Installér cuDNN-bibliotekerne:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Opsæt Python Virtuel Miljø
Ubuntu 22.04 kommer med Python 3.10. Installér venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Opret og aktiver det virtuelle miljø:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Installér BitsAndBytes fra Kilde
Navigér til BitsAndBytes-mappen og byg 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. Installér PyTorch
Installér PyTorch med følgende kommando:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Installér Hugging Face og Transformers
Installér transformers og accelerate-bibliotekerne:
<p>pip install transformers pip install accelerate</p>
Parallelt Processings Kraft
I deres kerne er GPU’er højtydende parallelt 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 af disse GPU’er, hvilket muliggør, at de kan skrive kode, der kan udnytte de parallelt processeringsevner i hardwaren.
Accelererende LLM-træning med GPU’er og CUDA.
Træning af store sprogmodeller er en beregningskrævende opgave, der kræver behandling af store mængder tekstdata og udførelse af talrige matrixoperationer. GPU’er, med deres tusinder af kerner og højhastigheds hukommelsesbåndbredde, er ideelt egnet til disse opgaver. Ved at udnytte CUDA kan udviklere optimere deres kode til at udnytte de parallelt processeringsevner i GPU’er, hvilket betydeligt reducerer den tid, der kræves til at træne LLM’er.
For eksempel var træningen af GPT-3, en af de største sprogmodeller til dato, mulig takket være brugen 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 resulterede i dens imponerende præstation i naturlige sprogopgaver.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Indlæs forudtrænet GPT-2-model og tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')</p>
<p># Flyt model til GPU, hvis tilgængelig
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)</p>
<p># Definér træningsdata og hyperparametre
train_data = [...] # Din træningsdata
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>
<p># Definér loss-funktion og optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>
<p># Træningsløkke
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Forbered input- og target-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)</p>
<p># Fremadgang
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>
<p># Baglæns og optimisering
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>
<p>print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')</p>
I dette eksempel demonstrerer vi træningen af en GPT-2-sprogmodel med PyTorch og CUDA-aktiverede GPU’er. Modellen indlæses på GPU’en (hvis tilgængelig), og træningsløkken udnytter parallelt processeringsevnerne i GPU’er til at udføre effektive fremad- og baglæns pass, 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-aktiverede biblioteker, der muliggør effektiv implementering af dyb læring-modeller, herunder LLM’er. Disse biblioteker leverer optimiserede implementationer af almindelige operationer, såsom matrixmultiplicationer, convolutioner og aktiveringsfunktioner, hvilket tillader udviklere at fokusere på modelarkitektur og træningsprocessen i stedet for lavniveauoptimering.
Et sådant bibliotek er cuDNN (CUDA Deep Neural Network-bibliotek), der leverer højtydende implementationer af standardrutiner, der bruges i dybe neurale netværk. Ved at udnytte cuDNN kan udviklere betydeligt accelerere træning og inferens af deres modeller, hvilket resulterer i performancesforbedringer på op til flere størrelsesordener i forhold til CPU-baserede implementationer.
<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 kodeeksempel definerer vi en residual-blok for et convolutionelt neuralt netværk (CNN) med PyTorch. Autocast-kontekstmanageren fra PyTorch’s Automatic Mixed Precision (AMP) bruges til at aktivere mixed-precision-træning, hvilket kan give betydelige performancesforbedringer 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 Skalabilitet
Da LLM’er og dyb læring-modeller fortsætter med at vokse 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 proceskraft af multiple GPU’er på tværs af multiple maskiner.
CUDA og tilhørende biblioteker, såsom NCCL (NVIDIA Collective Communications Library), leverer effektive kommunikationsprimitiver, der muliggør nahtløs dataoverførsel og synkronisering på tværs af multiple GPU’er, hvilket muliggør distribueret træning i en hidtil uset skala.
<p>import torch.distributed as dist</p> <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Initialiser distribueret træning dist.init_process_group(backend='nccl', init_method='...') local_rank = dist.get_rank() torch.cuda.set_device(local_rank)</p> <p># Opret model og flyt til GPU model = MyModel().cuda()</p> <p># Indpak model med DDP model = DDP(model, device_ids=[local_rank])</p> <p># Træningslø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)</p> <p>outputs = model(inputs) loss = criterion(outputs, targets)</p> <p>optimizer.zero_grad() loss.backward() optimizer.step()</p>
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 skalerbarhed 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.
Deploying Deep Learning-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 deploy og inferens. Da dyb læring-modeller bliver mere komplekse og ressourcekrævende, er GPU-acceleration afgørende for at opnå realtid-præstation i produktionsmiljøer.
NVIDIA’s TensorRT er en højpræstations dyb læring-inferens-optimizer og runtime, der giver lav-forsinkelses- og høj-gennemstrømnings-inferens på CUDA-aktiverede GPU’er. TensorRT kan optimere og accelerere modeller, der er trænet i rammer som TensorFlow, PyTorch og MXNet, hvilket muliggør effektiv deploy på forskellige platforme, fra indlejrede systemer til datacentre.
import tensorrt as trt <p># Indlæs forudtrænet model model = load_model(...)</p> <p># Opret 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 model success = parser.parse_from_file(model_path) engine = builder.build_cuda_engine(network)</p> <p># Kør inferens på GPU context = engine.create_execution_context() inputs, outputs, bindings, stream = allocate_buffers(engine)</p> <p># Sæt input-data og kør inferens set_input_data(inputs, input_data) context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p> # Behandl output # ...
I dette eksempel demonstrerer vi brugen af TensorRT til at deployere en forudtrænet dyb læring-model på en CUDA-aktiveret GPU. Modellen indlæses og optimeres af TensorRT, der genererer en højtydende optimeret inferens-motor, der er tilpasset til den specifikke model og hardware. Denne motor kan derefter bruges til at udføre effektiv inferens på GPU’en, mens den udnytter CUDA til accelereret beregning.
Konklusion
Kombinationen af GPU’er og CUDA har været afgørende for fremgangen i store sprogmodeller, computer-vision, talegenkendelse og andre områder af dyb læring. Ved at udnytte de parallelt processeringsevner i GPU’er og de optimerede biblioteker, der leveres af CUDA, kan forskere og udviklere træne og deployere stadig mere komplekse modeller med høj effektivitet.
Da AI-feltet fortsætter med at udvikle sig, vil betydningen af GPU’er og CUDA kun vokse. Med endnu mere kraftfuld hardware og software-optimeringer kan vi forvente at se yderligere gennembrud i udviklingen og deployeringen af AI-systemer, der udvider grænserne for, hvad der er muligt.
