Suivi comportemental

Name: Potato
Author: Potato

Enregistrez le détail des interactions des annotateurs dans Potato : temps passé, clics, historique des modifications et événements d'interface, pour l'analyse qualité et la recherche comportementale.

Le suivi comportemental de Potato enregistre le détail des interactions pendant les sessions d'annotation. Les chercheurs peuvent ainsi analyser le comportement des annotateurs, les rythmes de travail, le recours à l'assistance IA et la façon dont les décisions se prennent.

Vue d'ensemble

Le système de suivi comportemental capte :

Chaque action d'annotation : choix d'étiquettes, annotations d'empans, saisies de texte
Des horodatages précis : côté serveur et côté client
Le recours à l'assistance IA : quand les suggestions ont été affichées et si elles ont été acceptées
Le focus et les temps : temps passé sur chaque élément, profondeur de défilement
L'historique de navigation : le parcours complet à travers les instances

Ce qui est enregistré

Événements d'interaction

Chaque interaction de l'utilisateur avec l'interface d'annotation est captée :

Type d'événement	Description	Exemple de cible
`click`	Clics de souris sur un élément	`label:positive`, `nav:next`
`focus_in`	Un élément prend le focus	`textbox:explanation`
`focus_out`	Un élément perd le focus	`label:negative`
`keypress`	Raccourcis clavier	`key:1`, `nav:ArrowRight`
`navigation`	Navigation entre instances	`next`, `prev`, `instance_load`
`save`	Enregistrement d'une annotation	`instance:123`
`annotation_change`	Modification d'étiquette	`schema:sentiment`

Recours à l'assistance IA

Le cycle de vie complet de l'annotation assistée par IA est suivi :

json

{
  "request_timestamp": 1706500010.0,
  "response_timestamp": 1706500012.5,
  "schema_name": "sentiment",
  "suggestions_shown": ["positive", "neutral"],
  "suggestion_accepted": "positive",
  "time_to_decision_ms": 3500
}

Modifications d'annotation

Historique détaillé des modifications, pour toutes les annotations :

json

{
  "timestamp": 1706500002.5,
  "schema_name": "sentiment",
  "label_name": "positive",
  "action": "select",
  "old_value": null,
  "new_value": true,
  "source": "user"
}

Types de source :

user - Interaction directe de l'utilisateur
ai_accept - L'utilisateur a accepté une suggestion de l'IA
keyboard - Raccourci clavier
prefill - Prérempli depuis la configuration

Format des données

Chaque instance annotée comporte un objet behavioral_data :

json

{
  "id": "instance_123",
  "annotations": {
    "sentiment": {"positive": true}
  },
  "behavioral_data": {
    "instance_id": "instance_123",
    "session_start": 1706500000.0,
    "session_end": 1706500045.0,
    "total_time_ms": 45000,
    "interactions": [...],
    "ai_usage": [...],
    "annotation_changes": [...],
    "navigation_history": [...],
    "focus_time_by_element": {
      "label:positive": 2500,
      "textbox:explanation": 8000
    },
    "scroll_depth_max": 75.5
  }
}

Configuration

Le suivi comportemental est actif par défaut. Aucune configuration supplémentaire n'est nécessaire.

Mode debug côté navigateur

Pour activer les journaux de débogage du traceur d'interactions :

javascript

// In browser console
window.interactionTracker.setDebugMode(true);

Exemples d'analyse

Charger les données comportementales

python

import json
from pathlib import Path
 
def load_behavioral_data(annotation_dir: str) -> dict:
    data = {}
    for user_dir in Path(annotation_dir).iterdir():
        if not user_dir.is_dir():
            continue
        state_file = user_dir / 'user_state.json'
        if state_file.exists():
            with open(state_file) as f:
                user_state = json.load(f)
            user_id = user_state.get('user_id')
            behavioral = user_state.get('instance_id_to_behavioral_data', {})
            data[user_id] = behavioral
    return data

Analyser le temps d'annotation

python

def analyze_annotation_time(behavioral_data: dict) -> dict:
    stats = {}
    for user_id, instances in behavioral_data.items():
        times = []
        for instance_id, bd in instances.items():
            if 'total_time_ms' in bd:
                times.append(bd['total_time_ms'] / 1000)
        if times:
            stats[user_id] = {
                'mean_time': sum(times) / len(times),
                'min_time': min(times),
                'max_time': max(times),
                'total_instances': len(times)
            }
    return stats

Détecter les comportements suspects

python

def detect_suspicious_annotators(behavioral_data: dict,
                                  min_time_threshold: float = 2.0) -> list:
    suspicious = []
    for user_id, instances in behavioral_data.items():
        fast_count = 0
        for instance_id, bd in instances.items():
            time_sec = bd.get('total_time_ms', 0) / 1000
            if time_sec < min_time_threshold:
                fast_count += 1
 
        total = len(instances)
        if total > 0:
            fast_rate = fast_count / total
            if fast_rate > 0.5:
                suspicious.append({
                    'user_id': user_id,
                    'fast_rate': fast_rate,
                    'total_instances': total
                })
    return suspicious

Intégration au tableau de bord d'administration

Le tableau de bord d'administration comporte un onglet Analyse comportementale avec :

Carte de chaleur des interactions : représentation visuelle des schémas d'interaction
Métriques d'assistance IA : taux d'acceptation et de rejet, temps de décision
Distribution des temps : histogramme des temps d'annotation
Alertes d'activité suspecte : annotateurs signalés pour examen

Points de terminaison de l'API

Enregistrer des interactions

http

POST /api/track_interactions
Content-Type: application/json
 
{
  "instance_id": "instance_123",
  "events": [...],
  "focus_time": {"element": ms},
  "scroll_depth": 75.5
}

Lire les données comportementales

http

GET /api/behavioral_data/<instance_id>

Renvoie l'intégralité des données comportementales d'une instance.

Bonnes pratiques

Pour les chercheurs

Établir une référence : recueillez les données comportementales d'annotateurs éprouvés pour disposer d'un point de comparaison
Indicateurs de qualité : croisez les données comportementales avec l'accord inter-annotateurs pour évaluer la qualité
Évaluation de la formation : comparez les comportements avant et après la formation
Effet de l'IA : mesurez l'influence de l'assistance IA sur la qualité et la vitesse d'annotation

Pour les projets d'annotation

Surveillez en temps réel : le tableau de bord d'administration permet de repérer les problèmes tôt
Fixez des seuils : définissez les plages acceptables pour les temps et les métriques d'interaction
Faites des retours : appuyez-vous sur ces observations pour donner un retour ciblé aux annotateurs

Dépannage

Aucune donnée comportementale n'est collectée

Vérifiez que interaction_tracker.js est bien chargé (onglet Réseau du navigateur)
Cherchez des erreurs JavaScript dans la console du navigateur
Vérifiez que les points de terminaison de l'API sont joignables (/api/track_interactions)

Les données ne sont pas conservées

Vérifiez que l'état utilisateur est bien enregistré (cherchez user_state.json)
Vérifiez que le répertoire de sortie des annotations est accessible en écriture

Pour aller plus loin

Tableau de bord d'administration - Suivi en temps réel
Historique d'annotation - Suivi détaillé des modifications
Contrôle de la qualité - Contrôles de qualité automatisés

Pour les détails d'implémentation, consultez la documentation source.