Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Infrastruktur og GPU'er

Lektion 13 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. Dimensionering af din GPU-infrastruktur
  2. Hvad hver model kræver
  3. Kvantisering: Byt præcision for hukommelse
  4. SkyPilot: Multi-cloud orkestrering
  5. Cerebrium: Serverless GPU
  6. Håndtering af produktionsbelastning
  7. Vigtige pointer

Dimensionering af din GPU-infrastruktur

Valget af den rette GPU, hukommelseskapacitet og orkestreringsværktøj er et afgørende skridt ved self-hosting. En underdimensioneret model degraderer ikke elegant: den nægter at starte, eller den crascher under den første rigtige belastning. Vi gennemgår hardwarekravene til Mistral-modeller, kvantiseringsteknikker, der reducerer hukommelsesbehovet, samt to orkestreringsværktøjer: SkyPilot og Cerebrium.

Hvad hver model kræver

Følgende tabel viser FP16-krav uden kvantisering – dette er grundlaget for enhver dimensioneringsberegning.

ModelParametreMinimum VRAMAnbefalet 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 ikke denne tabel for at estimere en model, der ikke er opført. I FP16 skal du budgettere med cirka 2 GB VRAM pr. milliard parametre: for en 7B-model giver 7 x 2 = 14 GB minimum, plus overhead til KV-cachen og inferensmotoren – derfor viser tabellen 16 GB. Denne margin forklarer, hvorfor et 16 GB-kort knap kan håndtere Mistral 7B, og hvorfor det ikke er tilstrækkeligt, når du betjener lange kontekster for flere samtidige brugere.

Kvantisering: Byt præcision for hukommelse

Kvantisering reducerer præcisionen af modelvægte for at sænke hukommelsesforbruget, ofte med minimal påvirkning af kvaliteten. I FP8 (otte bits per vægt) halveres hukommelsesforbruget sammenlignet med FP16, og aktivering passer med et simpelt 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
ModelFP16FP8Reduktion
Mistral 7B14 GB7 GB-50%
Mistral Nemo24 GB12 GB-50%
Mixtral 8x7B100 GB50 GB-50%

Den praktiske konsekvens er klar: En Mixtral 8x7B, der krævede to A100-80GB-kort i FP16, passer på et enkelt kort i FP8, hvilket halverer din timepris. INT4 (fire bits) går endnu videre, men påvirkningen af kvaliteten bliver mærkbar; det aktiveres i TGI via et dedikeret 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
PræcisionHukommelseKvalitetHastighed
FP16BasislinjeBasislinjeBasislinje
FP8-50%-1 til -2%+10-20%
INT4-75%-3 til -5%+30-50%

I praksis anbefaler vi FP8 til produktion – kvalitetstabet er ubetydeligt. INT4 fungerer til prototyping eller hukommelsesbegrænsede miljøer, typisk en demo på en workstation med en GPU i forbrugerklasse.

SkyPilot: Multi-cloud orkestrering

SkyPilot er et open source-framework til udrulning af LLM’er på enhver cloud – AWS, GCP, Azure, Lambda Labs og andre. Det vælger automatisk den billigste GPU og håndterer klargøring, så du ikke manuelt skal sammenligne spotpriser på tværs af tre udbydere før hver opstart. Mistral leverer klar-til-brug YAML-filer, hvis struktur beskriver maskinen, opsætningen og serve-kommandoen:

# 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

Hele livscyklussen for et cluster reduceres derefter til fire kommandoer:

# 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 sidste to kommandoer er dem, folk glemmer. Et A10G-cluster, der løber over en weekend, koster lige så meget som en måneds API-brug for moderate arbejdsbyrder, hvilket er grunden til, at det betyder noget at kende de omtrentlige tal:

ModelSkyPilot-konfigurationEstimeret cloud-omkostning
Mistral 7BA10G:1~$1/time
Mixtral 8x7BA100-80GB:2~$6/time
Mixtral 8x22BA100-80GB:4~$12/time

Ét sidste punkt fortjener din opmærksomhed: SkyPilot opretter VM’er med åbne porte som standard. I produktion skal du begrænse netværksadgang med sikkerhedsgrupper eller firewall-regler, placere en load balancer med autentificering foran tjenesten og aldrig lade port 8000 være eksponeret for internettet. En uautentificeret vLLM-server, der er offentligt tilgængelig, er en GPU, du betaler for på andres vegne.

Cerebrium: Serverless GPU

Cerebrium tager den modsatte tilgang til SkyPilot: I stedet for at administrere maskiner beskriver du en tjeneste og betaler kun for den beregning, du faktisk bruger, med automatisk skalering. Kom i gang med tre kommandoer:

pip install cerebrium
cerebrium login
cerebrium init mistral-vllm

Hele udrulningen beskrives derefter 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"

Indstillingen min_replicas = 0 er den største fordel ved denne tilgang: Når ingen kalder tjenesten, koster den ingenting. Kompromiset er, at den første anmodning efter en inaktiv periode skal vente på, at en instans starter. Kommandoen cerebrium deploy er alt, du behøver for at publicere; platformen håndterer GPU-klargøring, automatisk skalering fra nul til N replikaer, load balancing og overvågning.

Håndtering af produktionsbelastning

For at øge gennemstrømningen skal du ikke lede efter en større GPU – gang antallet af instanser op bag en load balancer, hvor hver betjener den samme model på sit eget kort:

                    ┌─── vLLM instance 1 (GPU A)
Load Balancer ──────┼─── vLLM instance 2 (GPU B)
                    └─── vLLM instance 3 (GPU C)

Fem nøgletal er nok til at administrere hele opsætningen: Tokens per sekund måler genereringsgennemstrømning; TTFB (Time To First Byte) angiver latensen før det første token, hvilket er det, brugeren oplever; GPU-udnyttelsen bør overstige 80 % under belastning, ellers betaler du for inaktiv hardware; overvåg GPU-hukommelse for at forudse OOM-fejl; og kødybde, antallet af ventende anmodninger, signalerer mætning, før brugerne klager. På en enkelt maskine giver en simpel kontinuerlig opdatering allerede dig det væsentlige:

# Monitor GPU utilization
watch -n 1 nvidia-smi

Vigtige pointer

  • Budgetter med ~2 GB VRAM pr. milliard parametre i FP16
  • FP8-kvantisering halverer hukommelsesforbruget med ubetydelig påvirkning af kvaliteten
  • SkyPilot forenkler multi-cloud-uadrulning med klar-til-brug YAML-konfigurationer
  • Cerebrium tilbyder serverless GPU med automatisk skalering (betaling pr. beregning)
  • Tilføj en load balancer i produktion og overvåg GPU-nøgletal kontinuerligt