indices = np.argsort(importances)[::-1]
========================================
Важность функций с лесами деревьев
========================================
В этом примере показано использование лесов деревьев для оценки важности признаков в задаче искусственной классификации. Красные столбцы – это важность признаков леса, а также их изменчивость между деревьями.
печать (__doc__)
импортировать numpy как np
импортировать matplotlib.pyplot как plt
из sklearn.datasets импортировать make_classification
из sklearn.ensemble импортировать ExtraTreesClassifier
# Создайте задачу классификации, используя 3 информативных признака
X, y = make_classification(n_samples=1000,
n_features=10,
n_informative=3,
n_redundant=0,
n_repeated=0,
n_classes=2,
random_state=0,
shuffle=False)
# Построить лес и вычислить важность признаков
forest = ExtraTreesClassifier(n_estimators=250,
random_state=0)
forest.fit(X, y)
Importants = forest.feature_importances_
std = np.std([tree.feature_importances_ for tree in forest.estimators_],
axis=0)
> индексы = np.argsort(важность)[::-1]
# Распечатать рейтинг функций
print("Рейтинг функций:")
для f в диапазоне (X.shape[1]):
print("%d. функция %d (%f)" % (f + 1, индексы[f], важности[индексы[f]]) )
# Отображение важности признаков леса
plt.figure()
plt.title("Важность признаков")
plt.bar(range(X.shape [1]), Importants[indices],
color="r", yerr=std[indices], align="center")
plt.xticks(range(X.shape[1]) , индексы)
plt.xlim([-1, X.shape[1]])
plt.show()
Как и ожидалось, график предполагает, что 3 признака информативны, а остальные
нет.
Ранжирование признаков:
1. признак 1 (0,295902)
2. признак 2 (0,208351)
3. признак 0 (0,177632)
4. признак 3 (0,047121)
5. признак 6 (0,046303)
6. признак 8 (0,046013)
7. признак 7 (0,045575)
8. признак 4 (0,044614)
9. признак 9 ( 0,044577)
10. функция 5 (0,043912)
============================================
Пиксель важности с параллельным лесом деревьев
====================================== ======
В этом примере показано использование лесов деревьев для оценки важности пикселей в задаче классификации изображений (лица). Чем горячее пиксель, тем важнее.
В приведенном ниже коде также показано, как построение и вычисление прогнозов можно распараллелить в рамках нескольких заданий.
печать (__doc__)
время импорта
импортировать matplotlib.pyplot как plt
из sklearn.datasets импортировать fetch_olivetti_faces
из sklearn.ensemble импортировать ExtraTreesClassifier
# Количество ядер для параллельного подбора модели леса
n_jobs = 1
# Загружаем набор данных о лицах
data = fetch_olivetti_faces()
X = data.images.reshape((len(data.images), -1))
y = данные.цель
mask = y ‹ 5 # Ограничение до 5 классов
X = X[маска]
y = y[маска]
# Построить лес и вычислить важность пикселей
print("Подбор ExtraTreesClassifier для данных о лицах с %d ядрами..." % n_jobs)
t0 = time()
лес = ExtraTreesClassifier(n_estimators=1000,
max_features=128,
n_jobs=n_jobs,
random_state=0)
forest.fit(X, y)
print("выполнено за %0,3fs" % (time() — t0))
Importants = forest.feature_importances_
Importants = Importants.reshape(data .изображения[0].форма)
# Отображение важности пикселей
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(importances, cmap=plt. cm.hot)
fig.colorbar(cax)
plt.title("Важность пикселей с лесами деревьев")
plt.show()
Подгонка ExtraTreesClassifier к данным о лицах с 1 ядром…
выполнено за 1,446 с.
====================================
Построение прогнозов с перекрестной проверкой
= ====================================
В этом примере показано, как использовать cross_val_predict для визуализации ошибок предсказания.
из sklearn импортировать наборы данных
из sklearn.model_selection импортировать cross_val_predict
из sklearn импортировать linear_model
импортировать matplotlib.pyplot как plt
lr = linear_model.LinearRegression()
boston = datasets.load_boston()
y = boston.target
# cross_val_predict возвращает массив того же размера, что и `y`, где каждая запись
# является прогнозом, полученным перекрестной проверкой:
предсказанный = cross_val_predict(lr, boston.data, у, cv=10)
рис, ax = plt.subplots()
ax.scatter(y, предсказано, edgecolors=(0, 0, 0))
ax.plot([y.min(), y.max( )], [y.min(), y.max()], 'k — ', lw=4)
ax.set_xlabel('Измерено')
ax.set_ylabel('Прогнозировано')
plt.show()
============================================
Сюжет поверхности решений ансамблей деревьев в наборе данных iris
================================== ==========
Постройте поверхности решений лесов рандомизированных деревьев, обученных на парах признаков набора данных радужной оболочки.
На этом графике сравниваются поверхности решений, полученные классификатором дерева решений (первый столбец), классификатором случайного леса (второй столбец), классификатором дополнительных деревьев (третий столбец) и классификатором AdaBoost (четвертый столбец).
В первом ряду классификаторы строятся только по ширине и длине чашелистиков, во втором ряду — только по длине лепестков и длине чашелистиков, а в третьем ряду — только по ширине и длине лепестков.
печать (__doc__)
импортировать numpy как np
импортировать matplotlib.pyplot как plt
из matplotlib.colors импортировать ListedColormap
импорт из sklearn.
# Параметры
n_classes = 3
n_estimators = 30
cmap = plt.cm.RdYlBu
plot_step = 0.02 # ширина тонкого шага для контуров поверхности решений
plot_step_coarser = 0.5 # ширина шага для грубых догадок классификатора
RANDOM_SEED = 13 # фиксируем начальное значение на каждой итерации
# Загрузка данных
iris = load_iris()
plot_idx = 1
models = [DecisionTreeClassifier(max_depth=None),
RandomForestClassifier(n_estimators=n_estimators),
ExtraTreesClassifier(n_estimators=n_estimators),
AdaBoostClassifier(DecisionTreeClassifier(max_depth=3),
n_estimators =n_оценщиков)]
для пары в ([0, 1], [0, 2], [2, 3]):
для модели в моделях:
# Берем только два соответствующих признака
X = iris.data[:, пара]
y = iris.target
# Перемешать
idx = np.arange(X.shape[0])
np.random.seed(RANDOM_SEED)
np.random.shuffle(idx)
X = X[idx]
y = y[idx]
# Стандартизировать
mean = X.mean(axis=0)
std = X.std(axis=0)
X = (X — среднее) / std
# Train
clf = clone(model)
clf = model.fit(X, y)
scores = clf.score(X, y)
# Создайте заголовок для каждого столбца и консоли, используя функцию str() и
# отсекая бесполезные части строки< br /> model_title = str(type(model)).split(
«.»)[-1][:-2][:-len("Классификатор")]
model_details = model_title
if hasattr(model, «estimators_»):
model_details += «с {} оценщиками».format(
len(model.estimators_))
print( model_details + «с функциями», пара,
«имеет оценку», баллы)
plt.subplot(3, 4, plot_idx)
if plot_idx ‹= len(models):
# Добавить заголовок вверху каждого столбца
plt.title(model_title)
# Теперь постройте границу решения, используя мелкую сетку в качестве входных данных для
# заполненного контурного графика
x_min, x_max = X[:, 0].min() — 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() — 1, X[:, 1].max() + 1
xx , yy = np.meshgrid(np.arange(x_min, x_max, plot_step),
np.arange(y_min, y_max, plot_step))
# Постройте либо один DecisionTreeClassifier, либо альфа-смешение
# поверхностей решений ансамбля классификаторов
if isinstance(model, DecisionTreeClassifier):
Z = model.predict (np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
cs = plt.contourf(xx, yy, Z, cmap= cmap)
else:
# Выберите уровень альфа-смешивания в зависимости от количества
# используемых оценок
# (обратите внимание, что AdaBoost может использовать меньшее количество оценок< br /> #, чем его максимум, если достигается достаточно хорошее соответствие на раннем этапе)
estimator_alpha = 1.0 / len(model.estimators_)
для дерева в model.estimators_:
Z = tree.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
cs = plt.contourf(xx, yy , Z, alpha=estimator_alpha, cmap=cmap)
# Постройте более грубую сетку, чтобы построить набор групповых классификаций
#, чтобы показать, чем они отличаются от того, что мы видим в решениях
# поверхностей. Эти точки имеют регулярное пространство и не имеют
# черного контура
xx_coarser, yy_coarser = np.meshgrid(
np.arange(x_min, x_max, plot_step_coarser),
np.arange(y_min, y_max, plot_step_coarser))
Z_points_coarser = model.predict(np.c_[xx_coarser.ravel(),
yy_coarser.ravel()]
).reshape (xx_coarser.shape)
cs_points = plt.scatter(xx_coarser, yy_coarser, s=15,
c=Z_points_coarser, cmap=cmap,
edgecolors=”none”)
# Нанесите точки обучения, они сгруппированы вместе и имеют
# черный контур
plt.scatter(X[:, 0], X[:, 1], c =y,
cmap=ListedColormap(['r', 'y', 'b']),
edgecolor='k', s=20)
plot_idx += 1 # перемещение к следующему сюжету по порядку
plt.suptitle("Классификаторы подмножеств объектов набора данных Iris")
plt.axis("tight")
plt.show()
В порядке убывания качества при обучении (за пределами этого примера) всем 4 функциям с использованием 30 оценок и оценке с использованием 10-кратной перекрестной проверки мы видим:
ExtraTreesClassifier() # 0,95 балла
RandomForestClassifier() # 0,94 балла
AdaBoost(DecisionTree(max_depth=3)) # 0,94 балла
DecisionTree(max_depth=None) # 0,94 балла
Увеличение `max_depth` для AdaBoost снижает стандартное отклонение оценок (но средний балл не улучшается).
Дополнительные сведения о каждой модели см. в выводе консоли.
В этом примере вы можете попробовать:
1) измените «max_depth» для «DecisionTreeClassifier» и «AdaBoostClassifier», возможно, попробуйте «max_depth = 3» для «DecisionTreeClassifier» или «max_depth = None» для « AdaBoostClassifier``
2) варьировать ``n_estimators``
Стоит отметить, что RandomForests и ExtraTrees могут быть установлены параллельно на многих ядрах, поскольку каждое дерево строится независимо от других. Образцы AdaBoost строятся последовательно и поэтому не используют несколько ядер.
DecisionTree с признаками [0, 1] имеет оценку 0,9266666666666666
RandomForest с 30 оценщиками с характеристиками [0, 1] имеет оценку 0,92666666666666666
ExtraTrees с 30 оценщиками с характеристиками [0, 1] имеет оценка 0,9266666666666666
AdaBoost с 30 оценщиками с функциями [0, 1] имеет оценку 0,84
DecisionTree с функциями [0, 2] имеет оценку 0,99333333333333333
RandomForest с 30 оценщиками с функциями [0, 2] имеет оценку 0,9933333333333333
ExtraTrees с 30 оценщиками с функциями [0, 2] имеет оценку 0,99333333333333333
AdaBoost с 30 оценщиками с функциями [0, 2] имеет оценку 0,99333333333333333
DecisionTree с функциями [2, 3] имеет оценку 0,99333333333333333
RandomForest с 30 оценщиками с функциями [2, 3] имеет оценку 0,99333333333333333
ExtraTrees с 30 оценщиками с функциями [2, 3] имеет оценку 0,9933333333333333
AdaBoost с 30 оценщиками с функциями [2, 3] имеет оценку o f 0,99333333333333333
=======================================
Рабочие характеристики приемника (ROC) =======================================
Пример метрики рабочей характеристики приемника (ROC) для оценки качества выходных данных классификатора.
Кривые ROC обычно показывают истинное положительное значение по оси Y и ложноположительное значение по оси X. Это означает, что верхний левый угол графика является «идеальной» точкой — ложноположительный показатель равен нулю, а истинно положительный показатель равен единице. Это не очень реалистично, но это означает, что большая площадь под кривой (AUC) обычно лучше.
«Крутизна» ROC-кривых также важна, поскольку она идеальна для максимизации истинно положительного уровня при минимизации ложноположительного уровня.
печать (__doc__)
импортировать numpy как np
импортировать matplotlib.pyplot как plt
из цикла импорта itertools
из sklearn импортировать svm, наборы данных
из sklearn.metrics импортировать roc_curve, auc
из sklearn.model_selection импортировать train_test_split
из sklearn.preprocessing импортировать label_binarize
из sklearn.multiclass импортировать OneVsRestClassifier
из scipy import interp
# Импорт некоторых данных для экспериментов
iris = datasets.load_iris()
X = iris.data
y = iris.target
# Бинаризация вывода
y = label_binarize(y, class=[0, 1, 2])
n_classes = y.shape[1]
# Добавьте зашумленные функции, чтобы усложнить задачу
random_state = np.random.RandomState(0)
n_samples, n_features = X.shape
X = np.c_ [X, random_state.randn(n_samples, 200 * n_features)]
# перемешивание и разделение обучающих и тестовых наборов
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.5,
random_state=0)
# Научитесь прогнозировать один класс относительно другого
classifier = OneVsRestClassifier(svm.SVC(kernel='linear', Вероятность=True,
random_state=random_state))
y_score = classifier.fit(X_train, y_train).decision_function(X_test)
# Вычислить кривую ROC и площадь ROC для каждого класса
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i])
roc_auc[i] = auc(fpr [i], тпр[i])
# Вычислить микроусредненную кривую ROC и площадь ROC
fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel() )
roc_auc["микро"] = auc(fpr["микро"], tpr["микро"])
################################################### ############################
# График ROC-кривой для определенного класса< br /> plt.figure()
lw = 2
plt.plot(fpr[2], tpr[2], color='темнооранжевый',
lw=lw, label=' ROC-кривая (площадь = %0.2f)' % roc_auc[2])
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Коэффициент ложных срабатываний')
plt. ylabel('Истинный положительный показатель')
plt.title('Пример рабочей характеристики приемника')
plt.legend(loc="нижний правый")
plt.show()
################################################### #############################
# Постройте кривые ROC для мультиклассовой задачи
# Вычислить макро-усредненную кривую ROC и площадь ROC
# Сначала агрегируем все ложноположительные показатели
all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))
# Затем интерполируем все ROC-кривые в этих точках
mean_tpr = np.zeros_like(all_fpr)
for i in range(n_classes):
mean_tpr += interp(all_fpr , fпр[i], tпр[i])
# Наконец, усредняем и вычисляем AUC
mean_tpr /= n_classes
fpr["макрос"] = all_fpr
tpr["макрос"] = mean_tpr
roc_auc["макрос"] = auc(fpr["макрос"], tpr["макрос"])
# Постройте все ROC-кривые
plt.figure()
plt.plot(fpr["micro"], tpr["micro"],
label=' микроусредненная кривая ROC (площадь = {0:0,2f})'
''.format(roc_auc["micro"]),
color='deeppink', linestyle=':', linewidth =4)
plt.plot(fpr["макро"], tpr["макро"],
label='макро-усредненная ROC-кривая (площадь = {0:0.2f})'
''.format( roc_auc["макрос"]),
color='темно-синий', linestyle=':', linewidth=4)
colors = cycle(['aqua', 'темнооранжевый', 'васильковый'])
for i, color in zip(range(n_classes), colors):
plt.plot(fpr[i], tpr[i], color=color, lw=lw,
label='ROC-кривая класса {0} (площадь = {1:0.2f})'
''.format(i, roc_auc [я]))
plt.plot([0, 1], [0, 1], 'k — ', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Уровень ложных срабатываний')
plt.ylabel('Уровень истинных срабатываний')
plt.title('Некоторое расширение рабочих характеристик приемника для ')
plt.legend(loc="нижний правый")
plt.show()
Настройки мультикласса
— — — — — — — — — —
Кривые ROC обычно используются в двоичной классификации для изучения выходных данных классификатора. Чтобы расширить кривую ROC и область ROC до классификации с несколькими классами или несколькими метками, необходимо бинаризировать выходные данные. Для каждой метки можно построить одну ROC-кривую, но можно также построить ROC-кривую, рассматривая каждый элемент матрицы индикатора метки как бинарное предсказание (микроусреднение).
Другой критерий оценки для классификации по нескольким классам – это
макроусреднение, которое придает одинаковый вес классификации каждого ярлыка.
.. Примечание::
См. также :func:`sklearn.metrics.roc_auc_score`,
:ref:`sphx_glr_auto_examples_model_selection_plot_roc_crossval.py`.
