v1.0 - Version stable: multi-PC, détection UI-DETR-1, 3 modes exécution

- Frontend v4 accessible sur réseau local (192.168.1.40)
- Ports ouverts: 3002 (frontend), 5001 (backend), 5004 (dashboard)
- Ollama GPU fonctionnel
- Self-healing interactif
- Dashboard confiance

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Dom
2026-01-29 11:23:51 +01:00
parent 21bfa3b337
commit a27b74cf22
1595 changed files with 412691 additions and 400 deletions

View File

@@ -0,0 +1,246 @@
# 🗑️ Architecture de Nettoyage - Cycle de Vie des Données
**Date**: 7 janvier 2026
**Objectif**: Définir quand supprimer quoi dans le système RPA Vision V3
---
## 📊 Cycle de Vie Complet
```
┌─────────────────────────────────────────────────────────────────┐
│ 1. CAPTURE (Agent V0) │
│ - Screenshots bruts (PNG) │
│ - Events JSON │
│ - Chiffrement AES-256 │
└────────────────┬────────────────────────────────────────────────┘
│ ZIP chiffré (.enc)
┌─────────────────────────────────────────────────────────────────┐
│ 2. UPLOAD (Serveur) │
│ - Réception ZIP chiffré → /data/training/uploads/ │
│ - Déchiffrement │
│ - Extraction → /data/training/sessions/sess_*/ │
│ ├── sess_*.json │
│ └── shots/shot_*.png │
└────────────────┬────────────────────────────────────────────────┘
│ Données brutes disponibles
┌─────────────────────────────────────────────────────────────────┐
│ 3. TRAITEMENT (Worker) │
│ Pour chaque screenshot: │
│ - Détection UI (OpenCV + OWL-v2 + VLM) │
│ - Génération embeddings (CLIP) → /data/embeddings/ │
│ - Création ScreenState → /data/screen_states/ │
│ - OCR et extraction texte │
│ │
│ Résultat: Données structurées sans besoin des PNG bruts │
└────────────────┬────────────────────────────────────────────────┘
│ Embeddings + Screen States créés
┌─────────────────────────────────────────────────────────────────┐
│ 4. APPRENTISSAGE (Learning Manager) │
│ - Clustering DBSCAN sur embeddings │
│ - Détection patterns répétés │
│ - Construction WorkflowGraph │
│ - Indexation FAISS → /data/faiss_index/ │
│ - Sauvegarde Workflows → /data/workflows/ │
│ │
│ Résultat: Workflows exécutables créés │
└────────────────┬────────────────────────────────────────────────┘
│ Apprentissage TERMINÉ
┌─────────────────────────────────────────────────────────────────┐
│ 5. NETTOYAGE (Post-Learning Cleanup) ← TODO APRÈS POC │
│ ❌ SUPPRIMER: │
│ - Screenshots bruts (shots/*.png) │
│ - JSON session brut (sess_*.json) │
│ - ZIP chiffré (.enc) │
│ │
│ ✅ CONSERVER: │
│ - Embeddings (/data/embeddings/) │
│ - Screen States (/data/screen_states/) │
│ - Workflows (/data/workflows/) │
│ - Index FAISS (/data/faiss_index/) │
│ │
│ Gain: ~90% espace disque (PNG = gros fichiers) │
└─────────────────────────────────────────────────────────────────┘
```
---
## 🎯 Statut Actuel (POC/MVP)
### ✅ Ce qui Fonctionne
- Upload et déchiffrement ✅
- Extraction screenshots ✅
- Traitement et création embeddings ✅
- Création screen states ✅
### ⚠️ Problème Identifié
**Le nettoyage se fait TROP TÔT** (ligne 164 de `processing_pipeline.py`)
```python
# Après traitement (étape 3), mais AVANT apprentissage (étape 4)
self._cleanup_raw_files(session_id, stats) # ← TROP TÔT !
```
**Conséquence** :
- Screenshots supprimés avant l'apprentissage ❌
- Apprentissage ne peut pas accéder aux images ❌
- Impossible de valider visuellement les captures ❌
### 🔧 Solution Court Terme (POC)
**Désactiver complètement le nettoyage** jusqu'après le POC
```bash
sudo bash disable_premature_cleanup.sh
```
---
## 🚀 Architecture Cible (Post-POC)
### Option A : Nettoyage Automatique Post-Apprentissage
**Trigger** : Quand le workflow atteint l'état `AUTO_CONFIRMÉ`
```python
class LearningManager:
def promote_workflow(self, workflow_id: str):
workflow = self.get_workflow(workflow_id)
if workflow.state == LearningState.AUTO_CONFIRMED:
# Workflow validé → Plus besoin des données brutes
self._cleanup_learned_session(workflow.source_session_ids)
def _cleanup_learned_session(self, session_ids: List[str]):
"""Nettoie les données brutes des sessions apprises."""
for session_id in session_ids:
# Supprimer screenshots
screenshots_dir = Path(f"data/training/sessions/{session_id}/shots")
if screenshots_dir.exists():
shutil.rmtree(screenshots_dir)
# Supprimer JSON brut
for json_file in Path("data/training/sessions").rglob(f"*{session_id}.json"):
json_file.unlink()
# Supprimer ZIP
for zip_file in Path("data/training/uploads").glob(f"{session_id}.*"):
zip_file.unlink()
logger.info(f"Cleaned up learned session: {session_id}")
```
### Option B : Nettoyage Manuel Contrôlé
**Interface admin** : Bouton "Nettoyer sessions apprises"
**Avantage** : Contrôle total, utile pour debugging
### Option C : Nettoyage Par Rétention
**Règle** : Conserver X jours de données brutes, supprimer le reste
```python
# Nettoyer sessions > 30 jours avec workflow confirmé
retention_days = 30
cutoff_date = datetime.now() - timedelta(days=retention_days)
for session in get_all_sessions():
if session.created_at < cutoff_date:
if session.has_confirmed_workflow():
cleanup_session(session.id)
```
---
## 📋 Recommandation
### Court Terme (POC/MVP) - MAINTENANT
**Désactiver le nettoyage**
- Permet de valider le système complet
- Permet la démo avec screenshots visibles
- Réversible
### Moyen Terme (Production V1) - APRÈS POC
**Option A** : Nettoyage automatique post-apprentissage
- Logique claire et automatique
- Pas d'intervention manuelle
- Gain d'espace progressif
### Long Terme (Production V2)
**Option A + C** : Auto + Rétention
- Nettoyage immédiat post-apprentissage
- + Rétention de sécurité (30j)
- + Interface admin pour cas spéciaux
---
## 🔍 Données à Conserver TOUJOURS
**Pour l'exécution autonome** :
-**Embeddings** (vecteurs CLIP 512D) → Matching rapide
-**Screen States** (états analysés) → Context des écrans
-**Workflows** (graphes validés) → Exécution automatique
-**Index FAISS** (recherche vectorielle) → Performance
**Ces 4 éléments suffisent pour faire tourner le RPA !**
---
## 💾 Estimation Espace Disque
### Avant Nettoyage (Par Session)
```
- Screenshots (16 x 1920x1080 PNG) : ~15-20 MB
- JSON session brut : ~50 KB
- ZIP chiffré : ~15-20 MB
TOTAL par session : ~35-40 MB
```
### Après Nettoyage (Par Session)
```
- Embeddings (16 x 512 floats) : ~32 KB
- Screen States (16 x JSON) : ~20 KB
- Workflow (1 x JSON) : ~5 KB
TOTAL par session : ~60 KB
```
**Gain** : ~99% d'espace (35 MB → 60 KB par session)
---
## 🎯 Actions Immédiates
1.**Maintenant** : Désactiver nettoyage prématuré
```bash
sudo bash disable_premature_cleanup.sh
```
2. ✅ **Test** : Capturer nouvelle session
```bash
cd agent_v0 && ./run.sh
```
3. ✅ **Validation** : Vérifier screenshots conservés
```bash
ls -lhR /opt/rpa_vision_v3/data/training/sessions/sess_*/shots/
```
4.**Après POC** : Implémenter Option A (nettoyage post-apprentissage)
---
## 📞 Questions/Décisions
- [ ] Quelle option choisir pour la production ? (A, B, ou C)
- [ ] Durée de rétention souhaitée ? (30j, 90j ?)
- [ ] Interface admin nécessaire ?
- [ ] Logs audit des nettoyages ?
---
**Version** : 1.0 - POC/MVP
**Prochaine révision** : Après validation POC