Infrastruktur och GPU:er
På denna sida
Dimensionera din GPU-infrastruktur
Att välja rätt GPU, minneskapacitet och orkestreringsverktyg är ett avgörande steg vid egen hosting. En underdimensionerad modell degraderas inte snyggt: den vägrar starta eller kraschar vid första verkliga belastning. Vi går igenom hårdvarukraven för Mistral-modeller, kvantiseringstekniker som minskar minnesbehovet samt två orkestreringsverktyg: SkyPilot och Cerebrium.
Vad varje modell kräver
Följande tabell listar FP16-krav utan kvantisering – baslinjen för alla dimensioneringsberäkningar.
| Modell | Parametrar | Minsta VRAM | Rekommenderad GPU |
|---|---|---|---|
| Mistral 7B | 7B | 16 GB | 1x A10G / L4 |
| Mistral Nemo | 12B | 24 GB | 1x A10G / RTX 4090 |
| Mixtral 8x7B | 46.7B | 100 GB | 2x A100-80GB |
| Mixtral 8x22B | 141B | 300 GB | 4x A100-80GB |
| Mistral Large 2 | 123B | 250 GB | 4x A100-80GB |
| Codestral | 22B | 48 GB | 1x A100-80GB |
Du behöver inte denna tabell för att uppskatta en modell som inte finns listad. I FP16 bör du budgetera cirka 2 GB VRAM per miljard parametrar: för en 7B-modell blir det 7 x 2 = 14 GB minimum, plus overhead för KV-cache och inferensmotor – därför visar tabellen 16 GB. Denna marginal förklarar varför ett 16 GB-kort knappt klarar Mistral 7B, och varför det inte räcker när du betjänar långa kontexter för flera samtidiga användare.
Kvantisering: Byt precision mot minne
Kvantisering reducerar precisionen hos modellvikterna för att sänka minnesförbrukningen, ofta med minimal påverkan på kvaliteten. I FP8 (åtta bitar per vikt) halveras minnesanvändningen jämfört med FP16, och aktivering fungerar med ett enkelt argument:
# Serve a model in FP8 with vLLM
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--dtype float8_e4m3fn
| Modell | FP16 | FP8 | Minskning |
|---|---|---|---|
| Mistral 7B | 14 GB | 7 GB | -50% |
| Mistral Nemo | 24 GB | 12 GB | -50% |
| Mixtral 8x7B | 100 GB | 50 GB | -50% |
Den praktiska konsekvensen är tydlig: en Mixtral 8x7B som krävde två A100-80GB-kort i FP16 får plats på ett enda kort i FP8, vilket halverar din timkostnad. INT4 (fyra bitar) går ännu längre, men påverkan på kvaliteten blir märkbar; det aktiveras i TGI via ett dedikerat argument:
# AWQ quantization with TGI
docker run --gpus all --shm-size 1g \
-p 8080:80 \
-e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
ghcr.io/huggingface/text-generation-inference:2.0.3 \
--model-id mistralai/Mistral-7B-Instruct-v0.3 \
--quantize awq
| Precision | Minne | Kvalitet | Hastighet |
|---|---|---|---|
| FP16 | Baslinje | Baslinje | Baslinje |
| FP8 | -50% | -1 till -2% | +10-20% |
| INT4 | -75% | -3 till -5% | +30-50% |
I praktiken rekommenderar vi FP8 för produktion – kvalitetsförlusten är försumbar. INT4 fungerar för prototyper eller minnesbegränsade miljöer, vanligtvis en demo på en arbetsstation med ett GPU-kort för konsumentmarknaden.
SkyPilot: Molnöverskridande orkestrering
SkyPilot är ett öppen källkod-ramverk för att distribuera LLM:er på vilket moln som helst – AWS, GCP, Azure, Lambda Labs med flera. Det väljer automatiskt den billigaste GPU:n och hanterar provisionering, så du slipper manuellt jämföra spot-priser hos tre leverantörer inför varje start. Mistral tillhandahåller färdiga YAML-filer vars struktur beskriver maskinen, installationen och serve-kommandot:
# mistral-7b.yaml
resources:
accelerators: A10G:1
cloud: aws
setup: |
pip install vllm
run: |
vllm serve mistralai/Mistral-7B-Instruct-v0.3 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral
Hela livscykeln för ett kluster reduceras sedan till fyra kommandon:
# Install SkyPilot
pip install "skypilot[aws,gcp,azure]"
# Launch the cluster
sky launch -c mistral-7b mistral-7b.yaml --region us-east-1
# Check status
sky status
# Stop (to save money)
sky stop mistral-7b
# Delete
sky down mistral-7b
De två sista kommandona är de som folk glömmer. Ett A10G-kluster som lämnas igång över en helg kostar lika mycket som en månads API-användning för måttliga arbetsbelastningar, vilket är varför det är viktigt att känna till ungefärliga siffror:
| Modell | SkyPilot-konfig | Uppskattad molnkostnad |
|---|---|---|
| Mistral 7B | A10G:1 | ~1 USD/tim |
| Mixtral 8x7B | A100-80GB:2 | ~6 USD/tim |
| Mixtral 8x22B | A100-80GB:4 | ~12 USD/tim |
En sista punkt förtjänar din uppmärksamhet: SkyPilot skapar VM:er med öppna portar som standard. I produktion bör du begränsa nätverksåtkomst med säkerhetsgrupper eller brandväggsregler, placera en lastbalanserare med autentisering framför tjänsten och aldrig lämna port 8000 exponerad mot internet. En oautentiserad vLLM-server som är offentligt tillgänglig är ett GPU-kort du betalar för åt någon annan.
Cerebrium: Serverlösa GPU:er
Cerebrium tar motsatt approach jämfört med SkyPilot: istället för att hantera maskiner beskriver du en tjänst och betalar endast för den beräkningskraft du faktiskt använder, med automatisk skalning. Att komma igång tar tre kommandon:
pip install cerebrium
cerebrium login
cerebrium init mistral-vllm
Hela distributionen beskrivs sedan i en cerebrium.toml-fil:
[cerebrium.deployment]
name = "mistral-nemo"
python_version = "3.11"
[cerebrium.hardware]
gpu = "AMPERE_A10"
cpu = 4
memory = 16
[cerebrium.scaling]
min_replicas = 0
max_replicas = 5
cooldown = 60
[cerebrium.dependencies.pip]
vllm = "latest"
Inställningen min_replicas = 0 är den främsta fördelen med denna approach: när ingen anropar tjänsten kostar den ingenting. Kompromissen är att den första begäran efter en viloperiod måste vänta på att en instans startar. Kommandot cerebrium deploy är allt du behöver för att publicera; plattformen hanterar GPU-provisionering, automatisk skalning från noll till N repliker, lastbalansering och övervakning.
Hantera produktionsbelastning
För att öka genomströmningen ska du inte leta efter ett större GPU-kort – multiplicera istället instanserna bakom en lastbalanserare, där varje instans betjänar samma modell på sitt eget kort:
┌─── vLLM instance 1 (GPU A)
Load Balancer ──────┼─── vLLM instance 2 (GPU B)
└─── vLLM instance 3 (GPU C)
Fem nyckeltal räcker för att hantera hela setupen: tokens per sekund mäter genereringsgenomströmning; TTFB (Time To First Byte) ger latensen före första token, vilket är det användaren upplever; GPU-utilisering bör överstiga 80% under belastning, annars betalar du för inaktiv hårdvara; övervaka GPU-minne för att förutse OOM-fel; och ködjupet, antalet väntande begäranden, signalerar mättnad innan användarna klagar. På en enda maskin ger en enkel kontinuerlig uppdatering redan det väsentliga:
# Monitor GPU utilization
watch -n 1 nvidia-smi
Viktiga punkter
- Budgetera ~2 GB VRAM per miljard parametrar i FP16
- FP8-kvantisering halverar minnesanvändningen med försumbar påverkan på kvaliteten
- SkyPilot förenklar molnöverskridande distribution med färdiga YAML-konfigurationer
- Cerebrium erbjuder serverlösa GPU:er med automatisk skalning (betalning per beräkning)
- I produktion: lägg till en lastbalanserare och övervaka GPU-metriker kontinuerligt