mirror of
https://github.com/Ladebeze66/llm_lab.git
synced 2025-12-16 11:47:49 +01:00
409 lines
12 KiB
Markdown
409 lines
12 KiB
Markdown
# Adaptations spécifiques des scripts Python pour Windows
|
|
|
|
Ce document détaille les adaptations nécessaires pour chaque script Python du projet LLM Lab lors de la migration vers Windows.
|
|
|
|
## Modifications communes à tous les scripts
|
|
|
|
### 1. Gestion des chemins
|
|
|
|
Pour tous les scripts, remplacez les chemins absolus par des chemins relatifs:
|
|
|
|
```python
|
|
# Avant
|
|
DATA_DIR = '/home/fgras-ca/llm_lab/data'
|
|
|
|
# Après
|
|
import os
|
|
# Obtenir le chemin absolu du répertoire contenant le script
|
|
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
DATA_DIR = os.path.join(BASE_DIR, 'data')
|
|
```
|
|
|
|
### 2. Installation des dépendances Windows
|
|
|
|
Ces dépendances sont nécessaires pour Windows:
|
|
|
|
```cmd
|
|
pip install wmi psutil requests pillow
|
|
pip install pywin32 # Pour l'accès aux API Windows
|
|
```
|
|
|
|
## Adaptations spécifiques par fichier
|
|
|
|
### 1. chat_gui.py
|
|
|
|
```python
|
|
# Avant de créer la fenêtre principale:
|
|
import os
|
|
import platform
|
|
|
|
# Pour éviter les problèmes d'échelle sur les écrans haute résolution
|
|
if platform.system() == 'Windows':
|
|
import ctypes
|
|
try:
|
|
ctypes.windll.shcore.SetProcessDpiAwareness(1)
|
|
except:
|
|
pass
|
|
|
|
# Configuration CUDA pour Ollama
|
|
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
|
|
os.environ["OMP_NUM_THREADS"] = "8"
|
|
```
|
|
|
|
### 2. monitor.py
|
|
|
|
```python
|
|
def _update_system_info(self):
|
|
"""Met à jour les informations système"""
|
|
# Informations système
|
|
self.os_label.config(text=f"{platform.system()} {platform.release()}")
|
|
self.cpu_label.config(text=f"{psutil.cpu_count(logical=False)} cœurs ({psutil.cpu_count()} threads)")
|
|
|
|
# Détection avancée de la RAM
|
|
try:
|
|
if platform.system() == "Windows":
|
|
# Utiliser WMI pour Windows
|
|
import wmi
|
|
computer = wmi.WMI()
|
|
for os_info in computer.Win32_OperatingSystem():
|
|
total_ram = float(os_info.TotalVisibleMemorySize) / (1024 * 1024) # en GB
|
|
else:
|
|
# Utiliser psutil pour Linux/Mac
|
|
ram = psutil.virtual_memory()
|
|
total_ram = ram.total / (1024 * 1024 * 1024) # GB
|
|
|
|
self.ram_label.config(text=f"{total_ram:.1f} GB")
|
|
except Exception as e:
|
|
self._log(f"Erreur lors de la détection de la RAM: {str(e)}")
|
|
self.ram_label.config(text="Détection impossible")
|
|
```
|
|
|
|
### 3. utils/system_monitor.py
|
|
|
|
```python
|
|
def _check_gpu_available(self):
|
|
"""Vérifie si un GPU NVIDIA est disponible"""
|
|
try:
|
|
if platform.system() == "Windows":
|
|
import wmi
|
|
computer = wmi.WMI()
|
|
# Vérifier les contrôleurs vidéo
|
|
for gpu in computer.Win32_VideoController():
|
|
if "NVIDIA" in gpu.Name:
|
|
return True
|
|
return False
|
|
else:
|
|
# Pour Linux/Mac, utiliser nvidia-smi
|
|
result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
|
|
return result.returncode == 0
|
|
except:
|
|
return False
|
|
|
|
def _update_gpu_info(self):
|
|
"""Met à jour les informations GPU"""
|
|
if not self.gpu_available:
|
|
return
|
|
|
|
try:
|
|
if platform.system() == "Windows":
|
|
# Utiliser WMI pour Windows
|
|
import wmi
|
|
computer = wmi.WMI()
|
|
|
|
# Obtenir le nom du modèle GPU
|
|
for gpu in computer.Win32_VideoController():
|
|
if "NVIDIA" in gpu.Name:
|
|
model_name = gpu.Name
|
|
self.gpu_model_label.config(text=model_name)
|
|
break
|
|
|
|
# Utiliser nvidia-smi pour les métriques détaillées même sous Windows
|
|
result = subprocess.run(
|
|
['nvidia-smi', '--query-gpu=memory.total,memory.used,utilization.gpu,temperature.gpu',
|
|
'--format=csv,noheader,nounits'],
|
|
capture_output=True,
|
|
text=True,
|
|
check=True
|
|
)
|
|
|
|
if result.returncode == 0:
|
|
# Analyser les résultats
|
|
gpu_data = result.stdout.strip().split(',')
|
|
|
|
if len(gpu_data) >= 4:
|
|
# Mémoire totale et utilisée
|
|
total_memory = float(gpu_data[0].strip())
|
|
used_memory = float(gpu_data[1].strip())
|
|
memory_percent = (used_memory / total_memory) * 100 if total_memory > 0 else 0
|
|
|
|
self.gpu_memory_label.config(text=f"{used_memory:.0f} MiB / {total_memory:.0f} MiB")
|
|
self.gpu_mem_progress["value"] = memory_percent
|
|
self.gpu_mem_percent.config(text=f"{memory_percent:.1f}%")
|
|
|
|
# Utilisation GPU
|
|
gpu_util = float(gpu_data[2].strip())
|
|
self.gpu_compute_progress["value"] = gpu_util
|
|
self.gpu_compute_percent.config(text=f"{gpu_util:.1f}%")
|
|
|
|
# Température
|
|
temp = float(gpu_data[3].strip())
|
|
self.gpu_temp_progress["value"] = temp
|
|
self.gpu_temp_label.config(text=f"{temp:.1f}°C")
|
|
else:
|
|
# Code existant pour Linux/Mac
|
|
# ...
|
|
except Exception as e:
|
|
self._log(f"Erreur de mise à jour GPU: {str(e)}")
|
|
```
|
|
|
|
### 4. utils/ollama_api.py
|
|
|
|
```python
|
|
import os
|
|
import platform
|
|
import requests
|
|
import json
|
|
|
|
# Optimisations pour Windows
|
|
if platform.system() == "Windows":
|
|
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
|
|
os.environ["OMP_NUM_THREADS"] = str(os.cpu_count())
|
|
|
|
class OllamaAPI:
|
|
def __init__(self, base_url="http://localhost:11434"):
|
|
self.base_url = base_url
|
|
|
|
# Charger la configuration optimisée si elle existe
|
|
config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
|
|
"ollama_config.json")
|
|
self.default_params = {}
|
|
|
|
if os.path.exists(config_path):
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
self.default_params = json.load(f)
|
|
except:
|
|
pass
|
|
|
|
def generate(self, model, prompt, params=None):
|
|
"""Génère une réponse du modèle"""
|
|
url = f"{self.base_url}/api/generate"
|
|
|
|
# Fusionner les paramètres par défaut avec ceux fournis
|
|
request_params = self.default_params.copy()
|
|
if params:
|
|
request_params.update(params)
|
|
|
|
data = {
|
|
"model": model,
|
|
"prompt": prompt,
|
|
**request_params
|
|
}
|
|
|
|
response = requests.post(url, json=data)
|
|
response.raise_for_status()
|
|
|
|
return response.json()
|
|
```
|
|
|
|
### 5. installer.bat - Script d'installation Windows
|
|
|
|
```batch
|
|
@echo off
|
|
setlocal
|
|
|
|
echo Installation de LLM Lab pour Windows...
|
|
|
|
REM Vérifier si Python est installé
|
|
python --version > nul 2>&1
|
|
if %ERRORLEVEL% NEQ 0 (
|
|
echo Python n'est pas installé. Veuillez installer Python 3.10 ou supérieur.
|
|
echo Téléchargez Python depuis https://www.python.org/downloads/
|
|
exit /b 1
|
|
)
|
|
|
|
REM Créer l'environnement virtuel
|
|
if not exist venv (
|
|
echo Création de l'environnement virtuel...
|
|
python -m venv venv
|
|
)
|
|
|
|
REM Activer l'environnement virtuel
|
|
call venv\Scripts\activate
|
|
|
|
REM Installer les dépendances
|
|
echo Installation des dépendances...
|
|
pip install -r requirements.txt
|
|
pip install wmi psutil requests pillow pywin32
|
|
|
|
REM Vérifier si CUDA est disponible
|
|
where nvidia-smi > nul 2>&1
|
|
if %ERRORLEVEL% EQU 0 (
|
|
echo Détection de CUDA: NVIDIA GPU disponible
|
|
nvidia-smi
|
|
) else (
|
|
echo Aucun GPU NVIDIA détecté
|
|
)
|
|
|
|
REM Vérifier si Ollama est installé
|
|
curl -s http://localhost:11434/api/tags > nul 2>&1
|
|
if %ERRORLEVEL% EQU 0 (
|
|
echo Ollama est en cours d'exécution
|
|
) else (
|
|
echo Ollama n'est pas en cours d'exécution ou n'est pas installé
|
|
echo Téléchargez Ollama depuis https://ollama.com/download/windows
|
|
)
|
|
|
|
REM Créer les dossiers nécessaires
|
|
if not exist data mkdir data
|
|
if not exist logs mkdir logs
|
|
if not exist presets mkdir presets
|
|
if not exist history mkdir history
|
|
|
|
echo.
|
|
echo Installation terminée ! Pour lancer LLM Lab:
|
|
echo - Activez l'environnement: venv\Scripts\activate
|
|
echo - Lancez l'interface GUI: run.bat gui
|
|
echo - Lancez le moniteur: run.bat monitor
|
|
echo.
|
|
|
|
endlocal
|
|
```
|
|
|
|
## Configuration des modèles Ollama
|
|
|
|
Pour optimiser les performances des modèles, créez des fichiers Modelfile pour chaque modèle:
|
|
|
|
### Modelfile pour modèles Llama 3 (exemple)
|
|
|
|
```
|
|
FROM llama3:latest
|
|
|
|
# Optimisations pour Windows
|
|
PARAMETER temperature 0.7
|
|
PARAMETER num_ctx 8192
|
|
PARAMETER num_gpu 100
|
|
PARAMETER num_thread 8
|
|
PARAMETER num_batch 512
|
|
```
|
|
|
|
Pour appliquer:
|
|
```cmd
|
|
ollama create llama3-optimized -f Modelfile
|
|
```
|
|
|
|
## Monitoring des performances
|
|
|
|
Pour un monitoring plus précis sous Windows, ajoutez ces fonctions à `system_monitor.py`:
|
|
|
|
```python
|
|
def _get_windows_process_info(self, process_name):
|
|
"""Récupère les informations d'un processus Windows"""
|
|
if platform.system() != "Windows":
|
|
return None
|
|
|
|
import wmi
|
|
computer = wmi.WMI()
|
|
|
|
processes = []
|
|
for process in computer.Win32_Process():
|
|
if process_name.lower() in process.Name.lower():
|
|
processes.append({
|
|
'pid': process.ProcessId,
|
|
'name': process.Name,
|
|
'cpu': 0, # À calculer
|
|
'memory': float(process.WorkingSetSize) / (1024 * 1024) # MB
|
|
})
|
|
|
|
return processes
|
|
|
|
def _get_ollama_performance(self):
|
|
"""Récupère les performances d'Ollama"""
|
|
processes = []
|
|
|
|
if platform.system() == "Windows":
|
|
processes = self._get_windows_process_info("ollama")
|
|
else:
|
|
# Code Linux existant
|
|
pass
|
|
|
|
return processes
|
|
```
|
|
|
|
## Test de la migration
|
|
|
|
Créez un script `test_windows.py` pour vérifier que tout fonctionne correctement:
|
|
|
|
```python
|
|
import os
|
|
import platform
|
|
import psutil
|
|
import tkinter as tk
|
|
import requests
|
|
|
|
def check_system():
|
|
print(f"Système: {platform.system()} {platform.release()}")
|
|
print(f"Python: {platform.python_version()}")
|
|
|
|
# Vérifier RAM
|
|
ram = psutil.virtual_memory()
|
|
print(f"RAM: {ram.total / (1024**3):.1f} GB")
|
|
|
|
# Vérifier GPU
|
|
try:
|
|
import wmi
|
|
computer = wmi.WMI()
|
|
for gpu in computer.Win32_VideoController():
|
|
print(f"GPU: {gpu.Name}")
|
|
except:
|
|
print("Erreur lors de la détection du GPU via WMI")
|
|
|
|
# Vérifier Ollama
|
|
try:
|
|
response = requests.get("http://localhost:11434/api/tags")
|
|
if response.status_code == 200:
|
|
print("Ollama: En ligne")
|
|
models = response.json().get("models", [])
|
|
print(f"Modèles installés: {len(models)}")
|
|
for model in models:
|
|
print(f" - {model.get('name')}")
|
|
else:
|
|
print(f"Ollama: Erreur {response.status_code}")
|
|
except:
|
|
print("Ollama: Hors ligne")
|
|
|
|
# Vérifier Tkinter
|
|
try:
|
|
root = tk.Tk()
|
|
root.title("Test Tkinter")
|
|
tk.Label(root, text="Tkinter fonctionne correctement").pack(padx=20, pady=20)
|
|
print("Tkinter: OK")
|
|
return root
|
|
except:
|
|
print("Tkinter: Erreur")
|
|
return None
|
|
|
|
if __name__ == "__main__":
|
|
print("=== Test d'installation LLM Lab sur Windows ===")
|
|
root = check_system()
|
|
if root:
|
|
print("\nTout est correctement configuré!")
|
|
print("Fermer la fenêtre Tkinter pour terminer le test.")
|
|
root.mainloop()
|
|
else:
|
|
print("\nDes erreurs ont été détectées dans l'installation.")
|
|
```
|
|
|
|
## Recommandations spécifiques pour Windows
|
|
|
|
1. **Performances optimales**:
|
|
- Réglez le plan d'alimentation sur "Hautes performances"
|
|
- Désactivez l'économiseur d'écran et la mise en veille pendant l'utilisation
|
|
|
|
2. **GPU NVIDIA**:
|
|
- Utilisez le Panneau de configuration NVIDIA pour régler les performances sur "Préférer les performances maximales"
|
|
- Mettez à jour les pilotes régulièrement
|
|
|
|
3. **Antivirus**:
|
|
- Ajoutez le dossier LLM_Lab aux exceptions de l'antivirus
|
|
- Excluez `ollama.exe` du scan en temps réel |