llm_lab_perso/optimisation_modelfile.md

Optimisation des modèles Ollama pour Windows

Ce guide explique comment optimiser les performances des différents modèles Ollama sur Windows en utilisant des Modelfiles personnalisés.

Principes généraux d'optimisation

Les paramètres clés à ajuster pour chaque modèle sont:

Paramètre	Description	Impact
num_gpu	Pourcentage du modèle à charger sur GPU	Plus élevé = plus rapide, mais consomme plus de VRAM
num_thread	Nombre de threads CPU à utiliser	À ajuster selon votre CPU
num_ctx	Taille du contexte	Plus grand = plus de mémoire nécessaire
num_batch	Taille du lot pour l'inférence	Augmente la vitesse mais consomme plus de RAM
f16	Utilisation de la précision FP16	Réduit l'utilisation de mémoire de moitié
temperature	Niveau de créativité	N'affecte pas les performances
top_p	Contrôle de diversité	N'affecte pas les performances

Création d'un Modelfile optimisé

1. Créez un fichier nommé Modelfile (sans extension)
2. Ajoutez la configuration adaptée à votre modèle
3. Utilisez ollama create pour créer une version optimisée

Exemples de Modelfiles optimisés

Llama 3 8B - Performance maximale

FROM llama3:8b

PARAMETER temperature 0.7
PARAMETER num_gpu 100
PARAMETER num_thread 12
PARAMETER num_ctx 8192
PARAMETER num_batch 512

Llama 3 8B - Économie de mémoire

FROM llama3:8b

PARAMETER temperature 0.7
PARAMETER num_gpu 50
PARAMETER num_thread 8
PARAMETER num_ctx 4096
PARAMETER num_batch 256

Llama 3 70B - Haute performance (GPU 24GB+)

FROM llama3:70b

PARAMETER temperature 0.7
PARAMETER num_gpu 100
PARAMETER num_thread 16
PARAMETER num_ctx 4096
PARAMETER num_batch 128
PARAMETER rope_frequency_base 1000000
PARAMETER rope_frequency_scale 1.0

Mistral 7B - Équilibré

FROM mistral:7b

PARAMETER temperature 0.7
PARAMETER num_gpu 100
PARAMETER num_thread 8
PARAMETER num_ctx 8192
PARAMETER num_batch 512

Stable Code 3B - Optimisé pour programmation

FROM stablecode:3b

PARAMETER temperature 0.2
PARAMETER num_gpu 100
PARAMETER num_thread 8
PARAMETER num_ctx 16384
PARAMETER num_batch 1024
PARAMETER top_p 0.95

Nous-Hermes 2 Yi 34B - Modèle large

FROM nous-hermes2:34b

PARAMETER temperature 0.7
PARAMETER num_gpu 90
PARAMETER num_thread 12
PARAMETER num_ctx 4096
PARAMETER num_batch 128

Comment appliquer ces configurations

Pour créer une version optimisée d'un modèle:

ollama create llama3-8b-optimized -f Modelfile

Pour utiliser le modèle:

ollama run llama3-8b-optimized

Recommandations par taille de GPU

GPU 6-8 GB (ex: RTX 2060, RTX 3060)

• Modèles jusqu'à 7B
• Utilisez num_gpu 50-80
• Réduisez num_ctx à 2048-4096
• Essayez avec un paramètre f16 activé

GPU 12 GB (ex: RTX 3060 Ti, RTX 4070)

• Modèles jusqu'à 13B
• Utilisez num_gpu 70-100
• num_ctx jusqu'à 8192
• num_batch jusqu'à 512

GPU 16 GB (ex: RTX 3080, RTX 4080)

• Modèles jusqu'à 34B (avec optimisations)
• num_gpu 80-100
• num_ctx jusqu'à 8192
• num_batch jusqu'à 1024

GPU 24 GB+ (ex: RTX 3090, RTX 4090)

• Modèles jusqu'à 70B
• num_gpu 100
• num_ctx jusqu'à 16384
• num_batch jusqu'à 2048

Configuration système recommandée

Pour tirer le meilleur parti de ces optimisations:

[Windows Power Plan]
Plan d'alimentation: Hautes performances

[NVIDIA Control Panel]
Mode de gestion d'alimentation: Préférer les performances maximales
Mode de préemption CUDA: Automatique
Paramètre GPU scheduling: Automatique

Script d'optimisation automatique

Créez un fichier optimize_models.bat pour automatiser l'optimisation:

@echo off
setlocal

echo Optimisation des modèles Ollama pour Windows...

set MODEL=%1
if "%MODEL%"=="" (
    echo Usage: optimize_models.bat [model_name]
    echo Exemple: optimize_models.bat llama3:8b
    exit /b 1
)

REM Détecter la quantité de VRAM
for /f "tokens=*" %%a in ('nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits') do set VRAM=%%a
echo VRAM détectée: %VRAM% MiB

REM Déterminer les paramètres optimaux
set NUM_GPU=100
set NUM_CTX=8192
set NUM_BATCH=512

if %VRAM% LSS 8000 (
    set NUM_GPU=50
    set NUM_CTX=4096
    set NUM_BATCH=256
) else if %VRAM% LSS 12000 (
    set NUM_GPU=80
    set NUM_CTX=4096
    set NUM_BATCH=512
) else if %VRAM% LSS 16000 (
    set NUM_GPU=90
    set NUM_CTX=8192
    set NUM_BATCH=1024
) else if %VRAM% LSS 24000 (
    set NUM_GPU=100
    set NUM_CTX=8192
    set NUM_BATCH=1024
) else (
    set NUM_GPU=100
    set NUM_CTX=16384
    set NUM_BATCH=2048
)

REM Créer un Modelfile temporaire
echo FROM %MODEL% > Modelfile
echo. >> Modelfile
echo PARAMETER temperature 0.7 >> Modelfile
echo PARAMETER num_gpu %NUM_GPU% >> Modelfile
echo PARAMETER num_thread 8 >> Modelfile
echo PARAMETER num_ctx %NUM_CTX% >> Modelfile
echo PARAMETER num_batch %NUM_BATCH% >> Modelfile

REM Extraire le nom du modèle (sans tag)
for /f "tokens=1 delims=:" %%a in ("%MODEL%") do set MODEL_NAME=%%a

echo Configuration optimisée pour votre GPU:
echo - num_gpu: %NUM_GPU%
echo - num_ctx: %NUM_CTX%
echo - num_batch: %NUM_BATCH%

echo Création du modèle optimisé %MODEL_NAME%-optimized...
ollama create %MODEL_NAME%-optimized -f Modelfile

echo Modèle optimisé créé avec succès!
echo Utilisez: ollama run %MODEL_NAME%-optimized

del Modelfile

endlocal

Mesurer les performances

Utilisez ce script Python pour mesurer les performances de vos modèles optimisés:

import time
import requests
import json
import argparse

def benchmark_model(model_name, prompt_length=100, repeats=3):
    base_url = "http://localhost:11434/api/generate"
    
    # Créer un prompt de test
    prompt = "Explique-moi en détail " * prompt_length
    
    total_time = 0
    total_tokens = 0
    
    print(f"Benchmark du modèle: {model_name}")
    print(f"Longueur du prompt: {len(prompt)} caractères")
    print(f"Répétitions: {repeats}")
    print("-" * 50)
    
    for i in range(repeats):
        print(f"Test {i+1}/{repeats}...")
        
        start_time = time.time()
        
        response = requests.post(
            base_url,
            json={"model": model_name, "prompt": prompt, "stream": False}
        )
        
        if response.status_code != 200:
            print(f"Erreur: {response.status_code}")
            print(response.text)
            return
        
        result = response.json()
        end_time = time.time()
        
        duration = end_time - start_time
        tokens = len(result.get("response", "").split())
        
        total_time += duration
        total_tokens += tokens
        
        print(f"  Temps: {duration:.2f}s, Tokens: {tokens}")
        
        # Pause entre les tests
        time.sleep(1)
    
    avg_time = total_time / repeats
    avg_tokens = total_tokens / repeats
    tokens_per_second = avg_tokens / avg_time
    
    print("-" * 50)
    print(f"Résultats pour {model_name}:")
    print(f"Temps moyen: {avg_time:.2f}s")
    print(f"Tokens moyens: {avg_tokens:.0f}")
    print(f"Vitesse: {tokens_per_second:.2f} tokens/seconde")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Benchmark Ollama Models")
    parser.add_argument("model", help="Nom du modèle à tester")
    args = parser.parse_args()
    
    benchmark_model(args.model)

Utilisez ce script comme suit:

python benchmark_model.py llama3-8b-optimized