Налаштування тренування, доопрацювання та висновків LLM з використанням NVIDIA GPU та CUDA

Область штучного інтелекту (AI) пережила надзвичайні досягнення за останні роки, і в центрі цього процесу лежить потужна комбінація графічних процесорів (GPU) та платформи паралельних обчислень.

Моделі, такі як GPT, BERT, і більш недавно Llama, Mistral здатні зрозуміти та генерувати текст, подібний до людського, з безпрецедентною плавністю та узгодженістю. Однак тренування цих моделей вимагає величезної кількості даних та обчислювальних ресурсів, що робить GPU та CUDA незамінними інструментами в цьому процесі.

Цей комплексний посібник проведе вас через процес налаштування NVIDIA GPU на Ubuntu, охоплюючи встановлення необхідних програмних компонентів, таких як драйвер NVIDIA, CUDA Toolkit, cuDNN, PyTorch та ін.

Поява CUDA-прискорених AI-фреймворків

GPU-прискорене глибоке навчання було спровоковано розробкою популярних AI-фреймворків, які використовують CUDA для ефективних обчислень. Фреймворки, такі як TensorFlow, PyTorch та MXNet, мають вбудовану підтримку CUDA, що дозволяє безшовно інтегрувати прискорення GPU в глибоке навчання.

За даними NVIDIA Data Center Deep Learning Product Performance Study, CUDA-прискорені глибоке навчання можуть досягти до 100 раз швидшої продуктивності порівняно з реалізацією на основі CPU.

Технологія Multi-Instance GPU (MIG) від NVIDIA, представлена з архітектурою Ampere, дозволяє розділяти один GPU на кілька безпечних екземплярів, кожний з яких має自己的 виділені ресурси. Ця функція дозволяє ефективно розділяти ресурси GPU між кількома користувачами або завданнями, максимізуючи використання та знижуючи загальні витрати.

Прискорення висновків LLM з використанням NVIDIA TensorRT

Хоча GPU були інструментальними в тренуванні LLM, ефективний висновок є рівнозначно важливим для розгортання цих моделей в продукційних середовищах. NVIDIA TensorRT, високопродуктивний оптимізатор та(runtime) глибокого навчання, відіграє важливу роль у прискоренні висновків LLM на GPU, що підтримують CUDA.

За даними NVIDIA, TensorRT може забезпечити до 8 раз швидшу продуктивність висновків та 5 раз нижчу загальну вартість володіння для великих мовних моделей, таких як GPT-3, порівняно з висновками на основі CPU.

Зобов’язання NVIDIA щодо відкритих ініціатив стало рушійною силою широкого прийняття CUDA в дослідницькій спільноті AI. Проекти, такі як cuDNN, cuBLAS та NCCL, доступні як відкриті бібліотеки, що дозволяють дослідникам та розробникам використовувати повний потенціал CUDA для глибокого навчання.

Встановлення

При налаштуванні середовища розробки AI використання останніх драйверів та бібліотек не завжди є найкращим вибором. Наприклад, хоча останній драйвер NVIDIA (545.xx) підтримує CUDA 12.3, PyTorch та інші бібліотеки можуть ще не підтримувати цю версію. Тому ми будемо використовувати драйвер версії 535.146.02 з CUDA 12.2, щоб забезпечити сумісність.

Кроки встановлення

1. Встановлення драйвера NVIDIA

Спочатку ідентифікуйте модель свого GPU. Для цього посібника ми використовуємо NVIDIA GPU. Відвідайте сторінку завантаження драйвера NVIDIA, виберіть відповідний драйвер для свого GPU та запишіть версію драйвера.

Перевірка попередньо скомпільованих пакетів GPU на Ubuntu:

sudo ubuntu-drivers list --gpgpu

Перезапустіть комп’ютер та перевірте встановлення:

nvidia-smi

2. Встановлення CUDA Toolkit

CUDA Toolkit забезпечує середовище розробки для створення високопродуктивних застосунків з прискоренням GPU.

Для некластерної установки глибокого навчання ви можете використовувати:

sudo apt install nvidia-cuda-toolkit

<p>Однак, щоб забезпечити сумісність з BitsAndBytes, ми будемо слідувати цим крокам:</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>

Перевірка встановлення:

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

Встановлення змінних середовища:

<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. Встановлення cuDNN

Завантажте пакет cuDNN з веб-сайту NVIDIA Developer. Встановіть його за допомогою:

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

Слідуйте інструкціям для додавання ключа:

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

Встановлення бібліотек cuDNN:

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

4. Налаштування віртуального середовища Python

Ubuntu 22.04 поставляється з Python 3.10. Встановіть venv:

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

Створіть та активуйте віртуальне середовище:

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

5. Встановлення BitsAndBytes з джерела

Перейдіть до каталогу BitsAndBytes та збудуйте з джерела:

<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. Встановлення PyTorch

Встановіть PyTorch за допомогою команди:

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

7. Встановлення Hugging та Transformers

Встановіть бібліотеки transformers та accelerate:

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

Могутність паралельної обробки

В основі своїй GPU є високопаралельні процесори, призначені для ефективної обробки тисяч одночасних потоків. Ця архітектура робить їх добре придатними для обчислювально інтенсивних завдань, пов’язаних з тренуванням глибоких моделей навчання, включаючи LLM. Платформа CUDA, розроблена NVIDIA, забезпечує програмне середовище, яке дозволяє розробникам використовувати повний потенціал цих GPU, дозволяючи їм писати код, який може використовувати паралельні можливості апаратного забезпечення.
Прискорення тренування LLM з використанням GPU та CUDA.

Тренування великих мовних моделей є обчислювально вимогою задачею, яка вимагає обробки великої кількості текстових даних та виконання численних матричних операцій. GPU, з тисячами ядер та високою пропускною здатністю пам’яті, ідеально підходять для цих завдань. Використовуючи CUDA, розробники можуть оптимізувати свій код для використання паралельних можливостей GPU, суттєво скорочуючи час, необхідний для тренування LLM.

Наприклад, тренування GPT-3, однієї з найбільших мовних моделей на сьогоднішній день, стало можливим завдяки використанню тисяч GPU NVIDIA з оптимізованим кодом CUDA. Це дозволило тренувати модель на безпрецедентній кількості даних, що призвело до її вражаючої продуктивності у завданнях природної мови.

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

<p># Завантажте попередньо треновану модель GPT-2 та токенізацію
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')</p>

<p># Перемістіть модель на GPU, якщо він доступний
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)</p>

<p># Визначте дані тренування та гіперпараметри
train_data = [...] # Ваші дані тренування
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>

<p># Визначте функцію втрат та оптимізатор
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>

<p># Цикл тренування
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Підготовка вхідних та цільових послідовностей
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># Впередній прохід
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>

<p># Зворотній прохід та оптимізація
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>

<p>print(f'Епоха {epoch+1}/{num_epochs}, Втрата: {loss.item()}')</p>

У цьому прикладі коду ми демонструємо тренування моделі GPT-2 за допомогою PyTorch та GPU, що підтримують CUDA. Модель завантажується на GPU (якщо він доступний), а цикл тренування використовує паралельність GPU для виконання ефективних вперед та назад проходів, прискорюючи процес тренування.

CUDA-прискорені бібліотеки для глибокого навчання

Крім платформи CUDA сама по собі, NVIDIA та відкрита спільнота розробили ряд CUDA-прискорених бібліотек, які дозволяють ефективно реалізувати глибокі моделі навчання, включаючи LLM. Ці бібліотеки забезпечують оптимізовані реалізації загальних операцій, таких як матричні множення, конволюції та функції активації, дозволяючи розробникам зосередитися на архітектурі моделі та процесі тренування, а не на низькорівневій оптимізації.

Одна з таких бібліотек – cuDNN (CUDA Deep Neural Network library), яка забезпечує високо налаштовані реалізації стандартних процедур, використовуваних у глибоких нейронних мережах. Використовуючи cuDNN, розробники можуть суттєво прискорити тренування та висновок своїх моделей, досягнувши продуктивності на кілька порядків вищої порівняно з реалізацією на основі 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>

У цьому коді ми визначаємо залишковий блок для конволюційної нейронної мережі (CNN) за допомогою PyTorch. Контекстний менеджер autocast з PyTorch’s Automatic Mixed Precision (AMP) використовується для активації змішаної точності тренування, яка може забезпечити суттєве підвищення продуктивності на GPU, що підтримують CUDA, при збереженні високої точності. Функція F.relu оптимізована за допомогою cuDNN, забезпечуючи ефективне виконання на GPU.

БагатогPU та розподілене тренування для масштабованості

Поскільки LLM та глибокі моделі навчання продовжують рости у розмірі та складності, обчислювальні вимоги для тренування цих моделей також зростають. Для вирішення цієї проблеми дослідники та розробники звернулися до багатогPU та розподіленого тренування, яке дозволяє їм використовувати об’єднану обробну потужність кількох GPU на кількох машинах.

CUDA та пов’язані з ним бібліотеки, такі як NCCL (NVIDIA Collective Communications Library), забезпечують ефективні засоби зв’язку, які дозволяють здійснювати безшовний обмін даними та синхронізацію між кількома GPU, забезпечуючи розподілене тренування на безпрецедентному рівні.

</pre>
import torch.distributed as dist

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

<p># Ініціалізація розподіленого тренування
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)</p>

<p># Створення моделі та переміщення на GPU
model = MyModel().cuda()</p>

<p># Обгортання моделі в DDP
model = DDP(model, device_ids=[local_rank])</p>

<p># Цикл тренування (розподілене)
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>

У цьому прикладі ми демонструємо розподілене тренування за допомогою модуля PyTorch’s DistributedDataParallel (DDP). Модель обгорнута в DDP, який автоматично обробляє паралельність даних, синхронізацію градієнтів та зв’язок між кількома GPU за допомогою NCCL. Цей підхід дозволяє ефективно масштабувати процес тренування на кількох машинах, дозволяючи дослідникам та розробникам тренувати більші та більш складні моделі за розумний час.

Розгортання моделей глибокого навчання з CUDA

Хоча GPU та CUDA здебільшого використовувалися для тренування глибоких моделей навчання, вони також важливі для ефективного розгортання та висновку. Поскільки глибокі моделі навчання стають дедалі більш складними та ресурсоємними, прискорення GPU є важливим для досягнення продуктивності в режимі реального часу у виробничих середовищах.

Технологія NVIDIA TensorRT є високопродуктивним оптимізатором та runtime глибокого навчання, який забезпечує низьку затримку та високу пропускну здатність висновку на GPU, що підтримують CUDA. TensorRT може оптимізувати та прискорити моделі, треновані в рамках таких фреймворків, як TensorFlow, PyTorch та MXNet, дозволяючи ефективно розгортати їх на різних платформах, від вбудованих систем до центрів даних.

import tensorrt as trt

<p># Завантажте попередньо треновану модель
model = load_model(...)</p>

<p># Створіть двигун TensorRT
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)</p>

<p># Розпарсуйте та оптимізуйте модель
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)</p>

<p># Виконайте висновок на GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)</p>

<p># Встановіть вхідні дані та виконайте висновок
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p>

# Обробіть висновок
# ...

У цьому прикладі ми демонструємо використання TensorRT для розгортання попередньо тренованої глибокої моделі навчання на GPU, що підтримують CUDA. Модель спочатку розпарсовується та оптимізується за допомогою TensorRT, який генерує високо оптимізований двигун висновку, адаптований для конкретної моделі та апаратного забезпечення. Цей двигун можна використовувати для виконання ефективного висновку на GPU, використовуючи CUDA для прискореного обчислення.

Висновок

Комбінація GPU та CUDA була інструментальною у розвитку великих мовних моделей, комп’ютерного зору, розпізнавання мовлення та інших галузей глибокого навчання. Використовуючи паралельні можливості GPU та оптимізовані бібліотеки, забезпечені CUDA, дослідники та розробники можуть тренувати та розгортати дедалі більш складні моделі з високою ефективністю.

Поскільки галузь AI продовжує розвиватися, важливість GPU та CUDA буде тільки зростати. З ще більш потужним апаратним та програмним забезпеченням ми можемо очікувати подальших проривів у розвитку та розгортанні систем AI, що розширюють межі того, що можливо.