Skip to content

Apprentissage actif

Utilisez les 5 stratégies d'apprentissage actif de Potato — échantillonnage par incertitude, BADGE, BALD, par diversité et ensemble hybride — pour réduire le coût d'annotation jusqu'à 50 %.

L'apprentissage actif vous fait annoter plus efficacement en donnant la priorité aux exemples les plus informatifs. Au lieu d'annoter au hasard, vous vous concentrez sur les instances où le modèle est le plus incertain.

Fonctionnement

L'apprentissage actif de Potato réordonne automatiquement les instances à annoter à partir des prédictions d'un modèle :

  1. Collecte initiale - Réunir un nombre minimal d'annotations
  2. Entraînement - Entraîner un classifieur sur les annotations existantes
  3. Prédiction - Obtenir des scores d'incertitude pour les instances non annotées
  4. Réordonnancement - Faire remonter les instances les plus incertaines
  5. Annotation - Les annotateurs étiquettent les instances prioritaires
  6. Réentraînement - Mettre à jour le modèle périodiquement avec les nouvelles annotations

La boucle d'apprentissage actif : entraîner sur ce qui est étiqueté, noter le vivier non étiqueté par incertitude, annoter les éléments les plus incertains, puis réentraînerConsacrer l'effort d'annotation là où le modèle apprend le plus

Configuration

Configuration de base

yaml
active_learning:
  enabled: true
  schema_names:
    - sentiment  # Which annotation schemes to use
 
  min_annotations_per_instance: 1
  min_instances_for_training: 20
  update_frequency: 50  # Retrain after every 50 annotations
  max_instances_to_reorder: 1000

Configuration complète

yaml
active_learning:
  enabled: true
 
  # Which schemas to use for training
  schema_names:
    - sentiment
 
  # Minimum requirements
  min_annotations_per_instance: 1
  min_instances_for_training: 20
 
  # Retraining frequency
  update_frequency: 50
 
  # How many instances to reorder
  max_instances_to_reorder: 1000
 
  # Classifier configuration
  classifier_name: sklearn.linear_model.LogisticRegression
  classifier_params:
    C: 1.0
    max_iter: 1000
 
  # Query strategy
  query_strategy: uncertainty  # uncertainty, diversity, badge, bald, hybrid
 
  # Feature extraction
  vectorizer:
    type: TfidfVectorizer
    params:
      max_features: 5000
      ngram_range: [1, 2]
 
  # Model persistence
  model_persistence:
    enabled: true
    save_dir: "models/"
    max_saved_models: 5

Stratégies de sélection

Potato propose cinq stratégies de sélection pour retenir les instances les plus informatives :

StratégieDescription
uncertaintyRetient les instances sur lesquelles le modèle est le moins sûr (par défaut)
diversityRetient les instances les plus éloignées des données déjà annotées
badgeBatch Active learning by Diverse Gradient Embeddings
baldBayesian Active Learning by Disagreement
hybridEnsemble combinant plusieurs stratégies
yaml
active_learning:
  query_strategy: uncertainty  # or diversity, badge, bald, hybrid

Classifieurs pris en charge

Les classifieurs se déclarent par leur chemin d'import sklearn complet via classifier_name :

ClassifieurChemin sklearnConvient àVitesse
Régression logistiquesklearn.linear_model.LogisticRegressionClassification binaire ou multiclasseRapide
Forêt aléatoiresklearn.ensemble.RandomForestClassifierMotifs complexesMoyenne
SVCsklearn.svm.SVCPetits jeux de donnéesLente
Multinomial NBsklearn.naive_bayes.MultinomialNBClassification de texteTrès rapide

Exemples de classifieurs

yaml
# Logistic Regression (recommended starting point)
classifier_name: sklearn.linear_model.LogisticRegression
classifier_params:
  C: 1.0
  max_iter: 1000
 
# Random Forest
classifier_name: sklearn.ensemble.RandomForestClassifier
classifier_params:
  n_estimators: 100
  max_depth: 10
 
# Support Vector Classifier
classifier_name: sklearn.svm.SVC
classifier_params:
  kernel: rbf
  probability: true
 
# Naive Bayes
classifier_name: sklearn.naive_bayes.MultinomialNB
classifier_params:
  alpha: 1.0

Vectoriseurs

VectoriseurDescription
TfidfVectorizerTraits pondérés par TF-IDF (recommandé)
CountVectorizerSimples comptages de mots
HashingVectorizerÉconome en mémoire pour les gros vocabulaires
yaml
# TF-IDF (recommended)
vectorizer:
  type: TfidfVectorizer
  params:
    max_features: 5000
    ngram_range: [1, 2]
    stop_words: english
 
# Count Vectorizer
vectorizer:
  type: CountVectorizer
  params:
    max_features: 3000
    ngram_range: [1, 1]
 
# Hashing Vectorizer (for large datasets)
vectorizer:
  type: HashingVectorizer
  params:
    n_features: 10000

Intégration avec un LLM

L'apprentissage actif peut s'appuyer sur un LLM pour affiner la sélection des instances :

yaml
active_learning:
  enabled: true
  schema_names:
    - sentiment
 
  # LLM-based selection
  llm_integration:
    enabled: true
    endpoint_type: vllm
    base_url: http://localhost:8000/v1
    model: meta-llama/Llama-2-7b-chat-hf
 
    # Mock mode for testing
    mock_mode: false

Plusieurs schémas d'annotation

L'apprentissage actif peut alterner entre plusieurs schémas d'annotation :

yaml
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    labels: [Positive, Negative, Neutral]
 
  - annotation_type: radio
    name: topic
    labels: [Politics, Sports, Tech, Entertainment]
 
active_learning:
  enabled: true
  schema_names:
    - sentiment
    - topic
 
  # Schema-specific settings
  schema_config:

Persistance des modèles

Enregistrez et rechargez les modèles entraînés d'un redémarrage du serveur à l'autre :

yaml
active_learning:
  enabled: true
  schema_names:
    - sentiment
 
  model_persistence:
    enabled: true
    save_dir: "models/"
    max_saved_models: 5  # Keep last 5 models
 
    # Save to database instead of files
    use_database: false

Suivi de l'avancement

Le tableau de bord d'administration suit les métriques d'apprentissage actif :

  • Justesse actuelle du modèle
  • Nombre de cycles d'entraînement
  • Distribution de l'incertitude
  • Instances restantes
  • Historique des réentraînements

Accès via /admin avec votre clé d'API d'administration.

Bonnes pratiques

1. Commencer par un échantillonnage aléatoire

Recueillez des annotations initiales avant d'activer l'apprentissage actif :

yaml
active_learning:
  enabled: true
  min_instances_for_training: 50  # Wait for 50 annotations

2. Choisir un classifieur adapté

  • LogisticRegression : rapide, bon choix par défaut pour la plupart des tâches
  • RandomForest : meilleur sur les motifs complexes, mais plus lent
  • MultinomialNB : très rapide, adapté à la classification de texte simple

3. Surveiller la distribution des classes

L'apprentissage actif peut déséquilibrer les classes. Surveillez-la dans le tableau de bord d'administration et envisagez un échantillonnage stratifié.

4. Fixer une fréquence de réentraînement raisonnable

Un réentraînement trop fréquent gaspille les ressources :

yaml
update_frequency: 100  # Retrain every 100 annotations

5. Activer la persistance des modèles

Enregistrez les modèles pour éviter de repartir de zéro à chaque redémarrage :

yaml
model_persistence:
  enabled: true
  save_dir: "models/"

Exemple : configuration complète

yaml
annotation_task_name: "Sentiment Analysis with Active Learning"
task_dir: "."
port: 8000
 
data_files:
  - "data/reviews.json"
 
item_properties:
  id_key: id
  text_key: text
 
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    description: "What is the sentiment?"
    labels:
      - Positive
      - Negative
      - Neutral
 
active_learning:
  enabled: true
  schema_names:
    - sentiment
 
  min_annotations_per_instance: 1
  min_instances_for_training: 30
  update_frequency: 50
  max_instances_to_reorder: 500
 
  classifier_name: sklearn.linear_model.LogisticRegression
  classifier_params:
 
  query_strategy: uncertainty
 
  vectorizer:
 
  model_persistence:
 
output_annotation_dir: "output/"
export_annotation_format: "json"
user_config:
  allow_all_users: true

Combiner avec le support IA

Utilisez à la fois l'apprentissage actif et l'assistance par LLM :

yaml
active_learning:
  enabled: true
  schema_names:
    - sentiment
  min_instances_for_training: 30
 
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  features:
    label_suggestions:
      enabled: true

Cette combinaison fait remonter les instances incertaines tout en fournissant des suggestions de l'IA pour aider les annotateurs.

Dépannage

Échecs à l'entraînement

  • Vérifiez que les annotations sont assez nombreuses (min_instances_for_training)
  • Contrôlez la distribution des classes : il faut des exemples de chaque classe
  • Vérifiez que le format des données correspond au schéma

Performances lentes

  • Réduisez max_instances_to_reorder
  • Augmentez update_frequency
  • Utilisez HashingVectorizer pour les gros vocabulaires

Le modèle ne se met pas à jour

  • Vérifiez le réglage de update_frequency
  • Vérifiez que les annotations sont bien enregistrées
  • Cherchez des erreurs dans le tableau de bord d'administration

Pour aller plus loin

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