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

```python
# 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

```python
# 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

```bash
# 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:
```bash
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](https://github.com/mlfoundations/open_clip)
- [FAISS Docs](https://github.com/facebookresearch/faiss)
- [Spec Workflow Graph](.kiro/specs/workflow-graph-implementation/)

---

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