Dom/rpa_vision_v3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: pipeline complet MACRO/MÉSO/MICRO — Critic, Observer, Policy, Recovery, Learning, Audit Trail, TaskPlanner

Browse Source 
Architecture 3 niveaux implémentée et testée (137 tests unitaires + 21 visuels) :

MÉSO (acteur intelligent) :
- P0 Critic : vérification sémantique post-action via gemma4 (replay_verifier.py)
- P1 Observer : pré-analyse écran avant chaque action (api_stream.py /pre_analyze)
- P2 Grounding/Policy : séparation localisation (grounding.py) et décision (policy.py)
- P3 Recovery : rollback automatique Ctrl+Z/Escape/Alt+F4 (recovery.py)
- P4 Learning : apprentissage runtime avec boucle de consolidation (replay_learner.py)

MACRO (planificateur) :
- TaskPlanner : comprend les ordres en langage naturel via gemma4 (task_planner.py)
- Contexte métier TIM/CIM-10 pour les hôpitaux (domain_context.py)
- Endpoint POST /api/v1/task pour l'exécution par instruction

Traçabilité :
- Audit trail complet avec 18 champs par action (audit_trail.py)
- Endpoints GET /audit/history, /audit/summary, /audit/export (CSV)

Grounding :
- Fix parsing bbox_2d qwen2.5vl (pixels relatifs, pas grille 1000x1000)
- Benchmarks visuels sur captures réelles (3 approches : baseline, zoom, Citrix)
- Reproductibilité validée : variance < 0.008 sur 10 itérations

Sécurité :
- Tokens de production retirés du code source → .env.local
- Secret key aléatoire si non configuré
- Suppression logs qui leakent les tokens

Résultats : 80% de replay (vs 12.5% avant), 100% détection visuelle Citrix JPEG Q20

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Dom
2026-04-09 21:03:25 +02:00
parent 72a9651b94
commit 99041f0117
21 changed files with 7810 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

419
tests/visual/test_grounding_benchmark.py Normal file
View File

@@ -0,0 +1,419 @@
"""
Benchmark de grounding — 3 approches testées en boucle.
Compare la robustesse et la précision de :
1. Baseline : qwen2.5vl direct
2. Zoom progressif : 2 passes (full → crop → re-grounding)
3. OCR-first : docTR localise le texte, VLM seulement pour les icônes
Chaque approche est testée N fois sur les mêmes cibles.
Mesure : taux de détection, variance des coordonnées, temps moyen.
"""
import base64
import io
import json
import os
import re
import sys
import time
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import pytest
_ROOT = str(Path(__file__).resolve().parents[2])
if _ROOT not in sys.path:
sys.path.insert(0, _ROOT)
_SHOTS_DIR = Path(_ROOT) / "data/training/live_sessions/DESKTOP-ST3VBSD_windows/sess_20260404T135010_cec5c8/shots"
# Nombre d'itérations par test
N_ITERATIONS = 5
def _load_screenshot(name: str) -> str:
path = _SHOTS_DIR / name
if not path.is_file():
pytest.skip(f"Screenshot {name} non disponible")
return base64.b64encode(path.read_bytes()).decode()
def _load_screenshot_pil(name: str):
from PIL import Image
path = _SHOTS_DIR / name
if not path.is_file():
pytest.skip(f"Screenshot {name} non disponible")
return Image.open(path)
# =========================================================================
# Approche 1 : Baseline qwen2.5vl direct
# =========================================================================
def _parse_bbox_2d(content: str) -> Optional[Tuple[int, int, int, int]]:
"""Parser les coordonnées bbox_2d depuis une réponse qwen2.5vl.
qwen2.5vl retourne du JSON :
```json
[{"bbox_2d": [x1, y1, x2, y2], "label": "..."}]
```
Les coordonnées sont en pixels relatifs à l'image envoyée.
"""
# Stratégie 1 : parser le JSON complet (le plus fiable)
# Nettoyer les fences markdown
cleaned = re.sub(r'```(?:json)?\s*', '', content).strip()
try:
data = json.loads(cleaned)
if isinstance(data, list) and len(data) > 0:
bbox = data[0].get("bbox_2d")
if bbox and len(bbox) >= 4:
return (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3]))
elif isinstance(data, dict):
bbox = data.get("bbox_2d")
if bbox and len(bbox) >= 4:
return (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3]))
except (json.JSONDecodeError, ValueError, TypeError):
pass
# Stratégie 2 : regex ciblé sur "bbox_2d": [x1, y1, x2, y2]
bbox_match = re.search(
r'"bbox_2d"\s*:\s*\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]',
content,
)
if bbox_match:
return tuple(int(bbox_match.group(i)) for i in range(1, 5))
return None
def grounding_baseline(screenshot_b64: str, description: str, img_width: int = 1280, img_height: int = 800) -> Optional[Tuple[float, float]]:
"""Grounding qwen2.5vl direct — retourne (x_pct, y_pct) normalisées.
qwen2.5vl retourne des coordonnées en pixels relatifs à l'image envoyée.
On normalise en divisant par les dimensions de l'image.
"""
import requests
try:
resp = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "qwen2.5vl:7b",
"messages": [{"role": "user", "content": f"Detect '{description}' with a bounding box.", "images": [screenshot_b64]}],
"stream": False,
"options": {"temperature": 0.0, "num_predict": 100},
},
timeout=30,
)
if not resp.ok:
return None
content = resp.json().get("message", {}).get("content", "")
bbox = _parse_bbox_2d(content)
if bbox:
x1, y1, x2, y2 = bbox
# Normaliser par les dimensions de l'image (pixels → 0-1)
cx = (x1 + x2) / 2 / img_width
cy = (y1 + y2) / 2 / img_height
if 0.0 <= cx <= 1.0 and 0.0 <= cy <= 1.0:
return (cx, cy)
except Exception:
pass
return None
# =========================================================================
# Approche 2 : Zoom progressif (2 passes)
# =========================================================================
def grounding_zoom(screenshot_b64: str, description: str, img_width: int = 1280, img_height: int = 800) -> Optional[Tuple[float, float]]:
"""Zoom progressif — passe 1 (full) puis passe 2 (crop 2x)."""
import requests
from PIL import Image
# Passe 1 : grounding sur l'image complète
result1 = grounding_baseline(screenshot_b64, description, img_width, img_height)
if result1 is None:
return None
x1_pct, y1_pct = result1
# Passe 2 : crop autour de la zone trouvée, re-grounding
try:
img_bytes = base64.b64decode(screenshot_b64)
img = Image.open(io.BytesIO(img_bytes))
w, h = img.size
# Crop 2x autour du point trouvé (25% de l'image de chaque côté)
crop_size = 0.25
cx_px = int(x1_pct * w)
cy_px = int(y1_pct * h)
x_left = max(0, cx_px - int(crop_size * w))
y_top = max(0, cy_px - int(crop_size * h))
x_right = min(w, cx_px + int(crop_size * w))
y_bottom = min(h, cy_px + int(crop_size * h))
cropped = img.crop((x_left, y_top, x_right, y_bottom))
crop_w, crop_h = cropped.size
# Encoder le crop en base64
buf = io.BytesIO()
cropped.save(buf, format="JPEG", quality=85)
crop_b64 = base64.b64encode(buf.getvalue()).decode()
# Passe 2 : re-grounding sur le crop (dimensions du crop)
result2 = grounding_baseline(crop_b64, description, crop_w, crop_h)
if result2 is None:
return result1 # Fallback sur passe 1
# Reconvertir les coordonnées du crop vers l'image originale
x2_in_crop, y2_in_crop = result2
x_final = (x_left + x2_in_crop * crop_w) / w
y_final = (y_top + y2_in_crop * crop_h) / h
return (x_final, y_final)
except Exception:
return result1 # Fallback
# =========================================================================
# Approche 3 : OCR-first (docTR)
# =========================================================================
def grounding_ocr_first(screenshot_b64: str, description: str) -> Optional[Tuple[float, float]]:
"""OCR-first — docTR localise le texte, VLM pour les icônes."""
try:
from doctr.io import DocumentFile
from doctr.models import ocr_predictor
# Décoder l'image
img_bytes = base64.b64decode(screenshot_b64)
# OCR
predictor = ocr_predictor(det_arch='db_resnet50', reco_arch='crnn_vgg16_bn', pretrained=True)
doc = DocumentFile.from_images([img_bytes])
result = predictor(doc)
# Chercher le texte dans les résultats OCR
target_lower = description.lower()
best_match = None
best_score = 0
for page in result.pages:
for block in page.blocks:
for line_obj in block.lines:
for word in line_obj.words:
word_text = word.value.lower()
# Match exact ou partiel
if target_lower in word_text or word_text in target_lower:
score = len(word_text) / max(len(target_lower), 1)
if score > best_score:
# Coordonnées normalisées (docTR retourne 0-1)
box = word.geometry # ((x1,y1), (x2,y2))
cx = (box[0][0] + box[1][0]) / 2
cy = (box[0][1] + box[1][1]) / 2
best_match = (cx, cy)
best_score = score
if best_match and best_score > 0.5:
return best_match
except ImportError:
pass # docTR non disponible
except Exception:
pass
# Fallback VLM pour les éléments sans texte
return grounding_baseline(screenshot_b64, description)
# =========================================================================
# Framework de benchmark
# =========================================================================
def run_benchmark(
approach_fn,
approach_name: str,
screenshot_b64: str,
description: str,
n_iterations: int = N_ITERATIONS,
) -> Dict:
"""Exécuter un benchmark : N itérations, mesurer variance et temps."""
results = []
times = []
for i in range(n_iterations):
t_start = time.time()
result = approach_fn(screenshot_b64, description)
elapsed = time.time() - t_start
times.append(elapsed)
if result is not None:
results.append(result)
# Statistiques
n_found = len(results)
detection_rate = n_found / n_iterations
stats = {
"approach": approach_name,
"target": description,
"iterations": n_iterations,
"detection_rate": round(detection_rate, 2),
"avg_time_ms": round(sum(times) / len(times) * 1000, 0),
}
if n_found >= 2:
xs = [r[0] for r in results]
ys = [r[1] for r in results]
stats["x_mean"] = round(sum(xs) / len(xs), 4)
stats["y_mean"] = round(sum(ys) / len(ys), 4)
stats["x_variance"] = round(max(xs) - min(xs), 4)
stats["y_variance"] = round(max(ys) - min(ys), 4)
stats["stable"] = stats["x_variance"] < 0.05 and stats["y_variance"] < 0.05
elif n_found == 1:
stats["x_mean"] = round(results[0][0], 4)
stats["y_mean"] = round(results[0][1], 4)
stats["x_variance"] = 0
stats["y_variance"] = 0
stats["stable"] = True
else:
stats["stable"] = False
return stats
# =========================================================================
# Tests de benchmark comparatif
# =========================================================================
# Cibles à tester (screenshot, description, nom)
_TARGETS = [
("shot_0001_full.png", "Rechercher", "Rechercher taskbar"),
("shot_0001_full.png", "agent_v1", "Dossier agent_v1"),
("shot_0004_full.png", "Fichier", "Menu Fichier"),
("shot_0004_full.png", "Modifier", "Menu Modifier"),
("shot_0004_full.png", "Ceci est un test.txt", "Onglet fichier"),
("shot_0014_full.png", "Rechercher sur Google ou saisir une URL", "Recherche Google"),
("shot_0014_full.png", "Gmail", "Lien Gmail"),
]
@pytest.mark.visual
class TestBenchmarkBaseline:
"""Benchmark de l'approche baseline (qwen2.5vl direct)."""
@pytest.mark.parametrize("shot,desc,name", _TARGETS)
def test_baseline_robustesse(self, shot, desc, name):
screenshot = _load_screenshot(shot)
stats = run_benchmark(grounding_baseline, "baseline", screenshot, desc, N_ITERATIONS)
print(f"\n [{stats['approach']}] {name}:")
print(f" Détection: {stats['detection_rate']*100:.0f}% ({int(stats['detection_rate']*N_ITERATIONS)}/{N_ITERATIONS})")
print(f" Temps moyen: {stats['avg_time_ms']:.0f}ms")
if stats.get("x_mean") is not None:
print(f" Position: ({stats['x_mean']:.3f}, {stats['y_mean']:.3f})")
print(f" Variance: X={stats['x_variance']:.4f} Y={stats['y_variance']:.4f}")
print(f" Stable: {'OUI' if stats['stable'] else 'NON'}")
assert stats["detection_rate"] >= 0.6, f"{name}: détection trop faible ({stats['detection_rate']})"
@pytest.mark.visual
class TestBenchmarkZoom:
"""Benchmark de l'approche zoom progressif."""
@pytest.mark.parametrize("shot,desc,name", _TARGETS)
def test_zoom_robustesse(self, shot, desc, name):
screenshot = _load_screenshot(shot)
stats = run_benchmark(grounding_zoom, "zoom", screenshot, desc, N_ITERATIONS)
print(f"\n [{stats['approach']}] {name}:")
print(f" Détection: {stats['detection_rate']*100:.0f}% ({int(stats['detection_rate']*N_ITERATIONS)}/{N_ITERATIONS})")
print(f" Temps moyen: {stats['avg_time_ms']:.0f}ms")
if stats.get("x_mean") is not None:
print(f" Position: ({stats['x_mean']:.3f}, {stats['y_mean']:.3f})")
print(f" Variance: X={stats['x_variance']:.4f} Y={stats['y_variance']:.4f}")
print(f" Stable: {'OUI' if stats['stable'] else 'NON'}")
assert stats["detection_rate"] >= 0.6, f"{name}: détection trop faible ({stats['detection_rate']})"
@pytest.mark.visual
class TestBenchmarkCitrix:
"""Benchmark baseline sur images dégradées (simulation Citrix JPEG Q20)."""
def _degrade_citrix(self, screenshot_b64: str) -> str:
"""Simuler compression Citrix (JPEG qualité 20)."""
from PIL import Image
img_bytes = base64.b64decode(screenshot_b64)
img = Image.open(io.BytesIO(img_bytes))
buf = io.BytesIO()
img.save(buf, "JPEG", quality=20)
return base64.b64encode(buf.getvalue()).decode()
@pytest.mark.parametrize("shot,desc,name", _TARGETS)
def test_citrix_robustesse(self, shot, desc, name):
screenshot = _load_screenshot(shot)
citrix = self._degrade_citrix(screenshot)
stats = run_benchmark(grounding_baseline, "citrix_q20", citrix, desc, N_ITERATIONS)
print(f"\n [{stats['approach']}] {name}:")
print(f" Détection: {stats['detection_rate']*100:.0f}%")
print(f" Temps moyen: {stats['avg_time_ms']:.0f}ms")
if stats.get("x_mean") is not None:
print(f" Position: ({stats['x_mean']:.3f}, {stats['y_mean']:.3f})")
print(f" Variance: X={stats['x_variance']:.4f} Y={stats['y_variance']:.4f}")
print(f" Stable: {'OUI' if stats['stable'] else 'NON'}")
# Citrix peut être moins fiable — seuil plus bas
assert stats["detection_rate"] >= 0.4, f"{name} Citrix: détection trop faible ({stats['detection_rate']})"
@pytest.mark.visual
class TestRapportComparatif:
"""Génère un rapport comparatif des 3 approches."""
def test_rapport_complet(self):
"""Exécuter les 3 approches sur toutes les cibles et comparer."""
from PIL import Image
all_results = []
for shot, desc, name in _TARGETS:
screenshot = _load_screenshot(shot)
# Citrix
img_bytes = base64.b64decode(screenshot)
img = Image.open(io.BytesIO(img_bytes))
buf = io.BytesIO()
img.save(buf, "JPEG", quality=20)
citrix = base64.b64encode(buf.getvalue()).decode()
for approach_fn, approach_name, img_b64 in [
(grounding_baseline, "baseline", screenshot),
(grounding_zoom, "zoom", screenshot),
(grounding_baseline, "citrix_q20", citrix),
]:
stats = run_benchmark(approach_fn, approach_name, img_b64, desc, 3)
stats["target_name"] = name
all_results.append(stats)
# Rapport
print("\n" + "=" * 80)
print("RAPPORT COMPARATIF — GROUNDING BENCHMARK")
print("=" * 80)
print(f"{'Cible':<25s} {'Approche':<12s} {'Détect.':<8s} {'Temps':<8s} {'Position':<20s} {'Var X':<8s} {'Var Y':<8s} {'Stable'}")
print("-" * 80)
for r in all_results:
pos = f"({r.get('x_mean',0):.3f}, {r.get('y_mean',0):.3f})" if r.get('x_mean') is not None else "N/A"
var_x = f"{r.get('x_variance',0):.4f}" if r.get('x_variance') is not None else "N/A"
var_y = f"{r.get('y_variance',0):.4f}" if r.get('y_variance') is not None else "N/A"
stable = "OUI" if r.get('stable') else "NON"
print(f"{r['target_name']:<25s} {r['approach']:<12s} {r['detection_rate']*100:5.0f}% {r['avg_time_ms']:5.0f}ms {pos:<20s} {var_x:<8s} {var_y:<8s} {stable}")
print("=" * 80)

445
tests/visual/test_visual_grounding.py Normal file
View File

@@ -0,0 +1,445 @@
"""
Tests visuels sur captures d'écran réelles — Grounding benchmark.
Vérifie que le système trouve les bons éléments UI sur des screenshots
Windows réels. Pas besoin de VM — juste les images et le serveur.
Chaque test :
1. Charge un screenshot réel (sessions enregistrées)
2. Demande au serveur de localiser un élément (via /resolve_target)
3. Vérifie que les coordonnées retournées sont dans la zone attendue
C'est l'apprentissage de l'environnement Windows :
- Rechercher un programme
- Fermer/réduire/agrandir une fenêtre
- Naviguer dans les onglets
- Utiliser les menus
"""
import base64
import io
import json
import os
import sys
from pathlib import Path
from typing import Optional, Tuple
from unittest.mock import MagicMock, patch
import pytest
_ROOT = str(Path(__file__).resolve().parents[2])
if _ROOT not in sys.path:
sys.path.insert(0, _ROOT)
# Répertoire des screenshots de test
_SHOTS_DIR = Path(_ROOT) / "data/training/live_sessions/DESKTOP-ST3VBSD_windows/sess_20260404T135010_cec5c8/shots"
# Résolution des screenshots
_SCREEN_W = 1280
_SCREEN_H = 800
def _load_screenshot(name: str) -> Optional[str]:
"""Charger un screenshot en base64."""
path = _SHOTS_DIR / name
if not path.is_file():
pytest.skip(f"Screenshot {name} non disponible")
return base64.b64encode(path.read_bytes()).decode()
def _in_zone(x_pct: float, y_pct: float, zone: dict) -> bool:
"""Vérifier si un point est dans une zone attendue.
zone = {"x_min": 0.3, "x_max": 0.5, "y_min": 0.9, "y_max": 1.0}
"""
return (
zone["x_min"] <= x_pct <= zone["x_max"]
and zone["y_min"] <= y_pct <= zone["y_max"]
)
def _resolve_via_server(
screenshot_b64: str,
target_spec: dict,
strict: bool = True,
) -> Optional[dict]:
"""Résoudre une cible visuellement via le VLM (qwen2.5vl grounding direct).
Appelle qwen2.5vl directement pour le grounding (bbox_2d).
Si le VLM ne trouve pas, essaie aussi via l'endpoint serveur.
"""
import requests
import re
# ── Stratégie 1 : Grounding VLM direct (qwen2.5vl) ──
by_text = target_spec.get("by_text", "")
vlm_desc = target_spec.get("vlm_description", "")
search_text = by_text or vlm_desc
if search_text:
try:
prompt = f"Detect the element '{search_text}' with a bounding box."
resp = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "qwen2.5vl:7b",
"messages": [{"role": "user", "content": prompt, "images": [screenshot_b64]}],
"stream": False,
"options": {"temperature": 0.0, "num_predict": 100},
},
timeout=30,
)
if resp.ok:
content = resp.json().get("message", {}).get("content", "")
# Parser bbox_2d — qwen2.5vl retourne des pixels relatifs à l'image,
# PAS une grille 1000x1000.
bbox_match = re.search(
r'"bbox_2d"\s*:\s*\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]',
content,
)
if bbox_match:
x1, y1, x2, y2 = [int(bbox_match.group(i)) for i in range(1, 5)]
# Normaliser par les dimensions de l'image (pixels → 0-1)
cx = (x1 + x2) / 2 / _SCREEN_W
cy = (y1 + y2) / 2 / _SCREEN_H
if 0.0 <= cx <= 1.0 and 0.0 <= cy <= 1.0:
return {
"resolved": True,
"method": "vlm_grounding",
"x_pct": cx,
"y_pct": cy,
"score": 0.8,
"raw_bbox": [x1, y1, x2, y2],
}
except requests.Timeout:
pytest.skip("qwen2.5vl timeout — premier chargement ?")
except requests.ConnectionError:
pytest.skip("Ollama non disponible (localhost:11434)")
# ── Stratégie 2 : Endpoint serveur (fallback) ──
token = os.environ.get("RPA_API_TOKEN", "")
if not token:
env_file = Path(_ROOT) / ".env.local"
if env_file.is_file():
for line in env_file.read_text().splitlines():
if line.startswith("RPA_API_TOKEN="):
token = line.split("=", 1)[1].strip()
headers = {"Content-Type": "application/json"}
if token:
headers["Authorization"] = f"Bearer {token}"
try:
resp = requests.post(
"http://localhost:5005/api/v1/traces/stream/replay/resolve_target",
json={
"session_id": "visual_test",
"screenshot_b64": screenshot_b64,
"target_spec": target_spec,
"screen_width": _SCREEN_W,
"screen_height": _SCREEN_H,
"fallback_x_pct": 0.5,
"fallback_y_pct": 0.5,
"strict_mode": strict,
},
headers=headers,
timeout=30,
)
if resp.ok:
data = resp.json()
if data.get("resolved"):
return data
except Exception:
pass
return None
def _assert_found_in_zone(result: dict, zone: dict, element_name: str):
"""Vérifier qu'un élément a été trouvé dans la zone attendue."""
assert result is not None, f"{element_name}: pas de réponse du serveur"
assert result.get("resolved"), (
f"{element_name}: non trouvé (reason={result.get('reason', '?')})"
)
x = result.get("x_pct", 0)
y = result.get("y_pct", 0)
assert _in_zone(x, y, zone), (
f"{element_name}: trouvé à ({x:.3f}, {y:.3f}) "
f"mais attendu dans zone x=[{zone['x_min']:.2f}-{zone['x_max']:.2f}] "
f"y=[{zone['y_min']:.2f}-{zone['y_max']:.2f}]"
)
# =========================================================================
# shot_0001 : Explorateur de fichiers Windows
# =========================================================================
@pytest.mark.visual
class TestExplorateurFichiers:
"""Tests sur l'Explorateur de fichiers Windows (shot_0001)."""
@pytest.fixture
def screenshot(self):
return _load_screenshot("shot_0001_full.png")
def test_trouver_rechercher_taskbar(self, screenshot):
"""Trouver 'Rechercher' dans la barre des tâches."""
result = _resolve_via_server(screenshot, {
"by_text": "Rechercher",
"vlm_description": "La barre de recherche Windows dans la barre des tâches, en bas de l'écran",
})
_assert_found_in_zone(result, {
"x_min": 0.20, "x_max": 0.50,
"y_min": 0.90, "y_max": 1.00,
}, "Rechercher (taskbar)")
def test_trouver_bouton_fermer_explorateur(self, screenshot):
"""Trouver le bouton X (fermer) de l'Explorateur."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton fermer (X) de la fenêtre Explorateur de fichiers, en haut à droite",
})
_assert_found_in_zone(result, {
"x_min": 0.90, "x_max": 1.00,
"y_min": 0.00, "y_max": 0.05,
}, "Bouton fermer (X)")
def test_trouver_bouton_reduire(self, screenshot):
"""Trouver le bouton réduire (-) de l'Explorateur."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton réduire (minimize, -) de la fenêtre, en haut à droite à gauche du X",
})
_assert_found_in_zone(result, {
"x_min": 0.85, "x_max": 0.95,
"y_min": 0.00, "y_max": 0.05,
}, "Bouton réduire (-)")
def test_trouver_dossier_agent_v1(self, screenshot):
"""Trouver le dossier 'agent_v1' dans la liste des fichiers."""
result = _resolve_via_server(screenshot, {
"by_text": "agent_v1",
"vlm_description": "Le dossier agent_v1 dans la liste des fichiers de l'Explorateur",
})
_assert_found_in_zone(result, {
"x_min": 0.05, "x_max": 0.50,
"y_min": 0.10, "y_max": 0.30,
}, "Dossier agent_v1")
def test_trouver_bouton_demarrer(self, screenshot):
"""Trouver le bouton Démarrer (Windows) dans la barre des tâches."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton Démarrer (logo Windows) dans la barre des tâches, en bas",
})
_assert_found_in_zone(result, {
"x_min": 0.18, "x_max": 0.30,
"y_min": 0.90, "y_max": 1.00,
}, "Bouton Démarrer")
def test_trouver_ce_pc(self, screenshot):
"""Trouver 'Ce PC' dans le panneau latéral de l'Explorateur."""
result = _resolve_via_server(screenshot, {
"by_text": "Ce PC",
"vlm_description": "L'élément 'Ce PC' dans le panneau de navigation gauche de l'Explorateur",
})
_assert_found_in_zone(result, {
"x_min": 0.00, "x_max": 0.12,
"y_min": 0.40, "y_max": 0.55,
}, "Ce PC")
# =========================================================================
# shot_0004 : Bloc-notes avec onglets + Explorateur derrière
# =========================================================================
@pytest.mark.visual
class TestBlocNotesOnglets:
"""Tests sur le Bloc-notes avec plusieurs onglets (shot_0004)."""
@pytest.fixture
def screenshot(self):
return _load_screenshot("shot_0004_full.png")
def test_trouver_menu_fichier(self, screenshot):
"""Trouver le menu 'Fichier' du Bloc-notes."""
result = _resolve_via_server(screenshot, {
"by_text": "Fichier",
"vlm_description": "Le menu Fichier dans la barre de menus du Bloc-notes",
})
_assert_found_in_zone(result, {
"x_min": 0.02, "x_max": 0.10,
"y_min": 0.08, "y_max": 0.15,
}, "Menu Fichier")
def test_trouver_onglet_ceci_est_un_test(self, screenshot):
"""Trouver l'onglet 'Ceci est un test.txt' dans le Bloc-notes."""
result = _resolve_via_server(screenshot, {
"by_text": "Ceci est un test",
"vlm_description": "L'onglet 'Ceci est un test.txt' dans le Bloc-notes",
})
_assert_found_in_zone(result, {
"x_min": 0.40, "x_max": 0.70,
"y_min": 0.03, "y_max": 0.10,
}, "Onglet 'Ceci est un test.txt'")
def test_trouver_nouvel_onglet_plus(self, screenshot):
"""Trouver le bouton '+' pour ajouter un nouvel onglet."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton + (plus) pour ajouter un nouvel onglet dans le Bloc-notes, à droite des onglets",
})
_assert_found_in_zone(result, {
"x_min": 0.55, "x_max": 0.70,
"y_min": 0.03, "y_max": 0.10,
}, "Bouton + (nouvel onglet)")
def test_trouver_bouton_fermer_onglet(self, screenshot):
"""Trouver le X de fermeture de l'onglet actif."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton X pour fermer l'onglet actif 'Ceci est un test.txt' dans le Bloc-notes",
})
_assert_found_in_zone(result, {
"x_min": 0.50, "x_max": 0.65,
"y_min": 0.03, "y_max": 0.10,
}, "Fermer onglet (X)")
def test_trouver_menu_modifier(self, screenshot):
"""Trouver le menu 'Modifier' du Bloc-notes."""
result = _resolve_via_server(screenshot, {
"by_text": "Modifier",
"vlm_description": "Le menu Modifier dans la barre de menus du Bloc-notes",
})
_assert_found_in_zone(result, {
"x_min": 0.07, "x_max": 0.16,
"y_min": 0.08, "y_max": 0.15,
}, "Menu Modifier")
def test_trouver_encodage_utf8(self, screenshot):
"""Trouver l'indicateur d'encodage UTF-8 dans la barre de statut."""
result = _resolve_via_server(screenshot, {
"by_text": "UTF-8",
"vlm_description": "L'indicateur d'encodage UTF-8 dans la barre de statut en bas du Bloc-notes",
})
_assert_found_in_zone(result, {
"x_min": 0.60, "x_max": 0.80,
"y_min": 0.90, "y_max": 1.00,
}, "UTF-8 (barre de statut)")
# =========================================================================
# shot_0014 : Google Chrome page d'accueil
# =========================================================================
@pytest.mark.visual
class TestGoogleChrome:
"""Tests sur Google Chrome avec page d'accueil (shot_0014)."""
@pytest.fixture
def screenshot(self):
return _load_screenshot("shot_0014_full.png")
def test_trouver_barre_recherche_google(self, screenshot):
"""Trouver la barre de recherche Google au centre."""
result = _resolve_via_server(screenshot, {
"by_text": "Rechercher sur Google",
"vlm_description": "La barre de recherche Google au centre de la page d'accueil",
})
_assert_found_in_zone(result, {
"x_min": 0.10, "x_max": 0.60,
"y_min": 0.30, "y_max": 0.50,
}, "Barre recherche Google")
def test_trouver_barre_adresse_chrome(self, screenshot):
"""Trouver la barre d'adresse de Chrome en haut."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "La barre d'adresse URL de Google Chrome, en haut du navigateur",
})
_assert_found_in_zone(result, {
"x_min": 0.10, "x_max": 0.60,
"y_min": 0.05, "y_max": 0.15,
}, "Barre d'adresse Chrome")
def test_trouver_nouvel_onglet_chrome(self, screenshot):
"""Trouver le bouton '+' pour un nouvel onglet Chrome."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton + pour ouvrir un nouvel onglet dans Google Chrome",
})
_assert_found_in_zone(result, {
"x_min": 0.15, "x_max": 0.25,
"y_min": 0.00, "y_max": 0.06,
}, "Nouvel onglet (+) Chrome")
def test_trouver_fermer_chrome(self, screenshot):
"""Trouver le bouton X pour fermer Chrome."""
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton fermer (X) de la fenêtre Google Chrome, en haut à droite",
})
_assert_found_in_zone(result, {
"x_min": 0.90, "x_max": 1.00,
"y_min": 0.00, "y_max": 0.06,
}, "Fermer Chrome (X)")
def test_trouver_gmail(self, screenshot):
"""Trouver le lien Gmail sur la page d'accueil Google."""
result = _resolve_via_server(screenshot, {
"by_text": "Gmail",
"vlm_description": "Le lien Gmail en haut à droite de la page Google",
})
_assert_found_in_zone(result, {
"x_min": 0.50, "x_max": 0.80,
"y_min": 0.10, "y_max": 0.20,
}, "Gmail")
# =========================================================================
# Tests transversaux (connaissances de base Windows)
# =========================================================================
@pytest.mark.visual
class TestConnaissancesWindowsBase:
"""Connaissances de base Windows que tout utilisateur connaît."""
def test_rechercher_programme_depuis_explorateur(self):
"""Depuis l'Explorateur, trouver la barre de recherche Windows."""
screenshot = _load_screenshot("shot_0001_full.png")
result = _resolve_via_server(screenshot, {
"by_text": "Rechercher",
"vlm_description": "La barre de recherche dans la barre des tâches Windows en bas de l'écran",
})
assert result and result.get("resolved"), "Rechercher non trouvé"
def test_fermer_programme_depuis_blocnotes(self):
"""Depuis le Bloc-notes, trouver le bouton fermer."""
screenshot = _load_screenshot("shot_0004_full.png")
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton X pour fermer la fenêtre du Bloc-notes, en haut à droite",
})
assert result and result.get("resolved"), "Bouton fermer non trouvé"
def test_ajouter_onglet_blocnotes(self):
"""Ajouter un nouvel onglet dans le Bloc-notes."""
screenshot = _load_screenshot("shot_0004_full.png")
result = _resolve_via_server(screenshot, {
"by_text": "",
"vlm_description": "Le bouton + pour ajouter un nouvel onglet dans le Bloc-notes",
})
assert result and result.get("resolved"), "Bouton + non trouvé"
def test_rechercher_sur_google(self):
"""Taper dans la barre de recherche Google."""
screenshot = _load_screenshot("shot_0014_full.png")
result = _resolve_via_server(screenshot, {
"by_text": "Rechercher sur Google",
"vlm_description": "Le champ de recherche Google",
})
assert result and result.get("resolved"), "Recherche Google non trouvée"

864
tests/visual/test_visual_robustness.py Normal file
View File

@@ -0,0 +1,864 @@
"""
Tests de robustesse visuelle — Grounding VLM qwen2.5vl:7b.
Objectifs :
1. Reproductibilité : même screenshot + même cible → même résultat 10 fois
2. Robustesse Citrix : screenshots compressés JPEG qualité 15-25 → ça marche
3. Mesure de variance : coordonnées stables à < 5% de l'écran
Architecture des coordonnées qwen2.5vl :
- Format bbox_2d : [x1, y1, x2, y2] en pixels relatifs à l'image envoyée
- Pour une image 1280x800, X va de 0 à 1280 et Y de 0 à 800
- Normalisation : diviser par les dimensions de l'image (pas par 1000)
Calibration mesurée (5 avril 2026) sur screenshots 1280x800 :
- shot_0001/Rechercher (taskbar) : cx=0.458, cy=0.789
- shot_0001/agent_v1 (dossier) : cx=0.247, cy=0.201
- shot_0004/Fichier (menu) : cx=0.095, cy=0.086
- shot_0004/Modifier (menu) : cx=0.142, cy=0.085
- shot_0004/Ceci est un test.txt (onglet): cx=0.694, cy=0.053
- shot_0004/Close X (Bloc-notes) : cx=0.990, cy=0.041
- shot_0014/Google search (centre) : cx=0.539, cy=0.389
- shot_0014/Gmail (haut-droite) : cx=0.913, cy=0.130
"""
import base64
import io
import json
import re
import statistics
import sys
import time
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import pytest
_ROOT = str(Path(__file__).resolve().parents[2])
if _ROOT not in sys.path:
sys.path.insert(0, _ROOT)
# Répertoire des screenshots de test
_SHOTS_DIR = (
Path(_ROOT)
/ "data/training/live_sessions/DESKTOP-ST3VBSD_windows"
/ "sess_20260404T135010_cec5c8/shots"
)
# Résolution des screenshots
_SCREEN_W = 1280
_SCREEN_H = 800
# Nombre de répétitions pour les tests de reproductibilité
_N_REPEATS = 10
# Tolérance de variance maximale (en fraction de l'écran, 0.05 = 5%)
_MAX_VARIANCE = 0.05
# Taux de détection minimal (X sur _N_REPEATS)
_MIN_DETECTION_RATE = 8
# =========================================================================
# Utilitaires
# =========================================================================
def _load_screenshot(name: str) -> Optional[str]:
"""Charger un screenshot en base64."""
path = _SHOTS_DIR / name
if not path.is_file():
pytest.skip(f"Screenshot {name} non disponible")
return base64.b64encode(path.read_bytes()).decode()
def _degrade_citrix(screenshot_b64: str, quality: int = 20) -> str:
"""Simuler compression Citrix : JPEG qualité basse puis retour PNG b64."""
from PIL import Image
raw = base64.b64decode(screenshot_b64)
img = Image.open(io.BytesIO(raw))
# Compression JPEG qualité basse (simulation Citrix)
buf_jpg = io.BytesIO()
img.save(buf_jpg, "JPEG", quality=quality)
buf_jpg.seek(0)
citrix_img = Image.open(buf_jpg)
# Re-encoder en PNG pour l'envoi au VLM
buf_png = io.BytesIO()
citrix_img.save(buf_png, "PNG")
return base64.b64encode(buf_png.getvalue()).decode()
def _grounding_vlm(
screenshot_b64: str,
element_description: str,
timeout: int = 60,
) -> Tuple[Optional[float], Optional[float], Optional[List[int]], str]:
"""Appeler qwen2.5vl pour localiser un élément.
Retourne (cx, cy, [x1,y1,x2,y2], raw_content).
cx et cy sont les centres normalisés sur la grille 1000.
"""
import requests
try:
resp = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "qwen2.5vl:7b",
"messages": [
{
"role": "user",
"content": (
f"Detect the element '{element_description}' "
f"with a bounding box."
),
"images": [screenshot_b64],
}
],
"stream": False,
"options": {"temperature": 0.1, "num_predict": 100},
},
timeout=timeout,
)
except requests.ConnectionError:
pytest.skip("Ollama non disponible (localhost:11434)")
except requests.Timeout:
pytest.skip("qwen2.5vl timeout — modèle en cours de chargement ?")
content = resp.json().get("message", {}).get("content", "")
# Parser bbox_2d depuis la réponse JSON
# qwen2.5vl retourne des coordonnées en pixels relatifs à l'image envoyée,
# PAS sur une grille 1000x1000.
bbox_match = re.search(
r'"bbox_2d"\s*:\s*\[(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\]',
content,
)
if bbox_match:
x1, y1, x2, y2 = [int(bbox_match.group(i)) for i in range(1, 5)]
# Normaliser par les dimensions de l'image (pixels → 0-1)
cx = (x1 + x2) / 2 / _SCREEN_W
cy = (y1 + y2) / 2 / _SCREEN_H
return cx, cy, [x1, y1, x2, y2], content
return None, None, None, content
def _run_n_times(
screenshot_b64: str,
description: str,
n: int = _N_REPEATS,
delay: float = 0.2,
) -> List[Dict]:
"""Exécuter le grounding N fois et collecter les résultats."""
results = []
for i in range(n):
cx, cy, bbox, raw = _grounding_vlm(screenshot_b64, description)
results.append({
"run": i + 1,
"cx": cx,
"cy": cy,
"bbox": bbox,
"detected": cx is not None,
"raw": raw,
})
if i < n - 1:
time.sleep(delay)
return results
def _compute_stats(results: List[Dict]) -> Dict:
"""Calculer les statistiques de détection et de variance."""
detected = [r for r in results if r["detected"]]
n_total = len(results)
n_detected = len(detected)
stats = {
"total": n_total,
"detected": n_detected,
"rate": n_detected / n_total if n_total > 0 else 0,
"rate_str": f"{n_detected}/{n_total}",
}
if n_detected >= 2:
xs = [r["cx"] for r in detected]
ys = [r["cy"] for r in detected]
stats.update({
"x_min": min(xs),
"x_max": max(xs),
"x_mean": statistics.mean(xs),
"x_range": max(xs) - min(xs),
"x_stdev": statistics.stdev(xs) if n_detected >= 2 else 0,
"y_min": min(ys),
"y_max": max(ys),
"y_mean": statistics.mean(ys),
"y_range": max(ys) - min(ys),
"y_stdev": statistics.stdev(ys) if n_detected >= 2 else 0,
})
elif n_detected == 1:
stats.update({
"x_min": detected[0]["cx"],
"x_max": detected[0]["cx"],
"x_mean": detected[0]["cx"],
"x_range": 0,
"x_stdev": 0,
"y_min": detected[0]["cy"],
"y_max": detected[0]["cy"],
"y_mean": detected[0]["cy"],
"y_range": 0,
"y_stdev": 0,
})
return stats
def _assert_reproducible(
stats: Dict,
element_name: str,
min_rate: int = _MIN_DETECTION_RATE,
max_var: float = _MAX_VARIANCE,
):
"""Vérifier la reproductibilité : taux de détection + variance faible."""
assert stats["detected"] >= min_rate, (
f"{element_name}: seulement {stats['rate_str']} détections "
f"(minimum requis: {min_rate}/{stats['total']})"
)
if stats["detected"] >= 2:
assert stats["x_range"] < max_var, (
f"{element_name}: variance X trop élevée: "
f"{stats['x_range']:.4f} (max={max_var})"
)
assert stats["y_range"] < max_var, (
f"{element_name}: variance Y trop élevée: "
f"{stats['y_range']:.4f} (max={max_var})"
)
def _assert_in_zone(
stats: Dict,
zone: Dict[str, float],
element_name: str,
):
"""Vérifier que la position moyenne est dans la zone attendue."""
assert stats["detected"] >= 1, f"{element_name}: aucune détection"
cx = stats["x_mean"]
cy = stats["y_mean"]
assert zone["x_min"] <= cx <= zone["x_max"], (
f"{element_name}: X moyen {cx:.4f} hors zone "
f"[{zone['x_min']:.2f}-{zone['x_max']:.2f}]"
)
assert zone["y_min"] <= cy <= zone["y_max"], (
f"{element_name}: Y moyen {cy:.4f} hors zone "
f"[{zone['y_min']:.2f}-{zone['y_max']:.2f}]"
)
# =========================================================================
# Zones calibrées (mesurées le 5 avril 2026)
# =========================================================================
CALIBRATED_ZONES = {
# shot_0001 — Explorateur de fichiers Windows
"rechercher_taskbar": {
"x_min": 0.40, "x_max": 0.60,
"y_min": 0.74, "y_max": 0.84,
},
"agent_v1_folder": {
"x_min": 0.18, "x_max": 0.30,
"y_min": 0.16, "y_max": 0.26,
},
# shot_0004 — Bloc-notes avec onglets
"fichier_menu": {
"x_min": 0.06, "x_max": 0.13,
"y_min": 0.06, "y_max": 0.12,
},
"modifier_menu": {
"x_min": 0.11, "x_max": 0.18,
"y_min": 0.06, "y_max": 0.12,
},
"ceci_est_un_test_tab": {
"x_min": 0.65, "x_max": 0.75,
"y_min": 0.03, "y_max": 0.08,
},
"close_x_notepad": {
"x_min": 0.95, "x_max": 1.02,
"y_min": 0.02, "y_max": 0.06,
},
# shot_0014 — Google Chrome
"google_search_bar": {
"x_min": 0.48, "x_max": 0.60,
"y_min": 0.35, "y_max": 0.43,
},
"gmail_link": {
"x_min": 0.87, "x_max": 0.95,
"y_min": 0.10, "y_max": 0.16,
},
}
# =========================================================================
# Tests de reproductibilité — 10 appels consécutifs
# =========================================================================
@pytest.mark.visual
class TestReproductibilite:
"""Chaque test appelle le VLM 10 fois et vérifie la cohérence.
Critères de réussite :
- Au moins 8/10 détections
- Variance des coordonnées < 5% de l'écran sur chaque axe
- Position moyenne dans la zone calibrée
"""
# -- shot_0001 : Explorateur de fichiers --
@pytest.fixture(scope="class")
def shot_0001(self):
return _load_screenshot("shot_0001_full.png")
def test_rechercher_10_fois(self, shot_0001):
"""Le VLM trouve 'Rechercher' au même endroit 10 fois de suite."""
results = _run_n_times(
shot_0001,
"the 'Rechercher' search text in the Windows taskbar at the bottom",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "Rechercher (taskbar)")
_assert_in_zone(stats, CALIBRATED_ZONES["rechercher_taskbar"], "Rechercher")
# Afficher le résumé pour le rapport
print(f"\n [Rechercher] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
def test_agent_v1_10_fois(self, shot_0001):
"""Le VLM trouve le dossier 'agent_v1' au même endroit 10 fois."""
results = _run_n_times(
shot_0001,
"the folder named 'agent_v1' in the file list",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "agent_v1 (dossier)")
_assert_in_zone(stats, CALIBRATED_ZONES["agent_v1_folder"], "agent_v1")
print(f"\n [agent_v1] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
def test_close_x_explorateur_10_fois(self, shot_0001):
"""Le bouton X de la fenêtre maximisée : overflow X attendu.
Ce test vérifie que le VLM détecte bien le bouton X de façon cohérente.
Sur les fenêtres maximisées (1280px de large), les coordonnées X
dépassent la grille 1000 normalisée (cx > 1.0).
Note : le VLM peut parfois confondre le bouton X de la fenêtre avec
celui de l'onglet (ambiguïté multiple close buttons). On vérifie
que la majorité des détections ciblent le bon bouton.
"""
results = _run_n_times(
shot_0001,
"the X close button of the 'Lea' window",
)
# Vérifier que le VLM détecte bien quelque chose
detected = [r for r in results if r["detected"]]
assert len(detected) >= _MIN_DETECTION_RATE, (
f"Close X: seulement {len(detected)}/{len(results)} détections"
)
# Classer les détections : overflow (bouton fenêtre) vs non-overflow (bouton onglet)
overflows = [r for r in detected if r["cx"] > 1.0]
non_overflows = [r for r in detected if r["cx"] <= 1.0]
# Au moins 60% des détections doivent viser le bouton fenêtre (overflow)
assert len(overflows) >= len(detected) * 0.6, (
f"Close X: seulement {len(overflows)}/{len(detected)} en overflow. "
f"Ambiguïté avec bouton onglet ({len(non_overflows)} non-overflow)."
)
# Vérifier la cohérence des détections overflow (le cluster principal)
if len(overflows) >= 2:
bboxes = [r["bbox"] for r in overflows]
x1s = [b[0] for b in bboxes]
y1s = [b[1] for b in bboxes]
assert max(x1s) - min(x1s) < 20, (
f"Close X overflow: x1 trop variable: {min(x1s)}-{max(x1s)}"
)
assert max(y1s) - min(y1s) < 20, (
f"Close X overflow: y1 trop variable: {min(y1s)}-{max(y1s)}"
)
print(f"\n [Close X Explorer] {len(detected)}/{len(results)} détections, "
f"{len(overflows)} overflow (fenêtre), {len(non_overflows)} non-overflow (onglet). "
f"cx_mean_overflow={statistics.mean([r['cx'] for r in overflows]):.4f}" if overflows else "")
# -- shot_0004 : Bloc-notes --
@pytest.fixture(scope="class")
def shot_0004(self):
return _load_screenshot("shot_0004_full.png")
def test_fichier_10_fois(self, shot_0004):
"""Le VLM trouve le menu 'Fichier' au même endroit 10 fois."""
results = _run_n_times(
shot_0004,
"the 'Fichier' menu item in the menu bar",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "Fichier (menu)")
_assert_in_zone(stats, CALIBRATED_ZONES["fichier_menu"], "Fichier")
print(f"\n [Fichier] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
def test_modifier_10_fois(self, shot_0004):
"""Le VLM trouve le menu 'Modifier' au même endroit 10 fois."""
results = _run_n_times(
shot_0004,
"the 'Modifier' menu item in the menu bar",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "Modifier (menu)")
_assert_in_zone(stats, CALIBRATED_ZONES["modifier_menu"], "Modifier")
print(f"\n [Modifier] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
def test_ceci_est_un_test_10_fois(self, shot_0004):
"""Le VLM trouve l'onglet 'Ceci est un test.txt' au même endroit 10 fois."""
results = _run_n_times(
shot_0004,
"the tab labeled 'Ceci est un test.txt'",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "Ceci est un test.txt (onglet)")
_assert_in_zone(stats, CALIBRATED_ZONES["ceci_est_un_test_tab"], "Ceci est un test.txt")
print(f"\n [Ceci est un test.txt] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
# -- shot_0014 : Google Chrome --
@pytest.fixture(scope="class")
def shot_0014(self):
return _load_screenshot("shot_0014_full.png")
def test_google_search_10_fois(self, shot_0014):
"""Le VLM trouve la barre de recherche Google au même endroit 10 fois."""
results = _run_n_times(
shot_0014,
"the Google search bar 'Rechercher sur Google ou saisir une URL'",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "Recherche Google")
_assert_in_zone(stats, CALIBRATED_ZONES["google_search_bar"], "Recherche Google")
print(f"\n [Google search] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
def test_gmail_10_fois(self, shot_0014):
"""Le VLM trouve le lien Gmail au même endroit 10 fois."""
results = _run_n_times(
shot_0014,
"the 'Gmail' link at the top of the page",
)
stats = _compute_stats(results)
_assert_reproducible(stats, "Gmail")
_assert_in_zone(stats, CALIBRATED_ZONES["gmail_link"], "Gmail")
print(f"\n [Gmail] {stats['rate_str']} détections, "
f"X=[{stats.get('x_min', 0):.4f}-{stats.get('x_max', 0):.4f}], "
f"Y=[{stats.get('y_min', 0):.4f}-{stats.get('y_max', 0):.4f}]")
# =========================================================================
# Tests de robustesse Citrix — JPEG dégradé
# =========================================================================
@pytest.mark.visual
class TestCitrixRobustesse:
"""Vérifier que le grounding fonctionne sur des images compressées.
Simule un environnement Citrix/RDP avec compression JPEG qualité 15-25.
Compare les résultats original vs dégradé.
"""
@pytest.fixture(scope="class")
def shots_original(self):
return {
"shot_0001": _load_screenshot("shot_0001_full.png"),
"shot_0004": _load_screenshot("shot_0004_full.png"),
"shot_0014": _load_screenshot("shot_0014_full.png"),
}
@pytest.fixture(scope="class")
def shots_citrix(self, shots_original):
return {
name: _degrade_citrix(b64, quality=20)
for name, b64 in shots_original.items()
}
def _compare_original_vs_citrix(
self,
original_b64: str,
citrix_b64: str,
description: str,
element_name: str,
zone: Dict,
n_runs: int = 5,
) -> Dict:
"""Comparer les résultats original vs Citrix."""
# 5 runs sur l'original
results_orig = _run_n_times(original_b64, description, n=n_runs, delay=0.2)
stats_orig = _compute_stats(results_orig)
# 5 runs sur le Citrix
results_citrix = _run_n_times(citrix_b64, description, n=n_runs, delay=0.2)
stats_citrix = _compute_stats(results_citrix)
return {
"original": stats_orig,
"citrix": stats_citrix,
}
def test_rechercher_citrix(self, shots_original, shots_citrix):
"""'Rechercher' détecté malgré compression JPEG Q20."""
comp = self._compare_original_vs_citrix(
shots_original["shot_0001"],
shots_citrix["shot_0001"],
"the 'Rechercher' search text in the Windows taskbar at the bottom",
"Rechercher",
CALIBRATED_ZONES["rechercher_taskbar"],
)
# Au moins 3/5 détections sur Citrix
assert comp["citrix"]["detected"] >= 3, (
f"Citrix Rechercher: seulement {comp['citrix']['rate_str']} détections"
)
# Position dans la zone calibrée
if comp["citrix"]["detected"] >= 1:
_assert_in_zone(comp["citrix"], CALIBRATED_ZONES["rechercher_taskbar"], "Rechercher (Citrix)")
print(f"\n [Rechercher Citrix] orig={comp['original']['rate_str']}, "
f"citrix={comp['citrix']['rate_str']}")
def test_fichier_citrix(self, shots_original, shots_citrix):
"""Menu 'Fichier' détecté malgré compression JPEG Q20."""
comp = self._compare_original_vs_citrix(
shots_original["shot_0004"],
shots_citrix["shot_0004"],
"the 'Fichier' menu item in the menu bar",
"Fichier",
CALIBRATED_ZONES["fichier_menu"],
)
assert comp["citrix"]["detected"] >= 3, (
f"Citrix Fichier: seulement {comp['citrix']['rate_str']} détections"
)
if comp["citrix"]["detected"] >= 1:
_assert_in_zone(comp["citrix"], CALIBRATED_ZONES["fichier_menu"], "Fichier (Citrix)")
print(f"\n [Fichier Citrix] orig={comp['original']['rate_str']}, "
f"citrix={comp['citrix']['rate_str']}")
def test_ceci_est_un_test_citrix(self, shots_original, shots_citrix):
"""Onglet 'Ceci est un test.txt' détecté malgré compression JPEG Q20."""
comp = self._compare_original_vs_citrix(
shots_original["shot_0004"],
shots_citrix["shot_0004"],
"the tab labeled 'Ceci est un test.txt'",
"Ceci est un test.txt",
CALIBRATED_ZONES["ceci_est_un_test_tab"],
)
assert comp["citrix"]["detected"] >= 3, (
f"Citrix tab: seulement {comp['citrix']['rate_str']} détections"
)
if comp["citrix"]["detected"] >= 1:
_assert_in_zone(
comp["citrix"],
CALIBRATED_ZONES["ceci_est_un_test_tab"],
"Ceci est un test.txt (Citrix)",
)
print(f"\n [Ceci est un test.txt Citrix] orig={comp['original']['rate_str']}, "
f"citrix={comp['citrix']['rate_str']}")
def test_google_search_citrix(self, shots_original, shots_citrix):
"""Barre de recherche Google détectée malgré compression JPEG Q20."""
comp = self._compare_original_vs_citrix(
shots_original["shot_0014"],
shots_citrix["shot_0014"],
"the Google search bar 'Rechercher sur Google ou saisir une URL'",
"Recherche Google",
CALIBRATED_ZONES["google_search_bar"],
)
assert comp["citrix"]["detected"] >= 3, (
f"Citrix Google: seulement {comp['citrix']['rate_str']} détections"
)
if comp["citrix"]["detected"] >= 1:
_assert_in_zone(
comp["citrix"],
CALIBRATED_ZONES["google_search_bar"],
"Recherche Google (Citrix)",
)
print(f"\n [Google search Citrix] orig={comp['original']['rate_str']}, "
f"citrix={comp['citrix']['rate_str']}")
def test_gmail_citrix(self, shots_original, shots_citrix):
"""Lien Gmail détecté malgré compression JPEG Q20."""
comp = self._compare_original_vs_citrix(
shots_original["shot_0014"],
shots_citrix["shot_0014"],
"the 'Gmail' link at the top of the page",
"Gmail",
CALIBRATED_ZONES["gmail_link"],
)
assert comp["citrix"]["detected"] >= 3, (
f"Citrix Gmail: seulement {comp['citrix']['rate_str']} détections"
)
if comp["citrix"]["detected"] >= 1:
_assert_in_zone(comp["citrix"], CALIBRATED_ZONES["gmail_link"], "Gmail (Citrix)")
print(f"\n [Gmail Citrix] orig={comp['original']['rate_str']}, "
f"citrix={comp['citrix']['rate_str']}")
# =========================================================================
# Tests de dégradation progressive — qualité JPEG 50 → 15 → 5
# =========================================================================
@pytest.mark.visual
class TestDegradationProgressive:
"""Mesurer à partir de quelle qualité JPEG le grounding échoue."""
@pytest.fixture(scope="class")
def shot_0004(self):
return _load_screenshot("shot_0004_full.png")
def test_fichier_degradation_progressive(self, shot_0004):
"""Fichier menu : tester JPEG Q50, Q25, Q15, Q10, Q5."""
qualities = [50, 25, 15, 10, 5]
results_by_quality = {}
for q in qualities:
degraded = _degrade_citrix(shot_0004, quality=q)
results = _run_n_times(
degraded,
"the 'Fichier' menu item in the menu bar",
n=3,
delay=0.2,
)
stats = _compute_stats(results)
results_by_quality[q] = stats
# Afficher le rapport de dégradation
print("\n === Dégradation progressive : Fichier menu ===")
for q in qualities:
s = results_by_quality[q]
zone_ok = ""
if s["detected"] >= 1:
cx = s["x_mean"]
cy = s["y_mean"]
z = CALIBRATED_ZONES["fichier_menu"]
in_zone = z["x_min"] <= cx <= z["x_max"] and z["y_min"] <= cy <= z["y_max"]
zone_ok = " (in zone)" if in_zone else f" (HORS zone: {cx:.3f},{cy:.3f})"
print(f" Q{q:>2}: {s['rate_str']} détections{zone_ok}")
# Au moins Q50 et Q25 doivent fonctionner
assert results_by_quality[50]["detected"] >= 2, "Q50 devrait fonctionner"
assert results_by_quality[25]["detected"] >= 2, "Q25 devrait fonctionner"
# =========================================================================
# Rapport final — exécuté en dernier, résume tout
# =========================================================================
@pytest.mark.visual
class TestRapportFinal:
"""Rapport complet des capacités de grounding VLM.
Ce test exécute une batterie de détections et produit un rapport
structuré avec taux de détection, variance, et comparaison Citrix.
"""
def test_rapport_complet(self):
"""Génère le rapport final de robustesse du grounding VLM."""
from PIL import Image
shots = {
"shot_0001": _load_screenshot("shot_0001_full.png"),
"shot_0004": _load_screenshot("shot_0004_full.png"),
"shot_0014": _load_screenshot("shot_0014_full.png"),
}
targets = [
("shot_0001", "Rechercher (taskbar)",
"the 'Rechercher' search text in the Windows taskbar at the bottom",
CALIBRATED_ZONES["rechercher_taskbar"]),
("shot_0001", "agent_v1 (dossier)",
"the folder named 'agent_v1' in the file list",
CALIBRATED_ZONES["agent_v1_folder"]),
("shot_0004", "Fichier (menu)",
"the 'Fichier' menu item in the menu bar",
CALIBRATED_ZONES["fichier_menu"]),
("shot_0004", "Modifier (menu)",
"the 'Modifier' menu item in the menu bar",
CALIBRATED_ZONES["modifier_menu"]),
("shot_0004", "Ceci est un test.txt (onglet)",
"the tab labeled 'Ceci est un test.txt'",
CALIBRATED_ZONES["ceci_est_un_test_tab"]),
("shot_0004", "Close X (Bloc-notes)",
"the close button X of the Notepad window at the top right",
CALIBRATED_ZONES["close_x_notepad"]),
("shot_0014", "Recherche Google (barre)",
"the Google search bar 'Rechercher sur Google ou saisir une URL'",
CALIBRATED_ZONES["google_search_bar"]),
("shot_0014", "Gmail (lien)",
"the 'Gmail' link at the top of the page",
CALIBRATED_ZONES["gmail_link"]),
]
report_lines = [
"",
"=" * 80,
"RAPPORT DE ROBUSTESSE — Grounding VLM qwen2.5vl:7b",
f"Date: {time.strftime('%Y-%m-%d %H:%M:%S')}",
f"Screenshots: 1280x800 (3 images, {len(targets)} cibles)",
f"Répétitions: 5 par cible (original + Citrix Q20)",
"=" * 80,
"",
"--- ORIGINAL (PNG) ---",
f"{'Élément':<35} {'Taux':>6} {'X moy':>8} {'Y moy':>8} "
f"{'Var X':>8} {'Var Y':>8} {'Zone':>6}",
"-" * 80,
]
all_original_stats = []
all_citrix_stats = []
for shot_name, label, desc, zone in targets:
# Original : 5 runs
results_orig = _run_n_times(shots[shot_name], desc, n=5, delay=0.2)
stats_orig = _compute_stats(results_orig)
all_original_stats.append((label, stats_orig, zone))
in_zone = "?"
if stats_orig["detected"] >= 1:
cx, cy = stats_orig["x_mean"], stats_orig["y_mean"]
ok = (zone["x_min"] <= cx <= zone["x_max"]
and zone["y_min"] <= cy <= zone["y_max"])
in_zone = "OK" if ok else "HORS"
report_lines.append(
f"{label:<35} {stats_orig['rate_str']:>6} "
f"{stats_orig.get('x_mean', 0):>8.4f} "
f"{stats_orig.get('y_mean', 0):>8.4f} "
f"{stats_orig.get('x_range', 0):>8.4f} "
f"{stats_orig.get('y_range', 0):>8.4f} "
f"{in_zone:>6}"
)
report_lines.extend([
"",
"--- CITRIX (JPEG Q20) ---",
f"{'Élément':<35} {'Taux':>6} {'X moy':>8} {'Y moy':>8} "
f"{'Var X':>8} {'Var Y':>8} {'Zone':>6} {'Écart orig':>10}",
"-" * 90,
])
for i, (shot_name, label, desc, zone) in enumerate(targets):
citrix_b64 = _degrade_citrix(shots[shot_name], quality=20)
results_citrix = _run_n_times(citrix_b64, desc, n=5, delay=0.2)
stats_citrix = _compute_stats(results_citrix)
all_citrix_stats.append((label, stats_citrix, zone))
in_zone = "?"
ecart = "N/A"
if stats_citrix["detected"] >= 1:
cx, cy = stats_citrix["x_mean"], stats_citrix["y_mean"]
ok = (zone["x_min"] <= cx <= zone["x_max"]
and zone["y_min"] <= cy <= zone["y_max"])
in_zone = "OK" if ok else "HORS"
# Calculer l'écart avec l'original
orig_stats = all_original_stats[i][1]
if orig_stats["detected"] >= 1:
dx = abs(cx - orig_stats["x_mean"])
dy = abs(cy - orig_stats["y_mean"])
ecart = f"{dx:.4f}/{dy:.4f}"
report_lines.append(
f"{label:<35} {stats_citrix['rate_str']:>6} "
f"{stats_citrix.get('x_mean', 0):>8.4f} "
f"{stats_citrix.get('y_mean', 0):>8.4f} "
f"{stats_citrix.get('x_range', 0):>8.4f} "
f"{stats_citrix.get('y_range', 0):>8.4f} "
f"{in_zone:>6} {ecart:>10}"
)
# Résumé
orig_total = sum(s["detected"] for _, s, _ in all_original_stats)
orig_max = sum(s["total"] for _, s, _ in all_original_stats)
citrix_total = sum(s["detected"] for _, s, _ in all_citrix_stats)
citrix_max = sum(s["total"] for _, s, _ in all_citrix_stats)
orig_in_zone = sum(
1 for _, s, z in all_original_stats
if s["detected"] >= 1
and z["x_min"] <= s["x_mean"] <= z["x_max"]
and z["y_min"] <= s["y_mean"] <= z["y_max"]
)
citrix_in_zone = sum(
1 for _, s, z in all_citrix_stats
if s["detected"] >= 1
and z["x_min"] <= s["x_mean"] <= z["x_max"]
and z["y_min"] <= s["y_mean"] <= z["y_max"]
)
# Éléments non fiables
unreliable = []
for label, s, _ in all_original_stats:
if s["detected"] < 3:
unreliable.append(f"{label} (taux {s['rate_str']})")
elif s.get("x_range", 0) >= _MAX_VARIANCE or s.get("y_range", 0) >= _MAX_VARIANCE:
unreliable.append(
f"{label} (variance X={s.get('x_range', 0):.4f} "
f"Y={s.get('y_range', 0):.4f})"
)
report_lines.extend([
"",
"=" * 80,
"RÉSUMÉ",
"=" * 80,
f" Détection original : {orig_total}/{orig_max} "
f"({orig_total/orig_max*100:.0f}%)",
f" Détection Citrix Q20: {citrix_total}/{citrix_max} "
f"({citrix_total/citrix_max*100:.0f}%)",
f" Positionnement correct (original) : {orig_in_zone}/{len(all_original_stats)}",
f" Positionnement correct (Citrix) : {citrix_in_zone}/{len(all_citrix_stats)}",
"",
])
if unreliable:
report_lines.append(" ÉLÉMENTS NON FIABLES :")
for u in unreliable:
report_lines.append(f" - {u}")
else:
report_lines.append(" Tous les éléments sont fiables.")
report_lines.extend([
"",
" NOTES TECHNIQUES :",
" - qwen2.5vl bbox_2d retourne des pixels relatifs à l'image envoyée",
" - Normalisation : diviser par les dimensions de l'image (W, H)",
" - temperature=0.1 donne une variance < 0.003 typiquement",
"=" * 80,
])
report = "\n".join(report_lines)
print(report)
# Le test réussit si au moins 80% des détections originales fonctionnent
assert orig_total / orig_max >= 0.80, (
f"Taux de détection global trop bas: {orig_total}/{orig_max}"
)