Comment utiliser le moignon de décision comme apprenant faible dans Adaboost?

Je souhaite implémenter Adaboost à l'aide de Decision Stump. Est-il correct de prendre autant de décisions que les fonctionnalités de notre ensemble de données à chaque itération d'Adaboost?

Par exemple, si j'ai un ensemble de données avec 24 fonctionnalités, dois-je avoir 24 classificateur de moignon de décision à chaque itération? Ou devrais-je choisir au hasard certaines fonctionnalités et les classifier au lieu de toutes les fonctionnalités?

La façon typique de former un arbre de décision (à 1 niveau) consiste à trouver un tel attribut qui donne la répartition la plus pure. Autrement dit, si nous divisons notre ensemble de données en deux sous-ensembles, nous voulons que les étiquettes à l'intérieur de ces sous-ensembles soient aussi homogènes que possible. Il peut donc également être considéré comme la construction de nombreux arbres - un arbre pour chaque attribut - puis la sélection de l'arbre qui produit le meilleur fractionnement.

Dans certains cas, il est également judicieux de sélectionner un sous-ensemble d'attributs, puis de former des arbres sur le sous-ensemble. Par exemple, ceci est utilisé dans Random Forest pour réduire la corrélation entre les arbres individuels.

Mais en ce qui concerne AdaBoost, il suffit généralement de s'assurer que le classificateur de base peut être formé sur les points de données pesés, et la sélection aléatoire des fonctionnalités est moins importante. Les arbres de décision peuvent gérer des poids (voir par exemple ici ou ici ). Cela peut être fait en pondérant la contribution de chaque point de données à l'impureté totale du sous-ensemble.

Pour référence, j'ajouterai également mon implémentation AdaBoost en python en utilisant numpy et sklearnDecisionTreeClassifier avec max_depth=1:

# input: dataset X and labels y (in {+1, -1})
hypotheses = []
hypothesis_weights = []

N, _ = X.shape
d = np.ones(N) / N

for t in range(num_iterations):
    h = DecisionTreeClassifier(max_depth=1)

    h.fit(X, y, sample_weight=d)
    pred = h.predict(X)

    eps = d.dot(pred != y)
    alpha = (np.log(1 - eps) - np.log(eps)) / 2

    d = d * np.exp(- alpha * y * pred)
    d = d / d.sum()

    hypotheses.append(h)
    hypothesis_weights.append(alpha)

Pour prédire les étiquettes:

# X input, y output
y = np.zeros(N)
for (h, alpha) in zip(hypotheses, hypotheses_weight):
    y = y + alpha * h.predict(X)
y = np.sign(y)