Wdrażanie z vLLM
Na tej stronie
vLLM: Zalecany silnik wnioskowania
vLLM to najpopularniejszy silnik wnioskowania dla LLM napisany w Pythonie. Mistral AI rekomenduje go do samodzielnego hostowania, ponieważ jest łatwy w użyciu, wydajny i oferuje API kompatybilne z OpenAI. Przeprowadzimy Cię przez instalację i konfigurację, a następnie omówimy dwa tryby jego działania: wsadowy (offline) oraz serwerowy. Tryby te nie wykluczają się wzajemnie – wiele zespołów wykorzystuje pierwszy do przygotowania danych, a drugi do obsługi aplikacji.
Czego będziesz potrzebować
Pobieranie modeli odbywa się przez Hugging Face, co wymaga tokenu z uprawnieniem READ:
export HF_TOKEN="hf_your_token_here"
Przed pierwszym pobraniem musisz zaakceptować warunki użytkowania na stronie modelu w Hugging Face (na przykład: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Jest to jednorazowa czynność manualna dla każdego konta. Pominięcie tego kroku powoduje błędy pobierania, których diagnoza może zająć godzinę, ponieważ wyglądają one jak problemy z uwierzytelnianiem.
W przypadku środowiska Pythona użyj dedykowanego virtualenv, aby uniknąć konfliktów wersji z innymi projektami:
# Utwórz środowisko wirtualne
python -m venv vllm-env
source vllm-env/bin/activate
# Zainstaluj vLLM (wersja >= 0.6.1.post1)
pip install vllm
Kolejnym elementem jest sprzęt, który decyduje o tym, co faktycznie możesz uruchomić. Mistral 7B i Nemo zmieszczą się na pojedynczym GPU z 24 GB pamięci, typowo A10G, RTX 4090 lub L4. Mixtral 8x7B wymaga dwóch GPU po 80 GB, w praktyce kart A100-80GB. Mistral Large 2 w wersji open-weight, posiadający 123 miliardy parametrów, potrzebuje co najmniej czterech GPU A100-80GB. We wszystkich przypadkach przed instalacją vLLM zainstaluj sterowniki NVIDIA i CUDA 12.x.
Tryb offline: Przetwarzanie wsadowe
Tryb offline obsługuje partie żądań bez serwera HTTP. Ładujesz model do pamięci, przetwarzasz swoje żądania i odbierasz wyniki. Zwróć uwagę na trzy argumenty: tokenizer_mode, load_format oraz config_format. Wrócimy do nich – nie są opcjonalne.
from vllm import LLM
from vllm.sampling_params import SamplingParams
# Załaduj model z flagami Mistral
llm = LLM(
model="mistralai/Mistral-Nemo-Instruct-2407",
tokenizer_mode="mistral",
load_format="mistral",
config_format="mistral"
)
# Parametry generowania
sampling = SamplingParams(
max_tokens=8192,
temperature=0.3
)
# Przetwarzanie partii żądań
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)
Ten tryb sprawdza się przy wsadowym przetwarzaniu dokumentów – podsumowywaniu, klasyfikacji – ewaluacji modeli względem benchmarków, generowaniu danych syntetycznych oraz w skryptach testowych lub prototypowych. Zawsze, gdy nikt nie czeka na natychmiastową odpowiedź, zyskujesz dzięki pominięciu warstwy HTTP.
Tryb serwerowy: Udostępnianie API
Tryb serwerowy uruchamia punkt końcowy HTTP kompatybilny z API OpenAI:
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--host 0.0.0.0 \
--port 8000
Serwer udostępnia API na porcie 8000. Ma to istotne konsekwencje praktyczne: aplikacja napisana pod API OpenAI przełącza się na Twój samodzielnie hostowany model po zmianie dwóch linii: base_url i api_key. Twoje biblioteki, frameworki agentów i narzędzia testowe继续 działają bez zmian.
from openai import OpenAI
# Połącz z lokalnym serwerem vLLM
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="not-needed" # Brak autoryzacji domyślnie
)
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)
Komentarz # Brak autoryzacji domyślnie zasługuje na uwagę: serwer vLLM uruchomiony w ten sposób nie uwierzytelnia nikogo. Na maszynie deweloperskiej jest to wygodne. Na maszynie dostępnej w sieci to otwarte drzwi. Szybki test z linii poleceń potwierdza, że wszystko odpowiada, zanim przejdziesz dalej:
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
}'
Wdrażanie w Dockerze
Dla powtarzalnego wdrożenia oficjalny obraz pozwala uniknąć ponownej instalacji na każdej maszynie:
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
Trzy opcje w tym poleceniu wymagają wyjaśnienia. --runtime nvidia --gpus all daje kontenerowi dostęp do GPU NVIDIA; bez tego model próbowałby działać na CPU. Montowanie -v ~/.cache/huggingface:... współdzieli pamięć podręczną modeli z hostem, oszczędzając Ci ponownego pobierania dziesiątek gigabajtów przy każdym restarcie kontenera. --ipc=host przydziela pamięć współdzieloną niezbędną do komunikacji międzyprocesowej między GPU; pominięcie tego powoduje trudne do zdiagnozowania awarie, gdy tylko przejdziesz na wiele kart.
Trzy niezbędne flagi Mistral
| Flaga | Cel |
|---|---|
--tokenizer_mode mistral | Używa natywnego tokenizera Mistral (nie HF) |
--config_format mistral | Ładuje konfigurację w formacie Mistral |
--load_format mistral | Ładuje wagi w natywnym formacie Mistral |
Bez tych flag model może działać, ale z obniżoną wydajnością lub niepoprawnymi wynikami. To najczęstsza pułapka przy samodzielnym hostowaniu Mistral: nic się nie crashuje, serwer startuje, odpowiedzi przychodzą – są po prostu gorsze, niż powinny być, a Ty ryzykujesz błędny wniosek, że model jest rozczarowujący.
Dostrajanie wydajności
Gdy model nie mieści się na jednej karcie, równoległość tensorowa (tensor parallelism) rozdziela jego warstwy na wiele GPU. Przekazywana wartość odpowiada liczbie używanych kart:
vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--tensor-parallel-size 2
Drugim mechanizmem jest proporcja pamięci GPU rezerwowanej przez vLLM:
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--gpu-memory-utilization 0.9
Wartość domyślna (0.9) działa w większości przypadków. Zmniejsz ją, jeśli inne procesy korzystają z GPU – usługa wizyjna, zapomniany notebook – w przeciwnym razie pierwszy proces zajmie całą pamięć, a drugi nie zdoła się uruchomić.
Na koniec, dwa wywołania wystarczą, aby zweryfikować, czy serwer działa, co czyni je dobrymi sondami dla Twojego orkiestratora:
# Wylistuj dostępne modele
curl http://localhost:8000/v1/models
# Sprawdź stan serwera
curl http://localhost:8000/health
Kluczowe wnioski
- vLLM udostępnia API kompatybilne z OpenAI – możesz użyć SDK
openaido komunikacji - Trzy flagi
--tokenizer_mode mistral,--config_format mistral,--load_format mistralsą obowiązkowe - Tryb offline nadaje się do przetwarzania wsadowego; tryb serwerowy do aplikacji czasu rzeczywistego
- Docker upraszcza wdrażanie i zapewnia powtarzalność
- Równoległość tensorowa pozwala rozdzielać duże modele na wiele GPU