Geniusia_v2/geniusia2/README.md

RPA Vision V2

Système d'automatisation robotique à apprentissage progressif utilisant la vision par ordinateur et l'IA.

Vue d'Ensemble

RPA Vision V2 observe, apprend et automatise les interactions avec les interfaces utilisateur à travers trois modes opérationnels:

• 👀 Shadow: Observation uniquement, apprentissage des actions utilisateur
• 🤝 Assisté: Suggestions avec validation utilisateur requise
• 🤖 Autopilot: Exécution autonome après atteinte des seuils de confiance

Architecture

geniusia2/
├── core/              # Logique centrale (orchestration, apprentissage)
│   ├── config.py      # Configuration globale
│   └── utils/         # Utilitaires (image, vision, input)
├── gui/               # Interface PyQt5
│   └── dialogs/       # Dialogues de correction et tableau de bord
├── data/              # Données persistantes
│   ├── user_profiles/ # Profils d'apprentissage (JSON)
│   ├── logs/          # Logs chiffrés AES-256
│   └── faiss_index/   # Index de mémoire visuelle
└── models/            # Modèles IA
    ├── openclip/      # Embeddings visuels
    ├── owl_v2/        # Détection UI
    └── qwen2.5_vl/    # Raisonnement visuel

Installation

Prérequis

• Système: Linux (Ubuntu 20.04+), macOS 11+, ou Windows 10+
• Python: 3.9 ou supérieur
• RAM: 16GB minimum (32GB recommandé)
• GPU: NVIDIA avec 8GB+ VRAM (optionnel mais recommandé pour meilleures performances)
• Espace disque: 20GB minimum

Installation Automatique (Recommandé)

Le script d'installation configure automatiquement tout l'environnement:

# Rendre le script exécutable
chmod +x setup.sh

# Lancer l'installation
./setup.sh

Le script va:

1. ✅ Créer un environnement virtuel Python
2. ✅ Installer toutes les dépendances Python
3. ✅ Installer Ollama (si nécessaire)
4. ✅ Télécharger le modèle Qwen 2.5-VL
5. ✅ Créer les répertoires de données
6. ✅ Générer les clés de chiffrement
7. ✅ Configurer les modèles de vision

Installation Manuelle

Si vous préférez installer manuellement:

1. Créer un environnement virtuel:

python3 -m venv venv
source venv/bin/activate  # Linux/macOS
# ou
venv\Scripts\activate  # Windows

2. Installer les dépendances Python:

pip install --upgrade pip
pip install -r requirements.txt

3. Installer Ollama:

# Linux/macOS
curl -fsSL https://ollama.com/install.sh | sh

# Windows: Télécharger depuis https://ollama.com/download

4. Télécharger le modèle Qwen 2.5-VL:

ollama pull qwen2.5-vl:7b

5. Créer les répertoires:

mkdir -p data/{user_profiles,logs,faiss_index,whitelist}
mkdir -p models

6. Générer les clés de chiffrement:

python3 -c "from cryptography.fernet import Fernet; import os; key = Fernet.generate_key(); os.makedirs('data', exist_ok=True); open('data/.encryption_key', 'wb').write(key)"

Configuration

La configuration globale se trouve dans core/config.py:

• Modèles: Choix des modèles de vision et LLM
• Seuils: Critères de transition entre modes
• Performance: Latence maximale, taux de correction
• Sécurité: Chiffrement, liste blanche, rétention des logs

Utilisation

Démarrage

1. Activer l'environnement virtuel (si pas déjà fait):

source venv/bin/activate  # Linux/macOS
# ou
venv\Scripts\activate  # Windows

2. Lancer l'application:

python3 main.py

Interface Graphique

L'interface minimale affiche:

• Indicateur de mode: 👀 Shadow / 🤝 Assisté / 🤖 Autopilot
• Boutons de contrôle: Start, Stop, Pause
• Statut: État actuel du système
• Métriques: Confiance, observations, concordance

Raccourcis Clavier

Raccourci	Action
Ctrl+Pause	Arrêt d'urgence immédiat
Entrée	Valider une suggestion (mode Assisté)
Échap	Rejeter une suggestion (mode Assisté)
Alt+C	Ouvrir le dialogue de correction
Ctrl+D	Ouvrir le tableau de bord des métriques

Workflow Typique

1. Mode Shadow (👀):

   • Lancez l'application
   • Effectuez vos tâches normalement
   • Le système observe et apprend silencieusement
   • Après ≥20 observations avec ≥95% de concordance, transition automatique proposée

2. Mode Assisté (🤝):

   • Le système suggère des actions avec surlignage visuel
   • Validez avec Entrée ou rejetez avec Échap
   • Corrigez avec Alt+C si nécessaire
   • Après ≥20 validations avec ≥95% de concordance, passage en Autopilot proposé

3. Mode Autopilot (🤖):

   • Exécution automatique des tâches apprises
   • Notifications post-action (✔️ succès / ❌ échec)
   • Retour automatique en Assisté si confiance <90%
   • Rollback possible des 3 dernières actions

Liste Blanche

Pour des raisons de sécurité, seules les applications autorisées peuvent être automatisées:

1. Ajouter une application:

   • Cliquez sur "Gérer Liste Blanche" dans l'interface
   • Entrez le titre de la fenêtre (ex: "Firefox", "LibreOffice")
   • Confirmez l'ajout

2. Retirer une application:

   • Ouvrez le gestionnaire de liste blanche
   • Sélectionnez l'application
   • Cliquez sur "Retirer"

La liste blanche est sauvegardée dans data/whitelist/whitelist.json

Sécurité

RPA Vision V2 intègre plusieurs mécanismes de sécurité:

Chiffrement

• Logs chiffrés: Tous les logs sont chiffrés avec AES-256-GCM
• Clés sécurisées: Clés de chiffrement stockées dans data/.encryption_key
• Données sensibles: Aucune donnée sensible en clair sur disque

Contrôle d'Accès

• Liste blanche: Seules les applications autorisées peuvent être automatisées
• Validation admin: Ajout à la liste blanche nécessite confirmation
• Audit trail: Toutes les modifications de liste blanche sont journalisées

Mécanismes de Sécurité

• Arrêt d'urgence: Ctrl+Pause arrête immédiatement toute exécution
• Rollback: Annulation des 3 dernières actions en cas d'erreur
• Failsafe: Déplacer la souris dans le coin supérieur gauche arrête PyAutoGUI
• Détection de dérive: Alerte si l'UI change de manière inattendue

Confidentialité

• Données locales: Toutes les données restent sur votre machine
• Pas de télémétrie: Aucune donnée envoyée à des serveurs externes
• Rétention configurable: Durée de conservation des logs paramétrable

Bonnes Pratiques

1. Ne jamais ajouter d'applications sensibles (banque, admin système) à la liste blanche
2. Tester en mode Shadow avant de passer en Autopilot
3. Surveiller régulièrement le tableau de bord des métriques
4. Sauvegarder régulièrement data/ pour préserver l'apprentissage

Dépannage

Problèmes Courants

1. Erreur "Ollama not found"

# Vérifier si Ollama est installé
ollama --version

# Si non installé, installer:
curl -fsSL https://ollama.com/install.sh | sh

2. Erreur "Model not found"

# Télécharger le modèle
ollama pull qwen2.5-vl:7b

# Vérifier les modèles installés
ollama list

3. Erreur "Permission denied" sur setup.sh

# Rendre le script exécutable
chmod +x setup.sh

4. Latence élevée (>400ms)

• Vérifier que le GPU est utilisé (si disponible)
• Réduire la résolution de capture dans core/config.py
• Utiliser un modèle plus léger (qwen2.5-vl:3b au lieu de 7b)

5. Détection UI imprécise

• Augmenter le seuil de confiance dans core/config.py
• Essayer un autre modèle de vision (OWL-v2, DINO, YOLO)
• Fournir plus d'exemples en mode Shadow

6. Erreur "PyAutoGUI failsafe triggered"

• La souris a été déplacée dans le coin supérieur gauche
• C'est un mécanisme de sécurité
• Relancez l'application et évitez ce coin

Logs et Débogage

Les logs sont stockés dans data/logs/ (chiffrés). Pour les consulter:

from core.logger import Logger
from core.config import Config

config = Config()
logger = Logger(config.get_all())

# Récupérer les logs récents
logs = logger.get_logs(limit=100)
for log in logs:
    print(log)

Support

Pour signaler un bug ou demander de l'aide:

1. Vérifiez les logs dans data/logs/
2. Consultez la documentation des modules dans core/*/README.md
3. Vérifiez les métriques dans le tableau de bord

Performance

Métriques Cibles

Métrique	Cible	Critique
Latence	<400ms	<1000ms
Concordance	≥95%	≥90%
Taux de correction	<3%	<10%
Précision détection	≥90%	≥80%

Optimisations

1. GPU: Utiliser un GPU NVIDIA pour accélérer les modèles
2. Modèles: Choisir des modèles adaptés à votre matériel
3. Résolution: Réduire la résolution de capture si nécessaire
4. Cache: Les embeddings sont mis en cache dans FAISS
5. Batch: Les opérations sont groupées quand possible

Architecture Technique

Composants Principaux

• Orchestrator: Boucle cognitive principale
• LearningManager: Gestion de l'apprentissage et des transitions
• VisionUtils: Détection d'éléments UI avec modèles vision
• LLMManager: Raisonnement visuel avec Qwen 2.5-VL
• EmbeddingsManager: Mémoire visuelle avec OpenCLIP + FAISS
• WhitelistManager: Contrôle d'accès aux applications
• UIChangeDetector: Détection de dérives d'interface
• MetricsCollector: Surveillance des performances
• ReplayEngine: Rejeu et rollback d'actions

Flux de Données

Capture écran → Détection UI → Raisonnement LLM → Décision
                     ↓              ↓                ↓
                Embeddings → Mémoire FAISS → Apprentissage
                                                     ↓
                                              Exécution/Suggestion

Documentation Détaillée

• Exigences: .kiro/specs/rpa-vision-v2/requirements.md
• Design: .kiro/specs/rpa-vision-v2/design.md
• Tâches: .kiro/specs/rpa-vision-v2/tasks.md
• Modules:
  • core/ORCHESTRATOR_README.md
  • core/LEARNING_MANAGER_README.md
  • core/WHITELIST_MANAGER_README.md
  • core/UI_CHANGE_DETECTOR_README.md
  • core/utils/VISION_UTILS_README.md
  • gui/README.md
  • gui/dialogs/README.md

Contribution

Ce projet est en développement actif. Les contributions sont les bienvenues:

1. Fork le projet
2. Créer une branche feature
3. Commiter les changements
4. Pousser vers la branche
5. Ouvrir une Pull Request

Licence

Propriétaire - Amina 2025

Remerciements

• OpenCLIP: Embeddings visuels
• Ollama: Infrastructure LLM locale
• Qwen 2.5-VL: Modèle de vision-langage
• FAISS: Recherche de similarité vectorielle
• PyQt5: Interface graphique
• PyAutoGUI: Contrôle des entrées