rpa_vision_v3/docs/archive/misc/NEXT_SESSION.md

Prochaine Session - Guide de Reprise

Date de cette note: 22 Novembre 2024
Status actuel: Phase 2 - Task 2.8 COMPLÉTÉE ✅

Résumé Rapide

✅ CLIP Embedders sont fonctionnels et testés

Les embedders CLIP (ViT-B-32, 512D) fonctionnent correctement pour:

• Embedding de texte
• Embedding d'image
• Similarité cosinus
• Batch processing (manuel)

Prochaine Task: 2.9 - Intégrer CLIP dans StateEmbeddingBuilder

Objectif

Remplacer les vecteurs aléatoires actuels dans StateEmbeddingBuilder par de vrais embeddings CLIP.

Fichiers à Modifier

1. rpa_vision_v3/core/embedding/state_embedding_builder.py
   • Ajouter support pour CLIP embedders
   • Adapter pour la structure actuelle de ScreenState
   • Gérer conversion PIL.Image pour screenshots

Approche Recommandée

Option 1: Adapter le StateEmbeddingBuilder Existant

Modifier le fichier actuel pour:

1. Accepter un CLIPEmbedder en paramètre
2. Utiliser embed_text() et embed_image() au lieu de vecteurs aléatoires
3. Gérer la conversion des chemins de fichiers en PIL.Image

Option 2: Créer une Version Simplifiée

Créer un nouveau fichier simple_state_embedding_builder.py qui:

1. Prend un ScreenState simple (avec screenshot_path, window_title, ui_elements)
2. Utilise directement le CLIPEmbedder
3. Retourne un StateEmbedding avec vecteur fusionné

Recommandation: Option 2 pour avancer rapidement, puis migrer vers Option 1.

Code de Démarrage

# rpa_vision_v3/core/embedding/simple_state_embedding_builder.py

from typing import Optional
from pathlib import Path
import numpy as np
from PIL import Image

from .clip_embedder import CLIPEmbedder, create_clip_embedder
from .fusion_engine import FusionEngine
from ..models.state_embedding import StateEmbedding

class SimpleStateEmbeddingBuilder:
    """Version simplifiée du StateEmbeddingBuilder avec CLIP."""
    
    def __init__(self, 
                 clip_embedder: Optional[CLIPEmbedder] = None,
                 fusion_engine: Optional[FusionEngine] = None):
        self.clip_embedder = clip_embedder or create_clip_embedder()
        self.fusion_engine = fusion_engine or FusionEngine()
    
    def build_embedding(self, screen_state) -> StateEmbedding:
        """Construire un State Embedding depuis un ScreenState."""
        
        embeddings = {}
        
        # 1. Image embedding
        if screen_state.screenshot_path:
            img = Image.open(screen_state.screenshot_path)
            embeddings["image"] = self.clip_embedder.embed_image(img)
        
        # 2. Title embedding
        if screen_state.window_title:
            embeddings["title"] = self.clip_embedder.embed_text(screen_state.window_title)
        
        # 3. Text embedding (from UI elements)
        texts = [el.label for el in screen_state.ui_elements if el.label]
        if texts:
            combined_text = " ".join(texts[:10])  # Limit to 10
            embeddings["text"] = self.clip_embedder.embed_text(combined_text)
        
        # 4. UI embedding (from UI element types/roles)
        ui_descriptions = [f"{el.type} {el.role}" for el in screen_state.ui_elements[:20]]
        if ui_descriptions:
            ui_text = " ".join(ui_descriptions)
            embeddings["ui"] = self.clip_embedder.embed_text(ui_text)
        
        # Fusion
        return self.fusion_engine.create_state_embedding(
            embedding_id=f"state_{screen_state.timestamp}",
            embeddings=embeddings,
            metadata={"window_title": screen_state.window_title}
        )

Test à Créer

# rpa_vision_v3/examples/test_simple_state_embedding.py

from core.embedding.simple_state_embedding_builder import SimpleStateEmbeddingBuilder
from core.models.screen_state import ScreenState
from core.models.ui_element import UIElement, UIElementEmbeddings, VisualFeatures

# Créer un ScreenState de test
screen_state = ScreenState(
    timestamp=1700000000.0,
    window_title="Test App",
    screenshot_path="examples/test_synthetic_ui.png",
    ui_elements=[
        UIElement(
            element_id="btn1",
            type="button",
            role="primary_action",
            bbox=(50, 50, 150, 90),
            center=(100, 70),
            label="Login",
            label_confidence=0.9,
            embeddings=UIElementEmbeddings(),
            visual_features=VisualFeatures(
                dominant_color="#0066cc",
                has_icon=False,
                shape="rounded_rectangle",
                size_category="medium"
            ),
            confidence=0.9
        )
    ],
    screen_size=(800, 600)
)

# Construire l'embedding
builder = SimpleStateEmbeddingBuilder()
state_embedding = builder.build_embedding(screen_state)

print(f"✓ State Embedding: {state_embedding.fused_vector.shape}")
print(f"✓ Components: {list(state_embedding.component_vectors.keys())}")

Commandes Rapides

# Activer venv
source geniusia2/venv/bin/activate

# Tester CLIP
bash rpa_vision_v3/test_clip.sh

# Lancer tests unitaires
cd rpa_vision_v3
pytest tests/

# Voir les tasks
cat rpa_vision_v3/docs/specs/tasks.md

Fichiers Importants

Documentation

• rpa_vision_v3/PHASE2_CLIP_COMPLETE.md - Status Phase 2
• rpa_vision_v3/SESSION_22NOV_CLIP.md - Notes de session
• rpa_vision_v3/docs/specs/tasks.md - Task list complète

Code Core

• rpa_vision_v3/core/embedding/clip_embedder.py - CLIP embedder (geniusia2)
• rpa_vision_v3/core/embedding/fusion_engine.py - Fusion multi-modale
• rpa_vision_v3/core/embedding/state_embedding_builder.py - À adapter

Tests

• rpa_vision_v3/examples/test_clip_simple.py - Test CLIP ✅
• rpa_vision_v3/test_clip.sh - Script de test rapide

Problèmes Connus

1. Structure ScreenState

Le ScreenState actuel a une structure à 4 niveaux (raw, perception, semantic, context) mais nos tests utilisent une structure simplifiée. Il faudra:

• Soit adapter les tests pour la structure complète
• Soit créer une version simplifiée pour les tests

2. Interface CLIP

Le CLIP embedder de geniusia2 a une interface légèrement différente:

• Pas de embed_batch_texts() → utiliser list comprehension
• Pas de get_similarity() → utiliser np.dot()
• Pas de embedding_dim → utiliser get_dimension()
• Accepte seulement PIL.Image, pas de chemins

3. Dépendances

Utiliser le venv de geniusia2 pour avoir toutes les dépendances:

source geniusia2/venv/bin/activate

Métriques de Succès pour Task 2.9

✅ Task 2.9 sera complétée quand:

1. StateEmbeddingBuilder utilise de vrais CLIP embedders
2. Un test démontre la génération d'embeddings réels
3. La similarité entre états similaires est élevée (>0.8)
4. La similarité entre états différents est faible (<0.6)

Après Task 2.9

Phase 3: Détection UI Sémantique

• Intégrer VLM pour détection
• Classifier types et rôles
• Générer embeddings duaux

Phase 3.5: Optimisation Asynchrone

• Batch processing optimisé
• Caching des embeddings
• Utilisation GPU

Phase 4: Workflow Graphs

• Construction de graphes
• Matching de ScreenStates
• Détection de patterns

Questions à Résoudre

1. Structure de données: Utiliser la structure ScreenState complète ou simplifiée?
2. Batch processing: Implémenter maintenant ou plus tard?
3. Caching: Ajouter un cache d'embeddings dès maintenant?
4. GPU: Tester avec GPU ou rester sur CPU pour l'instant?

Ressources

• OpenCLIP Docs
• FAISS Docs
• Spec Workflow Graph

---

Prêt à continuer ? Commencez par Task 2.9 ! 🚀