Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Implementering med vLLM

Lektion 11 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. vLLM: Den anbefalede inferensmotor
  2. Hvad du skal bruge
  3. Offline-tilstand: Behandling af batches
  4. Servertilstand: Eksponering af en API
  5. Docker-implementering
  6. De tre essentielle Mistral-flag
  7. Finjustering af ydeevnen
  8. Vigtige pointer

vLLM: Den anbefalede inferensmotor

vLLM er den mest populære Python-inferensmotor til LLM’er. Mistral AI anbefaler den til selvhosting, fordi den er brugervenlig, yder godt og tilbyder en API, der er kompatibel med OpenAI. Vi gennemgår installation og konfiguration og dækker derefter de to brugstilstande: batch-tilstand (offline) og servertilstand. Disse tilstande udelukker ikke hinanden – mange teams bruger den første til at forberede data og den anden til at betjene applikationer.

Hvad du skal bruge

Download af modeller sker via Hugging Face, hvilket kræver en token med READ-tilladelse:

export HF_TOKEN="hf_your_token_here"

Før din første download skal du acceptere brugsbetingelserne på modellens Hugging Face-side (f.eks. huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Dette er et manuelt engangsstep pr. konto. Glemmer du det, fejler downloadsene, og det kan tage en time at diagnosticere, da de ligner autentificeringsproblemer.

Brug et dedikeret virtualenv til Python-miljøet for at undgå versionskonflikter med dine andre projekter:

# Opret et virtuelt miljø
python -m venv vllm-env
source vllm-env/bin/activate

# Installer vLLM (version >= 0.6.1.post1)
pip install vllm

Så er der hardwaren, som afgør, hvad du rent faktisk kan betjene. Mistral 7B og Nemo passer på et enkelt 24 GB GPU, typisk en A10G, RTX 4090 eller L4. Mixtral 8x7B kræver to 80 GB GPU’er, i praksis A100-80GB-kort. Mistral Large 2 i sin open-weight-version med sine 123 milliarder parametre kræver mindst fire A100-80GB GPU’er. I alle tilfælde skal du installere NVIDIA-drivere og CUDA 12.x før vLLM.

Offline-tilstand: Behandling af batches

Offline-tilstand håndterer batches af forespørgsler uden en HTTP-server. Du indlæser modellen i hukommelsen, behandler dine forespørgsler og henter resultaterne. Bemærk de tre argumenter tokenizer_mode, load_format og config_format: vi vender tilbage til dem – de er ikke valgfrie.

from vllm import LLM
from vllm.sampling_params import SamplingParams

# Indlæs modellen med Mistral-flag
llm = LLM(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    tokenizer_mode="mistral",
    load_format="mistral",
    config_format="mistral"
)

# Genereringsparametre
sampling = SamplingParams(
    max_tokens=8192,
    temperature=0.3
)

# Behandl en batch af forespørgsler
messages_batch = [
    [{"role": "user", "content": "What is PagedAttention?"}],
    [{"role": "user", "content": "Explain tensor parallelism."}],
    [{"role": "user", "content": "How does the KV cache work?"}],
]

results = llm.chat(messages=messages_batch[0], sampling_params=sampling)
for output in results:
    print(output.outputs[0].text)

Denne tilstand er ideel til batch-dokumentbehandling – sammenfatning, klassificering – model evaluering mod benchmarks, generering af syntetiske data samt test- eller prototyping-scripts. Når ingen venter på et øjeblikkeligt svar, drager du fordel af at springe HTTP-laget over.

Servertilstand: Eksponering af en API

Servertilstand starter et HTTP-endpoint, der er kompatibelt med OpenAI-API’en:

vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --host 0.0.0.0 \
    --port 8000

Serveren eksponerer API’en på port 8000. Den praktiske konsekvens er betydelig: En applikation skrevet til OpenAI-API’en skifter til din selvhostede model ved at ændre to linjer, base_url og api_key. Dine biblioteker, agent-frameworks og testværktøjer fortsætter med at fungere.

from openai import OpenAI

# Opret forbindelse til den lokale vLLM-server
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # Ingen auth som standard
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    messages=[
        {"role": "system", "content": "You are a DevOps expert."},
        {"role": "user", "content": "How do I monitor a vLLM server in production?"}
    ],
    temperature=0.3,
    max_tokens=1024
)
print(response.choices[0].message.content)

Kommentaren # Ingen auth som standard fortjener opmærksomhed: En vLLM-server startet på denne måde autentificerer ingen. På en udviklingsmaskine er det praktisk. På en netværkstilgængelig maskine er det en åben dør. En hurtig kommandolinjetest bekræfter, at alt svarer, før du går videre:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-Nemo-Instruct-2407",
        "messages": [{"role": "user", "content": "Hello, is this working?"}],
        "temperature": 0.3
    }'

Docker-implementering

For reproducerbar implementering undgår det officielle image geninstallation på hver maskine:

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --load_format mistral \
    --config_format mistral

Tre indstillinger i denne kommando fortjener en forklaring. --runtime nvidia --gpus all giver containeren adgang til NVIDIA GPU’er; uden dette ville modellen forsøge at køre på CPU’en. Mountingen -v ~/.cache/huggingface:... deler modelcachen med værten, så du slipper for at downloade titalls gigabyte hver gang containeren genstartes. --ipc=host giver den delte hukommelse, der er nødvendig til interproces-kommunikation mellem GPU’er; udelader du dette, opstår der svært diagnosticerbare nedbrud, så snart du går over til flere kort.

De tre essentielle Mistral-flag

FlagFormål
--tokenizer_mode mistralBruger den native Mistral-tokenizer (ikke HF’s)
--config_format mistralIndlæser konfiguration i Mistral-format
--load_format mistralIndlæser vægte i native Mistral-format

Uden disse flag kan modellen godt køre, men med forringet ydeevne eller forkerte resultater. Dette er den hyppigste fælde ved selvhosting af Mistral: Intet crasher, serveren starter, svarene kommer – de er bare dårligere, end de burde være, og du risikerer fejlagtigt at konkludere, at modellen er skuffende.

Finjustering af ydeevnen

Når en model ikke passer på et enkelt kort, fordeler tensor-parallelisme dens lag på tværs af flere GPU’er. Den værdi, der sendes, svarer til antallet af brugte kort:

vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --tensor-parallel-size 2

Den anden løftestang vedrører den andel af GPU-hukommelse, som vLLM reserverer:

vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --gpu-memory-utilization 0.9

Standardværdien (0,9) fungerer i de fleste tilfælde. Reducér den, hvis andre processer bruger GPU’en – en visionstjeneste, en glemt notebook – ellers tager den første proces al hukommelsen, og den anden fejler i at starte.

Endelig er to kald nok til at verificere, at en server er i live, hvilket gør dem til gode probes til din orchestrator:

# List tilgængelige modeller
curl http://localhost:8000/v1/models

# Tjek serverens helbredstilstand
curl http://localhost:8000/health

Vigtige pointer

  • vLLM eksponerer en OpenAI-kompatibel API – du kan bruge openai-SDK’et til at kommunikere
  • De tre flag --tokenizer_mode mistral, --config_format mistral, --load_format mistral er obligatoriske
  • Offline-tilstand egner sig til batchbehandling; servertilstand egner sig til realtidsapplikationer
  • Docker forenkler implementering og sikrer reproducerbarhed
  • Tensor-parallelisme lader dig fordele store modeller på tværs af flere GPU’er