Initial commit

archive/old_docs/ETAT_DONNEES_ET_SOLUTIONS.md

@@ -0,0 +1,204 @@
+# 📊 État des Données et Solutions
+
+## 🔍 Diagnostic Effectué
+
+### ✅ Ce qui fonctionne
+
+1. **105 tâches créées** dans `data/user_profiles/`
+   - Chaque tâche a un `metadata.json`
+   - Chaque tâche a un `signatures.pkl`
+   - Les embeddings CLIP sont **présents** dans les signatures
+
+2. **Logs fonctionnels**
+   - 6 fichiers de logs chiffrés (1 MB total)
+   - Logs quotidiens depuis le 13/11
+
+3. **Capture d'événements**
+   - Screenshots capturés en mémoire
+   - Embeddings générés avec CLIP
+   - Patterns détectés correctement
+
+### ❌ Ce qui manque
+
+1. **Index FAISS non créé**
+   - `data/faiss_index/embeddings.index` ❌ Absent
+   - `data/faiss_index/metadata.pkl` ❌ Absent
+   - **Raison** : `embeddings_manager.save_index()` n'est jamais appelé
+
+2. **Screenshots non sauvegardés sur disque**
+   - Pas de dossier `screenshots/` dans les tâches
+   - **Raison** : Les screenshots restent en mémoire uniquement
+
+## 🔧 Solutions
+
+### Solution 1 : Reconstruire l'index FAISS
+
+Les embeddings existent dans les `signatures.pkl`, on peut reconstruire l'index :
+
+```bash
+python3 rebuild_faiss_index.py
+```
+
+Ce script va :
+1. ✅ Parcourir toutes les tâches
+2. ✅ Extraire les embeddings des signatures
+3. ✅ Créer l'index FAISS
+4. ✅ Sauvegarder `embeddings.index` et `metadata.pkl`
+5. ✅ Tester la recherche
+
+**Résultat attendu** :
+- Index FAISS créé avec ~315 embeddings (105 tâches × 3 actions)
+- Recherche de similarité fonctionnelle
+- Prêt pour le rejeu intelligent
+
+### Solution 2 : Sauvegarder les screenshots (optionnel)
+
+Les screenshots ne sont pas strictement nécessaires car :
+- ✅ Les embeddings CLIP capturent l'information visuelle
+- ✅ Le rejeu utilise les embeddings, pas les images brutes
+
+Mais si tu veux les sauvegarder pour debug/visualisation :
+
+#### Modifier `learning_manager.py` :
+
+```python
+def _save_task(self, task: TaskProfile):
+    """Sauvegarde une tâche sur disque."""
+    import json
+    import pickle
+    from pathlib import Path
+    from PIL import Image
+    
+    task_dir = self.profiles_path / task.task_id
+    task_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Créer le dossier screenshots
+    screenshots_dir = task_dir / "screenshots"
+    screenshots_dir.mkdir(exist_ok=True)
+    
+    # Sauvegarder les métadonnées
+    metadata = {
+        "task_id": task.task_id,
+        "task_name": task.task_name,
+        "window_whitelist": task.window_whitelist,
+        "observation_count": task.observation_count,
+        "mode": task.mode,
+        "confidence_score": task.confidence_score
+    }
+    
+    with open(task_dir / "metadata.json", "w") as f:
+        json.dump(metadata, f, indent=2)
+    
+    # Sauvegarder les signatures ET screenshots
+    if "signatures" in task.metadata:
+        signatures = task.metadata["signatures"]
+        
+        # Sauvegarder les screenshots séparément
+        for i, sig in enumerate(signatures):
+            if "screenshot" in sig and sig["screenshot"] is not None:
+                screenshot = sig["screenshot"]
+                screenshot_path = screenshots_dir / f"action_{i}.png"
+                
+                # Convertir numpy array en image PIL si nécessaire
+                if isinstance(screenshot, np.ndarray):
+                    screenshot = Image.fromarray(screenshot)
+                
+                screenshot.save(screenshot_path)
+                
+                # Remplacer le screenshot par le chemin dans la signature
+                sig["screenshot_path"] = str(screenshot_path)
+                del sig["screenshot"]  # Libérer la mémoire
+        
+        # Sauvegarder les signatures (sans les screenshots en mémoire)
+        with open(task_dir / "signatures.pkl", "wb") as f:
+            pickle.dump(signatures, f)
+```
+
+### Solution 3 : Appeler save_index() automatiquement
+
+#### Modifier `orchestrator.py` ou `event_capture.py` :
+
+```python
+# Après la création d'une tâche
+task = self.learning_manager.create_task_from_signatures(...)
+
+# Sauvegarder l'index FAISS
+self.embeddings_manager.save_index()
+```
+
+Ou ajouter dans `learning_manager.py` :
+
+```python
+def _save_task(self, task: TaskProfile):
+    # ... code existant ...
+    
+    # Sauvegarder l'index FAISS après chaque tâche
+    if hasattr(self, 'embeddings_manager'):
+        self.embeddings_manager.save_index()
+```
+
+## 📊 Impact sur le Système
+
+### Avec l'index FAISS reconstruit :
+
+✅ **Recherche de similarité** fonctionnelle
+✅ **Suggestions d'actions** possibles
+✅ **Rejeu intelligent** amélioré
+✅ **Performance** optimisée (recherche rapide)
+
+### Sans les screenshots sur disque :
+
+⚠️ **Pas d'impact majeur** car :
+- Les embeddings CLIP contiennent l'information visuelle
+- Le rejeu utilise les embeddings pour localiser les éléments
+- Les screenshots en mémoire suffisent pendant la capture
+
+💡 **Recommandation** : Sauvegarder les screenshots uniquement pour :
+- Debug et visualisation
+- Ré-entraînement des modèles
+- Audit et traçabilité
+
+## 🚀 Actions Recommandées
+
+### Priorité 1 : Reconstruire l'index FAISS ⭐⭐⭐
+
+```bash
+python3 rebuild_faiss_index.py
+```
+
+**Temps** : ~30 secondes  
+**Impact** : Critique pour le rejeu intelligent
+
+### Priorité 2 : Ajouter save_index() automatique ⭐⭐
+
+Modifier le code pour appeler `save_index()` après chaque tâche créée.
+
+**Temps** : 5 minutes  
+**Impact** : Évite de devoir reconstruire l'index
+
+### Priorité 3 : Sauvegarder les screenshots ⭐
+
+Optionnel, utile pour debug.
+
+**Temps** : 15 minutes  
+**Impact** : Faible (nice to have)
+
+## 📝 Résumé
+
+| Élément | État | Solution | Priorité |
+|---------|------|----------|----------|
+| Embeddings | ✅ Présents | Aucune | - |
+| Index FAISS | ❌ Manquant | `rebuild_faiss_index.py` | ⭐⭐⭐ |
+| Screenshots | ⚠️ En mémoire | Modifier `_save_task()` | ⭐ |
+| Logs | ✅ Fonctionnels | Aucune | - |
+| Tâches | ✅ Sauvegardées | Aucune | - |
+
+## 🎯 Conclusion
+
+Le système **fonctionne** mais l'index FAISS n'a jamais été créé. C'est facile à corriger :
+
+1. **Court terme** : Exécuter `rebuild_faiss_index.py` pour créer l'index
+2. **Moyen terme** : Modifier le code pour appeler `save_index()` automatiquement
+3. **Long terme** : Ajouter la sauvegarde des screenshots si nécessaire
+
+**Le rejeu intelligent fonctionnera mieux avec l'index FAISS !** 🚀