Infrastructuur en GPU's
Op deze pagina
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.
| Model | Parameters | Minimum VRAM | Aanbevolen 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 |
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
| Model | FP16 | FP8 | Reductie |
|---|---|---|---|
| Mistral 7B | 14 GB | 7 GB | -50% |
| Mistral Nemo | 24 GB | 12 GB | -50% |
| Mixtral 8x7B | 100 GB | 50 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
| Precisie | Geheugen | Kwaliteit | Snelheid |
|---|---|---|---|
| FP16 | Basislijn | Basislijn | Basislijn |
| 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:
| Model | SkyPilot-configuratie | Geschatte cloudkosten |
|---|---|---|
| Mistral 7B | A10G:1 | ~$1/u |
| Mixtral 8x7B | A100-80GB:2 | ~$6/u |
| Mixtral 8x22B | A100-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