Distribution av stora språkmodeller på Kubernetes: En komplett guide

Stora språkmodeller (LLM) kan förstå och generera mänsklig text, vilket gör dem ovärderliga för en mängd olika tillämpningar, såsom chatbots, innehållsgenerering och språköversättning.

Men att distribuera LLM kan vara en utmanande uppgift på grund av deras enorma storlek och beräkningskrav. Kubernetes, ett öppen källkodscontainerorkestreringssystem, erbjuder en kraftfull lösning för att distribuera och hantera LLM på stor skala. I den här tekniska bloggen kommer vi att utforska processen för att distribuera LLM på Kubernetes, och täcka olika aspekter som containerisering, resursallokering och skalbarhet.

Att förstå stora språkmodeller

Innan vi dyker in i distributionsprocessen, låt oss kort förstå vad stora språkmodeller är och varför de får så mycket uppmärksamhet.

Stora språkmodeller (LLM) är en typ av neurala nätverksmodeller som tränats på stora mängder textdata. Dessa modeller lär sig att förstå och generera mänsklig språk genom att analysera mönster och relationer inom träningsdata. Några populära exempel på LLM är GPT (Generative Pre-trained Transformer), BERT (Bidirectional Encoder Representations from Transformers) och XLNet.

LLM har uppnått remarkabel prestanda i olika NLP-uppgifter, såsom textgenerering, språköversättning och frågesvar. Men deras enorma storlek och beräkningskrav utgör betydande utmaningar för distribution och inferens.

Varför Kubernetes för LLM-distribution?

Kubernetes är ett öppen källkodscontainerorkestreringssystem som automatiserar distribution, skalning och hantering av containeriserade applikationer. Det erbjuder flera fördelar för att distribuera LLM, inklusive:

• Skalbarhet: Kubernetes tillåter dig att skala din LLM-distribution horisontellt genom att lägga till eller ta bort beräkningsresurser efter behov, vilket säkerställer optimal resursutnyttjande och prestanda.
• Resurshantering: Kubernetes möjliggör effektiv resursallokering och isolering, vilket säkerställer att din LLM-distribution har tillgång till de nödvändiga beräknings-, minnes- och GPU-resurserna.
• Hög tillgänglighet: Kubernetes tillhandahåller inbyggda mekanismer för självläkning, automatiska utrullningar och återställningar, vilket säkerställer att din LLM-distribution förblir högt tillgänglig och motståndskraftig mot fel.
• Portabilitet: Containeriserade LLM-distributioner kan enkelt flyttas mellan olika miljöer, såsom lokala datacenter eller molnplattformar, utan behov av omfattande omkonfiguration.
• Ekosystem och community-stöd: Kubernetes har en stor och aktiv community, som tillhandahåller en mängd verktyg, bibliotek och resurser för att distribuera och hantera komplexa applikationer som LLM.

Förberedelse för LLM-distribution på Kubernetes:

Innan du distribuerar en LLM på Kubernetes, finns det flera förutsättningar att överväga:

1. Kubernetes-kluster: Du behöver ett Kubernetes-kluster som är inställt och körs, antingen lokalt eller på en molnplattform som Amazon Elastic Kubernetes Service (EKS) , Google Kubernetes Engine (GKE) eller Azure Kubernetes Service (AKS).
2. GPU-stöd: LLM är beräkningsintensiva och kräver ofta GPU-acceleration för effektiv inferens. Se till att ditt Kubernetes-kluster har tillgång till GPU-resurser, antingen genom fysiska GPU eller molnbaserade GPU-instanser.
3. Containerregister: Du behöver ett containerregister för att lagra dina LLM-Docker-avbildningar. Populära alternativ inkluderar Docker Hub, Amazon Elastic Container Registry (ECR), Google Container Registry (GCR) eller Azure Container Registry (ACR).
4. LLM-modellfiler: Hämta de förtränade LLM-modellfilerna (vikter, konfiguration och tokenisator) från respektive källa eller träna din egen modell.
5. Containerisering: Containerisera din LLM-applikation med Docker eller en liknande containerkörning. Detta innebär att skapa en Dockerfile som paketerar din LLM-kod, beroenden och modellfiler i en Docker-avbild.

Distribution av LLM på Kubernetes

När du har förutsättningarna på plats kan du fortsätta med att distribuera din LLM på Kubernetes. Distributionsprocessen omfattar vanligtvis följande steg:

Bygga Docker-avbild

Bygg Docker-avbild för din LLM-applikation med den tillhandahållna Dockerfilen och pusha den till ditt containerregister.

Skapa Kubernetes-resurser

Definiera Kubernetes-resurserna som krävs för din LLM-distribution, såsom Distributioner, Tjänster, ConfigMaps och Hemligheter. Dessa resurser definieras vanligtvis med YAML- eller JSON-manifest.

Konfigurera resurskrav

Specificera resurskraven för din LLM-distribution, inklusive CPU, minne och GPU-resurser. Det säkerställer att din distribution har tillgång till de nödvändiga beräkningsresurserna för effektiv inferens.

Distribuera till Kubernetes

Använd kubectl-kommandoraden eller ett Kubernetes-hanteringsverktyg (t.ex. Kubernetes Dashboard, Rancher eller Lens) för att tillämpa Kubernetes-manifest och distribuera din LLM-applikation.

Övervaka och skala

Övervaka prestanda och resursutnyttjande för din LLM-distribution med Kubernetes-övervakningsverktyg som Prometheus och Grafana. Justera resursallokering eller skala din distribution efter behov för att möta efterfrågan.

Exempel på distribution

Låt oss överväga ett exempel på att distribuera GPT-3-språkmodellen på Kubernetes med en förbyggd Docker-avbild från Hugging Face. Vi antar att du har ett Kubernetes-kluster som är inställt och konfigurerat med GPU-stöd.

Hämta Docker-avbild:

<p>docker pull huggingface/text-generation-inference:1.1.0</p>

Skapa en Kubernetes-distribution:

Skapa en fil med namnet gpt3-distribution.yaml med följande innehåll:

<p>apiVersion: apps/v1
kind: Deployment
metadata:
name: gpt3-distribution
spec:
replicas: 1
selector:
matchLabels:
app: gpt3
template:
metadata:
labels:
app: gpt3
spec:
containers:
- name: gpt3
image: huggingface/text-generation-inference:1.1.0
resources:
limits:
nvidia.com/gpu: 1
env:
- name: MODEL_ID
value: gpt2
- name: NUM_SHARD
value: "1"
- name: PORT
value: "8080"
- name: QUANTIZE
value: bitsandbytes-nf4</p>

Denna distribution specificerar att vi vill köra en replik av gpt3-containern med Docker-avbild huggingface/text-generation-inference:1.1.0. Distributionen anger också miljövariabler som krävs för containern för att ladda GPT-3-modellen och konfigurera inferensserven.

Skapa en Kubernetes-tjänst:

Skapa en fil med namnet gpt3-tjänst.yaml med följande innehåll:

<p>apiVersion: v1
kind: Service
metadata:
name: gpt3-tjänst
spec:
selector:
app: gpt3
ports:
- port: 80
targetPort: 8080
type: LoadBalancer</p>

Denna tjänst exponerar gpt3-distributionen på port 80 och skapar en LoadBalancer-typ av tjänst för att göra inferensserven tillgänglig från utanför Kubernetes-klustret.

Distribuera till Kubernetes:

Tillämpa Kubernetes-manifest med kubectl-kommandoraden:

<p>kubectl apply -f gpt3-distribution.yaml
kubectl apply -f gpt3-tjänst.yaml</p>

Övervaka distributionen:

Övervaka distributionsprogressen med följande kommandon:

<p>kubectl get pods
kubectl logs &lt;pod_name&gt;</p>

När poden körs och loggarna indikerar att modellen är laddad och redo, kan du hämta den externa IP-adressen för LoadBalancer-tjänsten:

kubectl get service gpt3-tjänst

Testa distributionen:

Du kan nu skicka begäranden till inferensserven med den externa IP-adressen och port som erhållits från föregående steg. Till exempel med curl:

<p>curl -X POST \
http://&lt;extern_ip&gt;:80/generate \
-H 'Content-Type: application/json' \
-d '{"inputs": "The quick brown fox", "parameters": {"max_new_tokens": 50}}'</p>

Detta kommando skickar en textgenereringsbegäran till GPT-3-inferensserven och ber den att fortsätta prompten “The quick brown fox” för upp till 50 ytterligare token.

Avancerade ämnen du bör känna till

Medan exemplet ovan demonstrerar en grundläggande distribution av en LLM på Kubernetes, finns det flera avancerade ämnen och överväganden att utforska: