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:

```cmd
ollama create llama3-8b-optimized -f Modelfile
```

Pour utiliser le modèle:

```cmd
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:

```ini
[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:

```batch
@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:

```python
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:
```cmd
python benchmark_model.py llama3-8b-optimized
```