Mengatur Pelatihan, Fine-Tuning, dan Inferensi LLM dengan NVIDIA GPUs dan CUDA

Bidang kecerdasan buatan (AI) telah menyaksikan kemajuan luar biasa dalam beberapa tahun terakhir, dan di jantungnya terletak kombinasi kuat dari unit pemrosesan grafis (GPUs) dan platform komputasi paralel.

Model seperti GPT, BERT, dan lebih baru Llama, Mistral mampu memahami dan menghasilkan teks seperti manusia dengan kelancaran dan kohesi yang belum pernah terjadi sebelumnya. Namun, pelatihan model ini memerlukan jumlah data dan sumber daya komputasi yang besar, membuat GPUs dan CUDA menjadi alat yang tak tergantikan dalam upaya ini.

Panduan komprehensif ini akan membantu Anda melalui proses pengaturan NVIDIA GPU pada Ubuntu, mencakup instalasi komponen perangkat lunak esensial seperti driver NVIDIA, CUDA Toolkit, cuDNN, PyTorch, dan lainnya.

Munculnya Kerangka AI yang Dipercepat CUDA

Pembelajaran dalam yang dipercepat GPU telah didorong oleh pengembangan kerangka AI populer yang memanfaatkan CUDA untuk komputasi yang efisien. Kerangka seperti TensorFlow, PyTorch, dan MXNet memiliki dukungan bawaan untuk CUDA, memungkinkan integrasi yang mulus dari percepatan GPU ke dalam pipa pembelajaran dalam.

Menurut NVIDIA Data Center Deep Learning Product Performance Study, model pembelajaran dalam yang dipercepat CUDA dapat mencapai kinerja yang lebih cepat hingga 100 kali lipat dibandingkan dengan implementasi berbasis CPU.

Teknologi Multi-Instance GPU (MIG) NVIDIA, yang diperkenalkan dengan arsitektur Ampere, memungkinkan satu GPU dipartisi menjadi beberapa instance yang aman, masing-masing dengan sumber daya yang didedikasikan. Fitur ini memungkinkan berbagi sumber daya GPU yang efisien di antara beberapa pengguna atau beban kerja, memaksimalkan utilitas dan mengurangi biaya secara keseluruhan.

Meningkatkan Inferensi LLM dengan NVIDIA TensorRT

Sementara GPU telah menjadi instrumental dalam pelatihan LLM, inferensi yang efisien sama pentingnya untuk menggelar model ini di lingkungan produksi. NVIDIA TensorRT, sebuah optimizer dan runtime inferensi pembelajaran dalam yang berkinerja tinggi, memainkan peran vital dalam mempercepat inferensi LLM pada GPU yang diaktifkan CUDA.

Menurut benchmark NVIDIA, TensorRT dapat menyediakan kinerja inferensi yang lebih cepat hingga 8 kali dan biaya total kepemilikan yang lebih rendah hingga 5 kali lipat dibandingkan dengan inferensi berbasis CPU untuk model bahasa besar seperti GPT-3.

Komitmennya NVIDIA terhadap inisiatif open-source telah menjadi kekuatan pendorong di balik adopsi CUDA yang luas di komunitas penelitian AI. Proyek seperti cuDNN, cuBLAS, dan NCCL tersedia sebagai perpustakaan open-source, memungkinkan peneliti dan pengembang memanfaatkan potensi penuh CUDA untuk pembelajaran dalam mereka.

Instalasi

Ketika mengatur pengembangan AI, menggunakan driver dan perpustakaan terbaru mungkin tidak selalu menjadi pilihan terbaik. Misalnya, sementara driver NVIDIA terbaru (545.xx) mendukung CUDA 12.3, PyTorch dan perpustakaan lain mungkin belum mendukung versi ini. Oleh karena itu, kita akan menggunakan driver versi 535.146.02 dengan CUDA 12.2 untuk memastikan kompatibilitas.

Langkah Instalasi

1. Instal Driver NVIDIA

Pertama, identifikasi model GPU Anda. Untuk panduan ini, kita menggunakan NVIDIA GPU. Kunjungi halaman unduh driver NVIDIA, pilih driver yang sesuai untuk GPU Anda, dan catat versi driver.

Untuk memeriksa paket GPU pra-bangun di Ubuntu, jalankan:

sudo ubuntu-drivers list --gpgpu

Restart komputer Anda dan verifikasi instalasi:

nvidia-smi

2. Instal CUDA Toolkit

CUDA Toolkit menyediakan lingkungan pengembangan untuk membuat aplikasi yang dipercepat GPU dengan kinerja tinggi.

Untuk setup non-LLM/pembelajaran dalam, Anda dapat menggunakan:

sudo apt install nvidia-cuda-toolkit

Namun, untuk memastikan kompatibilitas dengan BitsAndBytes, kita akan mengikuti langkah-langkah berikut:

[code language="BASH"]

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

Verifikasi instalasi:

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

Tetapkan variabel lingkungan:

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

Unduh paket cuDNN dari situs web pengembang NVIDIA. Instal dengan:

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

Ikuti instruksi untuk menambahkan keyring:

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

Instal perpustakaan cuDNN:

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

4. Atur Lingkungan Virtual Python

Ubuntu 22.04 dilengkapi dengan Python 3.10. Instal venv:

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

Buat dan aktifkan lingkungan virtual:

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

5. Instal BitsAndBytes dari Sumber

Navigasi ke direktori BitsAndBytes dan bangun dari sumber:

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

Instal PyTorch dengan perintah berikut:

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

7. Instal Hugging Face dan Transformers

Instal perpustakaan transformers dan accelerate:

pip install transformers
pip install accelerate

Kekuatan Pemrosesan Paralel

Pada intinya, GPU adalah pemroses paralel yang dirancang untuk menangani ribuan thread secara bersamaan dengan efisien. Arsitektur ini membuatnya sangat sesuai untuk tugas komputasi intensif yang terlibat dalam pelatihan model pembelajaran dalam, termasuk LLM. Platform CUDA, yang dikembangkan oleh NVIDIA, menyediakan lingkungan perangkat lunak yang memungkinkan pengembang memanfaatkan potensi penuh GPU ini, memungkinkan mereka untuk menulis kode yang dapat memanfaatkan kemampuan pemrosesan paralel perangkat keras.
Meningkatkan LLM Pelatihan dengan GPU dan CUDA.

Pelatihan model bahasa besar adalah tugas yang menantang secara komputasi yang memerlukan pemrosesan jumlah data teks yang besar dan melakukan banyak operasi matriks. GPU, dengan ribuan core dan bandwidth memori yang tinggi, sangat sesuai untuk tugas ini. Dengan memanfaatkan CUDA, pengembang dapat mengoptimalkan kode mereka untuk memanfaatkan kemampuan pemrosesan paralel GPU, secara signifikan mengurangi waktu yang dibutuhkan untuk melatih LLM.

Misalnya, pelatihan GPT-3, salah satu model bahasa terbesar hingga saat ini, dimungkinkan melalui penggunaan ribuan GPU NVIDIA yang menjalankan kode yang dioptimalkan CUDA. Ini memungkinkan model untuk dilatih pada jumlah data yang belum pernah terjadi sebelumnya, menghasilkan kinerja yang mengesankan dalam tugas bahasa alami.

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

# Muat model GPT-2 pra-pelatihan dan tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Pindahkan model ke GPU jika tersedia
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Tentukan data pelatihan dan hiperparameter
train_data = [...] # Data pelatihan Anda
batch_size = 32
num_epochs = 10
learning_rate = 5e-5

# Tentukan fungsi kerugian dan optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Loop pelatihan
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Siapkan urutan input dan target
inputs, targets = train_data[i:i+batch_size]
inputs = tokenizer(inputs, return_tensors="pt", padding=True)
inputs = inputs.to(device)
targets = targets.to(device)

# Langkah maju
outputs = model(**inputs, labels=targets)
loss = outputs.loss

# Langkah mundur dan optimasi
optimizer.zero_grad()
loss.backward()
optimizer.step()

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

Dalam contoh ini, kita mendemonstrasikan pelatihan model bahasa GPT-2 menggunakan PyTorch dan GPU yang diaktifkan CUDA. Model dimuat ke GPU (jika tersedia), dan loop pelatihan memanfaatkan paralelisme GPU untuk melakukan langkah maju dan mundur yang efisien, mempercepat proses pelatihan.

Perpustakaan CUDA yang Dipercepat untuk Pembelajaran Dalam

Selain platform CUDA itu sendiri, NVIDIA dan komunitas open-source telah mengembangkan berbagai perpustakaan yang dipercepat CUDA yang memungkinkan implementasi model pembelajaran dalam yang efisien, termasuk LLM. Perpustakaan ini menyediakan implementasi yang dioptimalkan dari operasi umum, seperti perkalian matriks, konvolusi, dan fungsi aktivasi, memungkinkan pengembang untuk fokus pada arsitektur model dan proses pelatihan daripada optimasi tingkat rendah.

Salah satu perpustakaan tersebut adalah cuDNN (CUDA Deep Neural Network library), yang menyediakan implementasi yang sangat dioptimalkan dari rutinitas standar yang digunakan dalam jaringan saraf dalam. Dengan memanfaatkan cuDNN, pengembang dapat secara signifikan mempercepat pelatihan dan inferensi model mereka, mencapai peningkatan kinerja beberapa kali lipat dibandingkan dengan implementasi berbasis 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

Dalam contoh ini, kita mendefinisikan blok residu untuk jaringan saraf konvolusi (CNN) menggunakan PyTorch. Pengelola konteks autocast dari PyTorch’s Automatic Mixed Precision (AMP) digunakan untuk mengaktifkan pelatihan campuran presisi, yang dapat menyediakan peningkatan kinerja yang signifikan pada GPU yang diaktifkan CUDA sambil mempertahankan akurasi yang tinggi. Fungsi F.relu dioptimalkan oleh cuDNN, memastikan eksekusi yang efisien pada GPU.

Pelatihan Multi-GPU dan Terdistribusi untuk Skalabilitas

Karena LLM dan model pembelajaran dalam terus tumbuh dalam ukuran dan kompleksitas, persyaratan komputasi untuk melatih model ini juga meningkat. Untuk mengatasi tantangan ini, peneliti dan pengembang telah beralih ke teknik pelatihan multi-GPU dan terdistribusi, yang memungkinkan mereka untuk memanfaatkan daya pemrosesan gabungan dari beberapa GPU di seluruh mesin.

CUDA dan perpustakaan terkait, seperti NCCL (NVIDIA Collective Communications Library), menyediakan primitif komunikasi yang efisien yang memungkinkan transfer data dan sinkronisasi yang mulus di seluruh beberapa GPU, memungkinkan pelatihan terdistribusi pada skala yang belum pernah terjadi sebelumnya.

import torch.distributed as dist

from torch.nn.parallel import DistributedDataParallel as DDP

# Inisialisasi pelatihan terdistribusi
dist.init_process_group(backend='nccl', init_method='...')
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# Buat model dan pindahkan ke GPU
model = MyModel().cuda()

# Bungkus model dengan DDP
model = DDP(model, device_ids=[local_rank])

# Loop pelatihan (terdistribusi)
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()

Dalam contoh ini, kita mendemonstrasikan pelatihan terdistribusi menggunakan modul DistributedDataParallel (DDP) PyTorch. Model dibungkus dengan DDP, yang secara otomatis menangani paralelisme data, sinkronisasi gradien, dan komunikasi di seluruh beberapa GPU menggunakan NCCL. Pendekatan ini memungkinkan skala efisien proses pelatihan di seluruh beberapa mesin, memungkinkan peneliti dan pengembang untuk melatih model yang lebih besar dan lebih kompleks dalam waktu yang wajar.

Menggelar Model Pembelajaran Dalam dengan CUDA

Sementara GPU dan CUDA telah terutama digunakan untuk melatih model pembelajaran dalam, mereka juga sangat penting untuk inferensi yang efisien. Karena model pembelajaran dalam menjadi semakin kompleks dan intensif sumber daya, percepatan GPU sangat penting untuk mencapai kinerja waktu nyata di lingkungan produksi.

NVIDIA’s TensorRT adalah optimizer dan runtime inferensi pembelajaran dalam yang berkinerja tinggi yang menyediakan latensi rendah dan throughput tinggi inferensi pada GPU yang diaktifkan CUDA. TensorRT dapat mengoptimalkan dan mempercepat model yang dilatih dalam kerangka seperti TensorFlow, PyTorch, dan MXNet, memungkinkan penggelaran yang efisien di berbagai platform, dari sistem tertanam hingga pusat data.

import tensorrt as trt

# Muat model pra-pelatihan
model = load_model(...)

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

# Parse dan optimalkan model
success = parser.parse_from_file(model_path)
engine = builder.build_cuda_engine(network)

# Jalankan inferensi pada GPU
context = engine.create_execution_context()
inputs, outputs, bindings, stream = allocate_buffers(engine)

# Tetapkan data input dan jalankan inferensi
set_input_data(inputs, input_data)
context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)

# Proses output
# ...

Dalam contoh ini, kita mendemonstrasikan penggunaan TensorRT untuk menggelar model pembelajaran dalam pra-pelatihan pada GPU yang diaktifkan CUDA. Model pertama kali diparse dan dioptimalkan oleh TensorRT, yang menghasilkan mesin inferensi yang sangat dioptimalkan yang disesuaikan untuk model dan perangkat keras tertentu. Mesin ini kemudian dapat digunakan untuk melakukan inferensi yang efisien pada GPU, memanfaatkan CUDA untuk komputasi yang dipercepat.

Kesimpulan

Kombinasi GPU dan CUDA telah menjadi instrumental dalam menggerakkan kemajuan dalam model bahasa besar, penglihatan komputer, pengenalan suara, dan berbagai domain lainnya dari pembelajaran dalam. Dengan memanfaatkan kemampuan pemrosesan paralel GPU dan perpustakaan yang dioptimalkan yang disediakan oleh CUDA, peneliti dan pengembang dapat melatih dan menggelar model yang semakin kompleks dengan efisiensi tinggi.

Karena bidang AI terus berkembang, pentingnya GPU dan CUDA hanya akan meningkat. Dengan perangkat keras dan optimasi perangkat lunak yang lebih kuat, kita dapat mengharapkan kemajuan lebih lanjut dalam pengembangan dan penerapan sistem AI, mendorong batas apa yang mungkin.