324 lines
9.3 KiB
Markdown
324 lines
9.3 KiB
Markdown
# 🔄 Refonte : Détection de Workflows Complets
|
|
|
|
## 🎯 Objectif
|
|
|
|
Transformer le système d'un détecteur de **micro-patterns** (3 clics identiques) en un détecteur de **macro-workflows** (séquences d'actions répétées).
|
|
|
|
## ❌ Problème Actuel
|
|
|
|
### Ce qui est implémenté
|
|
```python
|
|
# EventCapture détecte :
|
|
Clic A, Clic A, Clic A → Pattern détecté ✅
|
|
```
|
|
|
|
**Problème** : Personne ne clique 3 fois sur le même bouton dans la vraie vie !
|
|
|
|
### Ce qu'il faut
|
|
```python
|
|
# Détecter des workflows :
|
|
Jour 1: [Ouvre App → Clic Menu → Type Texte → Sauvegarde]
|
|
Jour 2: [Ouvre App → Clic Menu → Type Texte → Sauvegarde]
|
|
Jour 3: [Ouvre App → Clic Menu → Type Texte → Sauvegarde]
|
|
→ Workflow détecté ✅
|
|
```
|
|
|
|
## ✅ Solution : Workflow Pattern Detector
|
|
|
|
### 1. Nouvelle Architecture
|
|
|
|
```
|
|
EventCapture (capture toutes les actions)
|
|
↓
|
|
WorkflowBuffer (garde les N dernières actions)
|
|
↓
|
|
WorkflowDetector (détecte les séquences répétées)
|
|
↓
|
|
WorkflowManager (crée et gère les workflows)
|
|
↓
|
|
SuggestionManager (suggère le workflow suivant)
|
|
```
|
|
|
|
### 2. Algorithme de Détection
|
|
|
|
#### Étape 1 : Segmentation Temporelle
|
|
```python
|
|
# Diviser les actions en "sessions"
|
|
# Une session = actions dans une fenêtre de temps (ex: 5 minutes)
|
|
|
|
Session 1: [Action1, Action2, Action3, Action4] # 10h00-10h05
|
|
Session 2: [Action5, Action6, Action7] # 10h30-10h35
|
|
Session 3: [Action8, Action9, Action10, Action11] # 11h00-11h05
|
|
```
|
|
|
|
#### Étape 2 : Comparaison de Séquences
|
|
```python
|
|
# Comparer les sessions pour trouver des similarités
|
|
|
|
def compare_sessions(session1, session2):
|
|
# Utiliser la distance de Levenshtein sur les embeddings
|
|
# Ou DTW (Dynamic Time Warping)
|
|
# Ou similarité cosinus entre séquences
|
|
|
|
similarity = calculate_sequence_similarity(session1, session2)
|
|
return similarity > threshold # ex: 0.75
|
|
```
|
|
|
|
#### Étape 3 : Détection de Répétition
|
|
```python
|
|
# Si 3 sessions similaires → Workflow détecté
|
|
|
|
if count_similar_sessions() >= 3:
|
|
workflow = create_workflow(sessions)
|
|
save_workflow(workflow)
|
|
notify_user("Workflow détecté !")
|
|
```
|
|
|
|
### 3. Structure de Données
|
|
|
|
#### Workflow
|
|
```python
|
|
@dataclass
|
|
class Workflow:
|
|
workflow_id: str
|
|
name: str # "Ouvrir OnlyOffice et créer document"
|
|
steps: List[WorkflowStep]
|
|
repetitions: int # Nombre de fois observé
|
|
confidence: float
|
|
last_seen: datetime
|
|
|
|
@dataclass
|
|
class WorkflowStep:
|
|
step_id: int
|
|
action_type: str # "click", "type", "scroll"
|
|
target_description: str # "Bouton Nouveau Document"
|
|
screenshot: np.ndarray
|
|
embedding: np.ndarray
|
|
position: Tuple[int, int]
|
|
window: str
|
|
```
|
|
|
|
### 4. Détection en Temps Réel
|
|
|
|
```python
|
|
class WorkflowDetector:
|
|
def __init__(self):
|
|
self.action_buffer = deque(maxlen=100) # 100 dernières actions
|
|
self.sessions = []
|
|
self.known_workflows = []
|
|
|
|
def on_action(self, action):
|
|
# Ajouter l'action au buffer
|
|
self.action_buffer.append(action)
|
|
|
|
# Vérifier si on doit créer une nouvelle session
|
|
if self.should_start_new_session(action):
|
|
self.finalize_current_session()
|
|
self.start_new_session()
|
|
|
|
# Ajouter l'action à la session courante
|
|
self.current_session.append(action)
|
|
|
|
# Vérifier si on détecte un workflow
|
|
if len(self.sessions) >= 3:
|
|
workflow = self.detect_workflow()
|
|
if workflow:
|
|
self.on_workflow_detected(workflow)
|
|
|
|
def should_start_new_session(self, action):
|
|
# Nouvelle session si :
|
|
# - Plus de 5 minutes depuis la dernière action
|
|
# - Changement de fenêtre majeur
|
|
# - Action de "fin" (fermeture, sauvegarde)
|
|
|
|
if not self.current_session:
|
|
return True
|
|
|
|
last_action = self.current_session[-1]
|
|
time_gap = action.timestamp - last_action.timestamp
|
|
|
|
return (
|
|
time_gap > timedelta(minutes=5) or
|
|
action.window != last_action.window or
|
|
action.action_type in ["close", "save"]
|
|
)
|
|
|
|
def detect_workflow(self):
|
|
# Comparer les 3 dernières sessions
|
|
recent_sessions = self.sessions[-3:]
|
|
|
|
# Calculer la similarité entre elles
|
|
sim_01 = self.compare_sessions(recent_sessions[0], recent_sessions[1])
|
|
sim_12 = self.compare_sessions(recent_sessions[1], recent_sessions[2])
|
|
sim_02 = self.compare_sessions(recent_sessions[0], recent_sessions[2])
|
|
|
|
avg_similarity = (sim_01 + sim_12 + sim_02) / 3
|
|
|
|
if avg_similarity > 0.75:
|
|
# Créer le workflow
|
|
return self.create_workflow_from_sessions(recent_sessions)
|
|
|
|
return None
|
|
|
|
def compare_sessions(self, session1, session2):
|
|
# Utiliser DTW (Dynamic Time Warping) pour comparer
|
|
# les séquences d'embeddings
|
|
|
|
embeddings1 = [action.embedding for action in session1]
|
|
embeddings2 = [action.embedding for action in session2]
|
|
|
|
distance = dtw_distance(embeddings1, embeddings2)
|
|
similarity = 1 / (1 + distance)
|
|
|
|
return similarity
|
|
```
|
|
|
|
### 5. Suggestion de Workflow
|
|
|
|
```python
|
|
class WorkflowSuggestionManager:
|
|
def check_for_workflow_suggestion(self, current_actions):
|
|
# Vérifier si les actions actuelles correspondent
|
|
# au début d'un workflow connu
|
|
|
|
for workflow in self.known_workflows:
|
|
match_score = self.match_workflow_start(
|
|
current_actions,
|
|
workflow.steps
|
|
)
|
|
|
|
if match_score > 0.75:
|
|
# On est probablement au début du workflow !
|
|
return {
|
|
"workflow": workflow,
|
|
"confidence": match_score,
|
|
"next_steps": workflow.steps[len(current_actions):]
|
|
}
|
|
|
|
return None
|
|
|
|
def match_workflow_start(self, current_actions, workflow_steps):
|
|
# Comparer les N premières actions avec le début du workflow
|
|
|
|
if len(current_actions) > len(workflow_steps):
|
|
return 0.0
|
|
|
|
similarities = []
|
|
for i, action in enumerate(current_actions):
|
|
step = workflow_steps[i]
|
|
sim = cosine_similarity(action.embedding, step.embedding)
|
|
similarities.append(sim)
|
|
|
|
return np.mean(similarities)
|
|
```
|
|
|
|
## 📊 Exemple Concret
|
|
|
|
### Scénario : OnlyOffice
|
|
|
|
```python
|
|
# Jour 1 - 10h00
|
|
Session 1:
|
|
1. Clic sur lanceur (embedding_1)
|
|
2. Type "office" (embedding_2)
|
|
3. Clic sur OnlyOffice (embedding_3)
|
|
4. Clic "Nouveau document" (embedding_4)
|
|
5. Type "Bonjour" (embedding_5)
|
|
6. Clic "Fermer" (embedding_6)
|
|
7. Clic "Non" (embedding_7)
|
|
|
|
# Jour 2 - 14h30
|
|
Session 2:
|
|
1. Clic sur lanceur (embedding_1') # Similaire à embedding_1
|
|
2. Type "office" (embedding_2')
|
|
3. Clic sur OnlyOffice (embedding_3')
|
|
4. Clic "Nouveau document" (embedding_4')
|
|
5. Type "Hello" (embedding_5') # Différent mais même type d'action
|
|
6. Clic "Fermer" (embedding_6')
|
|
7. Clic "Non" (embedding_7')
|
|
|
|
# Jour 3 - 16h00
|
|
Session 3:
|
|
1. Clic sur lanceur (embedding_1'')
|
|
2. Type "office" (embedding_2'')
|
|
3. Clic sur OnlyOffice (embedding_3'')
|
|
4. Clic "Nouveau document" (embedding_4'')
|
|
5. Type "Test" (embedding_5'')
|
|
6. Clic "Fermer" (embedding_6'')
|
|
7. Clic "Non" (embedding_7'')
|
|
|
|
# Détection
|
|
compare_sessions(Session1, Session2) = 0.89
|
|
compare_sessions(Session2, Session3) = 0.91
|
|
compare_sessions(Session1, Session3) = 0.87
|
|
|
|
avg_similarity = 0.89 > 0.75 ✅
|
|
|
|
→ Workflow "Ouvrir OnlyOffice et créer document" détecté !
|
|
```
|
|
|
|
### Jour 4 - Suggestion
|
|
|
|
```python
|
|
# L'utilisateur commence
|
|
Action 1: Clic sur lanceur
|
|
Action 2: Type "office"
|
|
|
|
# Le système détecte
|
|
match_score = match_workflow_start([Action1, Action2], Workflow.steps)
|
|
match_score = 0.92 > 0.75 ✅
|
|
|
|
# Suggestion !
|
|
"Je peux continuer ce workflow pour toi ?"
|
|
[Oui] [Non] [Corriger]
|
|
```
|
|
|
|
## 🔧 Implémentation
|
|
|
|
### Fichiers à Créer
|
|
|
|
1. `geniusia2/core/workflow_detector.py` - Détection de workflows
|
|
2. `geniusia2/core/workflow_manager.py` - Gestion des workflows
|
|
3. `geniusia2/core/session_manager.py` - Segmentation en sessions
|
|
|
|
### Fichiers à Modifier
|
|
|
|
1. `geniusia2/core/event_capture.py` - Intégrer WorkflowDetector
|
|
2. `geniusia2/core/orchestrator.py` - Utiliser workflows au lieu de patterns
|
|
3. `geniusia2/core/suggestion_manager.py` - Suggérer workflows complets
|
|
|
|
## 📈 Avantages
|
|
|
|
### Avant (Micro-Patterns)
|
|
- ❌ Détecte seulement les clics répétés
|
|
- ❌ Inutilisable en pratique
|
|
- ❌ Ne correspond pas à l'usage réel
|
|
|
|
### Après (Macro-Workflows)
|
|
- ✅ Détecte les workflows complets
|
|
- ✅ Utilisable en pratique
|
|
- ✅ Correspond à l'usage réel
|
|
- ✅ Vrai RPA Vision !
|
|
|
|
## 🎯 Prochaines Étapes
|
|
|
|
1. **Implémenter WorkflowDetector** (3-4h)
|
|
2. **Implémenter SessionManager** (2h)
|
|
3. **Modifier EventCapture** (1h)
|
|
4. **Tester avec ton workflow OnlyOffice** (1h)
|
|
5. **Ajuster les seuils** (1h)
|
|
|
|
**Total** : ~8-10 heures de développement
|
|
|
|
## 💡 Note Importante
|
|
|
|
C'est un **changement majeur** mais **nécessaire** pour que le système soit vraiment utilisable !
|
|
|
|
Le système actuel est un MVP qui ne fonctionne que pour des cas d'usage artificiels.
|
|
|
|
Avec cette refonte, on aura un **vrai RPA Vision** qui apprend des workflows réels ! 🚀
|
|
|
|
---
|
|
|
|
**Veux-tu qu'on commence l'implémentation ?** 💪
|