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

Initial commit

Browse Source
This commit is contained in:
Dom
2026-03-05 00:20:25 +01:00
commit dcd4de9945
1954 changed files with 669380 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

687
.kiro/specs/rpa-vision-v2/design.md Normal file
View File

@@ -0,0 +1,687 @@
# Document de Design
## Vue d'Ensemble
RPA Vision V2 est un système d'automatisation à apprentissage progressif construit sur une architecture cognitive qui suit le paradigme Observer → Réfléchir → Agir. Le système utilise des modèles de vision par ordinateur de pointe pour la détection d'éléments UI, des modèles de langage pour le raisonnement visuel, et des mécanismes de mémoire adaptative pour apprendre les flux de travail utilisateur de manière incrémentale à travers trois modes opérationnels : Shadow, Assisté et Autopilot.
L'architecture est modulaire, avec une séparation claire entre la logique centrale (orchestration, apprentissage, embeddings), les composants IA (détection vision, raisonnement LLM), l'interface utilisateur (GUI PyQt5), et la persistance des données (logs chiffrés, index FAISS, profils utilisateur).
## Architecture
### Architecture de Haut Niveau
```
┌─────────────────────────────────────────────────────────────────┐
│ Couche Interface Utilisateur │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
│ │ GUI Minimale │ │ Dialogue de │ │ Tableau de Bord │ │
│ │ (PyQt5) │ │ Correction │ │ Résumé │ │
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────────────┐
│ Couche Orchestration Centrale │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Orchestrateur (Boucle Cognitive) │ │
│ │ Observer → Réfléchir → Agir → Apprendre → Répéter │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↕ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
│ │ Gestionnaire │ │ Gestionnaire │ │ Rejeu Async │ │
│ │Apprentissage │ │ Embeddings │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────────────┐
│ Couche IA/Vision │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
│ │ Utils Vision │ │ Gestionnaire │ │ Utils Image │ │
│ │ OWL-v2/DINO │ │ LLM │ │ Capture/ROI │ │
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────────────┐
│ Couche Persistance des Données │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
│ │ Logs │ │ Profils │ │ Index FAISS │ │
│ │ Chiffrés │ │ Utilisateur │ │ (Embeddings) │ │
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
### Structure des Répertoires
```
/AI/amina/geniusia2/
├── core/
│ ├── orchestrator.py # Boucle cognitive principale
│ ├── replay_async.py # Moteur de rejeu d'actions
│ ├── embeddings_manager.py # Gestion OpenCLIP + FAISS
│ ├── learning_manager.py # État d'apprentissage & transitions de mode
│ ├── logger.py # Journalisation chiffrée AES-256
│ ├── config.py # Configuration globale
│ └── utils/
│ ├── image_utils.py # Capture d'écran, extraction ROI
│ ├── vision_utils.py # Interfaces modèles vision
│ └── input_utils.py # PyAutoGUI/PyDirectInput (AZERTY)
├── gui/
│ ├── minimal_gui.py # Interface PyQt5 principale
│ └── dialogs/
│ ├── correction_dialog.py
│ └── summary_dashboard.py
├── data/
│ ├── user_profiles/ # Profils d'apprentissage tâches (JSON)
│ ├── logs/ # Logs d'actions chiffrés
│ └── faiss_index/ # Index de mémoire visuelle
└── models/
├── openclip/ # Encodeurs visuels
├── owl_v2/ # Détecteur open-vocabulary
└── qwen2.5_vl/ # Modèle vision-langage (Ollama)
```
## Composants et Interfaces
### 1. Orchestrateur (orchestrator.py)
**Responsabilité** : Boucle cognitive principale implémentant le paradigme Observer → Réfléchir → Agir.
**Méthodes Clés** :
- `run()` : Boucle d'événements principale
- `capture_context()` : Capture d'écran et détection de fenêtre
- `detect_elements(frame, intent)` : Détection d'éléments UI basée sur la vision
- `reason_about_action(detections, context)` : Prise de décision basée sur LLM
- `execute_or_suggest(decision)` : Exécution d'action dépendante du mode
- `learn_from_feedback(feedback)` : Mise à jour de l'état d'apprentissage
**Interfaces** :
```python
class Orchestrator:
def __init__(self, config, learning_manager, vision_utils, llm_manager, gui):
self.config = config
self.learning_manager = learning_manager
self.vision = vision_utils
self.llm = llm_manager
self.gui = gui
self.running = False
def run(self):
"""Boucle cognitive principale"""
while self.running:
# Observer
frame = self.capture_context()
intent = self.learning_manager.get_current_intent()
# Réfléchir
detections = self.vision.detect(frame, intent)
decision = self.llm.reason_about_action(detections, context)
# Agir (dépendant du mode)
mode = self.learning_manager.get_mode()
if mode == "shadow":
self.learning_manager.observe(decision)
elif mode == "assist":
feedback = self.gui.show_suggestion(decision)
self.learning_manager.confirm_action(feedback)
elif mode == "auto":
self.execute_action(decision)
self.learning_manager.record_execution(decision)
```
### 2. Gestionnaire d'Apprentissage (learning_manager.py)
**Responsabilité** : Suit la progression d'apprentissage, gère les transitions de mode, calcule les scores de confiance.
**Attributs Clés** :
- `mode` : Mode opérationnel actuel (shadow/assist/auto)
- `tasks` : Dictionnaire des Séquence_Actions apprises
- `current_context` : Contexte de tâche actif
- `embeddings_index` : Référence à l'index FAISS
- `logger` : Référence au logger chiffré
**Méthodes Clés** :
- `observe(action)` : Enregistrer l'observation en mode Shadow
- `suggest_action(context)` : Générer une suggestion en mode Assisté
- `confirm_action(feedback)` : Traiter la validation/correction utilisateur
- `evaluate_task(task_id)` : Calculer confiance et concordance
- `should_transition_to_auto(task_id)` : Vérifier l'éligibilité autopilot
- `rollback_if_low_confidence(task_id)` : Rétrograder au mode Assisté
- `calculate_confidence(vision_conf, llm_score, history)` : Calculer le score de confiance
**Interfaces** :
```python
class LearningManager:
def __init__(self, embeddings_manager, logger, config):
self.mode = "shadow" # Mode initial
self.tasks = {} # task_id -> TaskProfile
self.embeddings_manager = embeddings_manager
self.logger = logger
self.config = config
def calculate_confidence(self, vision_conf, llm_score, task_id):
"""Calculer le score de confiance pondéré"""
history_score = self.tasks[task_id].get_historical_performance()
return 0.6 * vision_conf + 0.3 * llm_score + 0.1 * history_score
def should_transition_to_auto(self, task_id):
"""Vérifier si la tâche remplit les critères autopilot"""
task = self.tasks[task_id]
return (task.observation_count >= 20 and
task.concordance_rate >= 0.95)
def rollback_if_low_confidence(self, task_id):
"""Rétrograder au mode Assisté si confiance faible"""
task = self.tasks[task_id]
if task.mode == "auto" and task.confidence_score < 0.90:
task.mode = "assist"
self.logger.log_mode_transition(task_id, "auto", "assist", "low_confidence")
```
### 3. Gestionnaire d'Embeddings (embeddings_manager.py)
**Responsabilité** : Gère les embeddings visuels en utilisant OpenCLIP et l'indexation FAISS pour la recherche de similarité.
**Méthodes Clés** :
- `encode_image(image)` : Générer un embedding 512-d avec OpenCLIP
- `add_to_index(embedding, metadata)` : Stocker l'embedding dans FAISS
- `search_similar(embedding, k=5)` : Trouver les k embeddings les plus similaires
- `rebuild_index()` : Reconstruire l'index FAISS après mises à jour
- `get_embedding_similarity(emb1, emb2)` : Calculer la similarité cosinus
**Interfaces** :
```python
class EmbeddingsManager:
def __init__(self, model_path, index_path):
self.clip_model = self.load_openclip(model_path)
self.faiss_index = self.load_or_create_index(index_path)
self.metadata_store = {} # id -> mapping métadonnées
def encode_image(self, image):
"""Générer un embedding 512-d"""
with torch.no_grad():
embedding = self.clip_model.encode_image(image)
return embedding.cpu().numpy()
def add_to_index(self, embedding, metadata):
"""Stocker l'embedding avec métadonnées"""
idx = self.faiss_index.ntotal
self.faiss_index.add(embedding.reshape(1, -1))
self.metadata_store[idx] = metadata
return idx
def search_similar(self, query_embedding, k=5):
"""Trouver les k plus proches voisins"""
distances, indices = self.faiss_index.search(
query_embedding.reshape(1, -1), k
)
results = [
{
"id": int(idx),
"distance": float(dist),
"metadata": self.metadata_store[int(idx)]
}
for dist, idx in zip(distances[0], indices[0])
]
return results
```
### 4. Utils Vision (vision_utils.py)
**Responsabilité** : Interface vers les modèles de vision (OWL-v2, Grounding DINO, YOLO-World) pour la détection d'éléments UI.
**Méthodes Clés** :
- `detect_with_owlv2(prompt, frame)` : Détection open-vocabulary avec OWL-v2
- `detect_with_dino(prompt, frame)` : Détection Grounding DINO
- `detect_with_yolo(prompt, frame)` : Détection YOLO-World
- `select_best_detection(detections, context)` : Choisir la détection la plus confiante
- `extract_roi(frame, bbox)` : Extraire la région d'intérêt
**Format de Sortie de Détection** :
```python
{
"label": "valider_button",
"confidence": 0.93,
"bbox": (x, y, w, h), # Coordonnées en pixels
"embedding": np.array([...]), # Embedding visuel 512-d
"model": "owl-v2"
}
```
### 5. Gestionnaire LLM (llm_manager.py)
**Responsabilité** : Interface vers Ollama pour le raisonnement visuel utilisant Qwen 2.5-VL ou CogVLM.
**Méthodes Clés** :
- `reason_about_detections(detections, context, intent)` : Sélectionner la meilleure action
- `generate_with_vision(prompt, images)` : Génération multi-modale
- `score_action_relevance(action, intent)` : Calculer la confiance LLM
**Interfaces** :
```python
class LLMManager:
def __init__(self, model_name="qwen2.5-vl:3b", ollama_host="localhost:11434"):
self.model_name = model_name
self.ollama_client = ollama.Client(host=ollama_host)
def reason_about_detections(self, detections, context, intent):
"""Utiliser VLM pour sélectionner la meilleure action"""
prompt = f"""Étant donné ces éléments UI et l'intention utilisateur '{intent}',
avec quel élément devrait-on interagir ?
Éléments : {[d['label'] for d in detections]}
Contexte : {context}
Répondre avec le label de l'élément et la confiance (0-1)."""
images = [d['roi_image'] for d in detections]
response = self.ollama_client.generate(
model=self.model_name,
prompt=prompt,
images=images
)
return self.parse_llm_response(response)
```
### 6. Logger (logger.py)
**Responsabilité** : Journalisation chiffrée AES-256 avec format JSON structuré.
**Méthodes Clés** :
- `log_action(action_data)` : Enregistrer l'action avec chiffrement
- `log_correction(correction_data)` : Enregistrer la correction utilisateur
- `log_mode_transition(task_id, from_mode, to_mode, reason)` : Enregistrer les changements de mode
- `get_logs(task_id=None, start_time=None, end_time=None)` : Interroger les logs
- `encrypt_entry(data)` : Chiffrement AES-256
- `decrypt_entry(encrypted_data)` : Déchiffrement AES-256
**Format d'Entrée de Log** :
```python
{
"timestamp": "2025-11-13T10:32:04.123Z",
"window": "Dolibarr - Facturation",
"action": "click",
"element": "valider_button",
"bbox": [450, 320, 120, 40],
"confidence": 0.97,
"mode": "auto",
"result": "success",
"task_id": "ouvrir_facture_001"
}
```
### 7. GUI Minimale (minimal_gui.py)
**Responsabilité** : Interface PyQt5 pour l'affichage des modes, suggestions et retours utilisateur.
**Composants Clés** :
- Indicateur de mode (👀 Shadow | 🤝 Assisté | 🤖 Auto)
- Contrôles Start/Stop/Pause
- Superposition de suggestion avec éléments UI surlignés
- Raccourcis clavier (Entrée/Échap/Alt+C/Ctrl+Pause)
- Système de notifications pour alertes et confirmations
**Interfaces** :
```python
class MinimalGUI(QMainWindow):
def __init__(self, orchestrator):
super().__init__()
self.orchestrator = orchestrator
self.init_ui()
self.setup_shortcuts()
def show_suggestion(self, decision):
"""Afficher la superposition de suggestion et attendre l'entrée utilisateur"""
overlay = SuggestionOverlay(decision)
overlay.show()
return overlay.wait_for_feedback() # Retourne : "accept", "reject", ou "correct"
def show_notification(self, message, notification_type="info"):
"""Afficher une notification non intrusive"""
notification = QNotification(message, notification_type)
notification.show()
def update_mode_indicator(self, mode):
"""Mettre à jour l'icône de mode dans l'UI"""
icons = {"shadow": "👀", "assist": "🤝", "auto": "🤖"}
self.mode_label.setText(f"{icons[mode]} {mode.capitalize()}")
```
### 8. Tableau de Bord Résumé (summary_dashboard.py)
**Responsabilité** : Afficher les statistiques de tâches, niveaux de confiance et historique d'exécution.
**Fonctionnalités Clés** :
- Tableau de métriques en temps réel
- Filtrage et recherche de tâches
- Visualisation des tendances de confiance
- Historique des corrections
- Fonctionnalité d'export
**Métriques du Tableau de Bord** :
```python
{
"task_id": "ouvrir_facture",
"task_name": "Ouvrir Facture",
"mode": "auto",
"confidence": 97.3,
"observation_count": 45,
"concordance_rate": 98.2,
"correction_count": 1,
"last_execution": "2025-11-12T15:32:04",
"avg_latency_ms": 320,
"success_rate": 98.9
}
```
## Modèles de Données
### TaskProfile
```python
@dataclass
class TaskProfile:
task_id: str
task_name: str
mode: str # "shadow", "assist", "auto"
observation_count: int
concordance_rate: float
confidence_score: float
correction_count: int
last_execution: datetime
window_whitelist: List[str]
action_sequence: List[Action]
embeddings: List[np.ndarray]
metadata: Dict[str, Any]
def to_json(self):
"""Sérialiser en JSON pour la persistance"""
return {
"task_id": self.task_id,
"task_name": self.task_name,
"mode": self.mode,
"observation_count": self.observation_count,
"concordance_rate": self.concordance_rate,
"confidence_score": self.confidence_score,
"correction_count": self.correction_count,
"last_execution": self.last_execution.isoformat(),
"window_whitelist": self.window_whitelist,
"action_sequence": [a.to_dict() for a in self.action_sequence],
"metadata": self.metadata
}
```
### Action
```python
@dataclass
class Action:
action_type: str # "click", "type", "scroll", "wait"
target_element: str
bbox: Tuple[int, int, int, int]
confidence: float
embedding: np.ndarray
timestamp: datetime
window_title: str
def to_dict(self):
return {
"action_type": self.action_type,
"target_element": self.target_element,
"bbox": list(self.bbox),
"confidence": self.confidence,
"timestamp": self.timestamp.isoformat(),
"window_title": self.window_title
}
```
### Detection
```python
@dataclass
class Detection:
label: str
confidence: float
bbox: Tuple[int, int, int, int]
embedding: np.ndarray
model_source: str # "owl-v2", "dino", "yolo"
roi_image: np.ndarray
```
## Gestion des Erreurs
### Échecs des Modèles de Vision
**Scénario** : Le modèle de vision ne parvient pas à détecter d'éléments UI.
**Gestion** :
1. Logger l'erreur avec contexte (fenêtre, capture d'écran)
2. Réessayer avec un modèle de vision alternatif (OWL-v2 → DINO → YOLO)
3. Si tous les modèles échouent, notifier l'utilisateur et mettre en pause l'automatisation
4. Demander une correction manuelle ou une ré-observation
### Échecs du Raisonnement LLM
**Scénario** : Service Ollama indisponible ou LLM retourne une réponse à faible confiance.
**Gestion** :
1. Revenir à la détection pure basée sur la vision (bbox avec confiance la plus élevée)
2. Réduire temporairement le poids du LLM dans le calcul de confiance
3. Logger l'opération en mode dégradé
4. Notifier l'utilisateur de la capacité de raisonnement réduite
### Violations de Seuil de Confiance
**Scénario** : Le score de confiance tombe en dessous du seuil pendant le mode Autopilot.
**Gestion** :
1. Geler immédiatement l'exécution de l'action
2. Faire passer la tâche en mode Assisté
3. Afficher une notification expliquant la baisse de confiance
4. Demander la validation utilisateur pour la prochaine action
5. Logger la transition de mode avec raison
### Violations de Liste Blanche
**Scénario** : Le système tente une action dans une fenêtre non présente dans la liste blanche.
**Gestion** :
1. Bloquer l'action immédiatement
2. Logger la violation de sécurité avec détails de la fenêtre
3. Afficher une alerte à l'utilisateur
4. Inviter l'utilisateur à ajouter la fenêtre à la liste blanche ou abandonner la tâche
### Échecs de Rollback
**Scénario** : L'opération de rollback ne peut pas restaurer l'état précédent.
**Gestion** :
1. Logger l'échec du rollback avec les actions tentées
2. Notifier l'utilisateur du rollback partiel
3. Fournir des instructions d'annulation manuelle
4. Mettre en pause l'automatisation jusqu'à confirmation de l'état par l'utilisateur
### Corruption de l'Index FAISS
**Scénario** : L'index FAISS devient corrompu ou inaccessible.
**Gestion** :
1. Tenter la reconstruction de l'index à partir des embeddings stockés
2. Si la reconstruction échoue, créer un nouvel index et marquer les tâches pour ré-observation
3. Notifier l'utilisateur de la perte de données et des tâches affectées
4. Continuer l'opération avec un contexte historique réduit
## Stratégie de Test
### Tests Unitaires
**Composants Centraux** :
- `LearningManager` : Tester le calcul de confiance, transitions de mode, évaluation de tâche
- `EmbeddingsManager` : Tester l'encodage, l'indexation, la recherche de similarité
- `Logger` : Tester le chiffrement/déchiffrement, l'interrogation des logs
- `Vision Utils` : Tester le parsing de détection, l'extraction ROI
- `LLM Manager` : Tester la génération de prompts, le parsing de réponses
**Framework de Test** : pytest avec fixtures pour données mock
### Tests d'Intégration
**Scénarios** :
1. **Transition Shadow → Assisté** : Vérifier que l'accumulation d'observations déclenche le changement de mode
2. **Transition Assisté → Autopilot** : Vérifier les exigences de seuil de confiance et de compteur d'observations
3. **Rollback Autopilot → Assisté** : Vérifier que la faible confiance déclenche la rétrogradation
4. **Boucle de Retour de Correction** : Vérifier que les corrections mettent à jour les embeddings et améliorent les prédictions futures
5. **Application de Liste Blanche** : Vérifier que les actions sont bloquées dans les fenêtres non présentes dans la liste blanche
6. **Opération de Rollback** : Vérifier que les 3 dernières actions peuvent être inversées
### Tests de Bout en Bout
**Flux de Travail de Test** :
1. **Cycle d'Apprentissage Complet** : Observation Shadow → Validation Assistée → Exécution Autopilot
2. **Adaptation au Changement d'UI** : Introduire des changements d'UI et vérifier que le système détecte et s'adapte
3. **Gestion Multi-Tâches** : Apprendre et exécuter plusieurs tâches simultanément
4. **Conformité Sécurité** : Vérifier que tous les logs sont chiffrés, liste blanche appliquée, rollback fonctionnel
**Environnement de Test** : Application UI contrôlée (ex : application web de test avec éléments connus)
### Tests de Performance
**Métriques** :
- Latence observation-vers-suggestion (cible : <400ms)
- Temps d'inférence du modèle de vision
- Temps de raisonnement LLM
- Temps de recherche de similarité FAISS
- Surcharge de chiffrement des logs
**Outils** : pytest-benchmark, cProfile pour le profilage
### Tests d'Acceptation Utilisateur
**Scénarios** :
1. Utilisateur non technique apprend une tâche simple (ex : remplissage de formulaire)
2. Utilisateur avancé automatise un flux de travail complexe (ex : saisie de données multi-étapes)
3. Administrateur examine les logs et le tableau de bord
4. Utilisateur corrige les mauvaises détections et vérifie l'amélioration de l'apprentissage
**Critères de Succès** :
- Taux de concordance ≥95% après 20 observations
- Taux de correction <3% en mode Autopilot
- Satisfaction utilisateur avec la réactivité et la clarté de l'UI
## Considérations de Sécurité
### Chiffrement
- Tous les logs chiffrés avec AES-256-CBC
- Clés de chiffrement stockées dans un trousseau sécurisé (keychain système)
- Politique de rotation des clés : tous les 90 jours
### Contrôle d'Accès
- Liste blanche appliquée au niveau de l'orchestrateur
- Aucune action permise en dehors des fenêtres de la liste blanche
- Modifications de la liste blanche nécessitent une confirmation administrateur
### Piste d'Audit
- Toutes les actions loggées avec contexte complet
- Logs immuables (ajout uniquement)
- Intégrité des logs vérifiée avec signatures HMAC
### Confidentialité
- Captures d'écran stockées temporairement en mémoire uniquement
- Embeddings anonymisés (pas de PII dans les métadonnées)
- Profils utilisateur stockés localement, jamais transmis
### Mécanismes de Sécurité
- Arrêt d'urgence Ctrl+Pause (niveau interruption matérielle)
- Capacité de rollback pour les 3 dernières actions
- Rétrogradation automatique de mode en cas de perte de confiance
- Override manuel toujours disponible
## Optimisation des Performances
### Optimisation des Modèles de Vision
- Quantification des modèles (FP16 ou INT8) pour inférence plus rapide
- Traitement par lots de multiples détections
- Détection basée sur ROI pour réduire la zone de traitement
- Mise en cache des modèles pour éviter les chargements répétés
### Optimisation FAISS
- Utiliser l'index IVF (Inverted File) pour les grands ensembles d'embeddings
- Optimisation et compactage périodiques de l'index
- Accélération GPU pour la recherche de similarité (si disponible)
### Optimisation LLM
- Utiliser des modèles quantifiés plus petits (Qwen 3B paramètres)
- Mise en cache des prompts pour requêtes répétées
- Regroupement de multiples requêtes de raisonnement
- Déploiement Ollama local pour minimiser la latence
### Optimisation GUI
- Mises à jour UI non bloquantes utilisant signaux/slots Qt
- Chargement paresseux des données du tableau de bord
- Rendu efficace de superposition avec capture d'écran minimale
- Gestion d'entrée utilisateur avec anti-rebond
## Considérations de Déploiement
### Exigences Système
- OS : Linux (Ubuntu 20.04+), Windows 10+, macOS 11+
- RAM : 16GB minimum (32GB recommandé pour grands modèles)
- GPU : GPU NVIDIA avec 8GB+ VRAM (optionnel mais recommandé)
- Stockage : 20GB pour modèles et données
- Python : 3.9+
### Dépendances
- PyTorch 2.0+
- Transformers (Hugging Face)
- OpenCLIP
- FAISS (variante CPU ou GPU)
- Ollama (pour LLM local)
- PyQt5
- PyAutoGUI / PyDirectInput
- cryptography (pour chiffrement AES)
### Étapes d'Installation
1. Installer Ollama et télécharger le modèle Qwen 2.5-VL
2. Télécharger les modèles de vision (OWL-v2, Grounding DINO)
3. Installer les dépendances Python via requirements.txt
4. Initialiser l'index FAISS et les clés de chiffrement
5. Configurer la liste blanche et les paramètres initiaux
6. Lancer la GUI et commencer l'observation en mode Shadow
### Configuration
Configuration globale dans `core/config.py` :
```python
CONFIG = {
"models": {
"vision": "owl-v2", # ou "dino", "yolo"
"llm": "qwen2.5-vl:3b",
"clip": "ViT-B-32"
},
"thresholds": {
"autopilot_observations": 20,
"autopilot_concordance": 0.95,
"confidence_min": 0.90,
"rollback_confidence": 0.85
},
"performance": {
"max_latency_ms": 400,
"max_correction_rate": 0.03
},
"security": {
"encryption_algorithm": "AES-256-CBC",
"log_retention_days": 90,
"key_rotation_days": 90
}
}
```

156
.kiro/specs/rpa-vision-v2/requirements.md Normal file
View File

@@ -0,0 +1,156 @@
# Document d'Exigences
## Introduction
RPA Vision V2 est un système d'automatisation robotique à apprentissage progressif qui utilise la vision par ordinateur et l'IA pour observer, apprendre et automatiser les interactions avec les interfaces utilisateur. Le système évolue à travers trois modes opérationnels : Shadow (observation uniquement), Assisté (suggestion avec validation), et Autopilot (exécution autonome). Il exploite des modèles d'IA de vision (OWL-v2, Grounding DINO, YOLO-World), de raisonnement visuel (Qwen 2.5-VL), et de mémoire adaptative (embeddings OpenCLIP avec indexation FAISS) pour apprendre progressivement les flux de travail utilisateur tout en maintenant la sécurité, la traçabilité et le contrôle utilisateur.
## Glossaire
- **Système_RPA**: L'application complète RPA Vision V2 incluant tous les modules, modèles IA et interfaces utilisateur
- **Mode_Shadow**: Mode opérationnel où le Système_RPA observe les actions utilisateur sans exécuter d'actions automatisées
- **Mode_Assisté**: Mode opérationnel où le Système_RPA suggère des actions nécessitant une validation utilisateur explicite avant exécution
- **Mode_Autopilot**: Mode opérationnel où le Système_RPA exécute des actions de manière autonome après avoir atteint les seuils de confiance
- **Détecteur_Vision**: Composant IA utilisant OWL-v2, Grounding DINO ou YOLO-World pour la détection d'éléments UI
- **Raisonneur_Visuel**: Composant IA utilisant Qwen 2.5-VL ou CogVLM via Ollama pour la compréhension visuelle et la prise de décision
- **Gestionnaire_Embeddings**: Composant gérant les embeddings OpenCLIP et l'index FAISS pour la mémoire visuelle
- **Gestionnaire_Apprentissage**: Composant central suivant la progression d'apprentissage, les scores de confiance et les transitions de mode
- **Séquence_Actions**: Une série d'interactions UI effectuées par l'utilisateur que le Système_RPA apprend à répliquer
- **Score_Confiance**: Métrique calculée (0-100%) combinant détection vision, raisonnement LLM et performance historique de la tâche
- **Compteur_Observations**: Nombre de fois où le Système_RPA a observé une Séquence_Actions spécifique
- **Taux_Concordance**: Pourcentage de prédictions réussies correspondant aux actions utilisateur réelles sur les exécutions récentes
- **Liste_Blanche**: Liste des fenêtres d'application autorisées où le Système_RPA est autorisé à opérer
- **Journal_Chiffré**: Journal chiffré AES-256 enregistrant toutes les actions système, décisions et retours utilisateur
- **Événement_Correction**: Retour utilisateur indiquant que le Système_RPA a fait une prédiction ou action incorrecte
- **Opération_Rollback**: Annulation des trois dernières actions automatisées pour restaurer l'état précédent
- **Tableau_Bord**: Interface utilisateur affichant les statistiques de tâches, niveaux de confiance, corrections et historique d'exécution
- **Élément_UI**: Composant visuel à l'écran (bouton, champ, menu) que le Système_RPA peut détecter et avec lequel interagir
## Exigences
### Exigence 1
**User Story:** En tant qu'utilisateur titulaire, je veux que le système observe mes activités quotidiennes sans effectuer d'actions automatisées, afin qu'il puisse apprendre mes habitudes et séquences d'actions en toute sécurité.
#### Critères d'Acceptation
1. LORSQUE le Système_RPA fonctionne en Mode_Shadow, LE Système_RPA DOIT capturer toutes les trames d'écran et coordonnées d'Élément_UI sans exécuter d'actions automatisées.
2. TANT QUE le Système_RPA fonctionne en Mode_Shadow, LE Système_RPA DOIT enregistrer toutes les interactions utilisateur avec horodatages, titres de fenêtres et positions d'Élément_UI dans le Journal_Chiffré.
3. LE Système_RPA DOIT fournir une interface de journal accessible à l'utilisateur affichant toutes les observations capturées avec horodatages et métadonnées associées.
4. LORSQU'une interaction utilisateur est capturée en Mode_Shadow, LE Système_RPA DOIT générer et stocker des embeddings visuels via le Gestionnaire_Embeddings pour la reconnaissance de motifs future.
5. LE Système_RPA DOIT afficher un indicateur visuel montrant que le Mode_Shadow est actif (icône 👀) dans l'interface utilisateur.
### Exigence 2
**User Story:** En tant qu'utilisateur, je veux recevoir des suggestions d'actions avec un retour visuel clair et des contrôles de validation simples, afin de gagner du temps tout en gardant le contrôle total sur ce qui est exécuté.
#### Critères d'Acceptation
1. LORSQUE le Système_RPA fonctionne en Mode_Assisté, LE Système_RPA DOIT surligner les Élément_UI suggérés avec une superposition visuelle claire avant toute exécution d'action.
2. LORSQUE le Système_RPA présente une suggestion en Mode_Assisté, LE Système_RPA DOIT attendre une entrée utilisateur explicite (touche Entrée pour validation, touche Échap pour refus, ou Alt+C pour correction) avant de procéder.
3. LORSQU'un utilisateur appuie sur la touche Entrée sur une suggestion, LE Système_RPA DOIT exécuter l'action suggérée et enregistrer la validation dans le Journal_Chiffré.
4. LORSQU'un utilisateur appuie sur la touche Échap sur une suggestion, LE Système_RPA DOIT annuler l'action suggérée et enregistrer le refus dans le Journal_Chiffré.
5. LORSQU'un utilisateur appuie sur Alt+C sur une suggestion, LE Système_RPA DOIT ouvrir un dialogue de correction permettant à l'utilisateur de spécifier l'Élément_UI ou l'action correcte.
6. LORSQU'un Événement_Correction est enregistré, LE Gestionnaire_Apprentissage DOIT mettre à jour les embeddings visuels et les seuils de détection pour améliorer les prédictions futures.
7. LE Système_RPA DOIT afficher un indicateur visuel montrant que le Mode_Assisté est actif (icône 🤝) dans l'interface utilisateur.
### Exigence 3
**User Story:** En tant qu'utilisateur avancé, je veux que le système agisse automatiquement sur les séquences stables et répétitives, afin de pouvoir automatiser complètement les flux de travail que j'effectue régulièrement.
#### Critères d'Acceptation
1. LORSQU'une Séquence_Actions a un Compteur_Observations supérieur ou égal à 20 ET un Taux_Concordance supérieur ou égal à 95%, LE Système_RPA DOIT proposer la transition de cette Séquence_Actions vers le Mode_Autopilot.
2. LORSQUE le Système_RPA fonctionne en Mode_Autopilot pour une Séquence_Actions, LE Système_RPA DOIT exécuter les actions de manière autonome sans nécessiter de validation utilisateur.
3. LORSQU'un utilisateur appuie sur Ctrl+Pause à tout moment, LE Système_RPA DOIT immédiatement arrêter toutes les actions automatisées et revenir au Mode_Assisté.
4. LORSQUE le Système_RPA termine une action en Mode_Autopilot, LE Système_RPA DOIT afficher une notification post-action avec indicateur de succès (✔️) ou d'échec (❌).
5. LORSQU'une notification post-action affiche un indicateur d'échec, LE Système_RPA DOIT permettre à l'utilisateur de fournir un retour correctif dans les 5 secondes.
6. LORSQU'un retour correctif est fourni après une action en Mode_Autopilot, LE Gestionnaire_Apprentissage DOIT enregistrer l'Événement_Correction et ajuster le Score_Confiance pour cette Séquence_Actions.
7. LE Système_RPA DOIT afficher un indicateur visuel montrant que le Mode_Autopilot est actif (icône 🤖) dans l'interface utilisateur.
### Exigence 4
**User Story:** En tant que système, je veux apprendre et ajuster continuellement mes prédictions en fonction des résultats réels, afin de maintenir la fiabilité même lorsque les interfaces utilisateur changent.
#### Critères d'Acceptation
1. LORSQU'une action automatisée est exécutée, LE Gestionnaire_Apprentissage DOIT calculer le delta entre l'emplacement prédit de l'Élément_UI et l'emplacement réel confirmé par l'utilisateur.
2. LORSQUE le delta entre prédiction et emplacement réel dépasse 10 pixels, LE Gestionnaire_Apprentissage DOIT déclencher un cycle de ré-entraînement pour les embeddings visuels associés à cette Séquence_Actions.
3. LORSQU'un cycle de ré-entraînement est déclenché, LE Gestionnaire_Embeddings DOIT mettre à jour les embeddings OpenCLIP et reconstruire l'index FAISS avec les nouvelles données visuelles.
4. LORSQUE le Score_Confiance pour une Séquence_Actions en Mode_Autopilot tombe en dessous de 90%, LE Système_RPA DOIT automatiquement faire revenir cette Séquence_Actions au Mode_Assisté.
5. LORSQU'une Séquence_Actions passe du Mode_Autopilot au Mode_Assisté en raison d'une faible confiance, LE Système_RPA DOIT notifier l'utilisateur avec la raison de la transition.
6. LE Gestionnaire_Apprentissage DOIT recalculer le Score_Confiance après chaque exécution d'action en utilisant la formule : 0,6 × confiance_vision + 0,3 × score_llm + 0,1 × performance_historique_tâche.
### Exigence 5
**User Story:** En tant que superviseur ou administrateur, je veux garantir la sécurité et la traçabilité de toutes les actions système, afin de prévenir les comportements indésirables et maintenir la conformité d'audit.
#### Critères d'Acceptation
1. LE Système_RPA DOIT chiffrer toutes les entrées de journal en utilisant le chiffrement AES-256 avant d'écrire dans le Journal_Chiffré.
2. LE Système_RPA DOIT enregistrer chaque action avec horodatage, titre de fenêtre, type d'action, identifiant d'Élément_UI, Score_Confiance, mode opérationnel et résultat d'exécution dans le Journal_Chiffré.
3. LE Système_RPA DOIT appliquer une Liste_Blanche de fenêtres d'application autorisées et NE DOIT PAS exécuter d'actions dans les fenêtres absentes de la Liste_Blanche.
4. LORSQU'une action est tentée dans une fenêtre non présente dans la liste blanche, LE Système_RPA DOIT bloquer l'action et enregistrer un événement de violation de sécurité dans le Journal_Chiffré.
5. LE Système_RPA DOIT fournir une capacité d'Opération_Rollback permettant l'annulation des trois dernières actions automatisées.
6. LORSQU'une Opération_Rollback est initiée, LE Système_RPA DOIT restaurer l'état précédent en exécutant les actions inverses dans l'ordre chronologique inverse.
7. LE Tableau_Bord DOIT afficher le taux de succès, la latence moyenne, le nombre de corrections et l'horodatage de dernière exécution pour chaque Séquence_Actions apprise.
8. LE Tableau_Bord DOIT mettre à jour les métriques en temps réel au fur et à mesure que les actions sont exécutées et les retours reçus.
### Exigence 6
**User Story:** En tant que composant d'auto-surveillance du système, je veux détecter la dégradation des performances et alerter les utilisateurs, afin de prévenir la dérive comportementale après les mises à jour d'UI.
#### Critères d'Acceptation
1. LE Gestionnaire_Apprentissage DOIT maintenir des seuils de confiance dynamiques qui s'adaptent en fonction des tendances récentes du Taux_Concordance pour chaque Séquence_Actions.
2. LORSQUE le Score_Confiance pour une action en attente tombe en dessous du seuil dynamique, LE Système_RPA DOIT afficher une notification à l'utilisateur indiquant l'incertitude.
3. LORSQUE l'incertitude est détectée en Mode_Autopilot, LE Système_RPA DOIT geler l'exécution de cette Séquence_Actions jusqu'à ce qu'une validation utilisateur soit fournie.
4. LORSQUE le Taux_Concordance pour une Séquence_Actions tombe en dessous de 85% sur les 10 dernières exécutions, LE Système_RPA DOIT automatiquement faire passer cette Séquence_Actions au Mode_Assisté.
5. LORSQU'un changement d'UI est détecté (similarité d'embedding visuel inférieure à 70% par rapport aux motifs stockés), LE Système_RPA DOIT alerter l'utilisateur et demander une ré-observation de la Séquence_Actions affectée.
6. LE Système_RPA DOIT suivre le taux d'Événement_Correction par Séquence_Actions et DOIT alerter l'utilisateur lorsque le taux de correction dépasse 5% sur 20 exécutions.
## Critères d'Acceptation Globaux
1. LE Système_RPA DOIT maintenir un Taux_Concordance supérieur ou égal à 95% sur les 10 dernières actions pour toute Séquence_Actions en Mode_Autopilot.
2. LE Système_RPA DOIT exécuter zéro action dans les fenêtres absentes de la Liste_Blanche.
3. LE Système_RPA DOIT compléter le pipeline observation-vers-suggestion avec une latence inférieure à 400 millisecondes.
4. LE Système_RPA DOIT maintenir un taux d'Événement_Correction inférieur à 3% sur toutes les Séquence_Actions.
5. LE Tableau_Bord DOIT être accessible et afficher des métriques précises en temps réel à tout moment pendant l'opération du système.
6. LE Journal_Chiffré DOIT maintenir son intégrité sans perte de données ni corruption tout au long de l'opération du système.

222
.kiro/specs/rpa-vision-v2/tasks.md Normal file
View File

@@ -0,0 +1,222 @@
# Plan d'Implémentation
- [x] 1. Configurer la structure du projet et les dépendances
- Créer la structure de répertoires /AI/amina/geniusia2/ avec core/, gui/, data/, models/
- Créer requirements.txt avec PyTorch, Transformers, OpenCLIP, FAISS, PyQt5, cryptography, ollama
- Créer core/config.py avec configuration globale (modèles, seuils, performance, sécurité)
- Initialiser les répertoires data/ pour user_profiles/, logs/, faiss_index/
- _Exigences : 1.1, 1.2, 1.3, 1.4, 1.5, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 6.1, 6.2, 6.3, 6.4, 6.5, 6.6_
- [x] 2. Implémenter les modèles de données et utilitaires de base
- [x] 2.1 Créer les dataclasses TaskProfile, Action, Detection dans core/models.py
- Implémenter TaskProfile avec sérialisation JSON
- Implémenter Action avec conversion dict
- Implémenter Detection avec métadonnées modèle
- _Exigences : 1.2, 1.4, 2.6, 4.1, 4.2, 4.3, 5.2, 6.1_
- [x] 2.2 Implémenter core/utils/image_utils.py pour capture d'écran et ROI
- Écrire fonction capture_screen() pour capturer l'écran complet
- Écrire fonction get_active_window() pour obtenir le titre de fenêtre active
- Écrire fonction extract_roi(frame, bbox) pour extraire région d'intérêt
- Écrire fonction draw_bbox(frame, bbox, label) pour dessiner bounding box
- _Exigences : 1.1, 1.2, 2.1, 4.1_
- [x] 3. Implémenter le système de journalisation chiffrée
- [x] 3.1 Créer core/logger.py avec chiffrement AES-256
- Implémenter classe Logger avec initialisation de clés AES
- Écrire méthode encrypt_entry(data) pour chiffrer les entrées
- Écrire méthode decrypt_entry(encrypted_data) pour déchiffrer
- Écrire méthode log_action(action_data) pour enregistrer actions
- Écrire méthode log_correction(correction_data) pour enregistrer corrections
- Écrire méthode log_mode_transition(task_id, from_mode, to_mode, reason)
- Écrire méthode get_logs(task_id, start_time, end_time) pour interroger logs
- _Exigences : 1.2, 1.3, 2.3, 2.4, 2.5, 2.6, 3.6, 4.1, 5.1, 5.2, 5.4, 6.2_
- [x] 4. Implémenter le gestionnaire d'embeddings avec OpenCLIP et FAISS
- [x] 4.1 Créer core/embeddings_manager.py
- Implémenter classe EmbeddingsManager avec chargement OpenCLIP
- Écrire méthode load_openclip(model_path) pour charger le modèle
- Écrire méthode load_or_create_index(index_path) pour FAISS
- Écrire méthode encode_image(image) pour générer embeddings 512-d
- Écrire méthode add_to_index(embedding, metadata) pour stocker
- Écrire méthode search_similar(query_embedding, k) pour recherche similarité
- Écrire méthode rebuild_index() pour reconstruire l'index
- Écrire méthode get_embedding_similarity(emb1, emb2) pour similarité cosinus
- _Exigences : 1.4, 2.6, 4.2, 4.3, 6.5_
- [x] 5. Implémenter les utilitaires de vision pour détection UI
- [x] 5.1 Créer core/utils/vision_utils.py avec interfaces modèles vision
- Implémenter classe VisionUtils avec chargement modèles (OWL-v2, DINO, YOLO)
- Écrire méthode detect_with_owlv2(prompt, frame) pour détection OWL-v2
- Écrire méthode detect_with_dino(prompt, frame) pour Grounding DINO
- Écrire méthode detect_with_yolo(prompt, frame) pour YOLO-World
- Écrire méthode select_best_detection(detections, context) pour sélection
- Implémenter gestion d'erreurs avec fallback entre modèles
- _Exigences : 1.1, 2.1, 4.1_
- [x] 6. Implémenter le gestionnaire LLM pour raisonnement visuel
- [x] 6.1 Créer core/llm_manager.py avec interface Ollama
- Implémenter classe LLMManager avec connexion Ollama
- Écrire méthode reason_about_detections(detections, context, intent)
- Écrire méthode generate_with_vision(prompt, images) pour génération multi-modale
- Écrire méthode score_action_relevance(action, intent) pour score confiance
- Écrire méthode parse_llm_response(response) pour parser réponses
- Implémenter gestion d'erreurs avec fallback vision pure
- _Exigences : 2.1, 4.6_
- [x] 7. Implémenter le gestionnaire d'apprentissage
- [x] 7.1 Créer core/learning_manager.py
- Implémenter classe LearningManager avec initialisation mode shadow
- Écrire méthode observe(action) pour enregistrer observations en mode Shadow
- Écrire méthode suggest_action(context) pour générer suggestions en mode Assisté
- Écrire méthode confirm_action(feedback) pour traiter validation/correction
- Écrire méthode calculate_confidence(vision_conf, llm_score, task_id) avec formule 0.6/0.3/0.1
- Écrire méthode evaluate_task(task_id) pour calculer concordance
- Écrire méthode should_transition_to_auto(task_id) pour vérifier critères (≥20 obs, ≥95% concordance)
- Écrire méthode rollback_if_low_confidence(task_id) pour rétrograder si <90%
- Écrire méthode get_current_intent() pour obtenir intention actuelle
- Écrire méthode record_execution(decision) pour enregistrer exécution
- Implémenter gestion des seuils dynamiques adaptatifs
- _Exigences : 1.2, 1.4, 2.6, 3.1, 3.6, 4.1, 4.2, 4.4, 4.5, 4.6, 6.1, 6.4, 6.6_
- [x] 8. Implémenter l'orchestrateur (boucle cognitive)
- [x] 8.1 Créer core/orchestrator.py
- Implémenter classe Orchestrator avec initialisation composants
- Écrire méthode run() pour boucle cognitive principale
- Écrire méthode capture_context() pour capture écran et fenêtre
- Écrire méthode detect_elements(frame, intent) pour détection UI
- Écrire méthode reason_about_action(detections, context) pour décision LLM
- Écrire méthode execute_or_suggest(decision) pour exécution selon mode
- Écrire méthode execute_action(decision) pour exécution réelle
- Écrire méthode learn_from_feedback(feedback) pour mise à jour apprentissage
- Implémenter vérification liste blanche avant exécution
- Implémenter gestion arrêt d'urgence Ctrl+Pause
- _Exigences : 1.1, 1.2, 2.1, 2.2, 2.3, 2.4, 2.5, 3.2, 3.3, 5.3, 5.4, 6.2, 6.3_
- [x] 9. Implémenter les utilitaires d'entrée pour actions UI
- [x] 9.1 Créer core/utils/input_utils.py
- Implémenter classe InputUtils avec support AZERTY
- Écrire méthode click(x, y) pour clic souris
- Écrire méthode type_text(text) pour saisie texte
- Écrire méthode scroll(direction, amount) pour défilement
- Écrire méthode wait(duration) pour attente
- Écrire méthode get_inverse_action(action) pour rollback
- _Exigences : 2.3, 3.2, 5.6_
- [x] 10. Implémenter le moteur de rejeu d'actions
- [x] 10.1 Créer core/replay_async.py
- Implémenter classe ReplayEngine pour rejeu asynchrone
- Écrire méthode replay_sequence(action_sequence) pour rejouer séquence
- Écrire méthode rollback_last_n(n) pour annuler n dernières actions
- Écrire méthode execute_inverse_actions(actions) pour rollback
- Implémenter gestion d'erreurs avec notification échec rollback
- _Exigences : 5.5, 5.6_
- [x] 11. Implémenter l'interface GUI minimale
- [x] 11.1 Créer gui/minimal_gui.py avec PyQt5
- Implémenter classe MinimalGUI héritant QMainWindow
- Créer interface avec indicateurs de mode (👀/🤝/🤖)
- Créer boutons Start/Stop/Pause
- Écrire méthode update_mode_indicator(mode) pour mise à jour icône
- Écrire méthode show_notification(message, type) pour notifications
- Implémenter setup_shortcuts() pour raccourcis clavier
- _Exigences : 1.5, 2.7, 3.7_
- [x] 11.2 Créer superposition de suggestion
- Implémenter classe SuggestionOverlay pour affichage suggestions
- Écrire méthode show_suggestion(decision) pour afficher avec surlignage
- Écrire méthode wait_for_feedback() pour attendre Entrée/Échap/Alt+C
- Implémenter surlignage visuel des éléments UI suggérés
- _Exigences : 2.1, 2.2, 2.3, 2.4, 2.5_
- [x] 12. Implémenter les dialogues de correction et notifications
- [x] 12.1 Créer gui/dialogs/correction_dialog.py
- Implémenter classe CorrectionDialog pour corrections utilisateur
- Créer interface permettant sélection élément correct
- Écrire méthode get_corrected_element() pour obtenir correction
- _Exigences : 2.5, 2.6_
- [x] 12.2 Implémenter système de notifications post-action
- Créer classe PostActionNotification pour succès/échec
- Implémenter affichage ✔️/❌ avec timeout 5 secondes
- Écrire méthode allow_corrective_feedback() pour retour correctif
- _Exigences : 3.4, 3.5, 3.6_
- [x] 12.3 Implémenter notifications de transition et alertes
- Créer notifications pour proposition passage Autopilot
- Créer notifications pour baisse confiance et retour Assisté
- Créer alertes pour violations liste blanche
- Créer alertes pour changements UI détectés
- _Exigences : 3.1, 4.5, 5.4, 6.2, 6.3, 6.5_
- [x] 13. Implémenter le tableau de bord résumé
- [x] 13.1 Créer gui/dialogs/summary_dashboard.py
- Implémenter classe SummaryDashboard avec QTableWidget
- Créer tableau avec colonnes : Tâche, Mode, Confiance, Observations, Concordance, Corrections, Dernière exécution
- Écrire méthode update_metrics(task_id, metrics) pour mise à jour temps réel
- Implémenter filtrage et recherche de tâches
- Implémenter visualisation tendances confiance
- Implémenter fonctionnalité export CSV/JSON
- _Exigences : 5.7, 5.8_
- [x] 14. Implémenter la gestion de la liste blanche
- [x] 14.1 Créer module de gestion liste blanche
- Implémenter classe WhitelistManager dans core/
- Écrire méthode is_window_allowed(window_title) pour vérification
- Écrire méthode add_to_whitelist(window_title) avec confirmation admin
- Écrire méthode load_whitelist() et save_whitelist() pour persistance
- Intégrer vérification dans orchestrator avant exécution
- _Exigences : 5.3, 5.4_
- [x] 15. Implémenter le système de détection de changements UI
- [x] 15.1 Créer module de détection de dérive
- Implémenter classe UIChangeDetector dans core/
- Écrire méthode detect_ui_change(current_embedding, stored_embeddings) avec seuil 70%
- Écrire méthode calculate_delta(predicted_bbox, actual_bbox) pour delta pixels
- Écrire méthode trigger_retraining(task_id) si delta >10 pixels
- Intégrer dans learning_manager pour surveillance continue
- _Exigences : 4.1, 4.2, 6.5_
- [x] 16. Implémenter le système de métriques et surveillance
- [x] 16.1 Créer module de métriques
- Implémenter classe MetricsCollector dans core/
- Écrire méthode track_latency(start_time, end_time) pour latence <400ms
- Écrire méthode track_concordance(task_id, success) pour taux concordance
- Écrire méthode track_correction_rate(task_id) pour taux <3%
- Écrire méthode check_performance_thresholds() pour alertes
- Intégrer dans orchestrator et learning_manager
- _Exigences : Critères globaux 1, 3, 4_
- [x] 17. Intégrer tous les composants et créer point d'entrée
- [x] 17.1 Créer main.py
- Initialiser configuration depuis config.py
- Instancier tous les gestionnaires (logger, embeddings, learning, vision, llm)
- Instancier orchestrator avec tous les composants
- Instancier GUI et connecter signaux/slots
- Lancer boucle cognitive dans thread séparé
- Lancer application PyQt5
- _Exigences : Toutes_
- [x] 17.2 Implémenter gestion gracieuse d'arrêt
- Écrire gestionnaire signal Ctrl+C pour arrêt propre
- Sauvegarder état apprentissage avant fermeture
- Fermer connexions (Ollama, FAISS)
- Finaliser logs
- _Exigences : 3.3, 5.1, 5.2_
- [x] 18. Créer scripts d'installation et configuration
- [x] 18.1 Créer setup.sh pour installation
- Script pour installer Ollama
- Script pour télécharger modèle Qwen 2.5-VL via Ollama
- Script pour télécharger modèles vision (OWL-v2, DINO)
- Script pour installer dépendances Python
- Script pour initialiser répertoires data/
- Script pour générer clés chiffrement initiales
- _Exigences : Toutes_
- [x] 18.2 Créer documentation utilisateur
- Rédiger README.md avec instructions installation
- Rédiger guide démarrage rapide
- Rédiger documentation configuration liste blanche
- Rédiger documentation raccourcis clavier
- _Exigences : Toutes_