Alat AI 101
Mengatur Pelatihan, Fine-Tuning, dan Inferensi LLM dengan NVIDIA GPUs dan CUDA
Tambahkan Unite.AI ke sumber pilihan Anda di Google
Bidang kecerdasan buatan (AI) telah menyaksikan kemajuan luar biasa dalam beberapa tahun terakhir, dan di jantungnya terletak kombinasi kuat antara unit pemrosesan grafis (GPUs) dan platform komputasi paralel.
Model seperti GPT, BERT, dan lebih baru Llama, Mistral dapat memahami dan menghasilkan teks seperti manusia dengan kelancaran dan koherensi yang belum pernah terjadi sebelumnya. Namun, pelatihan model ini memerlukan sejumlah besar data dan sumber daya komputasi, membuat GPUs dan CUDA menjadi alat yang sangat penting dalam upaya ini.
Panduan komprehensif ini akan memandu Anda melalui proses pengaturan NVIDIA GPU pada Ubuntu, mencakup instalasi komponen perangkat lunak esensial seperti driver NVIDIA, CUDA Toolkit, cuDNN, PyTorch, dan lain-lain.
Munculnya Kerangka AI yang Dipercepat CUDA
Deep learning 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 deep learning.
Menurut NVIDIA Data Center Deep Learning Product Performance Study, model deep learning 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 dalam lingkungan produksi. NVIDIA TensorRT, sebuah pengoptimal dan runtime inferensi deep learning 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 dalam komunitas penelitian AI. Proyek seperti cuDNN, cuBLAS, dan NCCL tersedia sebagai perpustakaan open-source, memungkinkan peneliti dan pengembang memanfaatkan potensi penuh CUDA untuk deep learning mereka.
Instalasi
Ketika mengatur pengembangan AI, menggunakan driver dan perpustakaan terbaru 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/deep learning, Anda dapat menggunakan:
sudo apt install nvidia-cuda-toolkit <p>Namun, untuk memastikan kompatibilitas dengan BitsAndBytes, kita akan mengikuti langkah-langkah berikut:</p> [code language=&quot;BASH&quot;] <p>git clone https://github.com/TimDettmers/bitsandbytes.git cd bitsandbytes/ bash install_cuda.sh 122 ~/local 1</p>
Verifikasi instalasi:
~/local/cuda-12.2/bin/nvcc --version
Tetapkan variabel lingkungan:
<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. Instal cuDNN
Unduh paket cuDNN dari situs web pengembang NVIDIA. Instal dengan:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Ikuti instruksi untuk menambahkan keyring:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Instal perpustakaan cuDNN:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Atur Lingkungan Virtual Python
Ubuntu 22.04 dilengkapi dengan Python 3.10. Instal venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Buat dan aktifkan lingkungan virtual:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Instal BitsAndBytes dari Sumber
Navigasikan ke direktori BitsAndBytes dan bangun dari sumber:
<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. Instal PyTorch
Instal PyTorch dengan perintah:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Instal Hugging dan Transformers
Instal perpustakaan transformers dan accelerate:
<p>pip install transformers pip install accelerate</p>
Kekuatan Pemrosesan Paralel
Pada intinya, GPU adalah pemroses paralel yang dirancang untuk menangani ribuan thread secara efisien. Arsitektur ini membuatnya sangat cocok untuk tugas-tugas komputasi intensif yang terlibat dalam pelatihan model deep learning, termasuk LLM. Platform CUDA, yang dikembangkan oleh NVIDIA, menyediakan lingkungan perangkat lunak yang memungkinkan pengembang memanfaatkan potensi penuh GPU ini, memungkinkan mereka menulis kode yang dapat memanfaatkan kemampuan pemrosesan paralel perangkat keras.
Meningkatkan pelatihan LLM dengan GPU dan CUDA.
Pelatihan model bahasa besar adalah tugas yang memerlukan komputasi besar dan memerlukan pemrosesan sejumlah besar data teks dan melakukan banyak operasi matriks. GPU, dengan ribuan core dan bandwidth memori yang tinggi, sangat ideal untuk tugas-tugas ini. Dengan memanfaatkan CUDA, pengembang dapat mengoptimalkan kode mereka untuk memanfaatkan kemampuan pemrosesan paralel GPU, secara signifikan mengurangi waktu yang diperlukan untuk melatih LLM.
Sebagai contoh, 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 sejumlah besar data yang belum pernah terjadi sebelumnya, menghasilkan kinerja yang mengesankan dalam tugas bahasa alami.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Muat model GPT-2 pra-pelatihan dan tokenizer
model = GPT2LMHeadModel.from_pretrained(&#039;gpt2&#039;)
tokenizer = GPT2Tokenizer.from_pretrained(&#039;gpt2&#039;)</p>
<p># Pindahkan model ke GPU jika tersedia
device = torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
model = model.to(device)</p>
<p># Tentukan data pelatihan dan hiperparameter
train_data = [...] # Data pelatihan Anda
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>
<p># Tentukan fungsi kerugian dan pengoptimal
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>
<p># 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=&quot;pt&quot;, padding=True)
inputs = inputs.to(device)
targets = targets.to(device)</p>
<p># Forward pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>
<p># Backward pass dan optimasi
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>
<p>print(f&#039;Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}&#039;)</p>
Dalam contoh kode ini, kita mendemonstrasikan pelatihan model bahasa GPT-2 menggunakan PyTorch dan GPU CUDA. Model dimuat ke GPU (jika tersedia), dan loop pelatihan memanfaatkan paralelisme GPU untuk melakukan forward dan backward pass yang efisien, mempercepat proses pelatihan.
Perpustakaan CUDA yang Dipercepat untuk Deep Learning
Selain platform CUDA itu sendiri, NVIDIA dan komunitas open-source telah mengembangkan berbagai perpustakaan yang dipercepat CUDA yang memungkinkan implementasi model deep learning yang efisien, termasuk LLM. Perpustakaan ini menyediakan implementasi yang dioptimalkan dari operasi umum, seperti perkalian matriks, konvolusi, dan fungsi aktivasi, memungkinkan pengembang fokus pada arsitektur model dan proses pelatihan daripada optimasi rendah tingkat.
Salah satu perpustakaan seperti itu 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 hingga beberapa pesanan besarnya dibandingkan dengan implementasi berbasis 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>
Dalam contoh kode ini, kita mendefinisikan blok residual untuk jaringan saraf konvolusi (CNN) menggunakan PyTorch. Konteks manajer autocast dari PyTorch’s Automatic Mixed Precision (AMP) digunakan untuk mengaktifkan pelatihan campuran presisi, yang dapat memberikan peningkatan kinerja yang signifikan pada GPU yang diaktifkan CUDA. Fungsi F.relu dioptimalkan oleh cuDNN, memastikan eksekusi yang efisien pada GPU.
Pelatihan Terdistribusi dan Multi-GPU untuk Skalabilitas
Karena LLM dan model deep learning terus tumbuh dalam ukuran dan kompleksitas, kebutuhan komputasi untuk melatih model ini juga meningkat. Untuk mengatasi tantangan ini, peneliti dan pengembang telah beralih ke teknik pelatihan terdistribusi dan multi-GPU, yang memungkinkan mereka 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.
&lt;/pre&gt; import torch.distributed as dist <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Inisialisasi pelatihan terdistribusi dist.init_process_group(backend=&#039;nccl&#039;, init_method=&#039;...&#039;) local_rank = dist.get_rank() torch.cuda.set_device(local_rank)</p> <p># Buat model dan pindahkan ke GPU model = MyModel().cuda()</p> <p># Bungkus model dengan DDP model = DDP(model, device_ids=[local_rank])</p> <p># 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)</p> <p>outputs = model(inputs) loss = criterion(outputs, targets)</p> <p>optimizer.zero_grad() loss.backward() optimizer.step()</p>
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 pelatihan yang efisien di seluruh beberapa mesin, memungkinkan peneliti dan pengembang melatih model yang lebih besar dan lebih kompleks dalam waktu yang wajar.
Menggelar Model Deep Learning dengan CUDA
Sementara GPU dan CUDA telah terutama digunakan untuk melatih model deep learning, mereka juga sangat penting untuk penggelaran dan inferensi yang efisien. Karena model deep learning menjadi semakin kompleks dan intensif sumber daya, percepatan GPU sangat penting untuk mencapai kinerja waktu nyata di lingkungan produksi.
NVIDIA’s TensorRT adalah pengoptimal dan runtime inferensi deep learning 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 pada berbagai platform, dari sistem terbenam hingga pusat data.
import tensorrt as trt <p># Muat model pra-pelatihan model = load_model(...)</p> <p># Buat mesin TensorRT logger = trt.Logger(trt.Logger.INFO) builder = trt.Builder(logger) network = builder.create_network() parser = trt.OnnxParser(network, logger)</p> <p># Parse dan optimalkan model success = parser.parse_from_file(model_path) engine = builder.build_cuda_engine(network)</p> <p># Jalankan inferensi pada GPU context = engine.create_execution_context() inputs, outputs, bindings, stream = allocate_buffers(engine)</p> <p># Tetapkan data input dan jalankan inferensi set_input_data(inputs, input_data) context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p> # Proses output # ...
Dalam contoh ini, kita mendemonstrasikan penggunaan TensorRT untuk menggelar model deep learning pra-pelatihan pada GPU yang diaktifkan CUDA. Model pertama kali diparse dan dioptimalkan oleh TensorRT, yang menghasilkan mesin inferensi yang sangat dioptimalkan dan disesuaikan dengan 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 mengemudi kemajuan dalam model bahasa besar, penglihatan komputer, pengenalan suara, dan berbagai domain deep learning lainnya. 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 tumbuh. Dengan perangkat keras yang lebih kuat dan optimasi perangkat lunak, kita dapat mengharapkan kemajuan lebih lanjut dalam pengembangan dan penggelaran sistem AI, mendorong batas apa yang mungkin.
