Konfigurowanie szkolenia, dostrajania i inferencji LLM z NVIDIA GPU i CUDA

Dziedzina sztucznej inteligencji (AI) doświadczyła znaczących postępów w ostatnich latach, a w jej centrum leży potężne połączenie jednostek przetwarzania grafiki (GPU) i platformy obliczeń równoległych.

Modele takie jak GPT, BERT, a ostatnio Llama, Mistral są w stanie zrozumieć i generować teksty podobne do ludzkich z niezwykłą płynnością i spójnością. Jednak szkolenie tych modeli wymaga ogromnych ilości danych i zasobów obliczeniowych, co sprawia, że GPU i CUDA są niezastąpionymi narzędziami w tym przedsięwzięciu.

Ten kompleksowy przewodnik przeprowadzi Cię przez proces konfigurowania NVIDIA GPU na Ubuntu, obejmujący instalację niezbędnych składników oprogramowania, takich jak sterownik NVIDIA, CUDA Toolkit, cuDNN, PyTorch i wiele innych.

Wzrost frameworków AI z przyspieszeniem CUDA

Przyspieszone głębokie uczenie się zostało napędzane przez rozwój popularnych frameworków AI, które wykorzystują CUDA do wydajnych obliczeń. Frameworki takie jak TensorFlow, PyTorch i MXNet mają wbudowane wsparcie dla CUDA, umożliwiając bezproblemową integrację przyspieszenia GPU z potokami głębokiego uczenia się.

Według NVIDIA Data Center Deep Learning Product Performance Study, modele głębokiego uczenia się z przyspieszeniem CUDA mogą osiągać nawet 100-krotnie szybszą wydajność w porównaniu z implementacjami opartymi na CPU.

Technologia Multi-Instance GPU (MIG) firmy NVIDIA, wprowadzona z architekturą Ampere, pozwala na podział jednej karty graficznej na wiele bezpiecznych instancji, z których każda ma własne dedykowane zasoby. Ta funkcja umożliwia wydajne udostępnianie zasobów GPU między wieloma użytkownikami lub obciążeniami, maksymalizując wykorzystanie i redukując ogólne koszty.

Przyspieszanie inferencji LLM z NVIDIA TensorRT

Podczas gdy karty graficzne były instrumentalne w szkoleniu LLM, wydajna inferencja jest równie istotna dla wdrożenia tych modeli w środowiskach produkcyjnych. NVIDIA TensorRT, optymalizator i środowisko uruchomieniowe dla głębokiego uczenia się, odgrywa istotną rolę w przyspieszaniu inferencji LLM na kartach graficznych z obsługą CUDA.

Według benchmarków NVIDIA, TensorRT może zapewnić nawet 8-krotnie szybszą wydajność inferencji i 5-krotnie niższy całkowity koszt posiadania w porównaniu z inferencją opartą na CPU dla dużych modeli językowych, takich jak GPT-3.

Zobowiązanie NVIDIA do inicjatyw open-source było siłą napędową powszechnego przyjęcia CUDA w społeczności badawczej AI. Projekty takie jak cuDNN, cuBLAS i NCCL są dostępne jako biblioteki open-source, umożliwiając badaczom i deweloperom wykorzystanie pełnego potencjału CUDA dla ich głębokiego uczenia się.

Instalacja

Podczas konfigurowania środowiska AI, używanie najnowszych sterowników i bibliotek nie zawsze jest najlepszym wyborem. Na przykład, podczas gdy najnowszy sterownik NVIDIA (545.xx) obsługuje CUDA 12.3, PyTorch i inne biblioteki mogą jeszcze nie obsługiwać tej wersji. Dlatego użyjemy sterownika w wersji 535.146.02 z CUDA 12.2, aby zapewnić zgodność.

Kroki instalacji

1. Zainstaluj sterownik NVIDIA

Najpierw zidentyfikuj swój model karty graficznej. W tym przewodniku użyjemy karty graficznej NVIDIA. Odwiedź stronę pobierania sterownika NVIDIA, wybierz odpowiedni sterownik dla Twojej karty graficznej i zanotuj wersję sterownika.

Aby sprawdzić prekompilowane pakiety GPU na Ubuntu, uruchom:

sudo ubuntu-drivers list --gpgpu

Uruchom ponownie komputer i zweryfikuj instalację:

nvidia-smi

2. Zainstaluj CUDA Toolkit

CUDA Toolkit zapewnia środowisko deweloperskie do tworzenia aplikacji z przyspieszeniem GPU o wysokiej wydajności.

Dla nie-LLM / głębokiego uczenia się, możesz użyć:

sudo apt install nvidia-cuda-toolkit

Jednak aby zapewnić zgodność z BitsAndBytes, wykonamy następujące kroki:

[code language="BASH"]

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

Zweryfikuj instalację:

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

Ustaw zmienne środowiskowe:

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

Pobierz pakiet cuDNN ze strony internetowej NVIDIA Developer. Zainstaluj go za pomocą:

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

Postępuj zgodnie z instrukcjami, aby dodać klucz:

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

Zainstaluj biblioteki cuDNN:

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

4. Skonfiguruj środowisko wirtualne Python

Ubuntu 22.04 jest wyposażony w Python 3.10. Zainstaluj venv:

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

Utwórz i aktywuj środowisko wirtualne:

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

5. Zainstaluj BitsAndBytes z kodu źródłowego

Przejdź do katalogu BitsAndBytes i zbuduj z kodu źródłowego:

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

Zainstaluj PyTorch za pomocą następującej komendy:

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

7. Zainstaluj Hugging Face i Transformers

Zainstaluj biblioteki transformers i accelerate:

pip install transformers
pip install accelerate

Moc przetwarzania równoległego

W swojej istocie karty graficzne są wysoko wydajnymi procesorami równoległymi, zaprojektowanymi do obsługi tysięcy współbieżnych wątków w sposób wydajny. Ta architektura sprawia, że są one idealnie dopasowane do zadania obliczeniowo intensywnych zadań związanych z szkoleniem modeli głębokiego uczenia się, w tym LLM. Platforma CUDA, opracowana przez NVIDIA, zapewnia środowisko programistyczne, które pozwala deweloperom wykorzystać pełny potencjał tych kart graficznych, umożliwiając im pisanie kodu, który może wykorzystywać możliwości przetwarzania równoległego sprzętu.
Przyspieszanie szkolenia LLM z kartami graficznymi i CUDA.

Szkolenie dużych modeli językowych jest zadaniem wymagającym obliczeniowo, które wymaga przetworzenia ogromnych ilości danych tekstowych i wykonania licznych operacji macierzowych. Karty graficzne, z ich tysiącami rdzeni i wysoką przepustowością pamięci, są idealnie dopasowane do tych zadań. Wykorzystując CUDA, deweloperzy mogą zoptymalizować swój kod, aby wykorzystać możliwości przetwarzania równoległego kart graficznych, znacznie redukując czas wymagany do szkolenia LLM.

Na przykład szkolenie GPT-3, jednego z największych modeli językowych do tej pory, było możliwe dzięki użyciu tysięcy kart graficznych NVIDIA z optymalizowanym kodem CUDA. To pozwoliło na szkolenie modelu na niezwykle dużej ilości danych, prowadząc do jego imponującej wydajności w zadaniach językowych.

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

# Załaduj pre-trenowany model GPT-2 i tokenizator
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Przenieś model na kartę graficzną, jeśli jest dostępna
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Zdefiniuj dane szkoleniowe i hiperparametry
train_data = [...] # Twoje dane szkoleniowe
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Zdefiniuj funkcję straty i optymalizator
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Pętla szkoleniowa
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Przygotuj dane wejściowe i wyjściowe
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Przód
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Backward i optymalizacja
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

W tym przykładzie kodu demonstrujemy szkolenie modelu GPT-2 z wykorzystaniem PyTorch i kart graficznych z obsługą CUDA. Model jest ładowany na kartę graficzną (jeśli jest dostępna), a pętla szkoleniowa wykorzystuje równoległość kart graficznych do wykonywania wydajnych kroków do przodu i do tyłu, przyspieszając proces szkolenia.

Biblioteki CUDA dla głębokiego uczenia się

Oprócz samej platformy CUDA, NVIDIA i społeczność open-source opracowali szereg bibliotek z przyspieszeniem CUDA, które umożliwiają wydajną implementację modeli głębokiego uczenia się, w tym LLM. Te biblioteki zapewniają zoptymalizowane implementacje typowych operacji, takich jak mnożenia macierzy, splotów i funkcji aktywacyjnych, pozwalając deweloperom skoncentrować się na architekturze modelu i procesie szkolenia, a nie na optymalizacji niskopoziomowej.

Jedną z takich bibliotek jest cuDNN (CUDA Deep Neural Network library), która zapewnia wysoko zoptymalizowane implementacje standardowych rutyn używanych w sieciach neuronowych. Wykorzystując cuDNN, deweloperzy mogą znacznie przyspieszyć szkolenie i inferencję swoich modeli, osiągając zyski wydajności sięgające nawet kilku rzędów wielkości w porównaniu z implementacjami opartymi na CPU.

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

W tym fragmencie kodu definiujemy blok resztowy dla sieci neuronowej wykorzystującej PyTorch. Menedżer kontekstu autocast z PyTorch’s Automatic Mixed Precision (AMP) jest używany do włączenia szkolenia z mieszaną precyzją, co może zapewnić znaczne zyski wydajności na kartach graficznych z obsługą CUDA, przy zachowaniu wysokiej dokładności. Funkcja F.relu jest zoptymalizowana przez cuDNN, zapewniając wydajną wykonywalność na kartach graficznych.

Wielokrotna karta graficzna i rozproszone szkolenie dla skalowalności

Podczas gdy LLM i modele głębokiego uczenia się nadal rosną w rozmiarze i złożoności, wymagania obliczeniowe dla szkolenia tych modeli również rosną. Aby rozwiązać ten problem, badacze i deweloperzy zwrócili się ku technikom szkolenia wielokartowego i rozproszonego, które pozwalają im wykorzystać łączną moc obliczeniową wielu kart graficznych na wielu maszynach.

CUDA i powiązane biblioteki, takie jak NCCL (NVIDIA Collective Communications Library), zapewniają wydajne prymitywy komunikacyjne, które umożliwiają bezproblemową transmisję danych i synchronizację między wieloma kartami graficznymi, umożliwiając rozproszone szkolenie w niezwykłej skali.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Zainicjuj rozproszone szkolenie
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Utwórz model i przenieś go na kartę graficzną
model = MyModel().cuda()

# Zawij model w DDP
model = DDP(model, device_ids=[local_rank])

# Pętla szkoleniowa (rozproszona)
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()

W tym przykładzie demonstrujemy rozproszone szkolenie z wykorzystaniem PyTorch’s DistributedDataParallel (DDP) modułu. Model jest zawijany w DDP, który automatycznie obsługuje równoległość danych, synchronizację gradientów i komunikację między wieloma kartami graficznymi z wykorzystaniem NCCL. Ten podejście umożliwia wydajne skalowanie procesu szkolenia na wiele maszyn, pozwalając badaczom i deweloperom szkolić większe i bardziej złożone modele w rozsądnym czasie.

Wdrożenie modeli głębokiego uczenia się z CUDA

Podczas gdy karty graficzne i CUDA były głównie używane do szkolenia modeli głębokiego uczenia się, są one również niezastąpione dla wydajnej inferencji. Podczas gdy modele głębokiego uczenia się stają się coraz bardziej złożone i wymagające zasobów, przyspieszenie GPU jest niezbędne do osiągnięcia wydajności w czasie rzeczywistym w środowiskach produkcyjnych.

NVIDIA’s TensorRT jest wysoko wydajnym optymalizatorem i środowiskiem uruchomieniowym dla inferencji głębokiego uczenia się, który zapewnia niską latencję i wysoką przepustowość inferencji na kartach graficznych z obsługą CUDA. TensorRT może optymalizować i przyspieszać modele szkolone w frameworkach takich jak TensorFlow, PyTorch i MXNet, umożliwiając wydajne wdrożenie na różnych platformach, od systemów wbudowanych do centrów danych.

import tensorrt as trt

# Załaduj pre-trenowany model
model = load_model(...)

# Utwórz silnik TensorRT
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Przeanalizuj i zoptymalizuj model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Uruchom inferencję na karcie graficznej
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Ustaw dane wejściowe i uruchom inferencję
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Przetwórz dane wyjściowe
# ...

W tym przykładzie demonstrujemy użycie TensorRT do wdrożenia pre-trenowanego modelu głębokiego uczenia się na karcie graficznej z obsługą CUDA. Model jest najpierw przeanalizowany i zoptymalizowany przez TensorRT, który generuje wysoko zoptymalizowany silnik inferencji dostosowany do konkretnego modelu i sprzętu. Ten silnik może być następnie użyty do wykonywania wydajnej inferencji na karcie graficznej, wykorzystując CUDA do przyspieszonego obliczeń.

Podsumowanie

Połączenie kart graficznych i CUDA było instrumentalne w napędzaniu postępów w dużych modelach językowych, rozpoznawaniu obrazów, rozpoznawaniu mowy i innych dziedzinach głębokiego uczenia się. Wykorzystując możliwości przetwarzania równoległego kart graficznych i zoptymalizowanych bibliotek dostarczonych przez CUDA, badacze i deweloperzy mogą szkolić i wdrażać coraz bardziej złożone modele z wysoką wydajnością.

Podczas gdy dziedzina AI nadal ewoluuje, znaczenie kart graficznych i CUDA będzie tylko rosło. Z jeszcze bardziej potężnym sprzętem i optymalizacjami oprogramowania, możemy oczekiwać dalszych przełomów w rozwoju i wdrożeniu systemów AI, przesuwając granice tego, co jest możliwe.