NVIDIA-näytönohjaimen ja CUDA:n asettaminen koulutukseen, hienosäätöön ja Inferenssiin LLM: n kanssa

Tekoälyalan (AI) on kokenut merkittäviä edistysaskelia viime vuosina, ja sen sydämessä on voimakas yhdistelmä grafiikkaprosessoreista (GPU) ja rinnakkaislaskennan alustasta.

Mallit, kuten GPT, BERT ja viimeaikaisemmin Llama, Mistral pystyvät ymmärtämään ja luomaan ihmismäistä tekstiä ennennäkemättömällä sulavuudella ja johdonmukaisuudella. Kuitenkin näiden mallien koulutus vaatii valtavat määrät dataa ja laskentaresursseja, mikä tekee GPU:ista ja CUDA:sta välttämättömiä työkaluja tässä pyrkimyksessä.

Tämä kattava opas opastaa sinua NVIDIA GPU:n asettamisessa Ubuntuun, kattaa olennaisen ohjelmisto-osien asennuksen, kuten NVIDIA-ajurin, CUDA-työkalupakin, cuDNN, PyTorch ja muita.

CUDA-kiihdytettyjen AI-kehysten nousu

GPU-kiihdytetty syvä oppiminen on saanut vauhtia suosittujen AI-kehysten kehittymisestä, jotka hyödyntävät CUDA:a tehokkaan laskennan vuoksi. Kehykset, kuten TensorFlow, PyTorch ja MXNet ovat sisäänrakennettu tuki CUDA:lle, mahdollistaen vaivattoman integroinnin GPU-kiihdytystä syväoppimisputkiin.

NVIDIA Data Center Deep Learning Product Performance Studyn mukaan CUDA-kiihdytetty syvä oppiminen voi saavuttaa jopa 100-kertaisen suorituskyvyn verrattuna CPU-pohjaisiin toteutuksiin.

NVIDIA:n Multi-Instance GPU (MIG) -tekniikka, joka esiteltiin Ampere-arkkitehtuurissa, sallii yhden GPU:n jakamisen useisiin turvallisiin instansseihin, joilla kullakin on omat omistusresursensa. Tämä ominaisuus mahdollistaa tehokkaan jakamisen GPU-resursseja useiden käyttäjien tai työkuormien kesken, maksimoimalla hyödyn ja vähentämällä kustannuksia.

LLM-inferenssin kiihdyttäminen NVIDIA TensorRT:llä

Vaikka GPU:t ovat olleet merkittäviä LLM-mallien koulutuksessa, tehokas inferenssi on yhtä tärkeä niiden käyttöönotossa tuotantoympäristöissä. NVIDIA TensorRT, korkean suorituskyvyn syvä oppimisen inferenssoptimoi ja ajonaikainen, on tärkeässä roolissa LLM-inferenssin kiihdyttämisessä CUDA-kiihdytettyjen GPU:iden kanssa.

NVIDIA:n mukaan TensorRT voi tarjota jopa 8-kertaisen inferenssin suorituskyvyn ja 5-kertaisen yleiskustannuksen laskun verrattuna CPU-pohjaisiin inferensseihin suurten kielen mallien, kuten GPT-3, kanssa.

NVIDIA:n sitoutuminen avoimen lähdekoodin aloitteisiin on ollut voimakas voima CUDA:n laajan hyväksymisen takana AI-tutkimusyhteisössä. Projektit, kuten cuDNN, cuBLAS ja NCCL ovat saatavilla avoimina kirjastoina, mahdollistaen tutkijoille ja kehittäjille hyödyntää CUDA:n täydellistä potentiaalia syväoppimissovelluksissa.

Asennus

Kun asetetaan AI-kehitystä, viimeisimpien ajureiden ja kirjastojen käyttäminen ei aina ole paras valinta. Esimerkiksi, vaikka viimeisin NVIDIA-ajuri (545.xx) tukee CUDA 12.3:aa, PyTorch ja muut kirjastot eivät välttämättä tue tätä versiota vielä. Siksi käytämme ajuria 535.146.02 ja CUDA 12.2:ta varmistamaan yhteensopivuuden.

Asennusohjeet

1. Asenna NVIDIA-ajuri

Tunnista ensin GPU-mallisi. Tässä opetusohjelmassa käytämme NVIDIA GPU:ta. Vieraile NVIDIA-ajurin lataussivulla, valitse sopiva ajuri GPU:lsi ja muista ajurin versio.

Tarkista ennalta koostetut GPU-paketit Ubuntuun:

[koodi kieli=”BASH”]

sudo ubuntu-drivers list –gpgpu

[/koodi]

Käynnistä tietokone uudelleen ja vahvista asennus:

[koodi kieli=”BASH”]

nvidia-smi

[/koodi]

2. Asenna CUDA-työkalupakki

CUDA-työkalupakki tarjoaa kehitysympäristön luomiseen korkean suorituskyvyn GPU-kiihdytettyjä sovelluksia varten.

Ei-LLM/syväoppimisasetteluun voit käyttää:

[koodi kieli=”BASH”]

sudo apt install nvidia-cuda-toolkit

Kuitenkin varmistamaan yhteensopivuuden BitsAndBytesin kanssa, seuraamme näitä vaiheita:

[koodi kieli=”BASH”]

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

[/koodi]

Vahvista asennus:

[koodi kieli=”BASH”]

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

[/koodi]

Aseta ympäristömuuttujat:

[koodi kieli=”BASH”]

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

[/koodi]

3. Asenna cuDNN

Lataa cuDNN-paketti NVIDIA-kehittäjien sivustolta. Asenna se seuraavasti:

[koodi kieli=”BASH”]

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

[/koodi]

Seuraa ohjeita avaimen lisäämiseksi:

[koodi kieli=”BASH”]

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

[/koodi]

Asenna cuDNN-kirjastot:

[koodi kieli=”BASH”]

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

[/koodi]

4. Määritä Python-virtuaaliympäristö

Ubuntu 22.04 tulee Python 3.10: n kanssa. Asenna venv:

[koodi kieli=”BASH”]

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

[/koodi]

Luo ja aktivoi virtuaaliympäristö:

[koodi kieli=”BASH”]

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

[/koodi]

5. Asenna BitsAndBytes lähtekoodista

Siirry BitsAndBytes-kansioon ja rakenna lähtekoodista:

[koodi kieli=”BASH”]

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

[/koodi]

6. Asenna PyTorch

Asenna PyTorch seuraavalla komennolla:

[koodi kieli=”BASH”]

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

[/koodi]

7. Asenna Hugging Face ja Transformers

Asenna transformers- ja accelerate-kirjastot:

[koodi kieli=”BASH”]

pip install transformers
pip install accelerate

[/koodi]

Rinnakkaisen prosessoinnin voima

GPU:iden ydin ovat erittäin rinnakkaiset prosessorit, jotka on suunniteltu käsittelemään tuhansia samanaikaisia säikeitä tehokkaasti. Tämä arkkitehtuuri tekee niistä hyvin soveltuvia laskennan vaativiin tehtäviin, mukaan lukien syväoppimisen mallien koulutus, kuten LLM:t. CUDA-alusta, jonka NVIDIA on kehittänyt, tarjoaa ohjelmisto-ympäristön, joka mahdollistaa kehittäjille hyödyntää GPU:iden täydellistä potentiaalia, mahdollistaen heidän kirjoittaa koodia, joka voi hyödyntää laitteiston rinnakkaisen prosessoinnin ominaisuuksia.

Kiihdyttäminen LLM -koulutusta GPU:iden ja CUDA:n avulla.

Suurten kielen mallien koulutus on laskennan vaativa tehtävä, joka vaatii suurten tekstidatamäärien prosessointia ja monien matriisilaskentojen suorittamista. GPU:t, joilla on tuhansia ytimiä ja korkea muistikaista, ovat ihanteellisia näille tehtäville. Hyödyntämällä CUDA:a, kehittäjät voivat optimoida koodinsa hyödyntämään GPU:iden rinnakkaisen prosessoinnin ominaisuuksia, merkittävästi vähentäen aikaa, joka vaaditaan LLM-mallien koulutukseen.

Esimerkiksi GPT -3:n koulutus, yksi suurimmista kielen malleista toistaiseksi, tehtiin mahdolliseksi käyttämällä tuhansia NVIDIA GPU:ita, joissa suoritettiin CUDA-optimoitua koodia. Tämä mahdollisti mallin kouluttamisen ennennäkemättömällä määrällä dataa, johtuen sen vaikuttavasta suorituskyvystä luonnollisen kielen tehtävissä.

[koodi kieli=”PYTHON”]

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

# Lataa esikoulutettu GPT-2-malli ja tokenizer
malli = GPT2LMHeadModel.from_pretrained(‘gpt2’)
tokenizer = GPT2Tokenizer.from_pretrained(‘gpt2′)

# Siirrä malli GPU:lle, jos mahdollista
laite = torch.device(“cuda” if torch.cuda.is_available() else “cpu”)
malli = malli.to(laite)

# Määritä koulutusdata ja hyperparametrit
koulutusdata = […] # Koulutusdata
batch_koko = 32
epochit = 10
oppiaines = 5e-5

# Määritä menetelmä ja optimoija
kriteeri = nn.CrossEntropyLoss()
optimoija = optim.Adam(malli.parametrit(), lr=oppiaines)

# Koulutussilmukka
for epoch in range(epochit):
for i in range(0, len(koulutusdata), batch_koko):
# Valmista syöte- ja kohdemerkinnät
syote, kohde = koulutusdata[i:i+batch_koko]
syote = tokenizer(syote, return_tensors=”pt”, padding=True)
syote = syote.to(laite)
kohde = kohde.to(laite)

# Etumeno
tulokset = malli(**syote, labels=kohde)
tappio = tulokset.tappio

# Takaisinmeno ja optimointi
optimoija.zero_grad()
tappio.backward()
optimoija.step()

print(f’Epoch {epoch+1}/{epochit}, Tappio: {tappio.item()}’)

[/koodi]

Tässä esimerkkipalassa näytämme, miten koulutetaan GPT-2 -kielen mallia PyTorchilla ja CUDA-kiihdytettyjen GPU:iden avulla. Malli ladataan GPU:lle (jos mahdollista), ja koulutussilmukka hyödyntää GPU:iden rinnakkaista prosessointia tehokkaan etumeno- ja takaisinmenon suorittamiseen, kiihdyttäen koulutusprosessia.

CUDA-kiihdytettyjä kirjastoja syväoppimiseen

NVIDIA:n ja avoimen lähdekoodin yhteisön kehittämät CUDA-kiihdytettyjä kirjastoja mahdollistavat tehokkaan toteutuksen syväoppimismalleja, mukaan lukien LLM:t. Nämä kirjastot tarjoavat optimoidut toteutukset yleisistä operaatioista, kuten matriisien kertolaskuista, konvoluutioista ja aktivaatiofunktioista, mahdollistaen kehittäjille keskittymisen mallin arkkitehtuuriin ja koulutusprosessiin ilman alhaisen tason optimoinnin vaivaa.

Yksi tällainen kirjasto on cuDNN (CUDA Deep Neural Network -kirjasto), joka tarjoaa erittäin optimoidut toteutukset standardirutiineista, joita käytetään syvissä neuroverkoissa. Hyödyntämällä cuDNN:ää, kehittäjät voivat merkittävästi kiihdyttää mallien koulutusta ja inferenssiä, saavuttaen suorituskyvyn parannuksia useita kertaa verrattuna CPU-pohjaisiin toteutuksiin.

[koodi kieli=”PYTHON”]

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

[/koodi]

Tässä koodipalassa määrittelemme residual-lokin konvoluutioverkkoon (CNN) PyTorchilla. Autocast-kontekstinhallinta PyTorchin Automatic Mixed Precision (AMP) -ominaisuudesta mahdollistaa sekoitettujen tarkkuuksien koulutuksen, joka voi tarjota merkittäviä suorituskyvyn parannuksia CUDA-kiihdytettyjen GPU:iden kanssa säilyttäen korkean tarkkuuden. F.relu-funktio on optimoitu cuDNN:llä, varmistaen tehokkaan suorituksen GPU:illa.

Moni-GPU- ja jakautunut koulutus skaalautuvuuden vuoksi

Kun LLM:t ja syväoppimismallit jatkavat kasvamistaan ja monimutkaisuuttaan, laskennan vaatimukset niiden koulutukseen kasvavat. Ratkaisemaan tämän haasteen, tutkijat ja kehittäjät ovat kääntyneet moni-GPU- ja jakautuneen koulutuksen tekniikoihin, jotka mahdollistavat useiden GPU:iden yhdistetyn laskentatehon hyödyntämisen useiden koneiden yli.

CUDA ja liittyvät kirjastot, kuten NCCL (NVIDIA Collective Communications Library), tarjoavat tehokkaat viestintäprimitiivit, jotka mahdollistavat vaivattoman datan siirron ja synkronoinnin useiden GPU:iden välillä, mahdollistaen jakautuneen koulutuksen ennennäkemättömällä skaalalla.

[koodi kieli=”PYTHON”]

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Käynnistä jakautunut koulutus
dist.init_process_group(backend=’nccl’, init_method=’…’)
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Luo malli ja siirrä se GPU:lle
malli = MyModel().cuda()

# Kääri malli DDP:llä
malli = DDP(malli, device_ids=[local_rank])

# Koulutussilmukka (jakautunut)
for epoch in range(epochit):
for data in koulutus_lataaja:
syote, kohde = data
syote = syote.cuda(non_blocking=True)
kohde = kohde.cuda(non_blocking=True)

tulokset = malli(syote)
tappio = kriteeri(tulokset, kohde)

optimoija.zero_grad()
tappio.backward()
optimoija.step()

[/koodi]

Tässä esimerkkipalassa näytämme jakautuneen koulutuksen PyTorchin DistributedDataParallel (DDP) -moduulilla. Malli kääritään DDP:llä, joka automaattisesti käsittelee datan jakautumisen, gradienttien synkronoinnin ja viestinnän useiden GPU:iden välillä NCCL:n avulla. Tämä lähestymistapa mahdollistaa koulutusprosessin tehokkaan skaalautumisen useiden koneiden yli, sallien tutkijoille ja kehittäjille kouluttaa suurempia ja monimutkaisempia malleja kohtuullisessa ajassa.

Syväoppimismallien käyttöönotto CUDA:lla

Vaikka GPU:t ja CUDA ovat pääasiassa käytetty syväoppimismallien koulutukseen, ne ovat myös tärkeitä mallien käyttöönotossa. Kun syväoppimismallit tulevat yhä monimutkaisemmiksi ja resursseja vaativammiksi, GPU-kiihdytys on välttämätöntä saavuttaaksesi reaaliaikaisen suorituskyvyn tuotantoympäristöissä.

NVIDIA:n TensorRT on korkean suorituskyvyn syväoppimisen inferenssoptimoi ja ajonaikainen, joka tarjoaa matalan viiveen ja korkean läpimenoisuuden CUDA-kiihdytettyjen GPU:iden kanssa. TensorRT voi optimoida ja kiihdyttää malleja, jotka on koulutettu kehyksissä kuten TensorFlow, PyTorch ja MXNet, mahdollistaen tehokkaan käyttöönoton eri alustoilla, käyttöjärjestelmistä datakeskuksiin.

[koodi kieli=”PYTHON”]

import tensorrt as trt

# Lataa esikoulutettu malli
malli = load_model(…)

# Luo TensorRT-moottori
loki = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(loki)
verkko = builder.create_network()
parser = trt.OnnxParser(verkko, logi)

# Parsaa ja optimoi malli
onnistui = parser.parse_from_file(malli_polku)
moottori = builder.build_cuda_engine(verkko)

# Suorita inferenssi GPU:lla
konteksti = moottori.create_execution_context()
syote, tulokset, sidokset, virta = allocate_buffers(moottori)

# Aseta syötedata ja suorita inferenssi
set_input_data(syote, syote_data)
konteksti.execute_async_v2(bindings=sidokset, stream_handle=virta.ptr)

# Prosessoi tulokset
# …

[/koodi]

Tässä esimerkkipalassa näytämme TensorRT:n käytön esikoulutetun syväoppimismallin käyttöönotossa CUDA-kiihdytettyjen GPU:iden kanssa. Malli parsitaan ja optimoidaan TensorRT:llä, joka luo erittäin optimoidun inferenssimootorin, joka on suunniteltu mallille ja laitteistolle. Tätä moottoria voidaan sitten käyttää tehokkaaseen inferenssiin GPU:lla, hyödyntäen CUDA:a kiihdytettyyn laskentaan.

Johtopäätös

GPU:iden ja CUDA:n yhdistelmä on ollut ratkaiseva tekijä suurten kielen mallien, tietokoneen näön, puheentunnistuksen ja muiden syväoppimisen alojen edistymisessä. Hyödyntämällä GPU:iden rinnakkaisen prosessoinnin ominaisuuksia ja CUDA:n tarjoamia optimoituja kirjastoja, tutkijat ja kehittäjät voivat kouluttaa ja käyttöönottaa yhä monimutkaisempia malleja tehokkaasti.

Kun tekoälyalan jatkaa kehittymistä, GPU:iden ja CUDA:n merkitys kasvaa entisestään. Uusien, tehokkaampien laitteiden ja ohjelmistoparannusten myötä voidaan odottaa näkevän edelleen läpimurtoja tekoälyjärjestelmien kehittämisessä ja käyttöönotossa, puskeen tekoälyn rajoja eteenpäin.