Geniusia_v2/docs/archive/old-summaries/INTEGRATION_SUMMARY.md

Résumé de l'Intégration du Nouveau Système d'Embeddings

📊 État Actuel

Le système d'embeddings est prêt et testé (100% tests passed), mais pas encore intégré dans l'application.

Ce qui existe déjà:

• ✅ Nouveau système: geniusia2/core/embedders/ (CLIP, FAISS, Fine-tuning)
• ✅ Ancien système: geniusia2/core/embeddings_manager.py (actuellement utilisé)
• ✅ Compatibilité: vision_analysis.py supporte les deux systèmes

Où l'ancien système est utilisé:

1. Orchestrator.__init__() → learning_manager.embeddings_manager
2. VisionAnalysis → Reçoit embeddings_manager en paramètre
3. VisionSearch → Utilise embeddings_manager
4. SuggestionManager → Utilise embeddings_manager
5. TaskReplayEngine → Utilise embeddings_manager

🎯 Plan d'Intégration (2 Options)

Option A: Migration Complète (Recommandé à terme)

Remplacer complètement l'ancien système par le nouveau.

Avantages:

• Bénéficie de toutes les améliorations (cache, fine-tuning, FAISS corrigé)
• Code plus propre
• Meilleure performance

Inconvénients:

• Plus de changements
• Risque de régression

Durée: 2-3 heures

Option B: Coexistence (Recommandé pour tests)

Garder l'ancien système, ajouter le nouveau en parallèle pour tests.

Avantages:

• Pas de régression possible
• Facile à rollback
• Permet de comparer

Inconvénients:

• Deux systèmes en parallèle
• Plus de mémoire

Durée: 30 minutes

🚀 Recommandation: Option B pour Commencer

Étape 1: Ajouter le nouveau système sans toucher l'ancien

# Dans Orchestrator.__init__(), ajouter:

# Nouveau système d'embeddings (en parallèle)
from .embedders import EmbeddingManager as NewEmbeddingManager, FAISSIndex, LightweightFineTuner

self.new_embedding_manager = NewEmbeddingManager(
    model_name="clip",
    cache_size=1000,
    fallback_enabled=True
)

self.faiss_index = FAISSIndex(self.new_embedding_manager.get_dimension())

self.fine_tuner = LightweightFineTuner(
    embedder=self.new_embedding_manager.embedder,
    trigger_threshold=10,
    max_examples=1000
)

# Charger checkpoint si existe
self.fine_tuner.load_checkpoint("orchestrator_finetuning")

# Charger index FAISS si existe
try:
    self.faiss_index.load("data/workflow_embeddings")
    self.logger.log_action({
        "action": "faiss_index_loaded",
        "num_embeddings": len(self.faiss_index)
    })
except FileNotFoundError:
    self.logger.log_action({
        "action": "faiss_index_not_found",
        "note": "Will create new index"
    })

Étape 2: Connecter aux événements workflow

# Dans _on_suggestion_accepted (quand workflow accepté)
def _on_suggestion_accepted(self, suggestion):
    # ... code existant ...
    
    # Ajouter exemple positif pour fine-tuning
    if hasattr(self, 'fine_tuner') and self.current_frame is not None:
        from PIL import Image
        import cv2
        
        # Convertir numpy BGR → PIL RGB
        frame_rgb = cv2.cvtColor(self.current_frame, cv2.COLOR_BGR2RGB)
        pil_image = Image.fromarray(frame_rgb)
        
        self.fine_tuner.add_positive_example(
            image=pil_image,
            workflow_id=suggestion.get('workflow_id', 'unknown'),
            metadata={'timestamp': time.time()}
        )

# Dans _on_suggestion_rejected (quand workflow rejeté)
def _on_suggestion_rejected(self, suggestion):
    # ... code existant ...
    
    # Ajouter exemple négatif pour fine-tuning
    if hasattr(self, 'fine_tuner') and self.current_frame is not None:
        from PIL import Image
        import cv2
        
        frame_rgb = cv2.cvtColor(self.current_frame, cv2.COLOR_BGR2RGB)
        pil_image = Image.fromarray(frame_rgb)
        
        self.fine_tuner.add_negative_example(
            image=pil_image,
            workflow_id=suggestion.get('workflow_id', 'unknown'),
            metadata={'timestamp': time.time()}
        )

Étape 3: Sauvegarder à l'arrêt

# Dans stop() ou shutdown()
def stop(self):
    # ... code existant ...
    
    # Sauvegarder fine-tuning
    if hasattr(self, 'fine_tuner'):
        self.fine_tuner.wait_for_training(timeout=30)
        self.fine_tuner.save_checkpoint("orchestrator_finetuning")
        self.logger.log_action({
            "action": "fine_tuner_checkpoint_saved",
            "stats": self.fine_tuner.get_stats()
        })
    
    # Sauvegarder FAISS
    if hasattr(self, 'faiss_index') and len(self.faiss_index) > 0:
        self.faiss_index.save("data/workflow_embeddings")
        self.logger.log_action({
            "action": "faiss_index_saved",
            "num_embeddings": len(self.faiss_index)
        })

📝 Modifications Minimales Nécessaires

Fichier: geniusia2/core/orchestrator.py

Lignes à ajouter:

1. Import (ligne ~20): from .embedders import EmbeddingManager as NewEmbeddingManager, FAISSIndex, LightweightFineTuner
2. Init (ligne ~150): Initialiser les 3 composants
3. Callbacks (lignes ~400-500): Ajouter exemples au fine-tuner
4. Stop (ligne ~600): Sauvegarder checkpoints

Total: ~50 lignes de code à ajouter

🧪 Tests Après Intégration

Test 1: Vérifier l'initialisation

python geniusia2/main.py --mode assist
# Vérifier dans les logs:
# - "new_embedding_manager initialized"
# - "faiss_index loaded" ou "faiss_index_not_found"
# - "fine_tuner initialized"

Test 2: Accepter un workflow

1. Lancer en mode Assist
2. Faire une action
3. Accepter la suggestion
4. Vérifier logs: "positive_example_added"

Test 3: Rejeter un workflow

1. Faire une action
2. Rejeter la suggestion
3. Vérifier logs: "negative_example_added"

Test 4: Trigger fine-tuning

1. Accepter/rejeter 10 workflows
2. Vérifier logs: "fine_tuning_started"
3. Attendre fin: "fine_tuning_complete"

Test 5: Persistence

1. Arrêter l'application (Ctrl+C)
2. Vérifier logs: "checkpoint_saved", "faiss_index_saved"
3. Relancer
4. Vérifier logs: "checkpoint_loaded"

⚠️ Points d'Attention

1. Mémoire: Le nouveau système ajoute ~2.5GB (CLIP + cache + FAISS)
2. Performance: Première génération d'embedding: 240ms, puis cache: <1ms
3. Thread: Fine-tuning tourne en background, ne bloque pas
4. Compatibilité: L'ancien système continue de fonctionner normalement

🎯 Prochaines Étapes

1. ✅ Intégrer (Option B) - 30 min
2. ✅ Tester en conditions réelles - 1h
3. ⏭️ Décider: Garder les deux ou migrer complètement
4. ⏭️ Monitorer les métriques de fine-tuning
5. ⏭️ Optimiser si nécessaire

📊 Métriques à Surveiller

# Ajouter dans les métriques de l'Orchestrator
self.metrics.update({
    "embedding_cache_hit_rate": 0.0,
    "fine_tuning_count": 0,
    "faiss_index_size": 0,
    "positive_examples": 0,
    "negative_examples": 0
})

# Mettre à jour périodiquement
if hasattr(self, 'new_embedding_manager'):
    stats = self.new_embedding_manager.get_stats()
    self.metrics["embedding_cache_hit_rate"] = stats['cache_hit_rate']

if hasattr(self, 'fine_tuner'):
    stats = self.fine_tuner.get_stats()
    self.metrics["fine_tuning_count"] = stats['training_count']
    self.metrics["positive_examples"] = stats['positive_examples']
    self.metrics["negative_examples"] = stats['negative_examples']

✅ Prêt à Intégrer !

Le système est prêt, documenté, testé. L'intégration est simple et sans risque (Option B).

On peut commencer quand tu veux ! 🚀