NVIDIA GPU'lar ve CUDA ile LLM'lerin Eğitimi, İnce Ayarı ve Çıkarımının Ayarlanması

Yapay zeka (AI) alanı son yıllarda kayda değer gelişmelere tanık oldu ve bunun merkezinde grafik işleme birimleri (GPU'lar) ile paralel hesaplama platformunun güçlü birleşimi yatıyor.

gibi modeller GPT, BERTve daha yakın zamanda lama, Karayel benzeri görülmemiş bir akıcılık ve tutarlılıkla insan benzeri metinleri anlama ve oluşturma yeteneğine sahiptirler. Ancak bu modellerin eğitimi büyük miktarda veri ve hesaplama kaynağı gerektirir ve bu da GPU'ları ve CUDA'yı bu çabada vazgeçilmez araçlar haline getirir.

Bu kapsamlı kılavuz, NVIDIA sürücüsü, CUDA Araç Takımı, cuDNN, PyTorch ve daha fazlası gibi temel yazılım bileşenlerinin kurulumunu kapsayan, Ubuntu'da bir NVIDIA GPU kurma sürecinde size yol gösterecektir.

CUDA ile Hızlandırılmış Yapay Zeka Çerçevelerinin Yükselişi

GPU ile hızlandırılmış derin öğrenme, verimli hesaplama için CUDA'dan yararlanan popüler yapay zeka çerçevelerinin geliştirilmesiyle desteklenmiştir. Gibi çerçeveler TensorFlow, PyTorch, ve MX Ağı GPU hızlandırmanın derin öğrenme hatlarına kusursuz entegrasyonunu sağlayan yerleşik CUDA desteğine sahiptir.

Göre NVIDIA Veri Merkezi Derin Öğrenme Ürün Performansı ÇalışmasıCUDA ile hızlandırılmış derin öğrenme modelleri, CPU tabanlı uygulamalara kıyasla 100 kata kadar daha hızlı performans elde edebilir.

Ampere mimarisiyle birlikte sunulan NVIDIA'nın Çoklu Örnek GPU (MIG) teknolojisi, tek bir GPU'nun her biri kendi özel kaynaklarına sahip birden fazla güvenli örneğe bölünmesine olanak tanır. Bu özellik, GPU kaynaklarının birden fazla kullanıcı veya iş yükü arasında verimli bir şekilde paylaşılmasını sağlayarak, kullanımı en üst düzeye çıkarır ve genel maliyetleri düşürür.

NVIDIA TensorRT ile Yüksek Lisans Çıkarımını Hızlandırma

GPU'lar LLM'lerin eğitiminde etkili olsa da, bu modellerin üretim ortamlarında konuşlandırılmasında verimli çıkarım da aynı derecede önemlidir. NVIDIA TensorRTYüksek performanslı bir derin öğrenme çıkarım iyileştiricisi ve çalışma zamanı olan CUDA özellikli GPU'larda LLM çıkarımını hızlandırmada hayati bir rol oynar.

NVIDIA'nın kıyaslamalarına göre TensorRT, GPT-8 gibi büyük dil modelleri için CPU tabanlı çıkarıma kıyasla 5 kata kadar daha hızlı çıkarım performansı ve 3 kata kadar daha düşük toplam sahip olma maliyeti sağlayabiliyor.

NVIDIA'nın açık kaynaklı girişimlere olan bağlılığı, yapay zeka araştırma topluluğunda CUDA'nın yaygın olarak benimsenmesinin arkasındaki itici güç olmuştur. cuDNN, kübik, ve NCCL araştırmacıların ve geliştiricilerin derin öğrenmeleri için CUDA'nın tüm potansiyelinden yararlanmalarına olanak tanıyan açık kaynak kitaplıklar olarak mevcuttur.

Montaj

Yapay zeka geliştirmeyi ayarlarken en yeni sürücüleri ve kitaplıkları kullanmak her zaman en iyi seçim olmayabilir. Örneğin, en son NVIDIA sürücüsü (545.xx) CUDA 12.3'ü desteklerken, PyTorch ve diğer kütüphaneler henüz bu sürümü desteklemiyor olabilir. Bu nedenle kullanacağız CUDA 535.146.02 ile sürücü sürümü 12.2 Uyumluluğu sağlamak için.

Kurulum Adımları

1. NVIDIA Sürücüsünü yükleyin

Öncelikle GPU modelinizi tanımlayın. Bu kılavuz için NVIDIA GPU'yu kullanıyoruz. Ziyaret edin NVIDIA Sürücü İndirme sayfası, GPU'nuz için uygun sürücüyü seçin ve sürücü sürümünü not edin.

Ubuntu'da önceden oluşturulmuş GPU paketlerini kontrol etmek için şunu çalıştırın:

sudo ubuntu-drivers list --gpgpu

Bilgisayarınızı yeniden başlatın ve kurulumu doğrulayın:

nvidia-smi

2. CUDA Araç Setini yükleyin

CUDA Araç Takımı, yüksek performanslı GPU ile hızlandırılmış uygulamalar oluşturmak için geliştirme ortamı sağlar.

Yüksek Lisans dışı/derin öğrenme kurulumu için şunları kullanabilirsiniz:

sudo apt install nvidia-cuda-toolkit

However, to ensure compatibility with BitsAndBytes, we will follow these steps:

[code language="BASH"]

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

Kurulumu doğrulayın:

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

Ortam değişkenlerini ayarlayın:

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. cuDNN'yi yükleyin

Atomic Cüzdanı indirin : cuDNN paketi itibaren NVIDIA Geliştirici web sitesi. Şununla yükleyin:

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

Anahtarlığı eklemek için talimatları izleyin:

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

cuDNN kitaplıklarını yükleyin:

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

4. Python Sanal Ortamını Kurun

Ubuntu 22.04, Python 3.10 ile birlikte geliyor. Venv'i yükleyin:

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

Sanal ortamı oluşturun ve etkinleştirin:

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

5. BitsAndBytes'ı Kaynaktan Kurun

BitsAndBytes dizinine gidin ve kaynaktan derleyin:

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. PyTorch'u yükleyin

PyTorch'u aşağıdaki komutla yükleyin:

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

7. Sarılma Yüzünü ve Transformatörleri Kurun

Transformatörleri kurun ve kütüphaneleri hızlandırın:

pip install transformers
pip install accelerate

Paralel İşlemenin Gücü

GPU'lar özünde binlerce eşzamanlı iş parçacığını verimli bir şekilde işlemek üzere tasarlanmış oldukça paralel işlemcilerdir. Bu mimari, onları Yüksek Lisans da dahil olmak üzere derin öğrenme modellerinin eğitiminde yer alan hesaplama açısından yoğun görevler için çok uygun hale getiriyor. NVIDIA tarafından geliştirilen CUDA platformu, geliştiricilerin bu GPU'ların tüm potansiyelinden yararlanmasına olanak tanıyarak, donanımın paralel işleme özelliklerinden yararlanabilecek kod yazmalarına olanak tanıyan bir yazılım ortamı sağlar.
Hızlanma Yüksek Lisans GPU'lar ve CUDA ile eğitim.

Büyük dil modellerinin eğitimi, büyük miktarda metin verisinin işlenmesini ve çok sayıda matris işleminin gerçekleştirilmesini gerektiren, hesaplama açısından zorlu bir görevdir. Binlerce çekirdeği ve yüksek bellek bant genişliğiyle GPU'lar bu görevler için idealdir. Geliştiriciler, CUDA'dan yararlanarak kodlarını GPU'ların paralel işleme özelliklerinden yararlanacak şekilde optimize edebilir, böylece LLM'leri eğitmek için gereken süreyi önemli ölçüde azaltabilirler.

Örneğin, eğitim GPTBugüne kadarki en büyük dil modellerinden biri olan -3, CUDA için optimize edilmiş kod çalıştıran binlerce NVIDIA GPU'nun kullanılmasıyla mümkün oldu. Bu, modelin benzeri görülmemiş miktarda veri üzerinde eğitilmesine olanak tanıdı ve doğal dil görevlerinde etkileyici performansa yol açtı.

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

# Load pre-trained GPT-2 model and tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Move model to GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Define training data and hyperparameters
train_data = [...] # Your training data
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Training loop
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Prepare input and target sequences
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Forward pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Backward pass and optimization
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

Bu örnek kod parçacığında, bir eğitimin eğitimini gösteriyoruz. GPT 2 PyTorch ve CUDA özellikli GPU'ları kullanan dil modeli. Model GPU'ya (varsa) yüklenir ve eğitim döngüsü, verimli ileri ve geri geçişler gerçekleştirmek için GPU'ların paralelliğinden yararlanarak eğitim sürecini hızlandırır.

Derin Öğrenme için CUDA ile Hızlandırılmış Kütüphaneler

CUDA platformunun kendisine ek olarak NVIDIA ve açık kaynak topluluğu, LLM'ler de dahil olmak üzere derin öğrenme modellerinin verimli bir şekilde uygulanmasına olanak tanıyan bir dizi CUDA hızlandırmalı kitaplık geliştirdi. Bu kitaplıklar, matris çarpımları, evrişimler ve etkinleştirme işlevleri gibi ortak işlemlerin optimize edilmiş uygulamalarını sağlayarak geliştiricilerin düşük düzeyli optimizasyon yerine model mimarisine ve eğitim sürecine odaklanmasına olanak tanır.

Böyle bir kütüphane, derin sinir ağlarında kullanılan standart rutinlerin yüksek düzeyde ayarlanmış uygulamalarını sağlayan cuDNN'dir (CUDA Derin Sinir Ağı kütüphanesi). Geliştiriciler, cuDNN'den yararlanarak modellerinin eğitimini ve çıkarımını önemli ölçüde hızlandırabilir ve CPU tabanlı uygulamalara kıyasla birkaç kata kadar performans artışı elde edebilir.

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

Bu kod parçasında, PyTorch kullanarak bir evrişimli sinir ağı (CNN) için bir artık blok tanımlıyoruz. PyTorch'un Otomatik Karışık Hassasiyet (AMP) özelliğindeki otomatik yayın bağlam yöneticisi, CUDA destekli GPU'larda yüksek doğruluk sağlarken önemli performans kazanımları sağlayabilen karışık hassasiyetli eğitimi etkinleştirmek için kullanılır. F.relu işlevi, GPU'larda verimli yürütmeyi garanti altına alarak cuDNN tarafından optimize edilmiştir.

Ölçeklenebilirlik için Çoklu GPU ve Dağıtılmış Eğitim

Yüksek Lisans ve derin öğrenme modellerinin boyutu ve karmaşıklığı büyümeye devam ettikçe, bu modellerin eğitimi için bilgi işlem gereksinimleri de artıyor. Bu zorluğun üstesinden gelmek için araştırmacılar ve geliştiriciler, birden fazla makinede birden fazla GPU'nun birleşik işlem gücünden yararlanmalarına olanak tanıyan çoklu GPU ve dağıtılmış eğitim tekniklerine yöneldiler.

CUDA ve NCCL (NVIDIA Toplu İletişim Kütüphanesi) gibi ilgili kütüphaneler, birden fazla GPU arasında kesintisiz veri aktarımı ve senkronizasyona olanak tanıyan etkili iletişim temelleri sağlayarak benzeri görülmemiş bir ölçekte dağıtılmış eğitime olanak tanır.

</pre>
import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Initialize distributed training
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Create model and move to GPU
model = MyModel().cuda()

# Wrap model with DDP
model = DDP(model, device_ids=[local_rank])

# Training loop (distributed)
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()

Bu örnekte, PyTorch'un DistributedDataParallel (DDP) modülünü kullanarak dağıtılmış eğitimi gösteriyoruz. Model, NCCL kullanarak veri paralelliğini, gradyan senkronizasyonunu ve birden fazla GPU arasında iletişimi otomatik olarak yöneten DDP ile sarmalanmıştır. Bu yaklaşım, eğitim sürecinin birden fazla makinede verimli bir şekilde ölçeklenmesini sağlayarak araştırmacıların ve geliştiricilerin daha büyük ve daha karmaşık modelleri makul bir sürede eğitmelerine olanak tanır.

CUDA ile Derin Öğrenme Modellerini Dağıtma

GPU'lar ve CUDA öncelikle derin öğrenme modellerini eğitmek için kullanılsa da verimli dağıtım ve çıkarım için de çok önemlidir. Derin öğrenme modelleri giderek daha karmaşık ve kaynak yoğun hale geldikçe, GPU hızlandırması hayati öneme sahiptir. üretim ortamlarında gerçek zamanlı performans elde etmek.

NVIDIA'nın TensorRT'si, yüksek performanslı derin öğrenme çıkarım optimizasyonu ve çalışma zamanı sağlayan bir araçtır. düşük gecikme süresi ve yüksek verim CUDA-etkin GPU'lara ilişkin çıkarım. TensorRT, TensorFlow, PyTorch ve MXNet gibi çerçevelerde eğitilen modelleri optimize edip hızlandırabilir, böylece gömülü sistemlerden veri merkezlerine kadar çeşitli platformlarda verimli dağıtıma olanak tanır.

import tensorrt as trt

# Load pre-trained model
model = load_model(...)

# Create TensorRT engine
logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)
network = builder.create_network()
parser = trt.OnnxParser(network, logger)

# Parse and optimize model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Run inference on GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Set input data and run inference
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Process output
# ...

Bu örnekte, önceden eğitilmiş bir derin öğrenme modelini CUDA özellikli bir GPU'ya dağıtmak için TensorRT'nin kullanımını gösteriyoruz. Model ilk önce belirli model ve donanıma göre uyarlanmış, yüksek derecede optimize edilmiş bir çıkarım motoru üreten TensorRT tarafından ayrıştırılır ve optimize edilir. Bu motor daha sonra hızlandırılmış hesaplama için CUDA'dan yararlanarak GPU üzerinde etkili çıkarımlar gerçekleştirmek için kullanılabilir.

Sonuç

GPU'lar ve CUDA'nın birleşimi, büyük dil modellerinde, bilgisayar görüşünde, konuşma tanımada ve derin öğrenmenin diğer çeşitli alanlarındaki gelişmelerin desteklenmesinde etkili olmuştur. Araştırmacılar ve geliştiriciler, GPU'ların paralel işleme yeteneklerinden ve CUDA tarafından sağlanan optimize edilmiş kitaplıklardan yararlanarak, giderek daha karmaşık hale gelen modelleri yüksek verimlilikle eğitebilir ve dağıtabilir.

Yapay zeka alanı gelişmeye devam ettikçe GPU'ların ve CUDA'nın önemi de artacaktır. Daha da güçlü donanım ve yazılım optimizasyonlarıyla, yapay zeka sistemlerinin geliştirilmesinde ve devreye alınmasında mümkün olanın sınırlarını zorlayan daha fazla atılım görmeyi bekleyebiliriz.