Dom/Geniusia_v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
Geniusia_v2/.kiro/specs/embedding-improvement/tasks.md
Dom dcd4de9945 Initial commit
2026-03-05 00:20:25 +01:00

12 KiB
Raw Permalink Blame History

Implementation Plan - Amélioration du Système d'Embeddings et Fine-tuning

Phase 1: Fix FAISS et Abstraction de Base

  • 1. Créer l'abstraction EmbedderBase

    • Créer geniusia2/core/embedders/__init__.py
    • Créer geniusia2/core/embedders/base.py avec classe abstraite EmbedderBase
    • Définir méthodes: embed(), get_dimension(), get_model_name(), supports_batch(), embed_batch()
    • Ajouter docstrings complètes
    • Requirements: 2.1, 2.2

  • 2. Implémenter CLIPEmbedder

    • Créer geniusia2/core/embedders/clip_embedder.py
    • Wrapper autour du code CLIP existant dans vision_analysis.py
    • Implémenter toutes les méthodes de EmbedderBase
    • Gérer GPU/CPU automatiquement
    • Normaliser les embeddings (L2 norm)
    • Requirements: 2.1, 2.2, 2.5, 6.4

  • 3. Créer FAISSIndex corrigé

    • Créer geniusia2/core/embedders/faiss_index.py
    • Implémenter add() avec validation de dimension
    • Implémenter search() avec conversion distance→similarity
    • Implémenter save() et load() avec metadata
    • Implémenter rebuild_if_needed() pour changement de dimension
    • Gérer les cas d'erreur (dimension mismatch, fichier corrompu)
    • Requirements: 1.1, 1.2, 1.3, 1.4, 1.5

  • * 3.1 Écrire tests unitaires pour FAISSIndex

    • Test add/search avec différentes dimensions
    • Test save/load round-trip
    • Test rebuild sur changement de dimension
    • Test gestion d'erreurs
    • Requirements: 1.1, 1.2, 1.3, 1.4, 1.5

  • * 3.2 Écrire test de propriété pour FAISS round-trip

    • Property 2: FAISS Index Persistence Round-trip
    • Validates: Requirements 1.3, 1.4
    • Générer embeddings aléatoires, sauvegarder, charger, vérifier résultats identiques

  • 4. Créer EmbeddingManager

    • Créer geniusia2/core/embedders/embedding_manager.py
    • Implémenter sélection de modèle avec fallback
    • Implémenter cache LRU manuel (1000 entrées)
    • Utiliser hash MD5 de l'image comme clé de cache
    • Logger le modèle chargé au démarrage
    • Requirements: 2.3, 2.4, 6.1, 6.2, 7.1, 7.3

  • * 4.1 Écrire tests pour EmbeddingManager

    • Test sélection de modèle
    • Test fallback sur erreur
    • Test cache hit/miss
    • Test éviction LRU
    • Requirements: 2.4, 6.1, 6.2

  • * 4.2 Écrire test de propriété pour cache consistency

    • Property 4: Cache Hit Consistency
    • Validates: Requirements 6.1
    • Générer images aléatoires, embedder 2x, vérifier résultats identiques

  • 5. Intégrer dans vision_analysis.py

    • Remplacer le code CLIP direct par EmbeddingManager
    • Ajouter paramètre de config pour choisir le modèle (clip/pix2struct)
    • Migrer les embeddings existants si nécessaire
    • Maintenir backward compatibility
    • Requirements: 2.3, 2.4

  • 6. Intégrer dans workflow_matcher.py

    • Utiliser EmbeddingManager au lieu de CLIP direct
    • Utiliser FAISSIndex pour les recherches de similarité
    • Gérer le cas où l'index n'existe pas encore
    • Requirements: 1.1, 1.2

  • 7. Checkpoint - Tester le système de base

    • Lancer l'application en mode Assist
    • Vérifier que les embeddings sont générés correctement
    • Vérifier que FAISS fonctionne sans erreurs de dimension
    • Vérifier que le cache fonctionne
    • Tester save/load de l'index FAISS
    • Ensure all tests pass, ask the user if questions arise.

Phase 2: Ajouter Pix2Struct

  • 8. Installer dépendances Pix2Struct

    • Ajouter transformers>=4.35.0 à requirements
    • Ajouter sentencepiece à requirements
    • Créer script d'installation install_pix2struct.sh
    • Tester l'installation sur la machine cible
    • Requirements: 3.1

  • 9. Implémenter Pix2StructEmbedder

    • Créer geniusia2/core/embedders/pix2struct_embedder.py
    • Charger le modèle google/pix2struct-base
    • Extraire les hidden states de l'encoder comme embeddings
    • Normaliser les embeddings (L2 norm)
    • Gérer GPU/CPU automatiquement
    • Implémenter toutes les méthodes de EmbedderBase
    • Requirements: 3.1, 3.2, 3.3, 3.5

  • * 9.1 Écrire tests pour Pix2StructEmbedder

    • Test chargement du modèle
    • Test génération d'embeddings
    • Test dimension consistency
    • Test GPU/CPU switching
    • Requirements: 3.1, 3.2, 3.3

  • * 9.2 Écrire test de propriété pour interface compatibility

    • Property 3: Embedder Interface Compatibility
    • Validates: Requirements 2.1, 2.2, 2.5
    • Tester CLIP et Pix2Struct avec images PIL aléatoires, vérifier format de sortie

  • 10. Tester Pix2Struct vs CLIP

    • Créer script de benchmark test_pix2struct_vs_clip.py
    • Comparer la qualité des embeddings sur des screenshots UI
    • Mesurer les performances (temps, mémoire)
    • Documenter les résultats
    • Requirements: 3.4, 6.5

  • 11. Ajouter configuration pour sélection de modèle

    • Ajouter paramètre embedding_model dans config
    • Valeurs possibles: "clip", "pix2struct"
    • Défaut: "clip" (pour compatibilité)
    • Documenter dans README
    • Requirements: 2.3, 7.1

  • 12. Checkpoint - Tester Pix2Struct

    • Lancer avec embedding_model=pix2struct
    • Vérifier que le modèle charge correctement
    • Comparer la précision du matching avec CLIP
    • Vérifier le fallback si Pix2Struct échoue
    • Ensure all tests pass, ask the user if questions arise.

Phase 3: Fine-tuning Léger

  • 13. Créer LightweightFineTuner

    • Créer geniusia2/core/embedders/fine_tuner.py
    • Implémenter collection d'exemples positifs/négatifs (deque maxlen=1000)
    • Implémenter trigger automatique tous les 10 exemples
    • Implémenter exécution en thread séparé
    • Implémenter sauvegarde/chargement de checkpoint
    • Requirements: 4.1, 4.2, 4.3, 5.1, 5.5

  • * 13.1 Écrire tests pour LightweightFineTuner

    • Test collection d'exemples
    • Test trigger threshold
    • Test thread séparé (non-blocking)
    • Test checkpoint save/load
    • Requirements: 4.1, 4.2, 4.3, 5.1

  • * 13.2 Écrire test de propriété pour example collection bounds

    • Property 7: Example Collection Bounds
    • Validates: Requirements 4.1, 4.2
    • Ajouter N exemples aléatoires (N > 1000), vérifier que len <= 1000

  • * 13.3 Écrire test de propriété pour fine-tuning non-blocking

    • Property 6: Fine-tuning Non-blocking
    • Validates: Requirements 5.1, 5.2
    • Lancer fine-tuning, vérifier que embed() continue de fonctionner

  • 14. Implémenter fine-tuning pour CLIPEmbedder

    • Ajouter méthode fine_tune() à CLIPEmbedder
    • Utiliser contrastive loss (positifs vs négatifs)
    • Fine-tuner uniquement la dernière couche de projection
    • Utiliser learning rate faible (1e-4)
    • Limiter à 1 epoch pour rapidité
    • Retourner métriques (loss, accuracy)
    • Requirements: 4.4, 5.2, 5.3, 7.2

  • 15. Implémenter fine-tuning pour Pix2StructEmbedder

    • Ajouter méthode fine_tune() à Pix2StructEmbedder
    • Utiliser contrastive loss (positifs vs négatifs)
    • Fine-tuner uniquement la dernière couche de l'encoder
    • Utiliser learning rate faible (1e-4)
    • Limiter à 1 epoch pour rapidité
    • Retourner métriques (loss, accuracy)
    • Requirements: 4.4, 5.2, 5.3, 7.2

  • 16. Intégrer fine-tuning dans Orchestrator

    • Ajouter LightweightFineTuner à l'orchestrator
    • Appeler add_positive_example() quand workflow accepté et réussi
    • Appeler add_negative_example() quand workflow rejeté
    • Sauvegarder checkpoint à l'arrêt
    • Charger checkpoint au démarrage
    • Requirements: 4.1, 4.2, 5.5

  • 17. Ajouter logging et métriques

    • Logger le début/fin du fine-tuning
    • Logger les métriques (loss, accuracy, durée)
    • Logger le nombre d'exemples collectés
    • Créer fichier de log dédié fine_tuning.log
    • Requirements: 7.2, 7.3

  • 18. Checkpoint Final - Tester le système complet

    • Lancer l'application en mode Assist
    • Accepter plusieurs workflows → vérifier collection d'exemples positifs
    • Rejeter plusieurs workflows → vérifier collection d'exemples négatifs
    • Attendre le trigger (10 exemples) → vérifier que fine-tuning démarre
    • Vérifier que l'application continue de fonctionner pendant le fine-tuning
    • Vérifier que les métriques sont loggées
    • Vérifier que le modèle s'améliore après fine-tuning
    • Ensure all tests pass, ask the user if questions arise.

Phase 4: Optimisations et Outils

  • 19. Optimiser les performances

    • Implémenter batch processing pour embed_batch()
    • Optimiser le cache (utiliser hash plus rapide si nécessaire)
    • Profiler les performances (temps, mémoire)
    • Ajuster les paramètres si nécessaire
    • Requirements: 6.3, 6.4, 6.5

  • * 19.1 Écrire tests de performance

    • Mesurer temps d'embedding (GPU vs CPU)
    • Mesurer temps de recherche FAISS
    • Mesurer temps de fine-tuning
    • Vérifier que les seuils sont respectés
    • Requirements: 6.5

  • 20. Créer outils de visualisation

    • Créer script visualize_embeddings.py
    • Utiliser t-SNE ou UMAP pour visualiser les embeddings
    • Afficher les clusters de workflows similaires
    • Comparer CLIP vs Pix2Struct visuellement
    • Requirements: 7.5

  • 21. Créer outils de debugging

    • Créer script debug_embeddings.py
    • Afficher les embeddings pour une image donnée
    • Afficher les résultats de recherche FAISS
    • Afficher l'historique de fine-tuning
    • Requirements: 7.4, 7.5

  • 22. Documentation finale

    • Documenter l'architecture dans README
    • Documenter comment choisir entre CLIP et Pix2Struct
    • Documenter le système de fine-tuning
    • Créer guide de troubleshooting
    • Requirements: All

Phase 5: Intégration dans l'Orchestrator

  • 23. Intégrer le système d'embeddings dans l'Orchestrator

    • Créer méthode _init_new_embedding_system()
    • Initialiser EmbeddingManager, FAISSIndex, LightweightFineTuner
    • Charger les checkpoints au démarrage
    • Gérer les erreurs d'initialisation
    • Requirements: All

  • 24. Implémenter l'indexation automatique des workflows

    • Créer méthode _index_workflow_in_faiss()
    • Convertir screenshots en embeddings
    • Indexer dans FAISS avec metadata
    • Logger les opérations
    • Requirements: 1.1, 1.2, 1.3

  • 25. Implémenter la collection d'exemples pour fine-tuning

    • Créer méthode _add_positive_example_for_finetuning()
    • Créer méthode _add_negative_example_for_finetuning()
    • Connecter aux callbacks de suggestions
    • Gérer la conversion d'images
    • Requirements: 4.1, 4.2, 5.1

  • 26. Implémenter la sauvegarde à l'arrêt

    • Créer méthode _save_embedding_system_on_shutdown()
    • Attendre la fin du fine-tuning en cours
    • Sauvegarder l'index FAISS
    • Sauvegarder le checkpoint du fine-tuner
    • Logger les statistiques
    • Requirements: 1.3, 5.5

  • 27. Créer tests d'intégration

    • Test d'initialisation du système
    • Test d'indexation de workflows
    • Test de collection d'exemples positifs/négatifs
    • Test du cache
    • Test de sauvegarde/chargement
    • Requirements: All

  • 28. Créer script de vérification

    • Vérifier l'installation de FAISS
    • Vérifier l'import des modules
    • Lancer les tests d'intégration
    • Vérifier les fichiers créés
    • Vérifier la documentation
    • Requirements: All

  • 29. Documentation de l'intégration

    • Créer EMBEDDING_SYSTEM_INTEGRATED.md
    • Documenter l'architecture complète
    • Documenter l'utilisation
    • Documenter le monitoring
    • Créer guide de troubleshooting
    • Requirements: All

Statut Final

✅ INTÉGRATION COMPLÈTE

Le système d'embeddings est maintenant complètement intégré dans GeniusIA v2 :

  • ✅ Tous les composants sont implémentés
  • ✅ Tous les tests passent
  • ✅ La documentation est complète
  • ✅ Le système est prêt pour la production

Date de complétion : 20 novembre 2024

Reference in New Issue View Git Blame Copy Permalink