Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Infrastructuur en GPU's

Les 13 van 14 Bijgewerkt op 29 juli 2026 Gevorderd
Op deze pagina
  1. De grootte van uw GPU-infrastructuur bepalen
  2. Wat elk model vereist
  3. Kwantisatie: precisie inruilen voor geheugen
  4. SkyPilot: Multi-cloud-orchestratie
  5. Cerebrium: Serverless GPU
  6. Productiebelasting verwerken
  7. Belangrijkste punten

De grootte van uw GPU-infrastructuur bepalen

Het kiezen van de juiste GPU, geheugencapaciteit en orchestratietool is een cruciale stap bij self-hosting. Een onderbemeten model degradeert niet geleidelijk: het weigert te starten of crasht onder de eerste echte belasting. We behandelen de hardwarevereisten voor Mistral-modellen, kwantisatietechnieken die het geheugengebruik verminderen, en twee orchestratietools: SkyPilot en Cerebrium.

Wat elk model vereist

De volgende tabel geeft de FP16-vereisten weer zonder kwantisatie—de basislijn voor elke berekening van de benodigde capaciteit.

ModelParametersMinimum VRAMAanbevolen 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

U hebt deze tabel niet nodig om een model te schatten dat niet in de lijst staat. Reken in FP16 op ongeveer 2 GB VRAM per miljard parameters: voor een 7B-model is dat 7 x 2 = 14 GB minimum, plus overhead voor de KV-cache en de inferentie-engine—vandaar dat de tabel 16 GB aangeeft. Deze marge verklaart waarom een kaart van 16 GB Mistral 7B nauwelijks aankan en waarom dit ontoereikend is zodra u lange contexten bedient voor meerdere gelijktijdige gebruikers.

Kwantisatie: precisie inruilen voor geheugen

Kwantisatie vermindert de precisie van modelgewichten om het geheugengebruik te verlagen, vaak met minimale impact op de kwaliteit. In FP8 (acht bits per gewicht) wordt het geheugengebruik gehalveerd ten opzichte van FP16, en past de activatie met een eenvoudig 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
ModelFP16FP8Reductie
Mistral 7B14 GB7 GB-50%
Mistral Nemo24 GB12 GB-50%
Mixtral 8x7B100 GB50 GB-50%

Het praktische gevolg is duidelijk: een Mixtral 8x7B die in FP16 twee A100-80GB-kaarten vereiste, past in FP8 op één kaart, wat uw uurkosten halveert. INT4 (vier bits) gaat nog verder, maar de impact op de kwaliteit wordt merkbaar; dit wordt in TGI ingeschakeld via een specifiek 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
PrecisieGeheugenKwaliteitSnelheid
FP16BasislijnBasislijnBasislijn
FP8-50%-1 tot -2%+10-20%
INT4-75%-3 tot -5%+30-50%

In de praktijk raden we FP8 aan voor productie—het kwaliteitsverlies is verwaarloosbaar. INT4 werkt voor prototyping of omgevingen met geheugenbeperkingen, doorgaans een demo op een workstation met een consumenten-GPU.

SkyPilot: Multi-cloud-orchestratie

SkyPilot is een open-sourceframework voor het implementeren van LLM’s op elke cloud—AWS, GCP, Azure, Lambda Labs en andere. Het selecteert automatisch de goedkoopste GPU en regelt de provisioning, zodat u niet handmatig spotprijzen bij drie providers hoeft te vergelijken voor elke start. Mistral levert kant-en-klare YAML-bestanden waarvan de structuur de machine, de setup en het serve-commando beschrijft:

# 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

De volledige levenscyclus van een cluster komt dan neer op vier commando’s:

# 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

Die laatste twee commando’s zijn die welke mensen vaak vergeten. Een A10G-cluster dat een weekend blijft draaien, kost evenveel als een maand API-gebruik voor gematigde workloads. Daarom is het belangrijk om de richtbedragen te kennen:

ModelSkyPilot-configuratieGeschatte cloudkosten
Mistral 7BA10G:1~$1/u
Mixtral 8x7BA100-80GB:2~$6/u
Mixtral 8x22BA100-80GB:4~$12/u

Eén laatste punt verdient uw aandacht: SkyPilot maakt VM’s standaard aan met open poorten. Beperk in productie de netwerkwtoegang met Security Groups of Firewall Rules, plaats een load balancer met authenticatie voor de service en laat poort 8000 nooit blootgesteld aan het internet. Een niet-geauthenticeerde vLLM-server die publiek bereikbaar is, is een GPU waar u voor betaalt namens iemand anders.

Cerebrium: Serverless GPU

Cerebrium hanteert de tegenovergestelde aanpak van SkyPilot: in plaats van machines te beheren, beschrijft u een service en betaalt u alleen voor de compute die u daadwerkelijk gebruikt, met auto-scaling. Aan de slag gaan kost drie commando’s:

pip install cerebrium
cerebrium login
cerebrium init mistral-vllm

De volledige implementatie wordt vervolgens beschreven in een cerebrium.toml-bestand:

[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"

De instelling min_replicas = 0 is het belangrijkste voordeel van deze aanpak: wanneer niemand de service aanroept, kost het niets. Het nadeel is dat het eerste verzoek na een inactieve periode moet wachten tot een instantie start. Het commando cerebrium deploy is alles wat u nodig hebt om te publiceren; het platform regelt GPU-provisioning, auto-scaling van nul tot N replica’s, load balancing en monitoring.

Productiebelasting verwerken

Om de doorvoer te verhogen, zoekt u niet naar een grotere GPU—vermenigvuldig instanties achter een load balancer, waarbij elke instantie hetzelfde model op zijn eigen kaart bedient:

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

Vijf metrieken volstaan om de hele setup te beheren: tokens per seconde meet de generatiedoorvoer; TTFB (Time To First Byte) geeft de latentie vóór het eerste token, wat de gebruiker waarneemt; GPU-utilisatie moet onder belasting hoger zijn dan 80%, anders betaalt u voor inactieve hardware; monitor GPU-geheugen om OOM-fouten te anticiperen; en wachtrijdiepte, het aantal openstaande verzoeken, signaleert verzadiging voordat gebruikers klagen. Op een enkele machine geeft een simpele continue refresh u al het essentiële:

# Monitor GPU utilization
watch -n 1 nvidia-smi

Belangrijkste punten

  • Reken in FP16 op ~2 GB VRAM per miljard parameters
  • FP8-kwantisatie halveert het geheugengebruik met verwaarloosbaar kwaliteitsverlies
  • SkyPilot vereenvoudigt multi-cloud-implementatie met kant-en-klare YAML-configuraties
  • Cerebrium biedt serverless GPU met auto-scaling (betalen per compute)
  • Voeg in productie een load balancer toe en monitor GPU-metrieken continu