Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Uvajanje z vLLM

Lekcija 11 od 14 Posodobljeno 29. julij 2026 Napredni
Na tej strani
  1. vLLM: Priporočeni pogon za sklepanje
  2. Kaj potrebuješ
  3. Offline način: Obdelava serij
  4. Strežniški način: Izpostavljanje API-ja
  5. Uvajanje z Dockerjem
  6. Tri bistvene zastavice Mistral
  7. Uglaševanje zmogljivosti
  8. Ključne ugotovitve

vLLM: Priporočeni pogon za sklepanje

vLLM je najbolj priljubljen pogon za sklepanje (inference engine) za velike jezikovne modele (LLM) v Pythonu. Mistral AI ga priporoča za samostojno gostovanje, ker je enostaven za uporabo, deluje zmogljivo in ponuja vmesnik API, združljiv z OpenAI. Skupaj bomo opravili namestitev in konfiguracijo, nato pa obravnavali dva načina uporabe: serijski (offline) način in strežniški način. Ta načina se ne izključujeta – številne ekipe prvega uporabljajo za pripravo podatkov, drugega pa za napajanje aplikacij.

Kaj potrebuješ

Prenos modelov poteka prek Hugging Facea, kar zahteva žeton z dovoljenjem READ:

export HF_TOKEN="hf_your_token_here"

Pred prvim prenosom sprejmi pogoje uporabe na strani modela v Hugging Faceu (na primer: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). To je enkraten, ročni korak za vsak račun. Če na to pozabiš, pride do napak pri prenosu, katerih diagnosticiranje lahko traja celo uro, saj so videti kot težave z avtentikacijo.

Za okolje Python uporabi namenski virtualni okolje (virtualenv), da se izogneš konfliktem različic z drugimi projekti:

# Ustvari virtualno okolje
python -m venv vllm-env
source vllm-env/bin/activate

# Namesti vLLM (različica >= 0.6.1.post1)
pip install vllm

Nato je tu strojna oprema, ki določa, kaj dejansko lahko gostiš. Mistral 7B in Nemo se prilegata na en GPU z 24 GB pomnilnika, običajno A10G, RTX 4090 ali L4. Mixtral 8x7B zahteva dva GPU-ja z 80 GB, v praksi kartice A100-80GB. Mistral Large 2 v svoji odprti različici s 123 milijardami parametrov potrebuje vsaj štiri GPU-je A100-80GB. V vseh primerih namesti gonilnike NVIDIA in CUDA 12.x pred namestitvijo vLLM.

Offline način: Obdelava serij

Offline način obravnava serije zahtev brez HTTP strežnika. Model naložiš v pomnilnik, obdelaš svoje zahteve in pridobiš rezultate. Upoštevaj tri argumente tokenizer_mode, load_format in config_format: vrnili se bomo k njim – niso izbirni.

from vllm import LLM
from vllm.sampling_params import SamplingParams

# Naloži model z zastavicami Mistral
llm = LLM(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    tokenizer_mode="mistral",
    load_format="mistral",
    config_format="mistral"
)

# Parametri generiranja
sampling = SamplingParams(
    max_tokens=8192,
    temperature=0.3
)

# Obdelava serije zahtev
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)

Ta način odlično deluje za serijsko obdelavo dokumentov – povzemanje, razvrščanje – evalvacijo modelov glede na referenčne vrednosti, generiranje sintetičnih podatkov ter skripte za testiranje ali prototipiranje. Kadar nihče ne čaka na takojšen odgovor, imaš korist iz izpuščanja plasti HTTP.

Strežniški način: Izpostavljanje API-ja

Strežniški način zažene končno točko HTTP, združljivo z API-jem OpenAI:

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

Strežnik izpostavi API na vratih 8000. Praktična posledica je pomembna: aplikacija, napisana za API OpenAI, preklopi na tvoj samostojno gostovani model s spremembo dveh vrstic, base_url in api_key. Tvoje knjižnice, ogrodja za agente in orodja za testiranje nadaljujejo z delovanjem.

from openai import OpenAI

# Poveži se z lokalnim strežnikom vLLM
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # Privzeto ni avtentikacije
)

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)

Komentar # Privzeto ni avtentikacije si zasluži pozornost: strežnik vLLM, zagnan na ta način, ne avtenticira nikogar. Na razvojnem računalniku je to priročno. Na računalniku, dostopnem prek omrežja, pa so to odprta vrata. Hiter test v ukazni vrstici potrdi, da vse odgovarja, preden nadaljuješ:

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
    }'

Uvajanje z Dockerjem

Za ponovljivo uvajanje uradna slika prepreči ponovno nameščanje na vsakem stroju:

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

Tri možnosti v tem ukazu si zaslužijo razlago. --runtime nvidia --gpus all omogoča kontejnerju dostop do GPU-jev NVIDIA; brez tega bi model poskusil teči na procesorju. Priklop -v ~/.cache/huggingface:... deli predpomnilnik modelov z gostiteljem, kar ti prihrani ponovno prenašanje desetin gigabajtov ob vsakem ponovnem zagonu kontejnerja. --ipc=host podeli deljeni pomnilnik, potreben za medprocesno komunikacijo med GPU-ji; če to izpustiš, pride do težko diagnosticirljivih zrušitev, takoj ko preideš na več kartic.

Tri bistvene zastavice Mistral

ZastavicaNamen
--tokenizer_mode mistralUporabi izvorni tokenizer Mistral (ne HF-jevega)
--config_format mistralNaloži konfiguracijo v formatu Mistral
--load_format mistralNaloži uteži v izvornem formatu Mistral

Brez teh zastavic se model morda zažene, vendar z poslabšano zmogljivostjo ali napačnimi rezultati. To je najpogostejša past pri samostojnem gostovanju Mistrala: nič se ne zruši, strežnik se zažene, odgovori prispejo – so le slabši, kot bi morali biti, in tvegaš, da napačno sklepaš, da je model razočaranje.

Uglaševanje zmogljivosti

Ko se model ne prilega na eno kartico, tenzorska vzporednost (tensor parallelism) porazdeli njegove plasti na več GPU-jev. Posredovana vrednost ustreza številu uporabljenih kartic:

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

Drugi vzvod se nanaša na delež pomnilnika GPU, ki ga vLLM rezervira:

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

Privzeta vrednost (0,9) deluje v večini primerov. Zmanjšaj jo, če GPU uporabljajo drugi procesi – storitev za vid, pozabljen zvezek – sicer prvi proces zavzame ves pomnilnik in drugi se ne more zagnati.

Končno, dva klica zadostujeta za preverjanje, ali je strežnik živ, kar ju dela za dobri sondi za tvoj orkestrator:

# Izpiši razpoložljive modele
curl http://localhost:8000/v1/models

# Preveri zdravje strežnika
curl http://localhost:8000/health

Ključne ugotovitve

  • vLLM izpostavlja API, združljiv z OpenAI – za komunikacijo lahko uporabiš SDK openai
  • Tri zastavice --tokenizer_mode mistral, --config_format mistral, --load_format mistral so obvezne
  • Offline način je primeren za serijsko obdelavo; strežniški način za aplikacije v realnem času
  • Docker poenostavi uvajanje in zagotavlja ponovljivost
  • Tenzorska vzporednost ti omogoča porazdelitev velikih modelov na več GPU-jev