ADABOOST : ADAPTIVE BOOSTING
MÉTHODES D'ENSEMBLE EN MACHINE LEARNING
Introduction au Machine Learning et Méthodes d'Ensemble
• Machine Learning : apprentissage automatique à partir des données
• Méthodes d'ensemble : combiner plusieurs modèles faibles → modèle fort
• Objectifs : précision, robustesse, généralisation
• Types : Bagging, Boosting, Stacking
• "L'union fait la force"
Concept du Boosting
• Apprentissage itératif : chaque modèle corrige les erreurs du précédent
• Focus adaptatif sur les exemples difficiles mal classés
• Pondération dynamique des observations à chaque itération
• Construction incrémentale d'un modèle fort à partir de modèles faibles
• Principe clé : "L'union fait la force"
ADABOOST
Présentation d'AdaBoost
• Créé par Freund & Schapire en 1996
• Algorithme de boosting le plus influent
• Ajustement dynamique des poids des erreurs
• Transforme weak learners en strong learner
• Classification binaire et multi-classes
Fonctionnement de l'Algorithme
Poids uniformes attribués à chaque observation : w_i = 1/n. Tous les exemples ont la même importance au départ.
Un classifieur faible (ex: decision stump) est entraîné sur les données pondérées. Il minimise l'erreur pondérée.
2.Entrainement
Erreur pondérée calculée : ε_t = Σ w_i × I(erreur). Plus ε est faible, plus le classifieur est performant.
3.Calcul d’eurreur
Fonctionnement d'AdaBoost
Calcul du poids α
α_t = 0.5 × ln((1-ε)/ε)
Plus l'erreur est faible, plus le classifieur a de poids dans le vote final
Mise à jour des poids
w_i = w_i × exp(α × erreur)
Les exemples mal classés reçoivent des poids plus élevés
Normalisation
Σ w_i = 1
Les poids sont normalisés pour former une distribution de probabilité
Fonctionnement AdaBoost
Étapes Finales
Boucle sur T itérations successives. Chaque itération entraîne un nouveau classifieur faible sur les données pondérées, renforçant progressivement le modèle global.
Répétition T Itérations
Vote pondéré des T classifieurs : H(x) = sign(Σ αₜ × hₜ(x)). Les classifieurs performants (α élevé) ont plus d'influence sur la décision finale.
Prédiction Finale
Combinaison intelligente des modèles faibles en un modèle fort. La pondération adaptative garantit que chaque classifieur contribue selon sa performance réelle.
Agrégation Modèles
Schéma Visuel du Fonctionnement d'AdaBoost
• Itération 1 : poids uniformes, erreurs identifiées
• Itération 2 : poids réajustés sur erreurs
• Itération 3 : poids affinés, classification optimisée
• Modèle final : vote pondéré des classifieurs
• Légende : taille = poids, rouge = erreur, vert = succès
Formules Mathématiques Clés
• Erreur pondérée : ε_t = Σ w_i × I(y_i ≠ h_t(x_i))
• Poids du classifieur : α_t = 0.5 × ln((1 - ε_t) / ε_t)
• Mise à jour poids : w_i^(t+1) = w_i^(t) × exp(α_t × I(erreur))
• Prédiction finale : H(x) = sign(Σ α_t × h_t(x))
Intuition : Plus ε_t est faible, plus α_t est élevé → le classifieur précis a plus de poids dans le vote final.
Implémentation AdaBoost en Python – Partie 1
import numpy as np
from sklearn.tree import DecisionTreeClassifier
class AdaBoostClassifier:
def init(self, n_estimators=50):
self.n_estimators = n_estimators
self.alphas = [] # Poids des classifieurs
self.models = [] # Classifieurs faibles
def fit(self, X, y):
n_samples = X.shape[0]
# Initialisation poids uniformes
weights = np.ones(n_samples) / n_samples
for t in range(self.n_estimators):
# Entraîner classifieur faible
model = DecisionTreeClassifier(max_depth=1)
model.fit(X, y, sample_weight=weights)
Implémentation Python – Partie 2
Calcul de l'erreur pondéréeerror = np.sum(weights * (predictions != y))
Coefficient alpha du classifieuralpha = 0.5 * np.log((1 - error) / (error + 1e-10))
Mise à jour des poids (augmenter erreurs)weights *= np.exp(alpha * (predictions != y))
Normalisation des poidsweights /= np.sum(weights)
Stockage modèle et alphaself.models.append(model)
self.alphas.append(alpha)
Implémentation Python – Partie 3
Méthode predict : vote pondéré des classifieurs
def predict(self, X):
predictions = np.zeros(len(X))
for alpha, model in zip(self.alphas, self.models):
predictions += alpha * model.predict(X)
return np.sign(predictions)
Exemple d'utilisation completX, y = make_classification(n_samples=500)
y = np.where(y == 0, -1, 1) # Conversion {-1, 1}
X_train, X_test, y_train, y_test = train_test_split(X, y)
Utilisation Simplifiée avec scikit-learn
• Import : AdaBoostClassifier, DecisionTreeClassifier
• Dataset : iris avec train_test_split (80/20)
• Classifieur de base : DecisionTree (max_depth=1)
• Entraînement : model.fit(X_train, y_train)
• Évaluation : accuracy_score, classification_report
Avantages et Inconvénients
• Haute précision sur données complexes
• Réduction du biais et de la variance
• Peu d'hyperparamètres à régler
• Compatible avec plusieurs classifieurs faibles
• Interprétabilité via importance des features
✓ Avantages
• Sensibilité au bruit et aux outliers
• Risque de surapprentissage
• Entraînement séquentiel, non parallélisable
• Dépendance au classifieur de base
• Temps de calcul parfois élevé
✗ Inconvénients
Comparaison AdaBoost vs Bagging vs Random Forest
AdaBoost
• Apprentissage séquentiel
• Pondération adaptative
• Corrige les erreurs
• Sensibilité bruit : élevée
• Non parallélisable
• Vitesse : moyenne
Bagging & Random Forest
• Apprentissage parallèle
• Pondération uniforme
• Réduit la variance
• Sensibilité bruit : faible
• Parallélisable
• Vitesse : rapide
Applications en Data Science
Détection de Spam
Classification emails spam/non-spam avec haute précision. Analyse des caractéristiques textuelles et métadonnées pour filtrage intelligent.
Détection de Fraude
Identification transactions suspectes en temps réel. Apprentissage adaptatif sur patterns frauduleux évolutifs.
Santé et Diagnostic
Diagnostic assisté par IA, prédiction de maladies, analyse d'imagerie médicale avec précision clinique.
Applications d'AdaBoost
Détection de visages avec l'algorithme Viola-Jones, reconnaissance d'objets en temps réel, classification d'images médicales, systèmes de surveillance intelligents.
Vision par Ordinateur
Texte brut → Prétraitement → Vectorisation TF-IDF → Classification AdaBoost → Prédiction finale. Architecture complète pour l'analyse textuelle automatisée.
Pipeline NLP
Classification d'opinions positives/négatives, analyse de reviews produits, détection d'émotions dans les réseaux sociaux, monitoring de marque en temps réel.
Sentiment Analysis
Pipeline NLP avec AdaBoost
Texte brut → Prétraitement (nettoyage, tokenisation)
→ Vectorisation TF-IDF (transformation numérique)
→ Classification AdaBoost (modèle entraîné)
→ Prédiction finale (sentiment positif/négatif)
Conclusion
✓ AdaBoost : méthode puissante et élégante
✓ Apprentissage séquentiel avec pondération adaptative
✓ Transforme modèles faibles en modèle fort
✓ Excellente précision sur données complexes
⚠️ Attention au bruit et qualité des données
🚀 Perspectives : Gradient Boosting, XGBoost, LightGBM
MERCI !