Infrastruktura AI na sprzęcie konsumentowym

Wdrażaj sztuczną inteligencję na poziomie przedsiębiorstwa na sprzęcie o niskim koszcie za pomocą otwartych modeli

Page content

Demokratyzacja AI jest tu. Z powodu otwartych źródeł LLM takich jak Llama 3, Mixtral i Qwen, które teraz rywalizują z modelami prywatnymi, zespoły mogą tworzyć potężną infrastrukturę AI za pomocą sprzętu konsumenta - znacznie obniżając koszty, jednocześnie utrzymując pełną kontrolę nad prywatnością danych i wdrażaniem.

Infrastruktura AI zespołu na sprzęcie konsumenta

Dlaczego samodzielne wdrażanie infrastruktury AI zespołu?

Lanscape zmienił się dramatycznie. To, co kiedyś wymagało klastrów GPU o wartości miliona dolarów, jest teraz osiągalne za pomocą sprzętu konsumenta kosztującego mniej niż wysokiej klasy stacja robocza.

Argumenty za samodzielnie wdrażaną infrastrukturą AI

Efektywność kosztowa

  • OpenAI GPT-4 kosztuje 0,03-0,06 dolarów za 1000 tokenów
  • Zespół przetwarzający 1 milion tokenów dziennie wydaje 900-1800 dolarów miesięcznie
  • System RTX 4090 o wartości 2000 dolarów osiąga punkt równowagi w 1-3 miesiącach
  • Po osiągnięciu punktu równowagi: nieograniczony dostęp przy zerowym koszcie krańcowym

Prywatność danych i zgodność

  • Pełna kontrola nad wrażliwymi danymi
  • Brak przesyłania danych do API trzecich stron
  • Zgodność z GDPR, HIPAA i branżową zgodnością
  • Opcje wdrożenia odciętego od sieci

Dostosowanie i kontrola

  • Dostosowywanie modeli do własnych danych
  • Brak limitów przepustowości ani kwot
  • Własne konfiguracje wdrażania
  • Niezależność od zmian dostawcy API

Przewidywalna wydajność

  • Stała opóźnienie bez wahania API
  • Brak zależności od dostępności usług zewnętrznych
  • Kontrolowalne przydział zasobów
  • Optymalizacja dla konkretnych obciążeń pracy

Wybór sprzętu: Budowanie serwera AI

Wybór GPU dla różnych budżetów

Budżetowy poziom (600-900 dolarów): modele 7B

  • NVIDIA RTX 4060 Ti 16GB (500 dolarów): Uruchamia modele 7B, 2-3 użytkowników równolegle
  • AMD RX 7900 XT (650 dolarów): 20 GB VRAM, świetny do wnioskowania
  • Zastosowanie: Małe zespoły (3-5 osób), standardowe zadania kodowania/pisania

Średni poziom (1200-1800 dolarów): modele 13B

  • NVIDIA RTX 4070 Ti (800 dolarów): 12 GB VRAM, dobre wydajność 7B
  • NVIDIA RTX 4090 (1600 dolarów): 24 GB VRAM, płynne uruchamianie modeli 13B
  • Używany RTX 3090 (800-1000 dolarów): 24 GB VRAM, świetna wartość
  • Uwaga: Aby zobaczyć najnowsze trendy cenowe dla nadchodzących modeli RTX 5080 i 5090, zobacz naszą analizę dynamicznych cen RTX 5080 i RTX 5090
  • Zastosowanie: Średnie zespoły (5-15 osób), złożone zadania rozumowania

Profesjonalny poziom (2500+ dolarów): modele 30B+

  • Wiele RTX 3090/4090 (1600+ dolarów): Wnioskowanie rozproszone
  • AMD Instinct MI210 (używany, 2000+ dolarów): 64 GB HBM2e
  • NVIDIA A6000 (używany, 3000+ dolarów): 48 GB VRAM, profesjonalna niezawodność
  • NVIDIA Quadro RTX 5880 Ada (48 GB): Dla profesjonalnych wdrożeń wymagających maksymalnej VRAM i niezawodności, rozważ możliwości i propozycje wartości Quadro RTX 5880 Ada
  • Zastosowanie: Duże zespoły (15+ osób), badania, dostosowanie modeli

Pełne rozważania systemu

CPU i pamięć

  • CPU: Ryzen 5 5600 lub Intel i5-12400 (wystarczające do serwowania AI)
  • RAM: Minimum 32 GB, zalecane 64 GB dla dużych okien kontekstu
  • Szybka pamięć pomaga w przetwarzaniu promptów i ładowaniu modeli
  • Optymalizacja CPU: Dla procesorów Intel z architekturą hybrydową (P-cores i E-cores), zobacz jak Ollama wykorzystuje różne typy rdzeni CPU do optymalizacji wydajności
  • Konfiguracja PCIe: Gdy planujesz konfiguracje wielo-GPU lub wdrożenia o wysokiej wydajności, zrozumienie ścieżek PCIe i ich wpływu na wydajność LLM jest kluczowe dla optymalnego przydziału pasma

Magazynowanie

  • NVMe SSD: minimum 1 TB dla modeli i cache
  • Modele: 4-14 GB każdy, utrzymaj 5-10 modeli załadowanych
  • Szybkie magazynowanie zmniejsza czas ładowania modeli

Zasilanie i chłodzenie

  • RTX 4090: 450 W TDP, wymaga 850 W+ zasilacza
  • Dobre chłodzenie jest konieczne dla pracy 24/7
  • Budżet 150-200 dolarów na jakość zasilacza i chłodzenia

Sieć

  • 1 Gbps wystarczy do dostępu API
  • 10 Gbps korzystne do rozproszonego trenowania
  • Niski opóźnienie ma znaczenie dla aplikacji w czasie rzeczywistym

Przykładowe konfiguracje

Konfiguracja budżetowa (1200 dolarów)

GPU: RTX 4060 Ti 16GB (500 dolarów)
CPU: Ryzen 5 5600 (130 dolarów)
RAM: 32 GB DDR4 (80 dolarów)
Płyta główna: B550 (120 dolarów)
Magazynowanie: 1 TB NVMe (80 dolarów)
Zasilacz: 650 W 80+ Gold (90 dolarów)
Obudowa: 80 dolarów
Razem: ~1200 dolarów

Optymalna konfiguracja (2500 dolarów)

GPU: RTX 4090 24GB (1600 dolarów)
CPU: Ryzen 7 5700X (180 dolarów)
RAM: 64 GB DDR4 (140 dolarów)
Płyta główna: X570 (180 dolarów)
Magazynowanie: 2 TB NVMe (120 dolarów)
Zasilacz: 1000 W 80+ Gold (150 dolarów)
Obudowa: 100 dolarów
Razem: ~2500 dolarów

Stos oprogramowania: lokalne serwowanie AI z otwartym źródłem

Platformy serwowania modeli

Ollama: Prostota pierwsza

# Instalacja Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Uruchomienie modelu
ollama run llama3:8b

# Serwer API (kompatybilny z OpenAI)
ollama serve

Zalety:

  • Prosta instalacja
  • Automatyczne zarządzanie modelem
  • Kompatybilny z API OpenAI
  • Efektywne kwantyzowanie GGUF
  • Wbudowana biblioteka modeli

Wydajność: Aby zobaczyć testy wydajności Ollama w różnych konfiguracjach sprzętu, w tym w serwerach i konsumentach GPU, zobacz naszą szczegółową porównawczą analizę NVIDIA DGX Spark, Mac Studio i RTX 4080.

Najlepsze do: zespołów, które dają priorytet łatwości użycia i szybkiej wdrożeniu

vLLM: Maksymalna wydajność

# Instalacja vLLM
pip install vllm

# Serwowanie modelu
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-chat-hf \
    --tensor-parallel-size 1

Zalety:

  • Najwyższa przepustowość
  • PagedAttention dla efektywności pamięci
  • Ciągłe grupowanie
  • Obsługa wielu GPU

Najlepsze do: scenariuszy wysokiej przepustowości, wielu użytkowników równolegle

LocalAI: Wszystko w jednym rozwiązaniu

# Wdrażanie w kontenerze
docker run -p 8080:8080 \
    -v $PWD/models:/models \
    localai/localai:latest

Zalety:

  • Wiele obsługiwanych backendów (llama.cpp, vLLM itp.)
  • Modele audio, obrazów i tekstu
  • Kompatybilny z API OpenAI
  • Rozszerzona obsługa modeli

Najlepsze do: zróżnicowanych obciążeń, wymagań multimodalnych

Konteneryzacja i orkiestracja

Konfiguracja Docker Compose

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped

  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - webui_data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama_data:
  webui_data:

Wdrażanie w Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      containers:
      - name: ollama
        image: ollama/ollama:latest
        ports:
        - containerPort: 11434
        resources:
          limits:
            nvidia.com/gpu: 1
        volumeMounts:
        - name: models
          mountPath: /root/.ollama
      volumes:
      - name: models
        persistentVolumeClaim:
          claimName: ollama-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: ollama-service
spec:
  selector:
    app: ollama
  ports:
  - port: 11434
    targetPort: 11434
  type: LoadBalancer

Wybór modeli i wdrażanie

Najlepsze modele otwartego źródła (listopad 2024)

Klasa modeli 7B parametrów (poziom wstępny)

  • Llama 3.1 8B: najnowszy od Meta, doskonała ogólna wydajność
  • Mistral 7B v0.3: silne rozumowanie, możliwości kodowania
  • Qwen2.5 7B: wielojęzyczny, silny w zadaniach technicznych
  • VRAM: 8-12 GB, Prędkość: ~30-50 tokenów/sec na RTX 4060 Ti

Klasa modeli 13B parametrów (wyrównany poziom)

  • Llama 3.1 13B: najlepsza ogólna jakość w klasie
  • Vicuna 13B: dofinansowany do rozmów
  • WizardCoder 13B: specjalizowany w kodowaniu
  • VRAM: 14-18 GB, Prędkość: ~20-30 tokenów/sec na RTX 4090

Klasa modeli 30B+ parametrów (wysoka jakość)

  • Llama 3.1 70B: rywalizuje z GPT-4 na wielu testach
  • Mixtral 8x7B: architektura MoE, efektywny model 47B
  • Yi 34B: silna wielojęzyczność
  • VRAM: 40 GB+ (wymaga wielu GPU lub ciężkiego kwantyzowania)

Strategie kwantyzacji

Poziomy kwantyzacji GGUF

  • Q4_K_M: 4-bit, ~50% rozmiaru, minimalna utrata jakości (zalecane)
  • Q5_K_M: 5-bit, ~60% rozmiaru, lepsza jakość
  • Q8_0: 8-bit, ~80% rozmiaru, bliska oryginalnej jakości
  • F16: pełna 16-bit, 100% rozmiaru, oryginalna jakość

Przykład: rozmiary modelu Llama 3.1 8B

  • Oryginalny (F16): 16 GB
  • Q8_0: 8,5 GB
  • Q5_K_M: 5,7 GB
  • Q4_K_M: 4,6 GB
# Ollama automatycznie używa optymalnej kwantyzacji
ollama pull llama3:8b

# Dla niestandardowej kwantyzacji z llama.cpp
./quantize models/llama-3-8b-f16.gguf models/llama-3-8b-q4.gguf Q4_K_M

Dostęp wielu użytkowników i bilansowanie obciążenia

Autoryzacja i kontrola dostępu

Autoryzacja API Key z nginx

http {
    upstream ollama_backend {
        server localhost:11434;
    }

    map $http_authorization $api_key {
        ~Bearer\s+(.+) $1;
    }

    server {
        listen 80;
        server_name ai.yourteam.com;

        location / {
            if ($api_key != "your-secure-api-key") {
                return 401;
            }

            proxy_pass http://ollama_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

Konfiguracja wielu użytkowników OpenWebUI

OpenWebUI oferuje wbudowane zarządzanie użytkownikami:

  • Rejestracja i autoryzacja użytkownika
  • Historia rozmów dla każdego użytkownika
  • Panel administratora do zarządzania użytkownikami
  • Kontrola dostępu oparta na rolach

Bilansowanie obciążenia wielu GPU

Rozdzielanie z nginx

upstream ollama_cluster {
    server gpu-node-1:11434;
    server gpu-node-2:11434;
    server gpu-node-3:11434;
}

server {
    listen 80;
    location / {
        proxy_pass http://ollama_cluster;
    }
}

Strategia kolejki żądań

  • vLLM obsługuje żądania równoległe z ciągłym grupowaniem
  • Ollama automatycznie kolejkuje żądania
  • Rozważ maksymalną liczbę równoległych żądań na podstawie VRAM

Zaawansowane wdrażanie

RAG (Retrieval Augmented Generation)

# Przykład konfiguracji RAG z LangChain
from langchain.llms import Ollama
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA

# Inicjalizacja modeli
llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Utwórz magazyn wektorowy
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Utwórz łańcuch RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# Zapytanie
result = qa_chain.run("Jakie jest nasza polityka urlopowania w firmie?")

Dostosowanie do zadań zespołu

# Dostosowanie LoRA z Unsloth (efektywne w pamięci)
from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # Ranga LoRA
    lora_alpha=16,
    lora_dropout=0,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
)

# Trenuj na swoich danych
trainer.train()

# Zapisz dostosowany model
model.save_pretrained("./models/company-llama-3-8b")

Monitorowanie i obserwowalność

Metryki Prometheus

# dodatek do docker-compose.yml
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

Kluczowe metryki do monitorowania

  • Wykorzystanie GPU i temperatura
  • Użycie VRAM
  • Opóźnienie i przepustowość żądań
  • Długość kolejki
  • Czas ładowania modeli
  • Prędkość generowania tokenów

Najlepsze praktyki bezpieczeństwa

Bezpieczeństwo sieci

  • Wdrażaj za VPN lub zaporem ogniową
  • Używaj TLS/SSL dla dostępu zewnętrznego
  • Wdrażaj ograniczenie przepustowości
  • Regularne aktualizacje bezpieczeństwa

Prywatność danych

  • Trzymaj modele i dane lokalnie
  • Szyfruj volume magazynowania
  • Audytuj logi dostępu
  • Wdrażaj polityki przechowywania danych

Kontrola dostępu

  • Rotacja kluczy API
  • Autoryzacja użytkownika
  • Uprawnienia oparte na rolach
  • Zarządzanie sesjami

Analiza kosztów i zwrotu z inwestycji

Całkowity koszt posiadania (3 lata)

Wdrażanie lokalne (konfiguracja RTX 4090)

  • Początkowy sprzęt: 2500 dolarów
  • Energia (450 W @ 0,12 dolarów/kWh, 24/7): 475 dolarów rocznie = 1425 dolarów na 3 lata
  • Konserwacja/aktualizacje: 500 dolarów na 3 lata
  • Całkowity koszt 3-letni: 4425 dolarów

Chmura API (GPT-4 równoważna)

  • Użycie: średnio 1 milion tokenów dziennie
  • Koszt: 0,04 dolarów za 1000 tokenów
  • Codzienny: 40 dolarów
  • Całkowity koszt 3-letni: 43 800 dolarów

Oszczędności: 39 375 dolarów (89% obniżka kosztów)

Analiza punktu równowagi

  • Zespół przetwarzający 500 000 tokenów dziennie: 4-6 miesięcy
  • Zespół przetwarzający 1 milion tokenów dziennie: 2-3 miesiące
  • Zespół przetwarzający 2 miliona+ tokenów dziennie: 1-2 miesiące

Strategie skalowania

Skalowanie wertykalne

  1. Dodaj więcej VRAM (uaktualnij GPU)
  2. Zwiększ pamięć systemową dla większych kontekstów
  3. Szybsze magazynowanie dla ładowania modeli

Skalowanie poziomowe

  1. Dodaj więcej węzłów GPU
  2. Wdrażaj bilansowanie obciążenia
  3. Wnioskowanie rozproszone z Ray
  4. Równoległe przetwarzanie modeli dla większych modeli

Hybrydowy podejście

  • Lokalne wdrażanie dla wrażliwych/standardowych zadań
  • API w chmurze dla szczytowych obciążeń lub specjalistycznych modeli
  • Optymalizacja kosztów poprzez inteligentne routowanie

Typowe wyzwania i rozwiązania

Wyzwanie: Czas ładowania modelu

  • Rozwiązanie: Trzymaj często używane modele w VRAM, użyj buforowania modeli

Wyzwanie: Wielu użytkowników równolegle

  • Rozwiązanie: Wdrażaj kolejki żądań, użyj ciągłego grupowania vLLM

Wyzwanie: Ograniczona VRAM

  • Rozwiązanie: Użyj skwantyzowanych modeli (Q4/Q5), wdrażaj wymianę modeli

Wyzwanie: Niespójna wydajność

  • Rozwiązanie: Monitoruj temperaturę GPU, wdrażaj odpowiednie chłodzenie, użyj spójnych rozmiarów partii

Wyzwanie: Aktualizacje modeli

  • Rozwiązanie: Skrypty automatycznej aktualizacji modeli, zarządzanie wersjami, procedury odcofania

Lista sprawdzania do rozpoczęcia

  • Wybierz GPU na podstawie rozmiaru zespołu i budżetu
  • Złóż lub kup sprzęt
  • Zainstaluj Ubuntu 22.04 lub podobny system Linux
  • Zainstaluj sterowniki NVIDIA i zestaw narzędzi CUDA
  • Zainstaluj Docker i docker-compose
  • Wdróż stos Ollama + OpenWebUI
  • Pobierz 2-3 modele (zaczynając od Llama 3.1 8B)
  • Skonfiguruj dostęp sieciowy i autoryzację
  • Ustaw monitorowanie (minimum statystyki GPU)
  • Wytrenuj zespół w użyciu API lub interfejsu sieciowego
  • Dokumentuj wdrożenie i procedury dostępu
  • Planuj kopie zapasowe i odzyskiwanie po awarii

Przydatne linki