Geniusia_v2/geniusia2/core/TASK_REPLAY_README.md

🎮 Système de Rejeu de Tâches

Vue d'ensemble

Le système de rejeu permet de rejouer automatiquement des tâches apprises en utilisant la reconnaissance visuelle pour localiser les éléments d'interface, même si leur position a changé.

Architecture

TaskReplayEngine
├── Chargement de tâche (load_task)
├── Recherche visuelle (find_element_visually)
│   ├── Capture d'écran
│   ├── Génération d'embeddings
│   └── Recherche par similarité
├── Exécution d'action (execute_action_at_location)
│   ├── Click
│   ├── Type
│   ├── Scroll
│   └── Drag
└── Monitoring en temps réel

Fonctionnalités

1. Rejeu Basique

from core.task_replay import TaskReplayEngine

# Rejouer une tâche
results = await replay_engine.replay_task(
    task_id="task_fc1d3e52",
    interactive=False
)

print(f"Succès: {results['success']}")
print(f"Actions exécutées: {results['executed_actions']}")

2. Rejeu avec Monitoring

def on_step_completed(step_result):
    print(f"Étape {step_result['step']}: {step_result['status']}")

results = await replay_engine.replay_task_with_monitoring(
    task_id="task_fc1d3e52",
    on_step_completed=on_step_completed
)

3. Liste des Tâches Disponibles

tasks = replay_engine.list_available_tasks()

for task in tasks:
    print(f"{task['task_name']}: {task['observation_count']} observations")

Reconnaissance Visuelle

Recherche par Grille

Le système divise l'écran en grille et recherche l'élément dans chaque cellule :

# Grille 4x4 par défaut
grid_size = 4

# Pour chaque cellule :
# 1. Extraire la région
# 2. Générer l'embedding CLIP
# 3. Calculer la similarité avec l'embedding cible
# 4. Retourner les meilleures correspondances

Seuil de Similarité

replay:
  similarity_threshold: 0.75  # Minimum pour accepter une correspondance
  max_search_attempts: 3      # Nombre de tentatives

Types d'Actions Supportées

Type	Description	Paramètres
click	Clic souris	x, y, button
type	Saisie texte	text, interval
scroll	Défilement	direction, amount
drag	Glisser-déposer	start_x, start_y, end_x, end_y

Gestion des Variations d'Interface

Adaptation Automatique

Le système s'adapte aux changements :

1. Position différente : Recherche visuelle localise l'élément
2. Taille différente : Utilise le centre de la région trouvée
3. Style différent : L'embedding CLIP capture la sémantique

Retry et Fallback

# Retry automatique si élément non trouvé
max_search_attempts = 3

# Délai entre tentatives
retry_delay = 0.5  # secondes

Mode Interactif

En mode interactif, le système demande confirmation avant chaque action :

results = await replay_engine.replay_task(
    task_id="task_fc1d3e52",
    interactive=True  # Demande confirmation
)

Résultats du Rejeu

{
    "task_id": "task_fc1d3e52",
    "success": True,
    "total_actions": 3,
    "executed_actions": 3,
    "failed_actions": 0,
    "actions": [
        {
            "step": 1,
            "success": True,
            "location": {
                "x": 640,
                "y": 360,
                "confidence": 0.89,
                "bbox": [600, 340, 680, 380]
            },
            "action_type": "click"
        },
        # ...
    ]
}

Logging

Tous les événements sont loggés :

# Démarrage du rejeu
{"action": "task_replay_started", "task_id": "...", "interactive": False}

# Élément trouvé
{"action": "element_found", "similarity": 0.89, "attempt": 1}

# Élément non trouvé
{"action": "element_not_found", "step": 2, "signature": "..."}

# Rejeu terminé
{"action": "task_replay_completed", "success": True, "executed": 3, "failed": 0}

Utilisation avec le CLI

# Lister les tâches disponibles
python test_task_replay.py

# Le script vous guidera pour :
# 1. Voir les tâches disponibles
# 2. Choisir une tâche
# 3. Rejouer avec monitoring en temps réel

Exemple Complet

import asyncio
from core.task_replay import TaskReplayEngine
from core.learning_manager import LearningManager
from core.embeddings_manager import EmbeddingsManager
from core.utils.vision_utils import VisionUtils
from core.utils.input_utils import InputUtils
from core.logger import Logger
from core.config import load_config

async def replay_example():
    # Initialiser
    config = load_config()
    logger = Logger(config)
    embeddings_manager = EmbeddingsManager(logger, config)
    learning_manager = LearningManager(embeddings_manager, logger, config)
    vision_utils = VisionUtils(logger, config)
    input_utils = InputUtils(logger, config)
    
    replay_engine = TaskReplayEngine(
        learning_manager,
        embeddings_manager,
        vision_utils,
        input_utils,
        logger,
        config
    )
    
    # Lister les tâches
    tasks = replay_engine.list_available_tasks()
    print(f"Tâches disponibles: {len(tasks)}")
    
    # Rejouer la première tâche
    if tasks:
        task_id = tasks[0]['task_id']
        results = await replay_engine.replay_task(task_id)
        
        if results['success']:
            print("✅ Tâche rejouée avec succès!")
        else:
            print(f"❌ Échec: {results['failed_actions']} actions échouées")

# Exécuter
asyncio.run(replay_example())

Limitations Actuelles

1. Recherche par grille : Peut manquer des petits éléments entre les cellules
2. Pas de détection d'objets : Utilise uniquement CLIP pour la similarité
3. Mode interactif basique : Pas d'interface graphique pour la confirmation

Améliorations Futures

• Recherche multi-échelle (grilles de différentes tailles)
• Intégration avec OWL-v2 pour détection précise
• Interface graphique pour le mode interactif
• Gestion des erreurs avec rollback automatique
• Support des actions conditionnelles
• Rejeu parallèle de plusieurs tâches

Configuration

replay:
  similarity_threshold: 0.75      # Seuil de similarité minimum
  max_search_attempts: 3          # Tentatives de recherche
  delay_between_actions: 0.5      # Délai entre actions (secondes)
  grid_size: 4                    # Taille de la grille de recherche

Dépendances

• numpy : Calculs d'embeddings
• PIL : Manipulation d'images
• pyautogui : Capture d'écran et contrôle souris/clavier
• asyncio : Exécution asynchrone

Tests

# Test complet avec interface interactive
python test_task_replay.py

# Test programmatique
python -c "
import asyncio
from test_task_replay import test_list_tasks
asyncio.run(test_list_tasks())
"