Przejdź do głównej treści
Polski— Wybierz język
Menu

Infrastruktura i karty GPU

Lekcja 13 z 14 Zaktualizowano 29 lipca 2026 Zaawansowany
Na tej stronie
  1. Dobór infrastruktury GPU
  2. Wymagania dla każdego modelu
  3. Kwantyzacja: wymiana precyzji na pamięć
  4. SkyPilot: orkiestracja wielochmurowa
  5. Cerebrium: GPU serverless
  6. Obsługa obciążenia produkcyjnego
  7. Kluczowe wnioski

Dobór infrastruktury GPU

Wybór odpowiedniej karty GPU, pojemności pamięci i narzędzia do orkiestracji to kluczowy krok przy samodzielnym hostowaniu modeli. Niedoszacowany model nie degraduje się łagodnie: po prostu nie uruchomi się lub padnie pod pierwszym realnym obciążeniem. Omówimy wymagania sprzętowe dla modeli Mistral, techniki kwantyzacji redukujące zapotrzebowanie na pamięć oraz dwa narzędzia do orkiestracji: SkyPilot i Cerebrium.

Wymagania dla każdego modelu

Poniższa tabela przedstawia wymagania w formacie FP16 bez kwantyzacji – jest to baza do wszelkich obliczeń dotyczących doboru zasobów.

ModelParametryMinimalna VRAMZalecana karta GPU
Mistral 7B7B16 GB1x A10G / L4
Mistral Nemo12B24 GB1x A10G / RTX 4090
Mixtral 8x7B46.7B100 GB2x A100-80GB
Mixtral 8x22B141B300 GB4x A100-80GB
Mistral Large 2123B250 GB4x A100-80GB
Codestral22B48 GB1x A100-80GB

Nie potrzebujesz tej tabeli, aby oszacować zapotrzebowanie modelu, którego na niej nie ma. W formacie FP16 przyjmij z grubsza 2 GB VRAM na miliard parametrów: dla modelu 7B wynosi to 7 × 2 = 14 GB minimum, plus narzut na pamięć podręczną KV i silnik wnioskowania – stąd w tabeli widzisz 16 GB. Ten margines wyjaśnia, dlaczego karta 16 GB ledwo obsługuje Mistral 7B i dlaczego nie wystarczy, gdy zaczniesz obsługiwać długie konteksty dla wielu użytkowników jednocześnie.

Kwantyzacja: wymiana precyzji na pamięć

Kwantyzacja redukuje precyzję wag modelu, aby zmniejszyć zużycie pamięci, często przy minimalnym wpływie na jakość. W formacie FP8 (osiem bitów na wagę) zużycie pamięci spada o połowę w porównaniu do FP16, a aktywacje mieszczą się dzięki prostemu argumentowi:

# 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
ModelFP16FP8Redukcja
Mistral 7B14 GB7 GB-50%
Mistral Nemo24 GB12 GB-50%
Mixtral 8x7B100 GB50 GB-50%

Konsekwencja praktyczna jest jasna: Mixtral 8x7B, który w FP16 wymagał dwóch kart A100-80GB, w FP8 zmieści się na jednej, co przecina Twój rachunek godzinowy na pół. Format INT4 (cztery bity) idzie jeszcze dalej, ale wpływ na jakość staje się zauważalny; w TGI włącza się go poprzez dedykowany 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
PrecyzjaPamięćJakośćSzybkość
FP16BazaBazaBaza
FP8-50%-1 do -2%+10-20%
INT4-75%-3 do -5%+30-50%

W praktyce zalecamy FP8 do środowisk produkcyjnych – utrata jakości jest pomijalna. INT4 sprawdza się przy prototypowaniu lub w środowiskach z ograniczoną pamięcią, typowo jako demo na stacji roboczej z konsumencką kartą GPU.

SkyPilot: orkiestracja wielochmurowa

SkyPilot to framework open source do wdrażania LLM w dowolnej chmurze – AWS, GCP, Azure, Lambda Labs i innych. Automatycznie wybiera najtańszą kartę GPU i zajmuje się aprowizacją, więc nie musisz ręcznie porównywać cen spot u trzech dostawców przed każdym uruchomieniem. Mistral udostępnia gotowe pliki YAML, których struktura opisuje maszynę, konfigurację i polecenie uruchomienia serwera:

# 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

Pełny cykl życia klastra sprowadza się następnie do czterech poleceń:

# 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

Ostatnie dwa polecenia to te, o których ludzie zapominają. Klaster A10G pozostawiony uruchomiony przez weekend kosztuje tyle, co miesiąc korzystania z API przy umiarkowanym obciążeniu. Dlatego warto znać przybliżone stawki:

ModelKonfiguracja SkyPilotSzacowany koszt w chmurze
Mistral 7BA10G:1~1 USD/h
Mixtral 8x7BA100-80GB:2~6 USD/h
Mixtral 8x22BA100-80GB:4~12 USD/h

Jeszcze jedna kwestia wymaga Twojej uwagi: SkyPilot domyślnie tworzy maszyny wirtualne z otwartymi portami. W środowisku produkcyjnym ogranicz dostęp sieciowy za pomocą grup zabezpieczeń (Security Groups) lub reguł zapory, postaw balanser obciążenia z uwierzytelnianiem przed usługą i nigdy nie wystawiaj portu 8000 bezpośrednio do internetu. Nieuwierzytelniony serwer vLLM dostępny publicznie to karta GPU, za którą płacisz w imieniu kogoś innego.

Cerebrium: GPU serverless

Cerebrium stosuje podejście przeciwne do SkyPilot: zamiast zarządzać maszynami, opisujesz usługę i płacisz tylko za faktycznie wykorzystane zasoby obliczeniowe, z automatycznym skalowaniem. Start zajmuje trzy polecenia:

pip install cerebrium
cerebrium login
cerebrium init mistral-vllm

Całe wdrożenie opisujesz następnie w pliku cerebrium.toml:

[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"

Ustawienie min_replicas = 0 to kluczowa zaleta tego podejścia: gdy nikt nie wywołuje usługi, nic Cię to nie kosztuje. Kompromisem jest to, że pierwsze żądanie po okresie bezczynności musi poczekać na uruchomienie instancji. Polecenie cerebrium deploy to wszystko, czego potrzebujesz do publikacji; platforma zajmuje się aprowizacją GPU, automatycznym skalowaniem od zera do N replik, balanserem obciążenia i monitorowaniem.

Obsługa obciążenia produkcyjnego

Aby zwiększyć przepustowość, nie szukaj większej karty GPU – pomnóż liczbę instancji za balanserem obciążenia, z których każda obsługuje ten sam model na własnej karcie:

                    ┌─── vLLM instance 1 (GPU A)
Load Balancer ──────┼─── vLLM instance 2 (GPU B)
                    └─── vLLM instance 3 (GPU C)

Wystarczy pięć metryk, aby zarządzać całą konfiguracją: liczba tokenów na sekundę mierzy przepustowość generowania; TTFB (Time To First Byte) określa opóźnienie przed pierwszym tokenem, które odczuwa użytkownik; wykorzystanie GPU powinno przekraczać 80% pod obciążeniem, w przeciwnym razie płacisz za bezczynny sprzęt; monitoruj pamięć GPU, aby przewidzieć błędy OOM; oraz głębokość kolejki, czyli liczba oczekujących żądań, sygnalizująca nasycenie, zanim użytkownicy zaczną się skarżyć. Na pojedynczej maszynie proste, ciągłe odświeżanie już daje Ci essentials:

# Monitor GPU utilization
watch -n 1 nvidia-smi

Kluczowe wnioski

  • Przyjmij budżet ~2 GB VRAM na miliard parametrów w formacie FP16
  • Kwantyzacja FP8 redukuje zużycie pamięci o połowę przy pomijalnym wpływie na jakość
  • SkyPilot upraszcza wdrożenia wielochmurowe dzięki gotowym konfiguracjom YAML
  • Cerebrium oferuje GPU serverless z automatycznym skalowaniem (płatność za zużycie)
  • W środowisku produkcyjnym dodaj balanser obciążenia i stale monitoruj metryki GPU