KI-Tools 101
Einrichten von Trainings-, Feinabstimmungs- und Inferenzprozessen für LLMs mit NVIDIA-GPUs und CUDA
Das Feld der künstlichen Intelligenz (KI) hat in den letzten Jahren bemerkenswerte Fortschritte erlebt, und im Mittelpunkt davon steht die leistungsstarke Kombination aus Grafikprozessoren (GPUs) und parallelen Rechenplattformen.
Modelle wie GPT, BERT und mehr recently Llama, Mistral sind in der Lage, menschliche Texte mit unvergleichlicher Flüssigkeit und Kohärenz zu verstehen und zu generieren. Allerdings erfordert das Training dieser Modelle enorme Mengen an Daten und Rechenressourcen, wodurch GPUs und CUDA unverzichtbare Werkzeuge in diesem Unterfangen sind.
Diese umfassende Anleitung führt Sie durch den Prozess der Einrichtung einer NVIDIA-GPU auf Ubuntu, einschließlich der Installation von wesentlichen Softwarekomponenten wie dem NVIDIA-Treiber, dem CUDA-Toolkit, cuDNN, PyTorch und mehr.
Der Aufstieg von CUDA-beschleunigten KI-Frameworks
Die GPU-beschleunigte Deep-Learning-Entwicklung wurde durch die Entwicklung von beliebten KI-Frameworks vorangetrieben, die CUDA für effiziente Berechnungen nutzen. Frameworks wie TensorFlow, PyTorch und MXNet haben eine integrierte Unterstützung für CUDA, was eine nahtlose Integration von GPU-Beschleunigung in Deep-Learning-Pipelines ermöglicht.
Laut der NVIDIA Data Center Deep Learning Product Performance Study können CUDA-beschleunigte Deep-Learning-Modelle bis zu 100-mal schnellere Leistung im Vergleich zu CPU-basierten Implementierungen erzielen.
NVIDIA’s Multi-Instance-GPU-Technologie (MIG), die mit der Ampere-Architektur eingeführt wurde, ermöglicht es, eine einzelne GPU in mehrere sichere Instanzen aufzuteilen, von denen jede ihre eigenen dedizierten Ressourcen hat. Diese Funktion ermöglicht eine effiziente Aufteilung von GPU-Ressourcen unter mehreren Benutzern oder Workloads, wodurch die Auslastung maximiert und die Gesamtkosten reduziert werden.
Beschleunigung von LLM-Inferenz mit NVIDIA TensorRT
Während GPUs bei der Ausbildung von LLMs instrumental waren, ist eine effiziente Inferenz ebenso wichtig für die Bereitstellung dieser Modelle in Produktionsumgebungen. NVIDIA TensorRT, ein Hochleistungs-Deep-Learning-Inferenz-Optimierer und Laufzeitumgebung, spielt eine wichtige Rolle bei der Beschleunigung von LLM-Inferenz auf CUDA-aktivierten GPUs.
Laut NVIDIA-Benchmarks kann TensorRT bis zu 8-mal schnellere Inferenzleistung und 5-mal geringere Gesamtkosten im Vergleich zu CPU-basierten Inferenz für große Sprachmodelle wie GPT-3 bieten.
NVIDIA’s Engagement für Open-Source-Initiativen war ein treibender Faktor hinter der weiten Verbreitung von CUDA in der KI-Forschungsgemeinschaft. Projekte wie cuDNN, cuBLAS und NCCL sind als Open-Source-Bibliotheken verfügbar, die es Forschern und Entwicklern ermöglichen, das volle Potenzial von CUDA für ihre Deep-Learning-Anwendungen zu nutzen.
Installation
Bei der Einrichtung von KI-Entwicklungen ist es nicht immer ratsam, die neuesten Treiber und Bibliotheken zu verwenden. Zum Beispiel unterstützt der neueste NVIDIA-Treiber (545.xx) CUDA 12.3, aber PyTorch und andere Bibliotheken unterstützen diese Version möglicherweise noch nicht. Daher verwenden wir Treiber-Version 535.146.02 mit CUDA 12.2, um Kompatibilität zu gewährleisten.
Installationschritte
1. Installieren des NVIDIA-Treibers
Zuerst müssen Sie Ihr GPU-Modell identifizieren. Für diese Anleitung verwenden wir die NVIDIA-GPU. Besuchen Sie die NVIDIA-Treiber-Download-Seite, wählen Sie den entsprechenden Treiber für Ihre GPU aus und notieren Sie die Treiberversion.
Um vorgefertigte GPU-Pakete auf Ubuntu zu überprüfen, führen Sie aus:
sudo ubuntu-drivers list --gpgpu
Starten Sie Ihren Computer neu und überprüfen Sie die Installation:
nvidia-smi
2. Installieren des CUDA-Toolkits
Das CUDA-Toolkit bietet die Entwicklungsumgebung für die Erstellung von hochleistungsorientierten GPU- beschleunigten Anwendungen.
Für eine Nicht-LLM/Deep-Learning-Einrichtung können Sie Folgendes verwenden:
sudo apt install nvidia-cuda-toolkit <p>Um jedoch die Kompatibilität mit BitsAndBytes zu gewährleisten, folgen wir diesen Schritten:</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>
Überprüfen Sie die Installation:
~/local/cuda-12.2/bin/nvcc --version
Setzen Sie die Umgebungsvariablen:
<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. Installieren von cuDNN
Laden Sie das cuDNN-Paket von der NVIDIA-Entwickler-Website herunter. Installieren Sie es mit:
<p>sudo apt install ./cudnn-local-repo-ubuntu2204-8.9.7.29_1.0-1_amd64.deb</p>
Folgen Sie den Anweisungen, um den Schlüsselring hinzuzufügen:
<p>sudo cp /var/cudnn-local-repo-ubuntu2204-8.9.7.29/cudnn-local-08A7D361-keyring.gpg /usr/share/keyrings/</p>
Installieren Sie die cuDNN-Bibliotheken:
<p>sudo apt update sudo apt install libcudnn8 libcudnn8-dev libcudnn8-samples</p>
4. Einrichten einer Python-Virtual-Umgebung
Ubuntu 22.04 kommt mit Python 3.10. Installieren Sie venv:
<p>sudo apt-get install python3-pip sudo apt install python3.10-venv</p>
Erstellen und aktivieren Sie die virtuelle Umgebung:
<p>cd mkdir test-gpu cd test-gpu python3 -m venv venv source venv/bin/activate</p>
5. Installieren von BitsAndBytes aus Quellcode
Navigieren Sie zum BitsAndBytes-Verzeichnis und bauen Sie es aus Quellcode:
<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. Installieren von PyTorch
Installieren Sie PyTorch mit dem folgenden Befehl:
<p>pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121</p>
7. Installieren von Hugging Face und Transformers
Installieren Sie die Transformers- und Accelerate-Bibliotheken:
<p>pip install transformers pip install accelerate</p>
Die Macht der parallelen Verarbeitung
Im Kern sind GPUs hochparallele Prozessoren, die darauf ausgelegt sind, Tausende von gleichzeitigen Threads effizient zu verarbeiten. Diese Architektur macht sie ideal für die rechenintensiven Aufgaben, die beim Training von Deep-Learning-Modellen, einschließlich LLMs, auftreten. Die CUDA-Plattform, die von NVIDIA entwickelt wurde, bietet eine Softwareumgebung, die es Entwicklern ermöglicht, das volle Potenzial dieser GPUs zu nutzen, indem sie Code schreiben können, der die parallelen Verarbeitungsfähigkeiten der Hardware ausnutzt.
Beschleunigen von LLM-Training mit GPUs und CUDA.
Das Training von großen Sprachmodellen ist eine rechenintensive Aufgabe, die die Verarbeitung großer Mengen an Textdaten und die Durchführung zahlreicher Matrixoperationen erfordert. GPUs mit ihren Tausenden von Kernen und hoher Speicherbandbreite sind ideal für diese Aufgaben geeignet. Durch die Nutzung von CUDA können Entwickler ihren Code optimieren, um die parallelen Verarbeitungsfähigkeiten von GPUs zu nutzen, wodurch die Trainingszeit für LLMs erheblich reduziert wird.
Beispielsweise wurde das Training von GPT-3, eines der größten Sprachmodelle, durch die Verwendung von Tausenden von NVIDIA-GPUs mit CUDA-optimiertem Code ermöglicht. Dies ermöglichte es dem Modell, auf eine unvergleichliche Menge an Daten trainiert zu werden, was zu seiner beeindruckenden Leistung in natürlichen Sprachaufgaben führte.
<p>import torch
import torch.nn as nn
import torch.optim as optim
from transformers import GPT2LMHeadModel, GPT2Tokenizer</p>
<p># Laden Sie das vorgefertigte GPT-2-Modell und den Tokenizer
model = GPT2LMHeadModel.from_pretrained(&#039;gpt2&#039;)
tokenizer = GPT2Tokenizer.from_pretrained(&#039;gpt2&#039;)</p>
<p># Verschieben Sie das Modell auf die GPU, wenn verfügbar
device = torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
model = model.to(device)</p>
<p># Definieren Sie die Trainingsdaten und Hyperparameter
train_data = [...] # Ihre Trainingsdaten
batch_size = 32
num_epochs = 10
learning_rate = 5e-5</p>
<p># Definieren Sie die Verlustfunktion und den Optimierer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)</p>
<p># Trainingsloop
for epoch in range(num_epochs):
for i in range(0, len(train_data), batch_size):
# Vorbereiten der Eingabe- und Zielsequenzen
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># Vorwärts-Pass
outputs = model(**inputs, labels=targets)
loss = outputs.loss</p>
<p># Rückwärts-Pass und Optimierung
optimizer.zero_grad()
loss.backward()
optimizer.step()</p>
<p>print(f&#039;Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}&#039;)</p>
In diesem Codebeispiel demonstrieren wir das Training eines GPT-2-Sprachmodells mit PyTorch und CUDA-aktivierten GPUs. Das Modell wird auf die GPU (wenn verfügbar) geladen, und die Trainingsloop nutzt die Parallelität von GPUs, um effiziente Vorwärts- und Rückwärts-Pässe durchzuführen, wodurch die Trainingszeit beschleunigt wird.
CUDA-beschleunigte Bibliotheken für Deep Learning
Neben der CUDA-Plattform selbst haben NVIDIA und die Open-Source-Gemeinschaft eine Reihe von CUDA-beschleunigten Bibliotheken entwickelt, die eine effiziente Implementierung von Deep-Learning-Modellen, einschließlich LLMs, ermöglichen. Diese Bibliotheken bieten optimierte Implementierungen von Standardroutinen wie Matrixmultiplikationen, Konvolutionen und Aktivierungsfunktionen, wodurch Entwickler sich auf die Modellarchitektur und den Trainingsprozess konzentrieren können, anstatt sich mit niedrigem Optimieren zu befassen.
Eine solche Bibliothek ist cuDNN (CUDA Deep Neural Network Library), die hoch optimierte Implementierungen von Standardroutinen bietet, die in Deep Neural Networks verwendet werden. Durch die Nutzung von cuDNN können Entwickler die Trainings- und Inferenzzeit ihrer Modelle erheblich beschleunigen und Leistungssteigerungen von bis zu mehreren Größenordnungen im Vergleich zu CPU-basierten Implementierungen erzielen.
<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>
In diesem Codebeispiel definieren wir einen Residualblock für ein Convolutional Neural Network (CNN) mit PyTorch. Der autocast-Kontext-Manager von PyTorch wird verwendet, um eine gemischte Präzision zu ermöglichen, die auf CUDA-aktivierten GPUs eine signifikante Leistungssteigerung bieten kann, während die Genauigkeit erhalten bleibt. Die F.relu-Funktion wird durch cuDNN optimiert, um eine effiziente Ausführung auf GPUs zu gewährleisten.
Mehrere GPUs und verteiltes Training für Skalierbarkeit
Da LLMs und Deep-Learning-Modelle immer größer und komplexer werden, steigen auch die Rechenanforderungen für die Ausbildung dieser Modelle. Um diese Herausforderung zu meistern, haben Forscher und Entwickler auf mehrere GPUs und verteilte Trainingsmethoden zurückgegriffen, die es ihnen ermöglichen, die kombinierte Rechenleistung mehrerer GPUs über mehrere Maschinen hinweg zu nutzen.
CUDA und zugehörige Bibliotheken wie NCCL (NVIDIA Collective Communications Library) bieten effiziente Kommunikationsprimitiven, die einen nahtlosen Datenaustausch und eine Synchronisation über mehrere GPUs hinweg ermöglichen, wodurch ein verteiltes Training in einem bisher unerreichten Umfang möglich wird.
&lt;/pre&gt; import torch.distributed as dist <p>from torch.nn.parallel import DistributedDataParallel as DDP</p> <p># Initialisieren Sie das verteilte Training 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># Erstellen Sie das Modell und verschieben Sie es auf die GPU model = MyModel().cuda()</p> <p># Umschließen Sie das Modell mit DDP model = DDP(model, device_ids=[local_rank])</p> <p># Trainingsloop (verteiltes Training) 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>
In diesem Beispiel demonstrieren wir ein verteiltes Training mit PyTorchs DistributedDataParallel (DDP)-Modul. Das Modell wird mit DDP umschlossen, was automatisch die Datenparallelisierung, Gradientensynchronisation und Kommunikation über mehrere GPUs hinweg mit NCCL übernimmt. Dieser Ansatz ermöglicht eine effiziente Skalierung des Trainingsprozesses über mehrere Maschinen hinweg, wodurch Forscher und Entwickler größere und komplexere Modelle in einer angemessenen Zeit trainieren können.
Bereitstellen von Deep-Learning-Modellen mit CUDA
Während GPUs und CUDA hauptsächlich für die Ausbildung von Deep-Learning-Modellen verwendet werden, sind sie auch für eine effiziente Bereitstellung und Inferenz unerlässlich. Da Deep-Learning-Modelle immer komplexer und ressourcenintensiver werden, ist eine GPU-Beschleunigung für die Erzielung von Echtzeitleistung in Produktionsumgebungen unerlässlich.
NVIDIA’s TensorRT ist ein Hochleistungs-Deep-Learning-Inferenz-Optimierer und Laufzeitumgebung, der eine niedrige Latenz und hohe Durchsatzrate bei der Inferenz auf CUDA-aktivierten GPUs bietet. TensorRT kann Modelle optimieren und beschleunigen, die in Frameworks wie TensorFlow, PyTorch und MXNet trainiert wurden, wodurch eine effiziente Bereitstellung auf verschiedenen Plattformen, von eingebetteten Systemen bis hin zu Rechenzentren, ermöglicht wird.
import tensorrt as trt <p># Laden Sie das vorgefertigte Modell model = load_model(...)</p> <p># Erstellen Sie den TensorRT-Motor logger = trt.Logger(trt.Logger.INFO) builder = trt.Builder(logger) network = builder.create_network() parser = trt.OnnxParser(network, logger)</p> <p># Parsen und Optimieren des Modells success = parser.parse_from_file(model_path) engine = builder.build_cuda_engine(network)</p> <p># Führen Sie die Inferenz auf der GPU aus context = engine.create_execution_context() inputs, outputs, bindings, stream = allocate_buffers(engine)</p> <p># Legen Sie die Eingabedaten fest und führen Sie die Inferenz aus set_input_data(inputs, input_data) context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)</p> # Verarbeiten Sie die Ausgabe # ...
In diesem Beispiel demonstrieren wir die Verwendung von TensorRT für die Bereitstellung eines vorgefertigten Deep-Learning-Modells auf einer CUDA-aktivierten GPU. Das Modell wird zuerst von TensorRT geparst und optimiert, was einen hoch optimierten Inferenz-Motor erzeugt, der auf die spezifische Hardware zugeschnitten ist. Dieser Motor kann dann verwendet werden, um eine effiziente Inferenz auf der GPU durchzuführen, wodurch die parallele Verarbeitung von CUDA genutzt wird.
Fazit
Die Kombination aus GPUs und CUDA war maßgeblich an den Fortschritten in großen Sprachmodellen, Computer-Vision, Spracherkennung und anderen Bereichen des Deep Learning beteiligt. Durch die Nutzung der parallelen Verarbeitungsfähigkeiten von GPUs und der optimierten Bibliotheken von CUDA können Forscher und Entwickler immer komplexere Modelle mit hoher Effizienz trainieren und bereitstellen.
Da das Feld der KI weiterhin evolviert, wird die Bedeutung von GPUs und CUDA nur noch zunehmen. Mit noch leistungsfähigerer Hardware und Software-Optimierungen können wir weitere Durchbrüche in der Entwicklung und Bereitstellung von KI-Systemen erwarten, die die Grenzen dessen, was möglich ist, weiter ausdehnen.
