Я пытаюсь реализовать Adaboost M1 в Python из этого псевдокода: 
Я кое-что добился, однако количество моих «неправильных прогнозов» не уменьшается.
Я проверил свою функцию обновления веса, и, похоже, она корректно обновляет веса.
Ошибка может быть в классификаторе, поскольку количество «неправильных прогнозов» является одним и тем же целым числом на каждой второй итерации - я пробовал 100 итераций. Я понятия не имею, почему он не дает меньше ошибок за итерацию.
Совет будет принят с благодарностью. Спасибо:)
from sklearn import tree
import pandas as pd
import numpy as np
import math
df = pd.read_csv("./dataset(3)/adaboost_train.csv")
X_train = df.loc[:,'x1':'x10']
Y_train = df[['y']]
def adaBoost(X_train,Y_train):
classifiers = []
# initializing the weights:
N = len(Y_train)
w_i = [1 / N] * N
T = 20
x_train = (X_train.apply(lambda x: x.tolist(), axis=1))
clf_errors = []
for t in range(T):
print("Iteration:", t)
# clf = clf2.fit(X_train,Y_train, sample_weight = w_i)
clf = tree.DecisionTreeClassifier(max_depth=1)
clf.fit(X_train, Y_train, sample_weight = w_i)
#Predict all the values:
y_pred = []
for sample in x_train:
p = clf.predict([sample])
p = p[0]
y_pred.append(p)
num_of_incorrect = calculate_error_clf(y_pred, Y_train)
clf_errors.append(num_of_incorrect)
error_internal = calc_error(w_i,Y_train,y_pred)
alpha = np.log((1-error_internal)/ error_internal)
print(alpha)
# Add the predictions, error and alpha for later use for every iteration
classifiers.append((y_pred, error_internal, alpha))
if t == 2 and y_pred == classifiers[0][0]:
print("TRUE")
w_i = update_weights(w_i,y_pred,Y_train,alpha,clf)
def calc_error(weights,Y_train,y_pred):
err = 0
for i in range(len(weights)):
if y_pred[i] != Y_train['y'].iloc[i]:
err= err + weights[i]
# Normalizing the error:
err = err/np.sum(weights)
return err
# If the prediction is true, return 0. If it is not true, return 1.
def check_pred(y_p, y_t):
if y_p == y_t:
return 0
else:
return 1
def update_weights(w,y_pred,Y_train,alpha,clf):
for j in range(len(w)):
if y_pred[j] != Y_train['y'].iloc[j]:
w[j] = w[j]* (np.exp( alpha * 1))
return w
def calculate_error_clf(y_pred, y):
sum_error = 0
for i in range(len(y)):
if y_pred[i] != y.iloc[i]['y']:
sum_error += 1
e = (y_pred[i] - y.iloc[i]['y'])**2
#sum_error += e
sum_error = sum_error
return sum_error
Я ожидаю, что ошибка уменьшится, но это не так. Например:
iteration 1: num_of_incorrect 4444
iteration 2: num_of_incorrect 4762
iteration 3: num_of_incorrect 4353
iteration 4: num_of_incorrect 4762
iteration 5: num_of_incorrect 4450
iteration 6: num_of_incorrect 4762
...
does not converge
