Konfiguracja szkolenia, dokształcania i inferencji LLM z wykorzystaniem procesorów NVIDIA GPU i CUDA

Obszar sztucznej inteligencji (AI) doświadczył znaczących postępów w ostatnich latach, a sercem tego leży potężne połączenie jednostek przetwarzania grafiki (GPU) i platformy przetwarzania równoległego.

Modele takie jak GPT, BERT, a ostatnio Llama, Mistral są w stanie zrozumieć i generować teksty ludzkie 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 konfiguracji procesora 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 popularności frameworków AI z przyspieszeniem CUDA

Przyspieszone przez GPU głębokie uczenie się zostało napędzane przez rozwój popularnych frameworków AI, które wykorzystują CUDA do efektywnej 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ę.

Zgodnie z 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ł jednego GPU na wiele bezpiecznych instancji, z których każda ma własne dedykowane zasoby. Ta funkcja umożliwia efektywne 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 wykorzystaniem NVIDIA TensorRT

Podczas gdy GPU były instrumentalne w szkoleniu LLM, efektywna inferencja jest równie ważna dla wdrożenia tych modeli w środowiskach produkcyjnych. NVIDIA TensorRT, optymalizator i środowisko uruchomieniowe inferencji głębokiego uczenia się, odgrywa kluczową rolę w przyspieszaniu inferencji LLM na GPU z wykorzystaniem CUDA.

Zgodnie z benchmarkami 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 konfiguracji ś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 też użyjemy wersji sterownika 535.146.02 z CUDA 12.2, aby zapewnić kompatybilność.

Kroki instalacji

1. Zainstaluj sterownik NVIDIA

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

Sprawdź, czy na Ubuntu są dostępne prekompilowane pakiety GPU, uruchamiając:

sudo ubuntu-drivers list --gpgpu

Uruchom ponownie komputer i sprawdź 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żna użyć:

sudo apt install nvidia-cuda-toolkit

<p>Jednak aby zapewnić kompatybilność z BitsAndBytes, wykonaj następujące kroki:</p>

[code language=&amp;quot;BASH&amp;quot;]

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

Sprawdź instalację:

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

Ustaw zmienne środowiskowe:

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

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

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

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

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

Zainstaluj biblioteki cuDNN:

<p>sudo apt update
sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>

4. Skonfiguruj środowisko wirtualne Python

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

<p>sudo apt-get install python3-pip
sudo apt install python3.10-venv</p>

Utwórz i aktywuj środowisko wirtualne:

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

5. Zainstaluj BitsAndBytes z źródła

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

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

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

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

7. Zainstaluj Hugging i Transformers

Zainstaluj biblioteki transformers i accelerate:

<p>pip install transformers
pip install accelerate</p>

Moc przetwarzania równoległego

W swojej istocie GPU są wysoko równoległymi procesorami zaprojektowanymi do obsługi tysięcy współbieżnych wątków w sposób wydajny. Ta architektura sprawia, że są one dobrze przystosowane do obciążeń obliczeniowych 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 GPU, umożliwiając im pisanie kodu, który może wykorzystywać możliwości przetwarzania równoległego sprzętu.
Przyspieszanie szkolenia LLM z wykorzystaniem GPU 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. GPU, z ich tysiącami rdzeni i wysoką przepustowością pamięci, są idealnie przystosowane do tych zadań. Wykorzystując CUDA, deweloperzy mogą zoptymalizować swój kod, aby wykorzystać możliwości przetwarzania równoległego GPU, 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 procesorów NVIDIA GPU 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.

<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>

<p># Załaduj pre-trenowany model GPT-2
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')</p>

<p># Przenieś model na GPU, jeśli jest dostępny
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)</p>

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

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

<p># 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)</p>

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

<p># Tył i optymalizacja
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

<p>print(f'Epoka {epoch+1}/{num_epochs}, Strata: {loss.item()}')</p>

W tym przykładzie kodu demonstrujemy szkolenie modelu GPT-2 z wykorzystaniem PyTorch i GPU z włączonym CUDA. Model jest załadowany na GPU (jeśli jest dostępny), a pętla szkoleniowa wykorzystuje równoległość GPU do wykonywania efektywnych 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 opracowały szereg bibliotek z przyspieszeniem CUDA, które umożliwiają efektywną implementację modeli głębokiego uczenia się, w tym LLM. Te biblioteki zapewniają zoptymalizowane implementacje standardowych operacji, takich jak mnożenie macierzy, konwolucje i funkcje aktywacyjne, pozwalając deweloperom skoncentrować się na architekturze modelu i procesie szkolenia, zamiast optymalizacji niskiego poziomu.

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 przyrosty wydajności rzędu kilku rzędów wielkości w porównaniu z implementacjami opartymi na CPU.

<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>

W tym przykładzie kodu definiujemy blok resztowy dla sieci neuronowej z wykorzystaniem PyTorch. Menedżer kontekstu autocast z PyTorch jest używany do włączenia szkolenia z mieszaną precyzją, co może zapewnić znaczne przyrosty wydajności na GPU z włączonym CUDA, przy zachowaniu wysokiej dokładności. Funkcja F.relu jest zoptymalizowana przez cuDNN, zapewniając efektywną wykonywalność na GPU.

Szkolenie wielo-GPU i rozproszone dla skalowalności

Podczas gdy modele LLM i 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 wielo-GPU i rozproszonego, które pozwalają im wykorzystywać łączną moc obliczeniową wielu GPU na wielu maszynach.

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

<p>import torch.distributed as dist</p>

<p>from torch.nn.parallel import DistributedDataParallel as DDP</p>

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

<p># Utwórz model i przenieś go na GPU
model = MyModel().cuda()</p>

<p># Zawij model w DDP
model = DDP(model, device_ids=[local_rank])</p>

<p># 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)</p>

<p>outputs = model(inputs)
loss = criterion(outputs, targets)</p>

<p>optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

W tym przykładzie demonstrujemy szkolenie rozproszone z wykorzystaniem modułu DistributedDataParallel (DDP) z PyTorch. Model jest zawijany w DDP, który automatycznie obsługuje paralelizm danych, synchronizację gradientów i komunikację między wieloma GPU z wykorzystaniem NCCL. Ten podejście umożliwia efektywne 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 GPU i CUDA były głównie używane do szkolenia modeli głębokiego uczenia się, są one również niezbędne do efektywnej wdrożenia i 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 optymalizatorem i środowiskiem uruchomieniowym inferencji głębokiego uczenia się, który zapewnia niską latencję i wysoką przepustowość inferencji na GPU z włączonym CUDA. TensorRT może zoptymalizować i przyspieszyć modele szkolone w frameworkach takich jak TensorFlow, PyTorch i MXNet, umożliwiając efektywne wdrożenie na różnych platformach, od systemów wbudowanych do centrów danych.

import tensorrt as trt

<p># Załaduj pre-trenowany model
model = load_model(...)</p>

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

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

<p># Uruchom inferencję na GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)</p>

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

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

W tym przykładzie demonstrujemy użycie TensorRT do wdrożenia pre-trenowanego modelu głębokiego uczenia się na GPU z włączonym CUDA. Model jest najpierw przeanalizowany i zoptymalizowany przez TensorRT, który generuje silnik inferencji zoptymalizowany dla konkretnego modelu i sprzętu. Ten silnik może być następnie użyty do wykonywania efektywnej inferencji na GPU, wykorzystując CUDA do przyspieszonego obliczania.

Podsumowanie

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

Wraz z dalszym rozwojem dziedziny AI, znaczenie GPU 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, przekraczając granice tego, co jest możliwe.