AI-verktyg 101
Konfigurera utbildning, finjustering och inferens av LLM med NVIDIA-GPU och CUDA
Lägg till Unite.AI bland dina föredragna källor på Google
Artificiell intelligens (AI) har sett anmärkningsvärda framsteg under de senaste åren, och i hjärtat av detta ligger den kraftfulla kombinationen av grafikprocessorer (GPU) och parallellbearbetningsplattform.
Modeller som GPT, BERT och mer nyligen Llama, Mistral kan förstå och generera mänsklig text med utanför detta fluens och sammanhang. Men för att träna dessa modeller krävs stora mängder data och beräkningsresurser, vilket gör GPU och CUDA oumbärliga verktyg i detta företag.
Denna omfattande guide kommer att vägleda dig genom processen att konfigurera en NVIDIA (NVDA ) -GPU på Ubuntu, med täckning av installationen av viktiga programkomponenter som NVIDIA-drivrutin, CUDA Toolkit, cuDNN, PyTorch och mer.
CUDA-accelererade AI-ramverk på uppgång
GPU-accelererad djupinlärning har drivits av utvecklingen av populära AI-ramverk som utnyttjar CUDA för effektiv beräkning. Ramverk som TensorFlow, PyTorch och MXNet har inbyggt stöd för CUDA, vilket möjliggör enkel integration av GPU-acceleration i djupinlärningspipelines.
Enligt NVIDIA Data Center Deep Learning Product Performance Study kan CUDA-accelererade djupinlärningsmodeller uppnå upp till 100 gånger snabbare prestanda jämfört med CPU-baserade implementationer.
NVIDIA:s Multi-Instance GPU (MIG)-teknik, introducerad med Ampere-arkitekturen, tillåter en enda GPU att delas in i flera säkra instanser, var och en med sina egna dedikerade resurser. Den här funktionen möjliggör effektiv delning av GPU-resurser mellan flera användare eller arbetsbelastningar, vilket maximerar utnyttjandet och minskar de totala kostnaderna.
Accelerera LLM-inferens med NVIDIA TensorRT
Medan GPU har varit avgörande för att träna LLM, är effektiv inferens lika viktig för att distribuera dessa modeller i produktionsmiljöer. NVIDIA TensorRT, en högpresterande djupinlärningsinferensoptimerare och körning, spelar en avgörande roll för att accelerera LLM-inferens på CUDA-aktiverade GPU.
Enligt NVIDIA:s benchmark kan TensorRT ge upp till 8 gånger snabbare inferensprestanda och 5 gånger lägre total ägandekostnad jämfört med CPU-baserad inferens för stora språkmodeller som GPT-3.
NVIDIA:s engagemang för öppen källkodsinitiativ har varit en drivande kraft bakom den omfattande antagandet av CUDA i AI-forskningsgemenskapen. Projekt som cuDNN, cuBLAS och NCCL är tillgängliga som öppen källkodsprogramvara, vilket möjliggör för forskare och utvecklare att utnyttja full potentialen av CUDA för sin djupinlärning.
Installation
När du konfigurerar AI-utveckling kan det inte alltid vara det bästa valet att använda de senaste drivrutinerna och biblioteken. Till exempel stöder den senaste NVIDIA-drivrutinen (545.xx) CUDA 12.3, men PyTorch och andra bibliotek kanske inte stöder den versionen ännu. Därför kommer vi att använda drivrutin version 535.146.02 med CUDA 12.2 för att säkerställa kompatibilitet.
Installationssteg
1. Installera NVIDIA-drivrutin
Först identifierar du din GPU-modell. För den här guiden använder vi NVIDIA GPU. Besök NVIDIA Driver Download-sidan, välj den lämpligaste drivrutinen för din GPU och notera drivrutinsversionen.
Kontrollera för förbyggda GPU-paket på Ubuntu, kör:
sudo ubuntu-drivers list --gpgpu
Starta om din dator och verifiera installationen:
nvidia-smi
2. Installera CUDA Toolkit
CUDA Toolkit tillhandahåller utvecklingsmiljön för att skapa högpresterande GPU-accelererade program.
För en icke-LLM/djupinlärningskonfiguration kan du använda:
sudo apt install nvidia-cuda-toolkit <p>Men för att säkerställa kompatibilitet med BitsAndBytes kommer vi att följa dessa steg:</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>
Verifiera installationen:
~/local/cuda-12.2/bin/nvcc --version
Ange miljövariabler:
<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. Installera cuDNN
Ladda ner cuDNN-paketet från NVIDIA Developer-webbplatsen. Installera det med:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Följ instruktionerna för att lägga till nyckelringen:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Installera cuDNN-biblioteken:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Konfigurera Python Virtual Environment
Ubuntu 22.04 kommer med Python 3.10. Installera venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Skapa och aktivera den virtuella miljön:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Installera BitsAndBytes från källkod
Navigera till BitsAndBytes-katalogen och bygg från källkod:
<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. Installera PyTorch
Installera PyTorch med följande kommando:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Installera Hugging och Transformers
Installera transformers- och accelerate-biblioteken:
<p>pip install transformers pip install accelerate</p>
Parallellbearbetningens kraft
I sin kärna är GPU:er högpresterande parallellprocessorer som är utformade för att hantera tusentals samtidiga trådar effektivt. Den här arkitekturen gör dem väl lämpade för de beräkningsintensiva uppgifterna som är involverade i att träna djupinlärningsmodeller, inklusive LLM. CUDA-plattformen, som utvecklats av NVIDIA, tillhandahåller en programvarumiljö som möjliggör för utvecklare att utnyttja full potentialen av dessa GPU:er, vilket möjliggör att de kan skriva kod som kan utnyttja parallellbearbetningsförmågan hos maskinvaran.
Accelerera LLM-träning med GPU och CUDA.
Träning av stora språkmodeller är en beräkningsintensiv uppgift som kräver bearbetning av stora mängder textdata och utförande av många matrisoperationer. GPU:er, med sina tusentals kärnor och höga minnesbandbredd, är idealiska för dessa uppgifter. Genom att utnyttja CUDA kan utvecklare optimera sin kod för att utnyttja parallellbearbetningsförmågan hos GPU:er, vilket signifikant minskar den tid som krävs för att träna LLM.
Till exempel gjordes träningen av GPT-3, en av de största språkmodellerna hittills, möjlig genom användning av tusentals NVIDIA-GPU:er som kör CUDA-optimerad kod. Detta möjliggjorde att modellen kunde tränas på en oöverträffad mängd data, vilket ledde till dess imponerande prestanda i naturliga språkuppgifter.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Ladda förtränad GPT-2-modell och tokenisator
model = GPT2LMHeadModel.from_pretrained(&#039;gpt2&#039;)
tokenizer = GPT2Tokenizer.from_pretrained(&#039;gpt2&#039;)</p>
<p># Flytta modell till GPU om tillgänglig
device = torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
model = model.to(device)</p>
<p># Definiera träningsdata och hyperparametrar
train_data = [...] # Din träningsdata
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>
<p># Definiera förlustfunktion och optimerare
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>
<p># Träningsloop
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Förbered indata och målsekvenser
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># Framåtriktad passering
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>
<p># Bakåtriktad passering och optimering
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>
<p>print(f&#039;Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}&#039;)</p>
I det här kodexemplet demonstrerar vi träning av en GPT-2-språkmodell med PyTorch och CUDA-aktiverade GPU:er. Modellen laddas till GPU (om tillgänglig), och träningsloopen utnyttjar parallellismen hos GPU:er för att utföra effektiv framåt- och bakåtriktad passering, vilket accelererar träningsprocessen.
CUDA-accelererade bibliotek för djupinlärning
Förutom CUDA-plattformen själv har NVIDIA och öppen källkodscommunityn utvecklat ett antal CUDA-accelererade bibliotek som möjliggör effektiv implementering av djupinlärningsmodeller, inklusive LLM. Dessa bibliotek tillhandahåller optimerade implementationer av vanliga operationer, såsom matrismultiplikationer, konvolutioner och aktiveringsfunktioner, vilket möjliggör för utvecklare att fokusera på modellarkitektur och träningsprocess snarare än lågnivåoptimering.
Ett sådant bibliotek är cuDNN (CUDA Deep Neural Network-bibliotek), som tillhandahåller högt justerade implementationer av standardrutiner som används i djupa neurala nätverk. Genom att utnyttja cuDNN kan utvecklare signifikant accelerera tränings- och inferensprocessen för sina modeller, vilket uppnår prestandavinster på upp till flera storleksordningar jämfört med CPU-baserade implementationer.
<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>
I det här kodexemplet definierar vi en residualblock för ett konvolutionsneuralt nätverk (CNN) med PyTorch. Autocast-kontexthanteraren från PyTorch:s Automatic Mixed Precision (AMP) används för att aktivera blandad precisionsträning, vilket kan ge signifikanta prestandavinster på CUDA-aktiverade GPU:er samtidigt som hög noggrannhet upprätthålls. F.relu-funktionen är optimerad av cuDNN, vilket säkerställer effektiv körning på GPU:er.
Multi-GPU och distribuerad träning för skalbarhet
Medan LLM och djupinlärningsmodeller fortsätter att växa i storlek och komplexitet, ökar också de beräkningskrav som krävs för att träna dessa modeller. För att möta den här utmaningen har forskare och utvecklare vänt sig till multi-GPU och distribuerad träningsteknik, vilket möjliggör att de kan utnyttja den kombinerade bearbetningskraften av flera GPU:er över flera maskiner.
CUDA och associerade bibliotek, såsom NCCL (NVIDIA Collective Communications Library), tillhandahåller effektiva kommunikationsprimitiver som möjliggör smidig dataöverföring och synkronisering över flera GPU:er, vilket möjliggör distribuerad träning i en aldrig tidigare skådad skala.
&lt;/pre&gt; import torch.distributed as dist <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Initiera distribuerad träning 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># Skapa modell och flytta till GPU model = MyModel().cuda()</p> <p># Omge modell med DDP model = DDP(model, device_ids=[local_rank])</p> <p># Träningsloop (distribuerad) 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>
I det här exemplet demonstrerar vi distribuerad träning med PyTorch:s DistributedDataParallel (DDP)-modul. Modellen omges av DDP, vilket automatiskt hanterar dataparallellism, gradientssynkronisering och kommunikation över flera GPU:er med hjälp av NCCL. Den här metoden möjliggör effektiv skalning av träningsprocessen över flera maskiner, vilket möjliggör för forskare och utvecklare att träna större och mer komplexa modeller på en rimlig tid.
Distribuera djupinlärningsmodeller med CUDA
Medan GPU:er och CUDA främst har använts för att träna djupinlärningsmodeller, är de också avgörande för effektiv distribution och inferens. Medan djupinlärningsmodeller blir alltmer komplexa och resurskrävande, är GPU-acceleration avgörande för att uppnå realtidsprestanda i produktionsmiljöer.
NVIDIA:s TensorRT är en högpresterande djupinlärningsinferensoptimerare och körning som tillhandahåller låglatens och högpresterande inferens på CUDA-aktiverade GPU:er. TensorRT kan optimera och accelerera modeller som tränats i ramverk som TensorFlow, PyTorch och MXNet, vilket möjliggör effektiv distribution på olika plattformar, från inbäddade system till datacenter.
import tensorrt as trt <p># Ladda förtränad modell model = load_model(...)</p> <p># Skapa TensorRT-motor logger = trt.Logger(trt.Logger.INFO) builder = trt.Builder(logger) network = builder.create_network() parser = trt.OnnxParser(network, logger)</p> <p># Parsa och optimera modell success = parser.parse_from_file(model_path) engine = builder.build_cuda_engine(network)</p> <p># Kör inferens på GPU context = engine.create_execution_context() inputs, outputs, bindings, stream = allocate_buffers(engine)</p> <p># Ställ in indata och kör inferens set_input_data(inputs, input_data) context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p> # Bearbeta utdata # ...
I det här exemplet demonstrerar vi användningen av TensorRT för att distribuera en förtränad djupinlärningsmodell på en CUDA-aktiverad GPU. Modellen parsas och optimeras av TensorRT, vilket genererar en högt optimerad inferensmotor som är anpassad för den specifika modellen och maskinvaran. Den här motorn kan sedan användas för att utföra effektiv inferens på GPU:en, vilket utnyttjar CUDA för accelererad beräkning.
Slutsats
Kombinationen av GPU:er och CUDA har varit avgörande för att driva framstegen inom stora språkmodeller, datorseende, taligenkänning och olika andra områden inom djupinlärning. Genom att utnyttja parallellbearbetningsförmågan hos GPU:er och de optimerade biblioteken som tillhandahålls av CUDA, kan forskare och utvecklare träna och distribuera alltmer komplexa modeller med hög effektivitet.
Så länge fältet AI fortsätter att utvecklas, kommer betydelsen av GPU:er och CUDA bara att öka. Med ännu kraftfullare maskinvara och programvaruoptimeringar kan vi förvänta oss att se ytterligare genombrott i utvecklingen och distributionen av AI-system, som kommer att utöka gränserna för vad som är möjligt.
