Nastavení školení, jemného ladění a inferencingu LLM s NVIDIA GPU a CUDA

Oblast umělé inteligence (AI) zažila v posledních letech pozoruhodný pokrok a v jejím srdci leží mocná kombinace grafických procesorů (GPU) a paralelní platformy pro výpočetní zpracování.

Modely, jako jsou GPT, BERT, a nedávno Llama, Mistral jsou schopny porozumět a generovat text podobný lidskému s bezprecedentní plynulostí a soudržností. Nicméně, školení těchto modelů vyžaduje obrovské množství dat a výpočetních zdrojů, což dělá GPU a CUDA nezbytnými nástroji v tomto úsilí.

Tento komplexní průvodce vás provede procesem nastavení NVIDIA GPU na Ubuntu, pokrývající instalaci základních softwarových komponent, jako je ovladač NVIDIA, CUDA Toolkit, cuDNN, PyTorch a další.

Vzestup CUDA urychlených AI rámců

GPU urychlené hluboké učení bylo poháněno vývojem populárních AI rámců, které využívají CUDA pro efektivní výpočet. Rámců, jako jsou TensorFlow, PyTorch, a MXNet mají vestavěnou podporu pro CUDA, umožňující bezproblémové integrování urychlení GPU do hlubokých učení.

Podle NVIDIA Data Center Deep Learning Product Performance Study, CUDA urychlené hluboké učení modely mohou dosáhnout až 100krát rychlejšího výkonu ve srovnání s implementacemi založenými na CPU.

NVIDIA’s Multi-Instance GPU (MIG) technologie, představená s architekturou Ampere, umožňuje rozdělit jeden GPU do více zabezpečených instancí, každá se svými vlastními věnovanými zdroji. Tato funkce umožňuje efektivní sdílení zdrojů GPU mezi několika uživateli nebo úlohami, maximalizuje využití a snižuje celkové náklady.

Zrychlení LLM inferencingu s NVIDIA TensorRT

Zatímco GPU byly instrumentální ve školení LLM, efektivní inferencing je stejně kritický pro nasazení těchto modelů v produkčních prostředích. NVIDIA TensorRT, high-performance hluboké učení inferencing optimizer a runtime, hraje vitální roli v urychlení LLM inferencingu na CUDA povolených GPU.

Podle NVIDIA’s benchmarků, TensorRT může poskytnout až 8krát rychlejší inferencing výkon a 5krát nižší celkové náklady na vlastnictví ve srovnání s CPU založenými inferencing pro velké jazykové modely, jako je GPT-3.

NVIDIA’s závazek k otevřeným zdrojům byl hnací silou za širokým přijetím CUDA v AI výzkumné komunitě. Projekty, jako cuDNN, cuBLAS, a NCCL jsou k dispozici jako otevřené zdrojové knihovny, umožňující výzkumníkům a vývojářům využít plný potenciál CUDA pro své hluboké učení.

Instalace

Při nastavení AI vývoje, použití nejnovějších ovladačů a knihoven nemusí být vždy nejlepší volbou. Například, zatímco nejnovější NVIDIA ovladač (545.xx) podporuje CUDA 12.3, PyTorch a další knihovny nemusí ještě podporovat tuto verzi. Proto budeme používat ovladač verzi 535.146.02 s CUDA 12.2 pro zajištění kompatibility.

Instalační kroky

1. Instalace NVIDIA ovladače

Nejprve identifikujte svůj model GPU. Pro tento průvodce použijeme NVIDIA GPU. Navštivte NVIDIA ovladač stažení stránku, vyberte příslušný ovladač pro váš GPU a poznamenejte si verzi ovladače.

Chcete-li zkontrolovat předem sestavené GPU balíčky na Ubuntu, spusťte:

sudo ubuntu-drivers list --gpgpu

Restartujte počítač a ověřte instalaci:

nvidia-smi

2. Instalace CUDA Toolkit

CUDA Toolkit poskytuje vývojové prostředí pro vytváření high-performance GPU urychlených aplikací.

Pro non-LLM/deep learning nastavení můžete použít:

sudo apt install nvidia-cuda-toolkit

Nicméně, pro zajištění kompatibility s BitsAndBytes, budeme postupovat podle těchto kroků:

[code language="BASH"]

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

Ověření instalace:

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

Nastavení proměnných prostředí:

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

Stáhněte cuDNN balíček z NVIDIA Developer webové stránky. Nainstalujte jej pomocí:

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

Postupujte podle instrukcí pro přidání klíče:

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

Instalace cuDNN knihoven:

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

4. Nastavení Python virtuálního prostředí

Ubuntu 22.04 přichází s Pythonem 3.10. Nainstalujte venv:

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

Vytvořte a aktivujte virtuální prostředí:

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

5. Instalace BitsAndBytes zdrojového kódu

Přejděte do adresáře BitsAndBytes a sestavte zdrojový kód:

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

Nainstalujte PyTorch pomocí následujícího příkazu:

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

7. Instalace Hugging Face a Transformers

Nainstalujte knihovny transformers a accelerate:

pip install transformers
pip install accelerate

Síla paralelního zpracování

V jádru jsou GPU vysoce paralelní procesory navržené pro efektivní zpracování tisíců současných vláken. Tato architektura je vhodná pro náročné úkoly ve školení hlubokých učení modelů, včetně LLM.

CUDA platforma, vyvinutá NVIDIA, poskytuje softwarové prostředí, které umožňuje vývojářům využít plný potenciál těchto GPU, umožňující jim psát kód, který může využít paralelní zpracování hardwaru.
Zrychlení LLM školení s GPU a CUDA.

Školení velkých jazykových modelů je náročný úkol, který vyžaduje zpracování obrovského množství textových dat a provedení mnoha maticových operací. GPU, s tisíci jádry a vysokou šířkou paměti, jsou ideální pro tyto úkoly. Díky CUDA mohou vývojáři optimalizovat svůj kód pro využití paralelního zpracování GPU, což výrazně snižuje čas potřebný pro školení LLM.

Například školení GPT-3, jednoho z největších jazykových modelů, bylo umožněno pomocí tisíců NVIDIA GPU běžících na CUDA optimalizovaném kódu. To umožnilo modelu být školen na bezprecedentním množství dat, vedoucí k jeho působivému výkonu v přirozeném jazykovém zpracování.

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

# Načtení předškoleného GPT-2 modelu a tokenizéru
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Přesunutí modelu na GPU, pokud je k dispozici
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Definice školicích dat a hyperparametrů
train_data = [...] # Vaše školicí data
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Definice ztrátové funkce a optimalizátoru
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Školicí smyčka
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Příprava vstupních a cílových sekvencí
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řední průchod
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Zadní průchod a optimalizace
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

V tomto příkladu demonstrujeme školení GPT-2 jazykového modelu pomocí PyTorch a CUDA povolených GPU. Model je načten na GPU (pokud je k dispozici), a školicí smyčka využívá paralelní zpracování GPU pro efektivní přední a zadní průchody, urychluje školení.

CUDA urychlené knihovny pro hluboké učení

Kromě CUDA platformy samotné, NVIDIA a otevřená komunita vyvinuli řadu CUDA urychlených knihoven, které umožňují efektivní implementaci hlubokých učení modelů, včetně LLM. Tyto knihovny poskytují optimalizované implementace běžných operací, jako jsou maticové násobení, konvoluce a aktivační funkce, umožňující vývojářům soustředit se na architekturu modelu a školení, spíše než na nízkoúrovňovou optimalizaci.

Jedna taková knihovna je cuDNN (CUDA Deep Neural Network knihovna), která poskytuje vysoce optimalizované implementace standardních rutin používaných v hlubokých neuronových sítích. Díky cuDNN mohou vývojáři výrazně urychlit školení a inferencing svých modelů, dosahující výkonových zisků až několika řádů ve srovnání s CPU založenými implementacemi.

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

V tomto příkladu definujeme reziduální blok pro konvoluční neuronovou síť (CNN) pomocí PyTorch. Autocast kontextový manažer z PyTorch’s Automatic Mixed Precision (AMP) je použit pro povolení smíšeného přesného školení, které může poskytnout významné výkonové zisky na CUDA povolených GPU, zatímco udržuje vysokou přesnost. F.relu funkce je optimalizována cuDNN, zajišťující efektivní provedení na GPU.

Více-GPU a distribuované školení pro škálovatelnost

Jak LLM a hluboké učení modely pokračují ve růstu velikosti a složitosti, tak i výpočetní požadavky pro školení těchto modelů rostou. Pro řešení této výzvy, výzkumníci a vývojáři se obrátili na více-GPU a distribuované školení techniky, které umožňují využití kombinovaného zpracování výkonu několika GPU napříč několika stroji.

CUDA a přidružené knihovny, jako je NCCL (NVIDIA Collective Communications Library), poskytují efektivní komunikační primitiva, která umožňují bezproblémovou výměnu dat a synchronizaci napříč několika GPU, umožňující distribuované školení na bezprecedentní škále.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Inicializace distribuovaného školení
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Vytvoření modelu a přesunutí na GPU
model = MyModel().cuda()

# Obalení modelu s DDP
model = DDP(model, device_ids=[local_rank])

# Školicí smyčka (distribuovaná)
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()

V tomto příkladu demonstrujeme distribuované školení pomocí PyTorch’s DistributedDataParallel (DDP) modulu. Model je obalen s DDP, který automaticky zpracovává data paralelně, gradienty synchronizuje a komunikuje napříč několika GPU pomocí NCCL. Tento přístup umožňuje efektivní škálování školicího procesu napříč několika stroji, umožňující výzkumníkům a vývojářům školení větších a složitějších modelů v rozumném čase.

Nasazení hlubokých učení modelů s CUDA

Zatímco GPU a CUDA byly primárně používány pro školení hlubokých učení modelů, jsou také kritické pro efektivní nasazení a inferencing. Jak hluboké učení modely se stávají stále složitějšími a náročnějšími, tak GPU urychlení je nezbytné pro dosažení reálného času výkonu v produkčních prostředích.

NVIDIA’s TensorRT je high-performance hluboké učení inferencing optimizer a runtime, který poskytuje nízkou latenci a vysoký propustný výkon inferencingu na CUDA povolených GPU. TensorRT může optimalizovat a urychlit modely školené v rámcích, jako jsou TensorFlow, PyTorch a MXNet, umožňující efektivní nasazení na různých platformách, od vestavěných systémů po datové centry.

import tensorrt as trt

# Načtení předškoleného modelu
model = load_model(...)

# Vytvoření TensorRT engine
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Parse a optimalizace modelu
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Spuštění inferencingu na GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Nastavení vstupních dat a spuštění inferencingu
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Zpracování výstupu
# ...

V tomto příkladu demonstrujeme použití TensorRT pro nasazení předškoleného hlubokého učení modelu na CUDA povoleném GPU. Model je nejprve načten a optimalizován TensorRT, který generuje vysoce optimalizovaný inferencing engine přizpůsobený pro konkrétní model a hardware. Tento engine může být pak použit pro efektivní inferencing na GPU, využívající CUDA pro urychlené výpočty.

Závěr

Kombinace GPU a CUDA byla instrumentální v pohánění pokroku v velkých jazykových modelech, počítačovém vidění, rozpoznávání řeči a různých dalších oblastech hlubokého učení. Díky využití paralelního zpracování GPU a optimalizovaných knihoven poskytnutých CUDA, výzkumníci a vývojáři mohou školení a nasazení stále složitějších modelů s vysokou efektivitou.

Jak oblast AI pokračuje ve vývoji, tak důležitost GPU a CUDA bude pouze růst. S ještě výkonnějším hardwarem a softwarovými optimalizacemi, můžeme očekávat další průlomy ve vývoji a nasazení AI systémů, tlačící hranice toho, co je možné.