1. Technische Einführung
NVIDIA Triton Inference Server ist eine für CPUs und GPUs optimierte Cloud- und Inferenzlösung.
Zu den unterstützten Modelltypen gehören TensorRT, TensorFlow, PyTorch (meta-llama/Llama-2-7b), Python (chatglm), ONNX Runtime und OpenVino.
NVIDIA Triton Server ist ein leistungsstarker Inferenzserver mit den folgenden Funktionen:
1. Hohe Leistung: Triton Server bietet hohe Leistung und geringe Latenz für Arbeitslasten, die GPUs für Inferenzen verwenden. Es ist in der Lage, mehrere Modelle gleichzeitig mit hohem Durchsatz und geringer Latenz zu bedienen.
2. Speicherverwaltung: Große Modelle erfordern oft große Mengen an Videospeicher für die Schlussfolgerung. Triton Server verfügt über einen flexiblen Speicherverwaltungsmechanismus, der Videospeicher effektiv verwalten und zuweisen kann, um sicherzustellen, dass die Inferenz großer Modelle effizient durchgeführt werden kann.
3. Skalierbarkeit: Triton Server unterstützt hochgradig gleichzeitige Inferenzanforderungen durch parallele Verarbeitung und asynchrone Inferenz. Es kann sich entsprechend den Anforderungen der Ladung automatisch ausdehnen und zusammenziehen.
4. Unterstützung mehrerer Modelle: Triton Server kann mehrere Modelle gleichzeitig bereitstellen und verwalten. Dadurch können Sie Serverressourcen gemeinsam nutzen und verschiedene Modelle auf konsistente Weise bereitstellen und verwalten.
5. Flexibilität: Triton Server unterstützt mehrere Modellformate und Inferenz-Frameworks, einschließlich TensorFlow, PyTorch, ONNX usw. Sie können Ihre bevorzugten Modelle und Tools für die Modellentwicklung und das Training verwenden und sie einfach auf Triton Server bereitstellen.
6. Erweiterte Funktionen: Triton Server bietet viele erweiterte Funktionen, wie z. B. Modellversionsverwaltung, Anforderungsgleichzeitigkeitskontrolle, dynamische Stapelgrößenoptimierung, Anforderungszeitverfolgung usw. Diese Funktionen verbessern die Modellbereitstellungs- und Verwaltungsfunktionen.
2. Üben
Bereitstellen eines Modells in 3 (N) einfachen Schritten, offizielle Dokumentation
https://github.com/triton-inference-server/server
Stellen Sie ein Modell in n einfachen Schritten bereit
Schritt 1: Triton-Server-Code abrufen
git clone -b r23.08 https://github.com/triton-inference-server/server.git #
Schritt 2: Verwenden Sie das Image tritonserver:22.12-py3, um den Triton-Server-Container zu erstellen
docker run --gpus all --shm-size=1g --ulimit memlock=-1 -p 8000:8000 -p 8001:8001 -p 8002:8002 --ulimit stack=67108864 -ti nvcr.io/nvidia/tritonserver :22.12-py3
Bitte achten Sie auf die Portzuordnung -p, da es später schwierig sein wird, sie zu ändern.
Die tritonserver-Version und die python_backend-Backend-Version müssen übereinstimmen.
Verwenden Sie beispielsweise 22.12
Schritt 3: Laden Sie das Python-Inferenz-Backend python_backend herunter
Dokumentation : https://github.com/triton-inference-server/python_backend
Laden Sie den Python-Backend-Code herunter:
Git-Klon https://github.com/triton-inference-server/python_backend -b r22.12
Vorgang im Container: Wenn Sie den Container auf halbem Weg verlassen, verwenden Sie den Befehl docker exec -it Containername/bin/bash, um den Container zu betreten
Wenn der Download nicht heruntergeladen werden kann, können Sie ihn in den Container kopieren: docker cp python_backend busy_galileo:/opt
Schritt 4: Modellverzeichnis erstellen
cd python_backend
1) Modellverzeichnis erstellen: mkdir -p models/chatglm2-6b/1/
2) Der Host kopiert chatglm2 in das Modellverzeichnis im Container: docker cp chatglm2-6b Containername:/Pfad in Container/models/chatglm2-6b
3) Erstellen Sie eine Modellkonfigurationsdatei: vi models/chatglm2-6b/ config.pbtxt, die verschiedene Parameter, Eingabe- und Ausgabeparameter, Modellpfade usw. enthält.
name: "chatglm2-6b"
backend: "python"
max_batch_size: 1
input [
{
name: "QUERY"
data_type: TYPE_STRING
dims: [ -1 ]
},
{
name: "max_new_tokens"
data_type: TYPE_UINT32
dims: [ -1 ]
},
{
name: "top_k"
data_type: TYPE_UINT32
dims: [ 1 ]
optional: true
},
{
name: "top_p"
data_type: TYPE_FP32
dims: [ 1 ]
optional: true
},
{
name: "temperature"
data_type: TYPE_FP32
dims: [ 1 ]
optional: true
},
{
name: "length_penalty"
data_type: TYPE_FP32
dims: [ 1 ]
optional: true
},
{
name: "repetition_penalty"
data_type: TYPE_FP32
dims: [ 1 ]
optional: true
},
{
name: "bos_token_id"
data_type: TYPE_UINT32
dims: [ 1 ]
optional: true
},
{
name: "eos_token_id"
data_type: TYPE_UINT32
dims: [ 1 ]
optional: true
},
{
name: "do_sample"
data_type: TYPE_BOOL
dims: [ 1 ]
optional: true
},
{
name: "num_beams"
data_type: TYPE_UINT32
dims: [ 1 ]
optional: true
}
]
output [
{
name: "OUTPUT"
data_type: TYPE_STRING
dims: [ -1, -1 ]
}
]
instance_group [
{
kind: KIND_GPU
}
]
parameters {
key: "model_path"
value: {
string_value: "/opt/tritonserver/python_backend/models/chatglm2-6b"
}
}Erstellen Sie model.py, um die vom Python-Code vi models/chatglm2-6b/1/model.py implementierte Modellinferenzlogik anzupassen
Die Eingabe, Ausgabe und Parameter des Modells können hier mithilfe von Python-Skripten verarbeitet werden
import triton_python_backend_utils as pb_utils
class TritonPythonModel:
@staticmethod
def auto_complete_config(auto_complete_model_config):
"""`auto_complete_config` is called only once when loading the model
def initialize(self, args):
"""`initialize` is called only once when the model is being loaded.
Implementing `initialize` function is optional. This function allows
the model to initialize any state associated with this model.
Parameters
----------
args : dict
Both keys and values are strings. The dictionary keys and values are:
* model_config: A JSON string containing the model configuration
* model_instance_kind: A string containing model instance kind
* model_instance_device_id: A string containing model instance device
ID
* model_repository: Model repository path
* model_version: Model version
* model_name: Model name
"""
print('Initialized...')
def execute(self, requests):
"""`execute` must be implemented in every Python model. `execute`
function receives a list of pb_utils.InferenceRequest as the only
argument. This function is called when an inference is requested
for this model.
Parameters
----------
requests : list
A list of pb_utils.InferenceRequest
Returns
-------
list
A list of pb_utils.InferenceResponse. The length of this list must
be the same as `requests`
"""
responses = []
def finalize(self):
"""`finalize` is called only once when the model is being unloaded.
Implementing `finalize` function is optional. This function allows
the model to perform any necessary clean ups before exit.
"""
print('Cleaning up...')Schritt 5: Installieren Sie die Inferenzumgebung und verschiedene Software
Die Cuda-Version und der Grafikkartentreiber müssen übereinstimmen, und das Cuda-Toolkit und die Treiberversion müssen übereinstimmen.
Informationen zur entsprechenden Beziehung finden Sie auf der offiziellen Website: https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions
1) Einführung und Installation des Brenners:
Das Torch-Framework für wissenschaftliches Rechnen ist darauf ausgelegt, effiziente Matrixoperationen und automatische Differenzierungsfunktionen für maschinelles Lernen und andere wissenschaftliche Rechenaufgaben bereitzustellen.
Bietet eine umfangreiche Bibliothek vorab trainierter Modelle und Algorithmen, die es Benutzern ermöglicht, schnell verschiedene maschinelle Lernaufgaben zu erstellen und zu trainieren.
pip install ./torch-1.12.1+cu116-cp38-cp38-linux_x86_64.whl
2) Grafikkartentreiber:
sh ./NVIDIA-Linux-x86_64-460.106.00.run
3) Cudnn-Einführung und Installation:
Die CUDA Deep Neural Network-Bibliothek ist eine von NVIDIA bereitgestellte GPU-beschleunigte Deep Neural Network (DNN)-Bibliothek. Es wurde entwickelt, um das Training und die Inferenz neuronaler Netzwerkmodelle bei Deep-Learning-Aufgaben zu optimieren und zu beschleunigen.
cuDNN bietet eine Reihe von Kernalgorithmen und -funktionen für gängige Deep-Learning-Aufgaben wie Convolutional Neural Networks (CNN) und Recurrent Neural Networks (RNN). Diese Algorithmen und Funktionen sind stark für die GPU-Architektur optimiert, um die beste Leistung und Effizienz zu bieten.
wget https://developer.download.nvidia.cn/compute/cuda/repos/ubuntu1804/x86_64/libcudnn8_8.1.1.33-1+cuda11.2_amd64.deb
dpkg -i libcudnn8_8.1.1.33-1+cuda11.2_amd64.deb
4) cuda:
Die Compute Unified Device Architecture-Bibliothek ist eine von NVIDIA entwickelte Parallel-Computing-Plattform und API für die GPU-Programmierung.
Über die CUDA-Bibliothek kann die Modellinferenz synchron oder asynchron auf der GPU durchgeführt werden und unterstützt gleichzeitig Stapelverarbeitung und paralleles Rechnen mit mehreren Karten, um die Geschwindigkeit und Effizienz der Modellinferenz zu verbessern.
wget https://developer.download.nvidia.com/compute/cuda/11.2.0/local_installers/cuda_11.2.0_460.27.04_linux.run
sudo sh cuda_11.2.0_460.27.04_linux.run
5) Verschiedene Software
nohup apt-get update
nohup apt-get install -y autoconf autogen clangd gdb git-lfs libb64-dev libz-dev locales-all mosh openssh-server python3-dev rapidjson-dev sudo tmux unzip zstd zip zsh
Schritt 6: Triton-Server starten
CUDA_VISIBLE_DEVICES=0 setsid tritonserver --model-repository=/opt/tritonserver/python_backend/models --backend-config=python,shm-region-prefix-name=prefix1_ --http-port 8000 --grpc-port 8001 -- metrics-port 8002 --log-verbose 1 --log-file /opt/tritonserver/logs/triton_server_gpu0.log
Erfolgreicher Start: HTTP-Port 8000, GRPC-Port 8001, Messport 8002
3. Testen
Rufen Sie einfach Python-Code auf, um die http-Schnittstelle aufzurufen
import requests
# 定义模型的输入数据
data = {
"inputs": [
{
"name": "QUERY",
"shape": [1,1],
"datatype": "BYTES",
"data": ["川普是不是四川人"]
},
{
"name": "max_new_tokens",
"shape" : [1,1],
"datatype": "UINT32",
"data": [15000]
},
]
}
headers = {
'Content-Type': 'application/json',
}
# 发送 POST 请求
response = requests.post('http://localhost:8000/v2/models/chatglm2-6b/infer', headers=headers, json=data)
result = response.json()
print(result)
Antwort:
{
"model_name": "chatglm2-6b",
"model_version": "1",
"outputs": [
{
"data": [
"\n\n 川普不是四川人，他出生于美国宾夕法尼亚州，是一个美国政治家、企业家和电视名人。"
],
"datatype": "BYTES",
"name": "OUTPUT",
"shape": []
}
]
}
4. Technische Leitung
CI (Continuous Integration, kontinuierliche Integration)/CD (Continuous Delivery, kontinuierliche Bereitstellung/Continuous Deployment, kontinuierliche Bereitstellung)
Zukünftig erreichbar:
1. Verwenden Sie k8s, um die Containerbereitstellung automatisch durchzuführen – ähnlich wie bei Xingyun
2. Speichern Sie ein vollständiges Docker-Image einer großen Modelllaufumgebung und laden Sie einfach die Modelldatei in das entsprechende Verzeichnis herunter, um den Dienst zu starten.
3. Stellen Sie mehrere Open-Source-Modelle auf einem einzigen Computer bereit, stellen Sie Antwortschnittstellen für verschiedene Modelle bereit und vergleichen Sie die Antworteffekte
4. Erstellen Sie dockerFile, um automatisch Basiscontainer zu erstellen
k8s-Dokumentation
https://kubernetes.io/zh-cn/docs/tasks/tools/
Installieren Sie Docker und kubeadm, kubenet auf allen Knoten
Stellen Sie Kubernetes Master bereit
Stellen Sie das Container-Netzwerk-Plug-in kubectl bereit
Stellen Sie den Kubernetes-Knoten bereit und fügen Sie den Knoten zum Kubernetes-Cluster hinzu
200 Yuan Geldstrafe und mehr als 1 Million Yuan beschlagnahmt You Yuxi: Die Bedeutung hochwertiger chinesischer Dokumente Musks Hardcore-Migrationsserver Solon für JDK 21, virtuelle Threads sind unglaublich! ! ! TCP-Überlastungskontrolle rettet das Internet- Flutter für OpenHarmony ist da. Die LTS-Periode des Linux-Kernels wird von 6 auf 2 Jahre wiederhergestellt. Go 1.22 behebt den Variablenfehler der For-Schleife. Svelte hat ein „neues Rad“ gebaut – Runen. Google feiert sein 25-jähriges JubiläumAutor: JD Technology Yang Jian
Quelle: JD Cloud Developer Community Bitte geben Sie beim Nachdruck die Quelle an