Distribuera med vLLM
På denna sida
vLLM: Den rekommenderade inferensmotorn
vLLM är den populäraste Python-baserade inferensmotorn för stora språkmodeller (LLM). Mistral AI rekommenderar den för självhosting eftersom den är enkel att använda, presterar bra och erbjuder ett API som är kompatibelt med OpenAI. Vi går igenom installation och konfiguration, och tar sedan upp de två användningslägena: batchläge (offline) och serverläge. Dessa lägen utesluter inte varandra – många team använder det första för att förbereda data och det andra för att betjäna applikationer.
Vad du behöver
Nedladdning av modeller sker via Hugging Face, vilket kräver en token med behörigheten READ:
export HF_TOKEN="hf_your_token_here"
Innan du laddar ner för första gången måste du acceptera användarvillkoren på modellens sida hos Hugging Face (till exempel: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Detta är ett engångsstepp som måste göras manuellt per konto. Att glömma detta leder till nedladdningsfel som kan ta en timme att felsöka, eftersom de ser ut som autentiseringsproblem.
För Python-miljön bör du använda en dedikerad virtuell miljö (virtualenv) för att undvika versionskonflikter med dina andra projekt:
# Skapa en virtuell miljö
python -m venv vllm-env
source vllm-env/bin/activate
# Installera vLLM (version >= 0.6.1.post1)
pip install vllm
Sedan har vi hårdvaran, som avgör vad du faktiskt kan distribuera. Mistral 7B och Nemo får plats på ett enda GPU-minne på 24 GB, vanligtvis ett A10G, RTX 4090 eller L4. Mixtral 8x7B kräver två GPU-minnen på 80 GB, i praktiken A100-80GB-kort. Mistral Large 2 i sin version med öppna vikter, med sina 123 miljarder parametrar, behöver minst fyra A100-80GB-GPU:er. I alla fall måste du installera NVIDIA-drivrutiner och CUDA 12.x innan vLLM.
Offline-läge: Bearbetning av batchar
Offline-läget hanterar batchar av förfrågningar utan en HTTP-server. Du laddar modellen i minnet, bearbetar dina förfrågningar och hämtar resultaten. Notera de tre argumenten tokenizer_mode, load_format och config_format: vi kommer tillbaka till dessa – de är inte valfria.
from vllm import LLM
from vllm.sampling_params import SamplingParams
# Ladda modellen med Mistral-flaggor
llm = LLM(
model="mistralai/Mistral-Nemo-Instruct-2407",
tokenizer_mode="mistral",
load_format="mistral",
config_format="mistral"
)
# Genereringsparametrar
sampling = SamplingParams(
max_tokens=8192,
temperature=0.3
)
# Bearbeta en batch av förfrågningar
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)
Detta läge utmärker sig för batchbearbetning av dokument – sammanfattning, klassificering – modellutvärdering mot referensvärden, generering av syntetiska data samt test- eller prototypskript. När ingen väntar på ett omedelbart svar drar du nytta av att hoppa över HTTP-lagret.
Serverläge: Exponera ett API
Serverläget startar en HTTP-slutpunkt som är kompatibel med OpenAI API:
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--host 0.0.0.0 \
--port 8000
Servern exponerar API:t på port 8000. Den praktiska konsekvensen är betydande: en applikation skriven för OpenAI API byter till din självhostade modell genom att ändra två rader, base_url och api_key. Dina bibliotek, agent-ramverk och testverktyg fortsätter att fungera.
from openai import OpenAI
# Anslut till den lokala vLLM-servern
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="not-needed" # Ingen autentisering 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 autentisering som standard förtjänar uppmärksamhet: en vLLM-server som startas på detta sätt autentiserar ingen. På en utvecklingsmaskin är detta bekvämt. På en maskin som är tillgänglig via nätverket är det en öppen dörr. Ett snabbt kommandoradstest bekräftar att allt svarar innan du går vidare:
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-distribution
För en reproducerbar distribution undviker den officiella image:n ominstallation på varje maskin:
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 alternativ i detta kommando förtjänar en förklaring. --runtime nvidia --gpus all ger containern tillgång till NVIDIA GPU:er; utan detta skulle modellen försöka köras på CPU:n. Monteringen -v ~/.cache/huggingface:... delar modellcachen med värddatorn, vilket sparar dig från att ladda ner tiotals gigabyte varje gång containern startas om. --ipc=host ger det delade minne som krävs för interprocesskommunikation mellan GPU:er; att utelämna detta orsakar svårfelsökta krascher så snart du går över till flera kort.
De tre avgörande Mistral-flaggorna
| Flagga | Syfte |
|---|---|
--tokenizer_mode mistral | Använder den nativa Mistral-tokenizern (inte HF:s) |
--config_format mistral | Laddar konfiguration i Mistral-format |
--load_format mistral | Laddar vikter i nativt Mistral-format |
Utan dessa flaggor kan modellen köras, men med försämrad prestanda eller felaktiga resultat. Detta är den vanligaste fallgropen vid självhosting av Mistral: inget kraschar, servern startar, svar kommer – de är bara sämre än de borde vara, och du riskerar att felaktigt dra slutsatsen att modellen är besvikande.
Finjustering av prestanda
När en modell inte får plats på ett enda kort fördelar tensorparallellism dess lager över flera GPU:er. Värdet som anges motsvarar antalet använda kort:
vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--tensor-parallel-size 2
Den andra hävstången gäller den andel av GPU-minnet som vLLM reserverar:
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--gpu-memory-utilization 0.9
Standardvärdet (0,9) fungerar i de flesta fall. Minska det om andra processer använder GPU:t – en visionstjänst, en bortglömd notebook – annars tar den första processen allt minne och den andra misslyckas med att starta.
Slutligen räcker två anrop för att verifiera att en server är vid liv, vilket gör dem till bra prober för din orchestrator:
# Lista tillgängliga modeller
curl http://localhost:8000/v1/models
# Kontrollera serverns hälsa
curl http://localhost:8000/health
Viktiga punkter
- vLLM exponerar ett API som är kompatibelt med OpenAI – du kan använda
openai-SDK:t för att kommunicera - De tre flaggorna
--tokenizer_mode mistral,--config_format mistral,--load_format mistralär obligatoriska - Offline-läge passar batchbearbetning; serverläge passar realtidsapplikationer
- Docker förenklar distribution och säkerställer reproducerbarhet
- Tensorparallellism låter dig distribuera stora modeller över flera GPU:er