Как добиться максимальной точности при небольшом количестве выбранных функций с помощью xgboost?

Question

Я искал несколько методов выбора функций и нашел о выборе функций с помощью XGBoost по следующей ссылке ( Важность и выбор функции XGBoost ). Я применил метод для своего случая, и результаты были следующие:

• Порог = 0,000, n = 11, Точность: 55,56%
• Порог = 0,000, n = 11, Точность : 55,56%
• Порог = 0,000, n = 11, Точность: 55,56%
• Порог = 0,000, n = 11, Точность: 55,56%
• Порог = 0,097, n = 7, точность: 55,56%
• порог = 0,105, n = 6, точность: 55,56%
• порог = 0,110, n = 5, точность: 50,00%
• порог = 0,114, n = 4, точность: 50,00%
• порог = 0,169, n = 3, точность: 44,44%
• порог = 0,177, n = 2, точность: 38,89%
• Порог = 0,228, n = 1, Точность: 33,33%

Итак, мой вопрос заключается в следующем: как в этом случае выбрать самую высокую точность с небольшим количеством функций [n ]? [Код можно найти по ссылке]

Edit 1:

Благодаря @Mihai Petre мне удалось заставить его работать с кодом в его ответе. У меня есть другой вопрос, скажем, я запустил код по ссылке и получил следующее:

Feature Importance results = [29.205832   5.0182242  0.         0.         0. 6.7736177 16.704327  18.75632    9.529003  14.012676   0.       ]
Features = [ 0  7  6  9  8  5  1 10  4  3  2]

• Thresh = 0,000, n = 11, Accuracy: 38,89%
• Thresh = 0,000, n = 11, точность: 38,89%
• порог = 0,000, n = 11, точность: 38,89%
• порог = 0,000, n = 11, точность: 38,89%
• порог = 0,050, n = 7, точность: 38,89%
• порог = 0,068, n = 6, точность: 38,89%
• порог = 0,095, n = 5, точность: 33,33%
• Порог = 0,140, ​​n = 4, точность: 38,89%
• порог = 0,167, n = 3, точность: 33,33%
• порог = 0,188, n = 2, Точность: 38,89%
• Порог = 0,292, n = 1, Точность: 38,89%

Как я могу удалить функции, которые давали нулевую важность функции, и получить функции с важностью функции значения?

Дополнительные вопросы:

1. Я пытаюсь найти лучший выбор функций, который включает использование конкретной модели классификации c и лучших функций, которые помогают дают высокую точность, скажем, например, с помощью классификатора KNN и хотели бы найти лучшие функции, выдающие высокую точность. Какой набор функций будет уместен для использования?
2. При реализации нескольких моделей классификации лучше всего выполнить выбор функций для каждой модели классификации или вам нужно сделать выбор функций один раз, а затем использовать выбранные функции для нескольких моделей классификации ?

Answer 1

Мне удалось разобраться. Найдите код ниже:

Чтобы получить наименьшее количество функций с максимальной точностью:

# Fit the model:
f_max = 8
f_min = 2
acc_max = accuracy
thresholds = np.sort(model_FS.feature_importances_)
obj_thresh = thresholds[0]
accuracy_list = []
for thresh in thresholds:
    # select features using threshold:
    selection = SelectFromModel(model_FS, threshold=thresh, prefit=True)
    select_X_train = selection.transform(X_train)
    # train model:
    selection_model = xgb.XGBClassifier()
    selection_model.fit(select_X_train, y_train)
    # eval model:
    select_X_test = selection.transform(X_test)
    selection_model_pred = selection_model.predict(select_X_test)
    selection_predictions = [round(value) for value in selection_model_pred]
    accuracy = accuracy_score(y_true=y_test, y_pred=selection_predictions)
    accuracy = accuracy * 100
    print('Thresh= %.3f, n= %d, Accuracy: %.2f%%' % (thresh, select_X_train.shape[1], accuracy))
    accuracy_list.append(accuracy)
    if(select_X_train.shape[1] < f_max) and (select_X_train.shape[1] >= f_min) and (accuracy >= acc_max):
        n_min = select_X_train.shape[1]
        acc_max = accuracy
        obj_thresh = thresh
# select features using threshold:
selection = SelectFromModel(model_FS, threshold=obj_thresh, prefit=True)
select_X_train = selection.transform(X_train)
# train model:
selection_model = xgb.XGBClassifier()
selection_model.fit(select_X_train, y_train)
# eval model:
select_X_test = selection.transform(X_test)
selection_model_pred = selection_model.predict(select_X_test)
accuracy = accuracy_score(y_test, predictions)
selection_predictions = [round(value) for value in selection_model_pred]
accuracy = accuracy_score(y_true=y_test, y_pred=selection_predictions)
print("Selected: Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (obj_thresh, select_X_train.shape[1], accuracy*100.0))
key_list = list(range(X_train.shape[1], 0, -1))
accuracy_dict = dict(zip(key_list, accuracy_list))
optimum_num_feat = n_min
print(optimum_num_feat)

# Printing out the features:
X_train = X_train.iloc[:, optimum_number_features]
X_test = X_test.iloc[:, optimum_number_features]

print('X Train FI: ')
print(X_train)
print('X Test FI: ')
print(X_test)

Чтобы получить функции со значениями важности без значения нулевой важности:

# Calculate feature importances
importances = model_FS.feature_importances_
print((model_FS.feature_importances_) * 100)

# Organising the feature importance in dictionary:
## The key value depends on your maximum number of features:
key_list = range(0, 11, 1)
feature_importance_dict = dict(zip(key_list, importances))
sort_feature_importance_dict = dict(sorted(feature_importance_dict.items(), key=lambda x: x[1], reverse=True))
print('Feature Importnace Dictionary (Sorted): ', sort_feature_importance_dict)

# Removing the features that have value zero in feature importance:
filtered_feature_importance_dict = {x:y for x,y in sort_feature_importance_dict.items() if y!=0}
print('Filtered Feature Importnace Dictionary: ', filtered_feature_importance_dict)
f_indices = list(filtered_feature_importance_dict.keys())
f_indices = np.asarray(f_indices)
print(f_indices)

X_train = X_train.loc[:, f_indices]
X_test = X_test.loc[:, f_indices]

print('X Train FI: ')
print(X_train)
print('X Test FI: ')
print(X_test)

Answer 2

Хорошо, так что то, что парень по вашей ссылке делает с

thresholds = sort(model.feature_importances_)
for thresh in thresholds:
    # select features using threshold
    selection = SelectFromModel(model, threshold=thresh, prefit=True)
    select_X_train = selection.transform(X_train)
    # train model
    selection_model = XGBClassifier()
    selection_model.fit(select_X_train, y_train)
    # eval model
    select_X_test = selection.transform(X_test)
    predictions = selection_model.predict(select_X_test)
    accuracy = accuracy_score(y_test, predictions)
    print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (thresh, select_X_train.shape[1], accuracy*100.0))

, - это создать отсортированный массив пороговых значений, а затем он тренирует XGBoost для каждого элемента массива thresholds.

Судя по вашему вопросу, я думаю, вы хотите выбрать только 6-й случай, с наименьшим количеством функций и высочайшей точностью. В этом случае вам нужно сделать что-то вроде этого:

selection = SelectFromModel(model, threshold=threshold[5], prefit=True)
select_X_train = selection.transform(X_train)
selection_model = XGBClassifier()
selection_model.fit(select_X_train, y_train)
select_X_test = selection.transform(X_test)
predictions = selection_model.predict(select_X_test)
accuracy = accuracy_score(y_test, predictions)
print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (threshold[5], select_X_train.shape[1], accuracy*100.0))

Если вы хотите автоматизировать все это, вы должны вычислить минимальное n, для которого точность максимальна. внутри это для l oop, и это будет выглядеть примерно так:

n_min = *your maximum number of used features*
acc_max = 0
thresholds = sort(model.feature_importances_)
obj_thresh = thresholds[0]
for thresh in thresholds:
    selection = SelectFromModel(model, threshold=thresh, prefit=True)
    select_X_train = selection.transform(X_train)
    selection_model = XGBClassifier()
    selection_model.fit(select_X_train, y_train)
    select_X_test = selection.transform(X_test)
    predictions = selection_model.predict(select_X_test)
    accuracy = accuracy_score(y_test, predictions)
    if(select_X_train.shape[1] < n_min) and (accuracy > acc_max):
        n_min = select_X_train.shape[1]
        acc_max = accuracy
        obj_thresh = thresh

selection = SelectFromModel(model, threshold=obj_thresh, prefit=True)
select_X_train = selection.transform(X_train)
selection_model = XGBClassifier()
selection_model.fit(select_X_train, y_train)
select_X_test = selection.transform(X_test)
predictions = selection_model.predict(select_X_test)
accuracy = accuracy_score(y_test, predictions)
print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (obj_thresh, select_X_train.shape[1], accuracy*100.0))