Come usare il moncone decisionale come studente debole in Adaboost?

Voglio implementare Adaboost usando Decision Stump. È corretto prendere la stessa quantità di decisione che le caratteristiche del nostro set di dati in ogni iterazione di Adaboost?

Ad esempio, se ho un set di dati con 24 funzionalità, dovrei avere un classificatore di 24 stump delle decisioni in ogni iterazione? O dovrei scegliere casualmente alcune funzionalità e farle classificatore al posto di tutte le funzionalità?

Il modo tipico di formare un albero decisionale (di 1 livello) è trovare un tale attributo che dia la divisione più pura. Vale a dire se dividiamo il nostro set di dati in due sottoinsiemi, vogliamo che le etichette all'interno di questi sottoinsiemi siano il più omogenee possibile. Quindi può anche essere visto come costruire molti alberi - un albero per ogni attributo - e quindi selezionare l'albero che produce la migliore divisione.

In alcuni casi ha anche senso selezionare un sottoinsieme di attributi e quindi formare alberi sul sottoinsieme. Ad esempio, questo viene utilizzato nella foresta casuale per ridurre la correlazione tra i singoli alberi.

Ma quando si tratta di AdaBoost, in genere è sufficiente assicurarsi che il classificatore di base possa essere addestrato sui punti dati pesati e che la selezione casuale delle funzioni sia meno importante. Gli alberi decisionali possono gestire pesi (vedere ad esempio qui o qui ). Può essere fatto ponderando il contributo di ciascun punto dati all'impurità totale del sottoinsieme.

Per riferimento aggiungerò anche la mia implementazione di AdaBoost in Python usando numpy e sklearnDecisionTreeClassifier con 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)

Per prevedere le etichette:

# 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)