Infrastructure d'IA sur le matériel grand public

Déployez l'intelligence artificielle d'entreprise sur des matériels abordables avec des modèles open source

Sommaire

La démocratisation de l’IA est ici. Avec des LLM open source comme Llama 3, Mixtral et Qwen qui rivalisent désormais avec les modèles propriétaires, les équipes peuvent construire une infrastructure puissante d’IA à l’aide du matériel grand public - réduisant les coûts tout en maintenant un contrôle complet sur la confidentialité des données et le déploiement.

Infrastructure d’IA de l’équipe sur du matériel grand public

Pourquoi héberger vous-même l’infrastructure d’IA de votre équipe ?

Le paysage a changé de manière spectaculaire. Ce qui nécessitait autrefois des clusters de GPU coûtant des millions de dollars est désormais réalisable avec du matériel grand public coûtant moins cher qu’un ordinateur de bureau haut de gamme.

Le cas pour une infrastructure d’IA hébergée localement

Efficacité des coûts

  • OpenAI GPT-4 coûte 0,03-0,06 $ par 1 000 tokens
  • Une équipe traitant 1 million de tokens par jour dépense 900-1 800 $ par mois
  • Un système RTX 4090 coûtant 2 000 $ atteint le seuil de rentabilité en 1-3 mois
  • Après le seuil de rentabilité : utilisation illimitée à un coût marginal nul

Confidentialité des données et conformité

  • Contrôle complet des données sensibles
  • Aucune donnée envoyée vers des API tierces
  • Conformité au RGPD, au HIPAA et aux normes sectorielles
  • Options de déploiement isolés

Personnalisation et contrôle

  • Ajuster les modèles sur des données propriétaires
  • Aucune limite de débit ou de quotas
  • Configurations de déploiement personnalisées
  • Indépendance vis-à-vis des changements des fournisseurs d’API

Prévisibilité des performances

  • Latence constante sans fluctuations des API
  • Aucune dépendance à la disponibilité des services externes
  • Allocation des ressources contrôlable
  • Optimisé pour vos charges de travail spécifiques

Sélection du matériel : Construction de votre serveur d’IA

Choix de GPU pour différents budgets

Niveau de budget (600-900 $) : Modèles 7B

  • NVIDIA RTX 4060 Ti 16GB (500 $) : Exécute des modèles 7B, 2-3 utilisateurs simultanés
  • AMD RX 7900 XT (650 $) : 20 GB de VRAM, excellent pour l’inférence
  • Cas d’utilisation : Petites équipes (3-5 personnes), tâches de codage/écriture standard

Niveau intermédiaire (1 200-1 800 $) : Modèles 13B

  • NVIDIA RTX 4070 Ti (800 $) : 12 GB de VRAM, bonnes performances pour 7B
  • NVIDIA RTX 4090 (1 600 $) : 24 GB de VRAM, exécute les modèles 13B de manière fluide
  • RTX 3090 d’occasion (800-1 000 $) : 24 GB de VRAM, excellent rapport qualité-prix
  • Note : Pour les tendances actuelles des prix des prochaines modèles RTX 5080 et RTX 5090, consultez notre analyse des dynamiques de prix des RTX 5080 et RTX 5090
  • Cas d’utilisation : Équipes moyennes (5-15 personnes), tâches de raisonnement complexes

Niveau professionnel (2 500 $+) : Modèles 30B+

  • Plusieurs RTX 3090/4090 (1 600 $+ chacun) : Inférence distribuée
  • AMD Instinct MI210 (d’occasion, 2 000 $+) : 64 GB de HBM2e
  • NVIDIA A6000 (d’occasion, 3 000 $+) : 48 GB de VRAM, fiabilité professionnelle
  • NVIDIA Quadro RTX 5880 Ada (48 GB) : Pour les déploiements professionnels nécessitant la quantité maximale de VRAM et de fiabilité, consultez les capacités et la proposition de valeur du Quadro RTX 5880 Ada
  • Cas d’utilisation : Grandes équipes (15+), recherche, ajustement

Considérations pour un système complet

CPU et mémoire

  • CPU : Ryzen 5 5600 ou Intel i5-12400 (suffisant pour le service d’IA)
  • Mémoire : 32 Go minimum, 64 Go recommandé pour les fenêtres de contexte importantes
  • Mémoire rapide aide au traitement des prompts et au chargement des modèles
  • Optimisation du CPU : Pour les CPU Intel avec architectures hybrides (P-cœurs et E-cœurs), découvrez comment Ollama utilise différents types de cœurs du CPU pour optimiser les performances
  • Configuration PCIe : Lors de la planification des configurations multi-GPU ou des déploiements à haute performance, comprendre les canaux PCIe et leur impact sur les performances des LLM est crucial pour une allocation optimale de bande passante

Stockage

  • SSD NVMe : 1 To minimum pour les modèles et le cache
  • Modèles : 4-14 Go chacun, gardez 5-10 modèles chargés
  • Le stockage rapide réduit le temps de chargement des modèles

Alimentation et refroidissement

  • RTX 4090 : 450 W TDP, nécessite un PSU de 850 W+
  • Un bon refroidissement est essentiel pour une utilisation 24/7
  • Budget de 150-200 $ pour un PSU et un refroidissement de qualité

Réseau

  • 1 Gbps suffisant pour l’accès API
  • 10 Gbps bénéfique pour l’entraînement distribué
  • Une faible latence importe pour les applications en temps réel

Exemples de configurations

Configuration économique (1 200 $)

GPU : RTX 4060 Ti 16GB (500 $)
CPU : Ryzen 5 5600 (130 $)
RAM : 32 Go DDR4 (80 $)
Mobo : B550 (120 $)
Stockage : 1 To NVMe (80 $)
PSU : 650 W 80+ Gold (90 $)
Boîtier : 80 $
Total : ~1 200 $

Configuration optimale (2 500 $)

GPU : RTX 4090 24GB (1 600 $)
CPU : Ryzen 7 5700X (180 $)
RAM : 64 Go DDR4 (140 $)
Mobo : X570 (180 $)
Stockage : 2 To NVMe (120 $)
PSU : 1 000 W 80+ Gold (150 $)
Boîtier : 100 $
Total : ~2 500 $

Pile logicielle : Service d’IA open source

Plateformes de service de modèles

Ollama : Simplicité première

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

# Exécuter un modèle
ollama run llama3:8b

# Serveur API (compatible OpenAI)
ollama serve

Avantages :

  • Installation extrêmement simple
  • Gestion automatique des modèles
  • API compatible OpenAI
  • Quantisation GGUF efficace
  • Bibliothèque de modèles intégrée

Performances : Pour des benchmarks de performances d’Ollama dans des configurations matérielles différentes, y compris les GPU d’entreprise et grand public, consultez notre comparaison détaillée du NVIDIA DGX Spark, Mac Studio et RTX 4080.

Meilleur pour : Les équipes priorisant l’aisance d’utilisation et le déploiement rapide

vLLM : Performance maximale

# Installer vLLM
pip install vllm

# Servir un modèle
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-chat-hf \
    --tensor-parallel-size 1

Avantages :

  • Plus grande throughput
  • PagedAttention pour l’efficacité mémoire
  • Batching continu
  • Support multi-GPU

Meilleur pour : Scénarios à forte throughput, utilisateurs simultanés multiples

LocalAI : Solution tout-en-un

# Déploiement Docker
docker run -p 8080:8080 \
    -v $PWD/models:/models \
    localai/localai:latest

Avantages :

  • Support multiple backend (llama.cpp, vLLM, etc.)
  • Modèles audio, image et texte
  • API compatible OpenAI
  • Support étendu des modèles

Meilleur pour : Charges de travail diverses, besoins multimodaux

Conteneurisation et orchestration

Configuration 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:

Déploiement 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

Sélection de modèles et déploiement

Meilleurs modèles open source (novembre 2024)

Classe de 7B paramètres (niveau d’entrée)

  • Llama 3.1 8B : Le plus récent de Meta, performance générale excellente
  • Mistral 7B v0.3 : Raisonnement fort, capacités de codage
  • Qwen2.5 7B : Multilingue, fort sur les tâches techniques
  • VRAM : 8-12 Go, Vitesse : ~30-50 tokens/sec sur RTX 4060 Ti

Classe de 13B paramètres (équilibrée)

  • Llama 3.1 13B : Meilleure qualité globale dans la classe
  • Vicuna 13B : Ajusté pour les conversations
  • WizardCoder 13B : Spécialisé pour le codage
  • VRAM : 14-18 Go, Vitesse : ~20-30 tokens/sec sur RTX 4090

Classe de 30B+ paramètres (haute qualité)

  • Llama 3.1 70B : Rivalise avec GPT-4 sur de nombreux benchmarks
  • Mixtral 8x7B : Architecture MoE, modèle efficace de 47B
  • Yi 34B : Bonne performance multilingue
  • VRAM : 40 Go+ (nécessite plusieurs GPU ou une quantisation lourde)

Stratégies de quantification

Niveaux de quantification GGUF

  • Q4_K_M : 4 bits, ~50 % de la taille, perte minimale de qualité (recommandé)
  • Q5_K_M : 5 bits, ~60 % de la taille, meilleure qualité
  • Q8_0 : 8 bits, ~80 % de la taille, qualité proche de l’originale
  • F16 : 16 bits complets, 100 % de la taille, qualité originale

Exemple : Tailles du modèle Llama 3.1 8B

  • Originale (F16) : 16 Go
  • Q8_0 : 8,5 Go
  • Q5_K_M : 5,7 Go
  • Q4_K_M : 4,6 Go
# Ollama utilise automatiquement la quantification optimale
ollama pull llama3:8b

# Pour la quantification personnalisée avec llama.cpp
./quantize models/llama-3-8b-f16.gguf models/llama-3-8b-q4.gguf Q4_K_M

Accès multi-utilisateurs et répartition de charge

Authentification et contrôle d’accès

Authentification par clé API avec 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;
        }
    }
}

Configuration multi-utilisateurs d’OpenWebUI

OpenWebUI fournit une gestion d’utilisateurs intégrée :

  • Enregistrement et authentification des utilisateurs
  • Historique des conversations par utilisateur
  • Tableau de bord d’administration pour la gestion des utilisateurs
  • Contrôle d’accès basé sur les rôles

Répartition de charge sur plusieurs GPU

Répartition en rond robin avec 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;
    }
}

Stratégie de file d’attente des requêtes

  • vLLM gère les requêtes simultanées avec un batchage continu
  • Ollama file automatiquement les requêtes
  • Considérez le nombre maximal de requêtes simultanées en fonction de la VRAM

Déploiements avancés

RAG (Génération Augmentée par Récupération)

# Exemple de configuration RAG avec LangChain
from langchain.llms import Ollama
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA

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

# Créer le magasin de vecteurs
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Créer la chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# Interroger
result = qa_chain.run("Quelle est notre politique de congés de la société ?")

Ajustement pour des tâches spécifiques à l’équipe

# Ajustement LoRA avec Unsloth (efficace en mémoire)
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,  # Rang LoRA
    lora_alpha=16,
    lora_dropout=0,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
)

# Entraînez sur votre ensemble de données
trainer.train()

# Enregistrez le modèle ajusté
model.save_pretrained("./models/company-llama-3-8b")

Surveillance et observabilité

Métriques Prometheus

# Ajout à 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

Métriques clés à surveiller

  • Utilisation et température du GPU
  • Utilisation de la VRAM
  • Latence et throughput des requêtes
  • Longueur de la file d’attente
  • Temps de chargement des modèles
  • Vitesse de génération de tokens

Bonnes pratiques de sécurité

Sécurité réseau

  • Déployer derrière un VPN ou un pare-feu
  • Utiliser TLS/SSL pour l’accès externe
  • Implémenter la limitation de débit
  • Mises à jour de sécurité régulières

Confidentialité des données

  • Gardez les modèles et les données sur site
  • Chiffrez les volumes de stockage
  • Audit des journaux d’accès
  • Implémentez des politiques de rétention des données

Contrôle d’accès

  • Rotation des clés API
  • Authentification des utilisateurs
  • Permissions basées sur les rôles
  • Gestion des sessions

Analyse des coûts et ROI

Coût total de possession (3 ans)

Auto-hébergé (configuration RTX 4090)

  • Coût initial du matériel : 2 500 $
  • Électricité (450 W @ 0,12 $/kWh, 24/7) : 475 $/an = 1 425 $ sur 3 ans
  • Maintenance/mises à niveau : 500 $ sur 3 ans
  • Coût total sur 3 ans : 4 425 $

API cloud (équivalent GPT-4)

  • Utilisation : 1 million de tokens par jour en moyenne
  • Coût : 0,04 $/1 000 tokens
  • Journalier : 40 $
  • Coût total sur 3 ans : 43 800 $

Économies : 39 375 $ (réduction de coûts de 89 %)

Analyse de seuil de rentabilité

  • Équipe traitant 500 000 tokens par jour : 4-6 mois
  • Équipe traitant 1 million de tokens par jour : 2-3 mois
  • Équipe traitant 2 millions de tokens par jour : 1-2 mois

Stratégies d’échelle

Échelle verticale

  1. Ajouter plus de VRAM (mettre à niveau le GPU)
  2. Augmenter la mémoire système pour des contextes plus grands
  3. Stockage plus rapide pour le chargement des modèles

Échelle horizontale

  1. Ajouter plus de nœuds GPU
  2. Implémenter un équilibrage de charge
  3. Inférence distribuée avec Ray
  4. Parallélisme des modèles pour des modèles plus grands

Approche hybride

  • Auto-hébergé pour les tâches sensibles/routinières
  • API cloud pour les pics de charge ou les modèles spécialisés
  • Optimisation des coûts grâce à une routage intelligente

Défis courants et solutions

Défi : Temps de chargement du modèle

  • Solution : Gardez les modèles fréquemment utilisés en VRAM, utilisez le cache des modèles

Défi : Plusieurs utilisateurs simultanés

  • Solution : Implémentez la file d’attente des requêtes, utilisez le batchage continu de vLLM

Défi : VRAM limitée

  • Solution : Utilisez des modèles quantifiés (Q4/Q5), implémentez le swappage des modèles

Défi : Performance incohérente

  • Solution : Surveillez la température du GPU, implémentez un bon refroidissement, utilisez des tailles de lots cohérentes

Défi : Mises à jour de modèles

  • Solution : Scripts d’actualisation automatique des modèles, gestion des versions, procédures de réversion

Liste de vérification pour commencer

  • Choisir un GPU en fonction de la taille de l’équipe et du budget
  • Assembler ou acheter du matériel
  • Installer Ubuntu 22.04 ou une distribution Linux similaire
  • Installer les pilotes NVIDIA et le kit CUDA
  • Installer Docker et docker-compose
  • Déployer le stack Ollama + OpenWebUI
  • Télécharger 2-3 modèles (commencez par Llama 3.1 8B)
  • Configurer l’accès réseau et l’authentification
  • Configurer la surveillance (statistiques GPU minimum)
  • Former l’équipe à l’utilisation de l’API ou de l’interface web
  • Documenter le déploiement et les procédures d’accès
  • Planifier les sauvegardes et la récupération après sinistre

Liens utiles