Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Infrastruktur och GPU:er

Lektion 13 av 14 Uppdaterad 29 juli 2026 Avancerad
På denna sida
  1. Dimensionera din GPU-infrastruktur
  2. Vad varje modell kräver
  3. Kvantisering: Byt precision mot minne
  4. SkyPilot: Molnöverskridande orkestrering
  5. Cerebrium: Serverlösa GPU:er
  6. Hantera produktionsbelastning
  7. Viktiga punkter

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.

ModellParametrarMinsta VRAMRekommenderad GPU
Mistral 7B7B16 GB1x A10G / L4
Mistral Nemo12B24 GB1x A10G / RTX 4090
Mixtral 8x7B46.7B100 GB2x A100-80GB
Mixtral 8x22B141B300 GB4x A100-80GB
Mistral Large 2123B250 GB4x A100-80GB
Codestral22B48 GB1x 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
ModellFP16FP8Minskning
Mistral 7B14 GB7 GB-50%
Mistral Nemo24 GB12 GB-50%
Mixtral 8x7B100 GB50 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
PrecisionMinneKvalitetHastighet
FP16BaslinjeBaslinjeBaslinje
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:

ModellSkyPilot-konfigUppskattad molnkostnad
Mistral 7BA10G:1~1 USD/tim
Mixtral 8x7BA100-80GB:2~6 USD/tim
Mixtral 8x22BA100-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