R random forest: R Random Forest Tutorial with Example

Содержание

пример решения задачи классификации на Python / Блог компании RUVDS.com / Хабр

У специалистов по обработке и анализу данных есть множество средств для создания классификационных моделей. Один из самых популярных и надёжных методов разработки таких моделей заключается в использовании алгоритма «случайный лес» (Random Forest, RF). Для того чтобы попытаться улучшить показатели модели, построенной с использованием алгоритма RF, можно воспользоваться оптимизацией гиперпараметров модели (Hyperparameter Tuning, HT).

Кроме того, распространён подход, в соответствии с которым данные, перед их передачей в модель, обрабатывают с помощью метода главных компонент (Principal Component Analysis, PCA). Но стоит ли вообще этим пользоваться? Разве основная цель алгоритма RF заключается не в том, чтобы помочь аналитику интерпретировать важность признаков?

Да, применение алгоритма PCA может привести к небольшому усложнению интерпретации каждого «признака» при анализе «важности признаков» RF-модели. Однако алгоритм PCA производит уменьшение размерности пространства признаков, что может привести к уменьшению количества признаков, которые нужно обработать RF-моделью. Обратите внимание на то, что объёмность вычислений — это один из основных минусов алгоритма «случайный лес» (то есть — выполнение модели может занять немало времени). Применение алгоритма PCA может стать весьма важной частью моделирования, особенно в тех случаях, когда работают с сотнями или даже с тысячами признаков. В результате, если самое важное — это просто создать наиболее эффективную модель, и при этом можно пожертвовать точностью определения важности признаков, тогда PCA, вполне возможно, стоит попробовать.

Теперь — к делу. Мы будем работать с набором данных по раку груди — Scikit-learn «breast cancer». Мы создадим три модели и сравним их эффективность. А именно, речь идёт о следующих моделях:

Базовая модель, основанная на алгоритме RF (будем сокращённо называть эту модель RF).

Та же модель, что и №1, но такая, в которой применяется уменьшение размерности пространства признаков с помощью метода главных компонент (RF + PCA).

Такая же модель, как и №2, но построенная с применением оптимизации гиперпараметров (RF + PCA + HT).

1. Импорт данных

Для начала загрузим данные и создадим датафрейм Pandas. Так как мы пользуемся предварительно очищенным «игрушечным» набором данных из Scikit-learn, то после этого мы уже сможем приступить к процессу моделирования. Но даже при использовании подобных данных рекомендуется всегда начинать работу, проведя предварительный анализ данных с использованием следующих команд, применяемых к датафрейму (df):

df.head() — чтобы взглянуть на новый датафрейм и понять, выглядит ли он так, как ожидается.

df.info() — чтобы выяснить особенности типов данных и содержимого столбцов. Возможно, перед продолжением работы понадобится произвести преобразование типов данных.

df.isna() — чтобы убедиться в том, что в данных нет значений NaN. Соответствующие значения, если они есть, может понадобиться как-то обработать, или, если нужно, может понадобиться убрать целые строки из датафрейма.

df.describe() — чтобы выяснить минимальные, максимальные, средние значения показателей в столбцах, чтобы узнать показатели среднеквадратического и вероятного отклонения по столбцам.

В нашем наборе данных столбец cancer (рак) — это целевая переменная, значение которой мы хотим предсказать, используя модель. 0 означает «отсутствие заболевания». 1 — «наличие заболевания».

import pandas as pd
from sklearn.datasets import load_breast_cancer
columns = ['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension']
dataset = load_breast_cancer()
data = pd.DataFrame(dataset['data'], columns=columns)
data['cancer'] = dataset['target']
display(data.head())
display(data.info())
display(data.isna().sum())
display(data.describe())

Фрагмент датафрейма с данными по раку груди. Каждая строка содержит результаты наблюдений за пациентом. Последний столбец, cancer, содержит целевую переменную, которую мы пытаемся предсказать. 0 означает «отсутствие заболевания». 1 — «наличие заболевания»

2. Разделение набора данных на учебные и проверочные данные

Теперь разделим данные с использованием функции Scikit-learn train_test_split. Мы хотим дать модели как можно больше учебных данных. Однако нужно, чтобы в нашем распоряжении было бы достаточно данных для проверки модели. В целом можно сказать, что, по мере роста количества строк в наборе данных, растёт и объём данных, которые можно рассматривать в качестве учебных.

Например, если есть миллионы строк, можно разделить набор, выделив 90% строк на учебные данные и 10% — на проверочные. Но исследуемый набор данных содержит лишь 569 строк. А это — не так уж и много для тренировки и проверки модели. В результате для того, чтобы быть справедливыми по отношению к учебным и проверочным данным, мы разделим набор на две равные части — 50% — учебные данные и 50% — проверочные. Мы устанавливаем stratify=y для обеспечения того, чтобы и в учебном, и в проверочном наборах данных присутствовало бы то же соотношение 0 и 1, что и в исходном наборе данных.

from sklearn.model_selection import train_test_split
X = data.drop('cancer', axis=1)  
y = data['cancer'] 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.50, random_state = 2020, stratify=y)

3. Масштабирование данных

Прежде чем приступать к моделированию, нужно выполнить «центровку» и «стандартизацию» данных путём их масштабирования. Масштабирование выполняется из-за того, что разные величины выражены в разных единицах измерения. Эта процедура позволяет организовать «честную схватку» между признаками при определении их важности. Кроме того, мы конвертируем y_train из типа данных Pandas Series в массив NumPy для того чтобы позже модель смогла бы работать с соответствующими целевыми показателями.

import numpy as np
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
X_train_scaled = ss.fit_transform(X_train)
X_test_scaled = ss.transform(X_test)
y_train = np.array(y_train)

4. Обучение базовой модели (модель №1, RF)

Сейчас создадим модель №1. В ней, напомним, применяется только алгоритм Random Forest. Она использует все признаки и настроена с использованием значений, задаваемых по умолчанию (подробности об этих настройках можно найти в документации к sklearn.ensemble.RandomForestClassifier). Сначала инициализируем модель. После этого обучим её на масштабированных данных. Точность модели можно измерить на учебных данных:

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import recall_score
rfc = RandomForestClassifier()
rfc.fit(X_train_scaled, y_train)
display(rfc.score(X_train_scaled, y_train))
# 1.0

Если нам интересно узнать о том, какие признаки являются самыми важными для RF-модели в деле предсказания рака груди, мы можем визуализировать и квантифицировать показатели важности признаков, обратившись к атрибуту feature_importances_:

feats = {}
for feature, importance in zip(data.columns, rfc_1.feature_importances_):
    feats[feature] = importance
importances = pd.DataFrame.from_dict(feats, orient='index').rename(columns={0: 'Gini-Importance'})
importances = importances.sort_values(by='Gini-Importance', ascending=False)
importances = importances.reset_index()
importances = importances.rename(columns={'index': 'Features'})
sns.set(font_scale = 5)
sns.set(style="whitegrid", color_codes=True, font_scale = 1.7)
fig, ax = plt.subplots()
fig.set_size_inches(30,15)
sns.barplot(x=importances['Gini-Importance'], y=importances['Features'], data=importances, color='skyblue')
plt.xlabel('Importance', fontsize=25, weight = 'bold')
plt.ylabel('Features', fontsize=25, weight = 'bold')
plt.title('Feature Importance', fontsize=25, weight = 'bold')
display(plt.show())
display(importances)

Визуализация «важности» признаков
Показатели важности признаков

5. Метод главных компонент

Теперь зададимся вопросом о том, как можно улучшить базовую RF-модель. С использованием методики снижения размерности пространства признаков можно представить исходный набор данных через меньшее количество переменных и при этом снизить объём вычислительных ресурсов, необходимых для обеспечения работы модели. Используя PCA, можно изучить кумулятивную выборочную дисперсию этих признаков для того чтобы понять то, какие признаки объясняют большую часть дисперсии в данных.
Инициализируем объект PCA (pca_test), указывая количество компонент (признаков), которые нужно рассмотреть. Мы устанавливаем этот показатель в 30 для того чтобы увидеть объяснённую дисперсию всех сгенерированных компонент до того, как примем решение о том, сколько компонент нам понадобится. Затем передаём в pca_test масштабированные данные X_train, пользуясь методом pca_test.fit(). После этого визуализируем данные.

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.decomposition import PCA
pca_test = PCA(n_components=30)
pca_test.fit(X_train_scaled)
sns.set(style='whitegrid')
plt.plot(np.cumsum(pca_test.explained_variance_ratio_))
plt.xlabel('number of components')
plt.ylabel('cumulative explained variance')
plt.axvline(linewidth=4, color='r', linestyle = '--', x=10, ymin=0, ymax=1)
display(plt.show())
evr = pca_test.explained_variance_ratio_
cvr = np.cumsum(pca_test.explained_variance_ratio_)
pca_df = pd.DataFrame()
pca_df['Cumulative Variance Ratio'] = cvr
pca_df['Explained Variance Ratio'] = evr
display(pca_df.head(10))

После того, как число используемых компонент превышает 10, рост их количества не очень сильно повышает объяснённую дисперсию
Этот датафрейм содержит такие показатели, как Cumulative Variance Ratio (кумулятивный размер объяснённой дисперсии данных) и Explained Variance Ratio (вклад каждой компоненты в общий объём объяснённой дисперсии)

Если взглянуть на вышеприведённый датафрейм, то окажется, что использование PCA для перехода от 30 переменных к 10 компонентам позволяет объяснить 95% дисперсии данных. Другие 20 компонент объясняют менее 5% дисперсии, а это значит, что от них мы можем отказаться. Следуя этой логике, воспользуемся PCA для уменьшения числа компонент с 30 до 10 для X_train и X_test. Запишем эти искусственно созданные наборы данных «пониженной размерности» в X_train_scaled_pca и в X_test_scaled_pca.

pca = PCA(n_components=10)
pca.fit(X_train_scaled)
X_train_scaled_pca = pca.transform(X_train_scaled)
X_test_scaled_pca = pca.transform(X_test_scaled)

Каждая компонента — это линейная комбинация исходных переменных с соответствующими «весами». Мы можем видеть эти «веса» для каждой компоненты, создав датафрейм.

pca_dims = []
for x in range(0, len(pca_df)):
    pca_dims.append('PCA Component {}'.format(x))
pca_test_df = pd.DataFrame(pca_test.components_, columns=columns, index=pca_dims)
pca_test_df.head(10).T

Датафрейм со сведениями по компонентам

6. Обучение базовой RF-модели после применения к данным метода главных компонент (модель №2, RF + PCA)

Теперь мы можем передать в ещё одну базовую RF-модель данные X_train_scaled_pca и y_train и можем узнать о том, есть ли улучшения в точности предсказаний, выдаваемых моделью.

rfc = RandomForestClassifier()
rfc.fit(X_train_scaled_pca, y_train)
display(rfc.score(X_train_scaled_pca, y_train))
# 1.0

Модели сравним ниже.

7. Оптимизация гиперпараметров. Раунд 1: RandomizedSearchCV

После обработки данных с использованием метода главных компонент можно попытаться воспользоваться оптимизацией гиперпараметров модели для того чтобы улучшить качество предсказаний, выдаваемых RF-моделью. Гиперпараметры можно рассматривать как что-то вроде «настроек» модели. Настройки, которые отлично подходят для одного набора данных, для другого не подойдут — поэтому и нужно заниматься их оптимизацией.

Начать можно с алгоритма RandomizedSearchCV, который позволяет довольно грубо исследовать широкие диапазоны значений. Описания всех гиперпараметров для RF-моделей можно найти здесь.

В ходе работы мы генерируем сущность param_dist, содержащую, для каждого гиперпараметра, диапазон значений, которые нужно испытать. Далее, мы инициализируем объект rs с помощью функции RandomizedSearchCV(), передавая ей RF-модель, param_dist, число итераций и число кросс-валидаций, которые нужно выполнить.

Гиперпараметр verbose позволяет управлять объёмом информации, который выводится моделью в ходе её работы (наподобие вывода сведений в процессе обучения модели). Гиперпараметр n_jobs позволяет указывать то, сколько процессорных ядер нужно использовать для обеспечения работы модели. Установка n_jobs в значение -1 приведёт к более быстрой работе модели, так как при этом будут использоваться все ядра процессора.

Мы будем заниматься подбором следующих гиперпараметров:

n_estimators — число «деревьев» в «случайном лесу».

max_features — число признаков для выбора расщепления.

max_depth — максимальная глубина деревьев.

min_samples_split — минимальное число объектов, необходимое для того, чтобы узел дерева мог бы расщепиться.

min_samples_leaf — минимальное число объектов в листьях.

bootstrap — использование для построения деревьев подвыборки с возвращением.

from sklearn.model_selection import RandomizedSearchCV
n_estimators = [int(x) for x in np.linspace(start = 100, stop = 1000, num = 10)]
max_features = ['log2', 'sqrt']
max_depth = [int(x) for x in np.linspace(start = 1, stop = 15, num = 15)]
min_samples_split = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]
min_samples_leaf = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]
bootstrap = [True, False]
param_dist = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}
rs = RandomizedSearchCV(rfc_2, 
                        param_dist, 
                        n_iter = 100, 
                        cv = 3, 
                        verbose = 1, 
                        n_jobs=-1, 
                        random_state=0)
rs.fit(X_train_scaled_pca, y_train)
rs.best_params_
# {'n_estimators': 700,
# 'min_samples_split': 2,
# 'min_samples_leaf': 2,
# 'max_features': 'log2',
# 'max_depth': 11,
# 'bootstrap': True}

При значениях параметров n_iter = 100 и cv = 3, мы создали 300 RF-моделей, случайно выбирая комбинации представленных выше гиперпараметров. Мы можем обратиться к атрибуту best_params_ для получения сведений о наборе параметров, позволяющем создать самую лучшую модель. Но на данной стадии это может не дать нам наиболее интересных данных о диапазонах параметров, которые стоит изучить на следующем раунде оптимизации. Для того чтобы выяснить то, в каком диапазоне значений стоит продолжать поиск, мы легко можем получить датафрейм, содержащий результаты работы алгоритма RandomizedSearchCV.

rs_df = pd.DataFrame(rs.cv_results_).sort_values('rank_test_score').reset_index(drop=True)
rs_df = rs_df.drop([
            'mean_fit_time', 
            'std_fit_time', 
            'mean_score_time',
            'std_score_time', 
            'params', 
            'split0_test_score', 
            'split1_test_score', 
            'split2_test_score', 
            'std_test_score'],
            axis=1)
rs_df.head(10)

Результаты работы алгоритма RandomizedSearchCV

Теперь создадим столбчатые графики, на которых, по оси Х, расположены значения гиперпараметров, а по оси Y — средние значения, показываемые моделями. Это позволит понять то, какие значения гиперпараметров, в среднем, лучше всего себя показывают.

fig, axs = plt.subplots(ncols=3, nrows=2)
sns.set(style="whitegrid", color_codes=True, font_scale = 2)
fig.set_size_inches(30,25)
sns.barplot(x='param_n_estimators', y='mean_test_score', data=rs_df, ax=axs[0,0], color='lightgrey')
axs[0,0].set_ylim([.83,.93])axs[0,0].set_title(label = 'n_estimators', size=30, weight='bold')
sns.barplot(x='param_min_samples_split', y='mean_test_score', data=rs_df, ax=axs[0,1], color='coral')
axs[0,1].set_ylim([.85,.93])axs[0,1].set_title(label = 'min_samples_split', size=30, weight='bold')
sns.barplot(x='param_min_samples_leaf', y='mean_test_score', data=rs_df, ax=axs[0,2], color='lightgreen')
axs[0,2].set_ylim([.80,.93])axs[0,2].set_title(label = 'min_samples_leaf', size=30, weight='bold')
sns.barplot(x='param_max_features', y='mean_test_score', data=rs_df, ax=axs[1,0], color='wheat')
axs[1,0].set_ylim([.88,.92])axs[1,0].set_title(label = 'max_features', size=30, weight='bold')
sns.barplot(x='param_max_depth', y='mean_test_score', data=rs_df, ax=axs[1,1], color='lightpink')
axs[1,1].set_ylim([.80,.93])axs[1,1].set_title(label = 'max_depth', size=30, weight='bold')
sns.barplot(x='param_bootstrap',y='mean_test_score', data=rs_df, ax=axs[1,2], color='skyblue')
axs[1,2].set_ylim([.88,.92])
axs[1,2].set_title(label = 'bootstrap', size=30, weight='bold')
plt.show()

Анализ значений гиперпараметров

Если проанализировать вышеприведённые графики, то можно заметить некоторые интересные вещи, говорящие о том, как, в среднем, каждое значение гиперпараметра влияет на модель.

n_estimators: значения 300, 500, 700, видимо, показывают наилучшие средние результаты.

min_samples_split: маленькие значения, вроде 2 и 7, как кажется, показывают наилучшие результаты. Хорошо выглядит и значение 23. Можно исследовать несколько значений этого гиперпараметра, превышающих 2, а также — несколько значений около 23.

min_samples_leaf: возникает такое ощущение, что маленькие значения этого гиперпараметра дают более высокие результаты. А это значит, что мы можем испытать значения между 2 и 7.

max_features: вариант sqrt даёт самый высокий средний результат.

max_depth: тут чёткой зависимости между значением гиперпараметра и результатом работы модели не видно, но есть ощущение, что значения 2, 3, 7, 11, 15 выглядят неплохо.

bootstrap: значение False показывает наилучший средний результат.

Теперь мы, воспользовавшись этими находками, можем перейти ко второму раунду оптимизации гиперпараметров. Это позволит сузить спектр интересующих нас значений.

8. Оптимизация гиперпараметров. Раунд 2: GridSearchCV (окончательная подготовка параметров для модели №3, RF + PCA + HT)

После применения алгоритма RandomizedSearchCV воспользуемся алгоритмом GridSearchCV для проведения более точного поиска наилучшей комбинации гиперпараметров. Здесь исследуются те же гиперпараметры, но теперь мы применяем более «обстоятельный» поиск их наилучшей комбинации. При использовании алгоритма GridSearchCV исследуется каждая комбинация гиперпараметров. Это требует гораздо больших вычислительных ресурсов, чем использование алгоритма RandomizedSearchCV, когда мы самостоятельно задаём число итераций поиска. Например, исследование 10 значений для каждого из 6 гиперпараметров с кросс-валидацией по 3 блокам потребует 10⁶ x 3, или 3000000 сеансов обучения модели. Именно поэтому мы и используем алгоритм GridSearchCV после того, как, применив RandomizedSearchCV, сузили диапазоны значений исследуемых параметров.

Итак, используя то, что мы выяснили с помощью RandomizedSearchCV, исследуем значения гиперпараметров, которые лучше всего себя показали:

from sklearn.model_selection import GridSearchCV
n_estimators = [300,500,700]
max_features = ['sqrt']
max_depth = [2,3,7,11,15]
min_samples_split = [2,3,4,22,23,24]
min_samples_leaf = [2,3,4,5,6,7]
bootstrap = [False]
param_grid = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}
gs = GridSearchCV(rfc_2, param_grid, cv = 3, verbose = 1, n_jobs=-1)
gs.fit(X_train_scaled_pca, y_train)
rfc_3 = gs.best_estimator_
gs.best_params_
# {'bootstrap': False,
# 'max_depth': 7,
# 'max_features': 'sqrt',
# 'min_samples_leaf': 3,
# 'min_samples_split': 2,
# 'n_estimators': 500}

Здесь мы применяем кросс-валидацию по 3 блокам для 540 (3 x 1 x 5 x 6 x 6 x 1) сеансов обучения модели, что даёт 1620 сеансов обучения модели. И уже теперь, после того, как мы воспользовались RandomizedSearchCV и GridSearchCV, мы можем обратиться к атрибуту best_params_ для того чтобы узнать о том, какие значения гиперпараметров позволяют модели наилучшим образом работать с исследуемым набором данных (эти значения можно видеть в нижней части предыдущего блока кода). Эти параметры используются при создании модели №3.

9. Оценка качества работы моделей на проверочных данных

Теперь можно оценить созданные модели на проверочных данных. А именно, речь идёт о тех трёх моделях, описанных в самом начале материала.

Проверим эти модели:

y_pred = rfc.predict(X_test_scaled)
y_pred_pca = rfc.predict(X_test_scaled_pca)
y_pred_gs = gs.best_estimator_.predict(X_test_scaled_pca)

Создадим матрицы ошибок для моделей и узнаем о том, как хорошо каждая из них способна предсказывать рак груди:

from sklearn.metrics import confusion_matrix
conf_matrix_baseline = pd.DataFrame(confusion_matrix(y_test, y_pred), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
conf_matrix_baseline_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_pca), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
conf_matrix_tuned_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_gs), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
display(conf_matrix_baseline)
display('Baseline Random Forest recall score', recall_score(y_test, y_pred))
display(conf_matrix_baseline_pca)
display('Baseline Random Forest With PCA recall score', recall_score(y_test, y_pred_pca))
display(conf_matrix_tuned_pca)
display('Hyperparameter Tuned Random Forest With PCA Reduced Dimensionality recall score', recall_score(y_test, y_pred_gs))

Результаты работы трёх моделей

Здесь оценивается метрика «полнота» (recall). Дело в том, что мы имеем дело с диагнозом рака. Поэтому нас чрезвычайно интересует минимизация ложноотрицательных прогнозов, выдаваемых моделями.

Учитывая это, можно сделать вывод о том, что базовая RF-модель дала наилучшие результаты. Её показатель полноты составил 94.97%. В проверочном наборе данных была запись о 179 пациентах, у которых есть рак. Модель нашла 170 из них.

Итоги

Это исследование позволяет сделать важное наблюдение. Иногда RF-модель, в которой используется метод главных компонент и широкомасштабная оптимизация гиперпараметров, может работать не так хорошо, как самая обыкновенная модель со стандартными настройками. Но это — не повод для того, чтобы ограничивать себя лишь простейшими моделями. Не попробовав разные модели, нельзя сказать о том, какая из них покажет наилучший результат. А в случае с моделями, которые используются для предсказания наличия у пациентов рака, можно сказать, что чем лучше модель — тем больше жизней может быть спасено.

Уважаемые читатели! Какие задачи вы решаете, привлекая методы машинного обучения?

Случайный лес (Random Forest) | Анализ малых данных

Случайный лес — один из самых потрясающих алгоритмов машинного обучения, придуманные Лео Брейманом и Адель Катлер ещё в прошлом веке. Он дошёл до нас в «первозданном виде» (никакие эвристики не смогли его существенно улучшить) и является одним из немногих универсальных алгоритмов. Универсальность заключается, во-первых, в том, что он хорош во многих задачах (по моим оценкам, 70% из встречающихся на практике, если не учитывать задачи с изображениями), во-вторых, в том, что есть случайные леса для решения задач классификации, регрессии, кластеризации, поиска аномалий, селекции признаков и т.д.

Этот пост — краткое практическое руководство для новичков — путеводитель по основным параметрам алгоритма с картинками (которые, кстати, построены на данных последнего конкурса Сбербанка и одной модельной задачи). Под тестом здесь понимается результат на скользящем контроле (для построения графиков использовано 5 фолдов), хотя для отложенного контроля (hold out) выводы будут такими же. Графики лежат в коридорах: дисперсионном и (если есть второй коридор) макс-минном. Все выводы и рекомендации — общие — не для конкретной задачи.

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

Выбирается подвыборка обучающей выборки размера samplesize (м.б. с возвращением) – по ней строится дерево (для каждого дерева — своя подвыборка).
Для построения каждого расщепления в дереве просматриваем max_features случайных признаков (для каждого нового расщепления — свои случайные признаки).
Выбираем наилучшие признак и расщепление по нему (по заранее заданному критерию). Дерево строится, как правило, до исчерпания выборки (пока в листьях не останутся представители только одного класса), но в современных реализациях есть параметры, которые ограничивают высоту дерева, число объектов в листьях и число объектов в подвыборке, при котором проводится расщепление.

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

В библиотеке scikit-learn есть такая реализация RF (привожу только для задачи классификации):

class sklearn.ensemble.RandomForestClassifier(n_estimators=10,
criterion='gini', max_depth=None, min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0.0,
max_features='auto', max_leaf_nodes=None, min_impurity_split=1e-07,
bootstrap=True, oob_score=False, n_jobs=1,
random_state=None, verbose=0, warm_start=False,
class_weight=None)

С алгоритмом работают по стандартной схеме, принятой в scikit-learn:

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import roc_auc_score
# далее - (X, y) - обучение, (X2, y2) - контроль
# модель - здесь (для контраста) рассмотрим регрессор
model =  RandomForestRegressor(n_estimators=10 ,
                               oob_score=True,
                               random_state=1)
model.fit(X, y) # обучение
a = model.predict(X2) # предсказание

print ("AUC-ROC (oob) = ", roc_auc_score(y, model.oob_prediction_))
print ("AUC-ROC (test) = ", roc_auc_score(y2, a))

Опишем, что означают основные параметры:

Число деревьев — n_estimators

Чем больше деревьев, тем лучше качество, но время настройки и работы RF также пропорционально увеличиваются. Обратите внимание, что часто при увеличении n_estimators качество на обучающей выборке повышается (может даже доходить до 100%), а качество на тесте выходит на асимптоту (можно прикинуть, скольких деревьев Вам достаточно).

Число признаков для выбора расщепления — max_features

График качества на тесте от значения этого праметра унимодальный, на обучении он строго возрастает. При увеличении max_features увеличивается время построения леса, а деревья становятся «более однообразными». По умолчанию он равен sqrt(n) в задачах классификации и n/3 в задачах регрессии. Это самый важный параметр! Его настраивают в первую очередь (при достаточном числе деревьев в лесе).

Минимальное число объектов, при котором выполняется расщепление — min_samples_split

Этот параметр, как правило, не очень важный и можно оставить значение по умолчанию (2). График качества на контроле может быть похожим на «расчёску» (нет явного оптимума). При увеличении параметра качество на обучении падает, а время построения RF сокращается.

Ограничение на число объектов в листьях — min_samples_leaf

Всё, что было описано про min_samples_split, годится и для описания этого параметра. Часто можно оставить значение по умолчанию (1). Кстати, по классике, в задачах регрессии рекомендуется использовать значение 5 (в библиотеке randomForest для R так и реализовано, в sklearn — 1).

Максимальная глубина деревьев — max_depth

Ясно, что чем меньше глубина, тем быстрее строится и работает RF. При увеличении глубины резко возрастает качество на обучении, но и на контроле оно, как правило, увеличивается. Рекомендуется использовать максимальную глубину (кроме случаев, когда объектов слишком много и получаются очень глубокие деревья, построение которых занимает значительное время). При использовании неглубоких деревьев изменение параметров, связанных с ограничением числа объектов в листе и для деления, не приводит к значимому эффекту (листья и так получаются «большими»). Неглубокие деревья рекомендуют использовать в задачах с большим числом шумовых объектов (выбросов).

Критерий расщепления — criterion

По смыслу это очень важный параметр, но по факту здесь нет вариантов выбора. В библиотеке sklearn для регрессии реализованы два критерия: “mse” и “mae”, соответствуют функциям ошибки, которые они минимизируют. В большинстве задач используется mse. Сравнить их пока не берусь, т.к. mae появился совсем недавно — в версии 0.18 (и по-моему, реализован с ошибкой). Для классификации реализованы критерии “gini” и “entropy”, которые соответствуют классическим критериям расщепления: Джини и энтропийному. Простой перебор поможет Вам выбрать, что использовать в конкретной задаче (в авторской реализации алгоритма использовался Джини). Подробнее о критериях надо писать отдельный пост;)

В sklearn-реализации случайного леса нет параметра samplesize, который регламентирует, из скольких объектов делать подвыборку для построения каждого дерева. Такой параметр есть в R-реализации, но, по сути, часто оптимально выбирать из всей выборки. Также рекомендуется выбирать подвыборку с возвращением: bootstrap=True (это и есть бэггинг — bootstrap aggregating).

Совет

По умолчанию в sklearn-овских методах n_jobs=1, т.е. случайный лес строится на одном процессоре. Если Вы хотите существенно ускорить построение, используйте n_jobs=-1 (строить на максимально возможном числе процессоров). Для построения воспроизводимых экспериментов используйте предустановку генератора псевдослучайных чисел: random_state.

П.С. Метод RF хорош ещё тем, что при построении леса параллельно может вычисляться т.н. oob-оценка качества алгоритма (которая очень точная и получается не в ущерб разделения на обучение/тест), oob-ответы алгоритмы (ответы, которые выдавал бы алгоритм на обучающей выборке, если бы «обучался не на ней»), оцениваются важности признаков (но об этом, опять же, надо писать в отдельном посте). Ну, и не стоит забывать про полный перебор значений параметров (если объектов в задаче не очень много).

Понравилось это:

Нравится Загрузка…

Похожее

Алгоритмы классификации — случайный лес

Случайный лес — это контролируемый алгоритм обучения, который используется как для классификации, так и для регрессии. Но, тем не менее, он в основном используется для задач классификации. Поскольку мы знаем, что лес составлен из деревьев, и больше деревьев означает более устойчивый лес. Точно так же алгоритм случайного леса создает деревья решений для выборок данных, а затем получает прогноз по каждой из них и, наконец, выбирает лучшее решение посредством голосования. Это метод ансамбля, который лучше, чем единое дерево решений, потому что он уменьшает переобучение путем усреднения результата.

Работа алгоритма случайного леса

Мы можем понять работу алгоритма Random Forest с помощью следующих шагов:

Шаг 1 — Сначала начните с выбора случайных выборок из заданного набора данных.
Шаг 2 — Далее этот алгоритм построит дерево решений для каждой выборки. Затем он получит результат прогнозирования из каждого дерева решений.
Шаг 3 — На этом этапе голосование будет проводиться для каждого прогнозируемого результата.
Шаг 4 — Наконец, выберите результат прогноза с наибольшим количеством голосов в качестве окончательного результата прогноза.

Шаг 1 — Сначала начните с выбора случайных выборок из заданного набора данных.

Шаг 2 — Далее этот алгоритм построит дерево решений для каждой выборки. Затем он получит результат прогнозирования из каждого дерева решений.

Шаг 3 — На этом этапе голосование будет проводиться для каждого прогнозируемого результата.

Шаг 4 — Наконец, выберите результат прогноза с наибольшим количеством голосов в качестве окончательного результата прогноза.

Следующая диаграмма проиллюстрирует его работу —

Реализация в Python

Во-первых, начните с импорта необходимых пакетов Python —

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

Затем загрузите набор данных iris с веб-ссылки следующим образом:

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

Далее нам нужно назначить имена столбцов для набора данных следующим образом:

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

Теперь нам нужно прочитать набор данных в pandas dataframe следующим образом:

dataset = pd.read_csv(path, names = headernames)
dataset.head()

	чашелистник длины	чашелистник ширины	Лепесток длина	Лепесток ширины	Учебный класс
0	5,1	3,5	1.4	0.2	Iris-setosa
1	4,9	3.0	1.4	0.2	Iris-setosa
2	4,7	3,2	1,3	0.2	Iris-setosa
3	4,6	3,1	1,5	0.2	Iris-setosa
4	5.0	3,6	1.4	0.2	Iris-setosa

Предварительная обработка данных будет выполняться с помощью следующих строк сценария.

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

Далее, мы разделим данные на разделение на поезда и тесты. Следующий код разделит набор данных на 70% данных обучения и 30% данных тестирования.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30)

Затем обучаем модель с помощью класса sklearn класса RandomForestClassifier следующим образом —

from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators = 50)
classifier.fit(X_train, y_train)

Наконец, нам нужно сделать прогноз. Это можно сделать с помощью следующего скрипта —

y_pred = classifier.predict(X_test)

Затем распечатайте результаты следующим образом —

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Выход

Confusion Matrix:
[[14 0 0]
   [ 0 18 1]
   [ 0 0 12]]
Classification Report:
              precision   recall   f1-score   support
    Iris-setosa    1.00     1.00       1.00        14
Iris-versicolor    1.00     0.95       0.97        19
 Iris-virginica    0.92     1.00       0.96        12

      micro avg    0.98     0.98        0.98       45
      macro avg    0.97     0.98        0.98       45
   weighted avg    0.98     0.98        0.98       45

Accuracy: 0.9777777777777777

Плюсы и минусы случайного леса

Pros

Ниже приведены преимущества алгоритма Random Forest —

Он преодолевает проблему переоснащения путем усреднения или объединения результатов различных деревьев решений.
Случайные леса хорошо работают с большим количеством элементов данных, чем одно дерево решений.
Случайный лес имеет меньшую дисперсию, чем одно дерево решений.
Случайные леса очень гибки и обладают очень высокой точностью.
Масштабирование данных не требует в алгоритме случайного леса. Он сохраняет хорошую точность даже после предоставления данных без масштабирования.
Алгоритмы Random Forest поддерживают хорошую точность даже при отсутствии значительной части данных.

Он преодолевает проблему переоснащения путем усреднения или объединения результатов различных деревьев решений.

Случайные леса хорошо работают с большим количеством элементов данных, чем одно дерево решений.

Случайный лес имеет меньшую дисперсию, чем одно дерево решений.

Случайные леса очень гибки и обладают очень высокой точностью.

Масштабирование данных не требует в алгоритме случайного леса. Он сохраняет хорошую точность даже после предоставления данных без масштабирования.

Алгоритмы Random Forest поддерживают хорошую точность даже при отсутствии значительной части данных.

Cons

Ниже приведены недостатки алгоритма Random Forest —

Сложность является основным недостатком алгоритмов случайного леса.

Построение Случайных лесов намного сложнее и отнимает больше времени, чем деревья решений.

Для реализации алгоритма Random Forest требуется больше вычислительных ресурсов.

Это менее интуитивно понятно в случае, когда у нас есть большая коллекция деревьев решений.

Процесс прогнозирования с использованием случайных лесов очень трудоемкий по сравнению с другими алгоритмами.

Введение в R: часть 3

Pavel Polishchuk, 2014

Примеры построения моделей в R.

Линейная регрессия (lm)
Метод частичных наименьших квадратов (pls)
Метод Random Forest (randomForest)
Пример решения классификационной задачи методом Random Forest

Линейная регрессия (lm)

Построение моделей

Сгенерируем набор данных для моделирования в соответствии с формулой
\[ Y = x_1 + x_2^2 + x_1 \times x_2 + noise \]

Для этого вначале инициализируем генератор случайных чисел, чтобы получать всегда воспроизводимый результат при генерации случайных чисел.

set.seed(50)

Сгенерируем случайные переменные $ x_1 $ и $ x_2 $ в соответствии с законом нормального распределения

x1 <- rnorm(n=200, mean=5, sd=2)
x2 <- rnorm(200, 2, 3)

Сгенерируем зависимую переменную в соответствии с вышеприведенной формулой

y <- x1 + x2^2 + x1*x2 + rnorm(200, 0, 0.5)

Объединим эти параметры в одном data.frame

df <- data.frame(y, x1, x2)

Рассмотрим созданный набор данных. Построим гистограмму распределению значений Y и посмотрим как рапределены значения переменных между собой попарно.

hist(df$y)

pairs(df)

Посчитаем матрицу взаимных корреляций всех переменных между собой и округлим результат до двух цифр после запятой

round(cor(df), 2)

      y    x1    x2
y  1.00  0.18  0.86
x1 0.18  1.00 -0.05
x2 0.86 -0.05  1.00

Помимо традиционного коэффицента корреляции Пирсона функцией cor можно посчитать ранговый коэффицент корреляции Спирмена.

round(cor(df, method="spearman"), 2)

      y    x1    x2
y  1.00  0.12  0.94
x1 0.12  1.00 -0.02
x2 0.94 -0.02  1.00

И из рисунка и из таблиц видно, что связь между $ y $ и $ x_2 $ довольно тесная.

Альтернативный способ представления данных — использование функции pairs.panels пакета psych, которая возвращает одновременно и диаграммы распределения данных и значения коэффициентов корреляции.

psych::pairs.panels(df)

Зададим индексы для объектов обучающей и тестовой выборки

train.ids <- 1:100
test.ids <- 101:200

Построим несколько моделей в соответствии с различными формулами, которые определяют вид искомой зависимости.

Попробуем сперва обычную линейную комбинацию исходных переменных.

m1 <- lm(y ~ x1 + x2, df[train.ids,])
summary(m1)


Call:
lm(formula = y ~ x1 + x2, data = df[train.ids, ])

Residuals:
   Min     1Q Median     3Q    Max 
-15.62  -7.56  -3.43   1.95  54.96 

Coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept)   -6.379      3.493   -1.83    0.071 .  
x1             3.377      0.625    5.40  4.8e-07 ***
x2             8.567      0.415   20.65  < 2e-16 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 12.3 on 97 degrees of freedom
Multiple R-squared:  0.818, Adjusted R-squared:  0.814 
F-statistic:  218 on 2 and 97 DF,  p-value: <2e-16

В результате мы получили уравнение вида \[ Y = 3.377\pm0.625*x_1 + 8,567\pm0,415*x_2 — 6,379\pm3,493 \]
Все коэффициенты в уравнении статистически значимы с высоким уронеем достоверности, кроме свободного члена, который имеет низкий уровень статистической достоверности. Величина $ R^2 = 0.818 $ является статистически достоверной.

Коэффициент детерминации

\[ R^2 = 1 — \frac{\sigma^2}{\sigma_y^2} = 1 — \frac{^{ESS}/_{n}}{^{TSS}/_{n}} = 1 — \frac{ESS}{TSS} = 1 — \frac{\sum_{i=1}^{n}(y_i — \hat{y}_i)^2}{\sum_{i=1}^{n}(y_i — \bar{y})^2} \]

Скорректированный коэффициент детерминации с использованием несмещенных оценок

\[ R_{adj}^2 = 1 — \frac{s^2}{s_y^2} = 1 — \frac{^{ESS}/_{n-k}}{^{TSS}/_{n-1}} =1 — (1- R^2)\frac{n-1}{n-k} \leq R^2 \]

$ y_i $ — наблюдаемое значение $ y $
$ \hat{y}_i $ — предсказанное по модели значение $ y $
$ \bar{y} $ — среднее значение наблюдаемых значений $ y $
$ n $ — количество наблюдений
$ k $ — количество параметров

Применим одну из простейших процедур отбора переменных — исключим незначащие члены из уравнения

m2 <- lm(y ~ x1 + x2 + 0, df[train.ids,])
summary(m2)


Call:
lm(formula = y ~ x1 + x2 + 0, data = df[train.ids, ])

Residuals:
   Min     1Q Median     3Q    Max 
-17.73  -8.88  -4.61   2.30  49.03 

Coefficients:
   Estimate Std. Error t value Pr(>|t|)    
x1    2.361      0.290    8.15  1.2e-12 ***
x2    8.267      0.386   21.44  < 2e-16 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 12.4 on 98 degrees of freedom
Multiple R-squared:  0.914, Adjusted R-squared:  0.913 
F-statistic:  524 on 2 and 98 DF,  p-value: <2e-16

Коэффициент детерминации существенно увеличился $ R^2 = 0.914 $

Сравнение моделей

Определим с помощью дисперсионного анализа является ли отличие моделей значимым или нет.

anova(m1, m2)

Analysis of Variance Table

Model 1: y ~ x1 + x2
Model 2: y ~ x1 + x2 + 0
  Res.Df   RSS Df Sum of Sq    F Pr(>F)  
1     97 14603                           
2     98 15105 -1      -502 3.33  0.071 .
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Величина 0.071 > 0.05, поэтому можно утверждать, что с вероятностью 95% отличие моделей не значимо и мы в праве выбрать любую модель.

Попытаемся построить более сложные модели.

Модель учитывающее произведение независимых переменных

m3 <- lm(y ~ x1*x2, df[train.ids,])
summary(m3)


Call:
lm(formula = y ~ x1 * x2, data = df[train.ids, ])

Residuals:
   Min     1Q Median     3Q    Max 
-10.35  -7.51  -3.06   3.77  51.30 

Coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept)    5.132      3.623    1.42    0.160    
x1             1.160      0.664    1.75    0.084 .  
x2             3.866      0.890    4.34  3.5e-05 ***
x1:x2          0.962      0.167    5.77  9.5e-08 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 10.6 on 96 degrees of freedom
Multiple R-squared:  0.865, Adjusted R-squared:  0.861 
F-statistic:  205 on 3 and 96 DF,  p-value: <2e-16

Модель второго порядка, учитывающая квадраты независимых переменных

m4 <- lm(y ~ poly(x1, 2) + poly(x2, 2), df[train.ids,])
summary(m4)


Call:
lm(formula = y ~ poly(x1, 2) + poly(x2, 2), data = df[train.ids, 
    ])

Residuals:
    Min      1Q  Median      3Q     Max 
-15.569  -2.232  -0.475   1.683  22.654 

Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept)    31.056      0.594   52.27  < 2e-16 ***
poly(x1, 2)1   65.297      5.983   10.91  < 2e-16 ***
poly(x1, 2)2  -24.414      5.979   -4.08  9.3e-05 ***
poly(x2, 2)1  253.662      5.991   42.34  < 2e-16 ***
poly(x2, 2)2  105.653      5.971   17.69  < 2e-16 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 5.94 on 95 degrees of freedom
Multiple R-squared:  0.958, Adjusted R-squared:  0.956 
F-statistic:  544 on 4 and 95 DF,  p-value: <2e-16

В последнем случае видно, что все коэффициенты в уравнении имеют высокую значимость и коэффициент детерминации также высокий $ R^2 = 0.958 $

Сравнение моделей указывает на значимое отличие последней модели от предыдущей.

anova(m2, m4)

Analysis of Variance Table

Model 1: y ~ x1 + x2 + 0
Model 2: y ~ poly(x1, 2) + poly(x2, 2)
  Res.Df   RSS Df Sum of Sq   F Pr(>F)    
1     98 15105                            
2     95  3354  3     11751 111 <2e-16 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Для сравнения построим модель с использованием правильной функциональной зависимости

m5 <- lm(y ~ x1 + x1:x2 + I(x2^2), df[train.ids,])
summary(m5)


Call:
lm(formula = y ~ x1 + x1:x2 + I(x2^2), data = df[train.ids, ])

Residuals:
    Min      1Q  Median      3Q     Max 
-1.0893 -0.3216  0.0275  0.3209  1.0808 

Coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept) -0.15588    0.15289   -1.02     0.31    
x1           1.03061    0.02750   37.48   <2e-16 ***
I(x2^2)      1.00983    0.00459  219.78   <2e-16 ***
x1:x2        0.99062    0.00436  226.95   <2e-16 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 0.518 on 96 degrees of freedom
Multiple R-squared:     1,  Adjusted R-squared:     1 
F-statistic: 9.97e+04 on 3 and 96 DF,  p-value: <2e-16

Свободный членя является не значимым, следовательно зависимость проходит через начало отсчета. Построим модель без свободного члена.

m6 <- lm(y ~ x1 + x1:x2 + I(x2^2) + 0, df[train.ids,])
summary(m6)


Call:
lm(formula = y ~ x1 + x1:x2 + I(x2^2) + 0, data = df[train.ids, 
    ])

Residuals:
    Min      1Q  Median      3Q     Max 
-1.0777 -0.3465  0.0152  0.3057  1.1711 

Coefficients:
        Estimate Std. Error t value Pr(>|t|)    
x1       1.00601    0.01319    76.2   <2e-16 ***
I(x2^2)  1.00769    0.00409   246.3   <2e-16 ***
x1:x2    0.99165    0.00425   233.5   <2e-16 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 0.518 on 97 degrees of freedom
Multiple R-squared:     1,  Adjusted R-squared:     1 
F-statistic: 2.2e+05 on 3 and 97 DF,  p-value: <2e-16

Прогноз значений для тестового набора данных

pred.m4 <- predict(m4, df[test.ids,])

Сопоставим качество прогноза с истинным значением $ y $

cor(pred.m4, df$y[test.ids])

[1] 0.9673

cor(pred.m4, df$y[test.ids]) ^ 2

[1] 0.9357

Визуализация моделей

Зададим вид вывода результатов и применим функцию plot к моделям m4 и m6.

# 2 x 2 pictures on one plot and square plotting region, independent of device size
par(mfrow = c(2, 2), pty = "s")  
plot(m4)

plot(m6)

Вернем вид вывода результатов к виду по умолчанию

par(mfrow = c(1, 1), pty = "m")

Метод частичных наименьших квадратов (pls)

require(pls)
pls.m1 <- plsr(y ~ ., data=df[train.ids, ], ncomp=2, validation="CV", segments=5, segment.type="random")

Воспользуемся функцией summary для вывода статистики модели

summary(pls.m1)

Data:   X dimension: 100 2 
    Y dimension: 100 1
Fit method: kernelpls
Number of components considered: 2

VALIDATION: RMSEP
Cross-validated using 5 random segments.
       (Intercept)  1 comps  2 comps
CV            28.6    13.87    14.00
adjCV         28.6    13.76    13.79

TRAINING: % variance explained
   1 comps  2 comps
X    69.23   100.00
y    78.68    81.78

Чтобы посчитать коэффициент детерминации для обучающей выборки и для случая кросс-валидации воспользуемся следующими функциями. Следует отметить, что модель pls в качестве прогнозированных значений возвращает массив!

# train
cor(pls.m1$fitted.values[,,2], df$y[train.ids]) ^ 2

[1] 0.8178

# cross-validation
cor(pls.m1$validation$pred[,,2], df$y[train.ids]) ^ 2

[1] 0.7604

Для pls модель также возможно использовать функцию plot, которая возвращает диаграмму зависимости предсказанных значений от наблюдаемых

plot(pls.m1)
abline(0, 1) # добавляет линию выходящую из начала координат и идущей под углом 45 градусов

Спрогноз

Введение в классификаторы Random Forest в Python

Random forests — это алгоритм обучения с учителем. Может использоваться как для классификации, так и для регрессии. Это также самый гибкий и простой в использовании алгоритм. Лес состоит из деревьев. Говорят, что чем больше у него деревьев, тем крепче лес. Случайные леса создают деревья решений для случайно выбранных выборок данных, получают прогнозы по каждому дереву и выбирают лучшее решение с помощью голосования. Это также обеспечивает довольно хороший показатель важности признака.

Случайные леса имеют множество применений, таких как рекомендательные системы, классификация изображений и выбор признаков. Он может быть использован для классификации соискателей, выявления мошеннической деятельности и прогнозирования заболеваний. Он лежит в основе алгоритма Boruta, который выбирает важные признаки в наборе данных.

Алгоритм Random Forests

Давайте разберем алгоритм с точки зрения неспециалистов. Предположим, вы хотите отправиться в путешествие, и вы хотели бы отправиться в место, которое вам понравится.

Итак, что вы делаете, чтобы найти место, которое вам понравится? Вы можете искать в Интернете, читать отзывы в туристических блогах и порталах, или вы также можете спросить своих друзей.

Предположим, вы решили спросить своих друзей и поговорили с ними об их прошлом опыте путешествий по разным местам. Вы получите некоторые рекомендации от каждого друга. Теперь вы должны составить список этих рекомендуемых мест. Затем вы просите их проголосовать (или выбрать одно лучшее место для поездки) из списка рекомендованных вами мест. Место с наибольшим количеством голосов будет вашим окончательным выбором для поездки.

В вышеуказанном процессе принятия решения есть две части. Во-первых, вы спросите своих друзей об их индивидуальном опыте путешествий и получите одну рекомендацию из нескольких мест, которые они посетили. Эта часть похожа на использование алгоритма дерева решений. Здесь каждый друг выбирает места, которые он или она уже посетили.

Вторая часть, после сбора всех рекомендаций, это процедура голосования для выбора лучшего места в списке рекомендаций. Весь этот процесс получения рекомендаций от друзей и голосования за них, чтобы найти лучшее место, известен как алгоритм random forests.

Технически это ансамблевый метод (основанный на подходе «разделяй и властвуй») деревьев решений, сгенерированных на случайно разбитом наборе данных. Эта коллекция классификаторов дерева решений также известна как лес. Отдельные деревья решений генерируются с использованием индикатора выбора атрибута, такого как прирост информации, коэффициент усиления и индекс Джини для каждого атрибута. Каждое дерево зависит от независимой случайной выборки. В задаче классификации голосует каждое дерево, и в качестве конечного результата выбирается самый популярный класс. В случае регрессии среднее значение всех выходных данных дерева считается конечным результатом. Это проще и мощнее по сравнению с другими алгоритмами нелинейной классификации.

Как работает алгоритм?

Он работает в четыре этапа:

1. Выбирает случайные выборки из данного набора данных.

2. Создает дерево решений для каждой выборки и получает результат прогноза из каждого дерева решений.

3. Проводит голосование за каждый прогнозируемый результат.

4. Выбирает результат прогноза с наибольшим количеством голосов в качестве окончательного прогноза.

Преимущества:

1. Случайные леса рассматриваются как высокоточный и надежный метод из-за количества деревьев решений, участвующих в процессе.

2. Он не страдает от проблемы переоснащения. Основная причина в том, что он принимает среднее значение всех прогнозов, что устраняет отклонения.

3. Алгоритм может использоваться как в задачах классификации, так и в регрессии.

4. Случайные леса также могут обрабатывать пропущенные значения. Есть два способа справиться с ними: использование медианных значений для замены непрерывных переменных и вычисление взвешенного по близости значения пропущенных значений.

5. Вы можете получить относительную важность признака, которая помогает в выборе наиболее полезных признаков для классификатора.

Недостатки:

1. Random forests медленно генерируют прогнозы, потому что у него много деревьев решений. Всякий раз, когда он делает прогноз, все деревья в лесу должны сделать прогноз для одного и того же заданного ввода и затем выполнить голосование по нему. Весь этот процесс занимает много времени.

2. Модель трудно интерпретировать по сравнению с деревом решений, где вы можете легко принять решение, следуя пути в дереве.

Нахождение важных признаков

Random forests также предлагает хороший индикатор выбора признаков. Scikit-learn обеспечивает дополнительную переменную в модели, которая показывает относительную важность или вклад каждого признака в прогнозе. Он автоматически вычисляет оценку релевантности каждого признака на этапе обучения. Затем он уменьшает релевантность, так что сумма всех баллов равна 1.

Эта оценка поможет вам выбрать наиболее важные признаки и отбросить наименее важные для построения модели.

Случайный лес использует значение gini importance или mean decrease in impurity (MDI) для расчета важности каждого признака. Gini importance также известна как total decrease in node impurity. Этот параметр показывает, насколько уменьшается подгонка или точность модели при отбрасывании переменной. Чем больше уменьшение, тем значительнее переменная. Здесь среднее уменьшение (mean decrease) является важным параметром для выбора переменной. Gini index может описывать общую объяснительную силу переменных.

Случайные леса против деревьев решений

1. Случайные леса — это множество деревьев решений.

2. Деревья с глубоким обучением могут страдать от переобучения, но случайные леса предотвращают переобучение, создавая деревья на случайных подмножествах.

3. Деревья решений в вычислительном отношении быстрее.

4. Случайные леса трудно интерпретировать, а дерево решений легко интерпретируется и может быть преобразовано в правила.

Создание классификатора с использованием Scikit-learn

Вы будете строить модель на наборе данных ирисов, который является очень известным набором классификации. Он включает длину чашелистика, ширину чашелистика, длину лепестка, ширину лепестка и тип цветов. Есть три вида или класса цветов: setosa, versicolor и virginia. Вы построите модель для классификации типа цветка. Набор данных доступен в библиотеке scikit-learn или вы можете скачать его из репозитория машинного обучения UCI.

Начните с импорта библиотеки наборов данных из scikit-learn и загрузите набор данных iris с помощью load_iris().

# импорт набора данных библиотеки scikit-learn
from sklearn import datasets
 
#Загрузка набора данных
iris = datasets.load_iris()

Вы можете напечатать имена цели и признаков, чтобы убедиться, что у вас правильный набор данных:

# выводим названия видов (setosa, versicolor,virginica)
print(iris.target_names)

# выводим названия четырех признаков
print(iris.feature_names)

['setosa' 'versicolor' 'virginica']
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

Это хорошая идея, всегда немного изучить ваши данные, чтобы вы знали, с чем работаете. Здесь вы можете видеть первые пять строк набора данных, а также целевую переменную для всего набора данных.

# выводим данные iris (верхние 5 записей)
print(iris.data[0:5])

# выводим имена iris (0:setosa, 1:versicolor, 2:virginica)
print(iris.target)

[[ 5.1  3.5  1.4  0.2]

 [ 4.9  3.   1.4  0.2]

 [ 4.7  3.2  1.3  0.2]

 [ 4.6  3.1  1.5  0.2]

 [ 5.   3.6  1.4  0.2]]

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2

 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

 2 2]

Здесь вы можете создать DataFrame набора данных iris следующим образом:

# Создаем DataFrame для набора данных iris.
import pandas as pd
data=pd.DataFrame({
    'sepal length':iris.data[:,0],
    'sepal width':iris.data[:,1],
    'petal length':iris.data[:,2],
    'petal width':iris.data[:,3],
    'species':iris.target
})

data.head()

petal length petal width sepal length sepal width species

0 1.4 0.2 5.1 3.5 0

1 1.4 0.2 4.9 3.0 0

2 1.3 0.2 4.7 3.2 0

3 1.5 0.2 4.6 3.1 0

4 1.4 0.2 5.0 3.6 0

Сначала вы разделяете столбцы на зависимые и независимые переменные (или признаки и метки). Затем вы разбиваете эти переменные на обучающий и тестовый наборы.

# импорт функции train_test_split
from sklearn.model_selection import train_test_split

X=data[['sepal length', 'sepal width', 'petal length', 'petal width']]  

y=data['species']  

# разбиваем набор данных на обучающий и тестовый наборы 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

После разделения вы будете обучать модель на обучающем наборе и выполнять прогнозы на тестовом наборе.

#Импортируем Random Forest
from sklearn.ensemble import RandomForestClassifier

#Создаем гауссовский классификатор
clf=RandomForestClassifier(n_estimators=100)

# Обучаем модель с использованием обучающего набора y_pred=clf.predict(X_test)
clf.fit(X_train,y_train)

y_pred=clf.predict(X_test)

После тренировки проверьте точность, используя фактические и прогнозируемые значения.

# Импортируем модуль scikit-learn metrics для расчета точности
from sklearn import metrics

#Точность модели, как часто верен классификатор?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

('Accuracy:', 0.93333333333333335)

Вы также можете сделать прогноз для одного элемента, например:

sepal length = 3

sepal width = 5

petal length = 4

petal width = 2

Теперь вы можете предсказать, какой это цветок.

clf.predict([[3, 5, 4, 2]])

array([2])

Здесь 2 цветка указываются как тип Virginica.

Определение важности признаков в Scikit-learn

Здесь вы находите важные признаки или выбираете признаки в наборе данных IRIS. В scikit-learn вы можете выполнить эту задачу следующим образом:

Во-первых, вам нужно создать модель случайных лесов.

Во-вторых, используйте переменную feature importance, чтобы увидеть оценки важности признаков.

В-третьих, визуализируйте эти оценки, используя библиотеку Seaborn.

#Создаем гауссовский классификатор
clf=RandomForestClassifier(n_estimators=100)

#Обучаем модель с использованием обучающего набора y_pred=clf.predict(X_test)
clf.fit(X_train,y_train)

RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
            max_depth=None, max_features='auto', max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=1, min_samples_split=2,
            min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=1,
            oob_score=False, random_state=None, verbose=0,
            warm_start=False)

import pandas as pd
feature_imp = pd.Series(clf.feature_importances_,index=iris.feature_names)

.sort_values(ascending=False)
feature_imp

petal width (cm)     0.458607
petal length (cm)    0.413859
sepal length (cm)    0.103600
sepal width (cm)     0.023933
dtype: float64

Вы также можете визуализировать важность признаков. Визуализации легко понять и интерпретировать.

Для визуализации вы можете использовать комбинацию matplotlib и seaborn. Поскольку seaborn построен поверх matplotlib, он предлагает ряд настраиваемых тем и предоставляет дополнительные типы сюжетов. Matplotlib — это расширенный набор seaborn, и оба одинаково важны для хорошей визуализации.

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# Создаем диаграмму
sns.barplot(x=feature_imp, y=feature_imp.index)
# Добавляем подписи к графику
plt.xlabel('Feature Importance Score')
plt.ylabel('Features')
plt.title("Visualizing Important Features")
plt.legend()
plt.show()

Генерация модели на выбранных признаках

Здесь вы можете удалить признак «sepal width», поскольку он имеет очень низкое значение, и выбрать 3 оставшиеся признака.

# Импорт функции train_test_split 
from sklearn.cross_validation import train_test_split

# Разделяем набор данных на признаки и метки
X=data[['petal length', 'petal width','sepal length']]

# удалили признак "sepal length"
y=data['species']                                       

# Разделяем набор данных на обучающий и тестовый наборы 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.70,

random_state=5) # 70% training and 30% test

После разделения вы сгенерируете модель для выбранных элементов обучающего набора, выполните прогнозы для выбранных признаках тестового набора и сравните фактические и прогнозируемые значения.

from sklearn.ensemble import RandomForestClassifier

#Создаем гауссовский классификатор
clf=RandomForestClassifier(n_estimators=100)

#Обучаем модель с использованием обучающего набора y_pred=clf.predict(X_test)
clf.fit(X_train,y_train)

# прогноз на тестовом наборе
y_pred=clf.predict(X_test)
#импорт модуля scikit-learn metrics для расчета точности

from sklearn import metrics
# Точность модели, как часто верен классификатор?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

('Accuracy:', 0.95238095238095233)

Вы можете видеть, что после удаления наименее важных признаков (sepal length) точность увеличивается. Это потому, что вы удалили вводящие в заблуждение данные и шум, что привело к повышению точности. Меньшее количество функций также сокращает время обучения.

Заключение

Поздравляем, вы дошли до конца этого урока!

В этом уроке вы узнали, что такое случайные леса, как они работают, поиск важных признаков, сравнение между случайными лесами и деревьями решений, преимущества и недостатки. Вы также научились строить модели, оценивать и находить важные признаки в scikit-learn.

Random Forest — это… Что такое Random Forest?

Random forest — (англ. случайный лес) алгоритм машинного обучения, предложенный Лео Брейманом[1][2] и Адель Катлер, заключающийся в использовании комитета (ансамбля) решающих деревьев. Алгоритм сочетает в себе две основные идеи: метод бэггинга… … Википедия

Random forest — In machine learning, a random forest is a classifier that consists of many decision trees and outputs the class that is the mode of the classes output by individual trees. The algorithm for inducing a random forest was developed by Leo Breiman… … Wikipedia

Random Forest — Ein Random Forest ist ein Klassifikationsverfahren, welches aus mehreren verschiedenen, unkorrelierten Entscheidungsbäumen besteht. Alle Entscheidungsbäume sind unter einer bestimmten Art von Randomisierung während des Lernprozesses gewachsen.… … Deutsch Wikipedia

Random naive Bayes — extends the Naive Bayes classifier by adopting the random forest principles: random input selection (bagging, i.e. bootstrap aggregating) and random feature selection ( [Breiman, 2001] ). Naive Bayes classifier Naive Bayes is a probabilistic… … Wikipedia

Random multinomial logit — In statistics and machine learning, random multinomial logit (RMNL) is a technique for (multi class) statistical classification using repeated multinomial logit analyses via Leo Breiman s random forests. Rationale for the new methodSeveral… … Wikipedia

Forest inventory — is the systematic collection of data and forest information for assessment or analysis. It is also commonly known as timber cruising. It is important for owners to cruise the timber to get an estimate of the value and possible uses of the timber … Wikipedia

Random encounter — A random encounter is a feature commonly used in hack and slash role playing games and computer and video games whereby encounters with non player character (NPC) enemies or other dangers occur sporadically and at random. In general, random… … Wikipedia

Forest City Stockade — The Forest City Stockade was built to defend the area settlers from Indian attacks. It became famous during the Dakota War of 1862. The following account is taken from Terry Tales 2, a book by Terry R. Shaw: It had been Jesse Branham, Sr.’s son… … Wikipedia

Allegheny National Forest — Infobox protected area | name = Allegheny National Forest iucn category = VI caption = locator x = 230 locator y = 64 location = Warren, McKean, Forest, and Elk counties, Pennsylvania, USA nearest city = Warren, PA lat degrees = 41 lat minutes =… … Wikipedia

Lake Forest College — Infobox University name = Lake Forest College native name = latin name = motto = Natura et Scientia Amore established = 1857 type = Liberal Arts School endowment = $76,700,000 staff = faculty = 117 president = Stephen D. Schutt provost = Janet… … Wikipedia

Учебное пособие по

R Random Forest с примером

Guru99

Home
Testing
- - Back
  - Agile Testing
  - BugZilla
  - Cucumber
  - Database Testing
  - ETL Testing
  - ETL Назад
  - JUnit
  - LoadRunner
  - Ручное тестирование
  - Мобильное тестирование
  - Mantis
  - Почтальон
  - QTP
  - Назад
  - Центр качества (ALM)
  - SAPUA
  - Управление тестированием
  - TestLink
SAP
- - Назад
  - ABAP
  - APO
  - Начинающий
  - Basis
  - BODS
  - BI
  - BPC
  - CO
  - Назад
  - CRM
  - Crystal Reports
  - QMO
  - Назад
  - PI / PO
  - PP
  - SD
  - SAPUI5
  - Безопасность
  - Менеджер решений
  - Successfactors
  - SAP Tutorials
- 8
- Обязательно учите!
  - - Назад
    - Бухгалтерский учет
    - Алгоритмы
    - Android
    - Блокчейн
    - Business Analyst
    - Создание веб-сайта
    - Облачные вычисления
    - COBOL
    - Учебные пособия по Excel
    - Программирование на Go
    - IoT
    - ITIL
    - Jenkins
    - MIS
    - Сетевые подключения
    - Операционная система
    - Назад
    - Prep
    - Prep
    - SEO
    - Разработка программного обеспечения
    - VBA
    900 05
- Big Data
  - - Назад
    - AWS
    - BigData
    - Cassandra
    - Cognos
    - Data Warehousing
    - DevOps Back
    - HBase
      - HBase
      - DevOps Back
      - HBase
        MongoDB
        NiFi
    Страница не найдена · GitHub Pages
    Страница не найдена · GitHub Pages
    Файл не найден
    Сайт, настроенный по этому адресу, не
    содержать запрошенный файл.
    Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу.
    Для корневых URL (например, http://example.com/ ) вы должны предоставить
    index.html файл.
    Прочтите полную документацию
    для получения дополнительной информации об использовании GitHub Pages .
    Полное руководство по случайному лесу в R с примерами
    Случайный лес в R:
    Учитывая потребность в более сложных вычислениях, мы не можем полагаться на упрощенные алгоритмы.Вместо этого мы должны использовать алгоритмы с более высокими вычислительными возможностями, и одним из таких алгоритмов является случайный лес. В этом сообщении блога о случайном лесу в R вы познакомитесь с основами случайного леса и его реализацией с помощью языка R.
    Чтобы получить более глубокие знания о Data Science, вы можете записаться на онлайн-курс Data Science Certification Training от Edureka с круглосуточной поддержкой и пожизненным доступом.
    Вот список тем, которые я буду освещать в блоге Random Forest In R:
    1. Что такое классификация?
    2. Что такое случайный лес?
    3. Зачем нужен случайный лес?
    4. Как работает случайный лес?
    5. Создание случайного леса
    6. Практическая реализация случайного леса в R
    Что такое классификация?
    Классификация — это метод прогнозирования класса данной точки входных данных.Проблемы классификации распространены в машинном обучении и относятся к методу контролируемого обучения.
    Допустим, вы хотите разделить свои электронные письма на 2 группы: спам и не спам. Для такого рода задач, когда вам нужно назначить точку входных данных различным классам, вы можете использовать алгоритмы классификации.
    В рамках классификации у нас есть 2 типа:
    - Бинарная классификация
    - Мультиклассовая классификация
    Классификация — случайный лес в R — Edureka
    Пример, который я приводил ранее о классификации писем как спам и не-спам имеет двоичный тип, потому что здесь мы классифицируем электронные письма на 2 класса (спам и неспам).
    Но давайте предположим, что мы хотим классифицировать наши электронные письма на 3 класса:
    - Спам-сообщения
    - Не-спам-сообщения
    - Черновики
    Итак, мы классифицируем электронные письма более чем на 2 класса, это именно то, что мультиклассовые средства классификации.
    Здесь следует отметить еще одну вещь: модели классификации обычно предсказывают непрерывное значение. Но это непрерывное значение представляет вероятность принадлежности данной точки данных к каждому выходному классу.
    Теперь, когда вы хорошо понимаете, что такое классификация, давайте взглянем на несколько алгоритмов классификации, используемых в машинном обучении:
    1. 1. Логистическая регрессия
      2. K ближайшего соседа (KNN)
      3. Дерево решений
      4. Поддержка Векторная машина
      5. Наивный байесовский
      6. Случайный лес
    Что такое случайный лес?
    Алгоритм случайного леса — это контролируемый алгоритм классификации и регрессии.Как следует из названия, этот алгоритм случайным образом создает лес из нескольких деревьев.
    Как правило, чем больше деревьев в лесу, тем крепче выглядит лес. Аналогичным образом, в классификаторе случайного леса, чем больше деревьев в лесу, тем выше точность результатов.
    
    Случайный лес — Случайный лес В R — Edureka
    Проще говоря, случайный лес строит несколько деревьев решений (называемых лесом) и склеивает их вместе, чтобы получить более точный и стабильный прогноз.Лес, который он строит, представляет собой набор деревьев решений, обученных методом упаковки.
    Прежде чем подробно обсудить случайный лес, нам нужно понять, как работают деревья решений.
    Многие из вас имеют в виду этот вопрос:
    В чем разница между случайным лесом и деревом решений?
    Позвольте мне объяснить.
    Допустим, вы хотите купить дом, но не можете решить, какой из них купить. Итак, вы проконсультируетесь с несколькими агентами, и они дадут вам список параметров, которые вы должны учитывать перед покупкой дома.Список включает:
    - Цена дома
    - Населенный пункт
    - Количество спален
    - Парковочное место
    - Доступные помещения
    Эти параметры известны как переменные-предикторы , которые используются для поиска переменной ответа. Вот схематическая иллюстрация того, как вы можете представить указанную выше постановку проблемы с помощью дерева решений.
    
    Пример дерева решений — случайный лес в R — Edureka
    Здесь важно отметить, что деревья решений строятся на основе всего набора данных с использованием всех переменных-предикторов.
    А теперь посмотрим, как Random Forest решит ту же проблему.
    Как я упоминал ранее, Случайный лес — это совокупность деревьев решений, он случайным образом выбирает набор параметров и создает дерево решений для каждого набора выбранных параметров.
    Взгляните на рисунок ниже.
    
    Случайный лес с 3 деревьями решений — Случайный лес в R — Edureka
    Здесь я создал 3 дерева решений, и каждое дерево решений принимает только 3 параметра из всего набора данных.Каждое дерево решений предсказывает результат на основе соответствующих переменных-предикторов, используемых в этом дереве, и, наконец, принимает среднее значение результатов всех деревьев решений в случайном лесу.
    Проще говоря, после создания нескольких деревьев решений с использованием этого метода каждое дерево выбирает или голосует за класс (в этом случае деревья решений будут выбирать, покупать дом или нет), а класс, получивший наибольшее количество голосов простым большинство называется прогнозируемым классом.
    В заключение, деревья решений строятся на основе всего набора данных с использованием всех переменных-предикторов, тогда как случайные леса используются для создания нескольких деревьев решений, так что каждое дерево решений строится только на части набора данных.
    Надеюсь, разница между деревьями решений и случайным лесом очевидна.
    Зачем использовать случайный лес?
    Вам может быть интересно, почему мы используем случайный лес, если мы можем решить те же проблемы с помощью деревьев решений. Позволь мне объяснить.
    - Несмотря на то, что деревья решений удобны и легко реализуются, им не хватает точности. Деревья решений очень эффективно работают с обучающими данными, которые использовались для их построения, но они не обладают гибкостью, когда дело доходит до классификации новой выборки.Это означает, что точность на этапе тестирования очень низкая.
    - Это происходит из-за процесса подгонки.
    Чрезмерная подгонка происходит, когда модель изучает обучающие данные до такой степени, что это отрицательно влияет на производительность модели на новых данных.
    - Это означает, что нарушение в обучающих данных записывается и изучается моделью как концепции. Но проблема здесь в том, что эти концепции не применимы к данным тестирования и отрицательно влияют на способность модели классифицировать новые данные, что снижает точность данных тестирования.
    Вот тут-то и пригодится случайный лес. Он основан на идее пакетирования, который используется для уменьшения разброса в прогнозах путем объединения результатов нескольких деревьев решений на разных выборках набора данных.
    Теперь давайте сосредоточимся на Случайном лесу.
    Как работает случайный лес?
    Чтобы понять случайный лес, рассмотрим приведенный ниже образец данных. В этом наборе данных у нас есть четыре прогнозных переменных, а именно:
    - Вес
    - Кровоток
    - Заблокированные артерии
    - Боль в груди
    Пример набора данных — случайный лес в R — Edureka
    Эти переменные используются, чтобы предсказать, есть ли у человека болезнь сердца.Мы собираемся использовать этот набор данных для создания случайного леса, который предсказывает, есть у человека сердечное заболевание или нет.
    Создание случайного леса
    Шаг 1. Создание набора данных начальной загрузки
    Загрузка — это метод оценки, используемый для прогнозирования набора данных путем повторной выборки. Чтобы создать самонастраиваемый набор данных, мы должны случайным образом выбрать образцы из исходного набора данных. Здесь следует отметить, что мы можем выбрать один и тот же образец более одного раза.
    
    Загрузочный набор данных — случайный лес в R — Edureka
    На приведенном выше рисунке я произвольно выбрал образцы из исходного набора данных и создал самонастраиваемый набор данных. Все просто, не правда ли? Что ж, в реальных задачах вы никогда не получите такой маленький набор данных, поэтому создание начального набора данных немного сложнее.
    Шаг 2: Создание деревьев решений
    - Наша следующая задача — построить дерево решений с использованием набора данных начальной загрузки, созданного на предыдущем шаге.Поскольку мы создаем случайный лес, мы не будем рассматривать весь созданный набор данных, вместо этого мы будем использовать только случайное подмножество переменных на каждом этапе.
    - В этом примере мы будем рассматривать только две переменные на каждом шаге. Итак, мы начинаем с корневого узла, здесь мы случайным образом выбираем две переменные в качестве кандидатов в корневой узел.
    - Допустим, мы выбрали кровоток и заблокированные артерии. Теперь из этих двух переменных мы должны выбрать переменную, которая лучше всего разделяет выборки.Для этого примера предположим, что заблокированные артерии — более важный предиктор, и поэтому назначим его корневым узлом.
    - Наш следующий шаг — повторить тот же процесс для каждого из следующих узлов ветвления. Здесь мы снова случайным образом выбираем две переменные в качестве кандидатов в узел ветвления, а затем выбираем переменную, которая лучше всего разделяет выборки.
    Точно так же мы строим дерево, рассматривая только случайные подмножества переменных на каждом шаге. Следуя описанному выше процессу, наше дерево будет выглядеть примерно так:
    
    Алгоритм случайного леса — случайный лес в R — Edureka
    Мы только что создали наше первое дерево решений.
    Шаг 3: вернитесь к шагу 1 и повторите
    Как я уже упоминал ранее, случайный лес представляет собой набор деревьев решений. Каждое дерево решений предсказывает выходной класс на основе соответствующих переменных-предикторов, используемых в этом дереве. Наконец, результат всех деревьев решений в случайном лесу записывается, и класс с большинством голосов вычисляется как выходной класс.
    Таким образом, теперь мы должны создать больше деревьев решений, рассматривая подмножество случайных переменных-предикторов на каждом шаге.Для этого вернитесь к шагу 1, создайте новый набор данных начальной загрузки, а затем постройте дерево решений, рассматривая только подмножество переменных на каждом шаге. Итак, выполнив указанные выше действия, наш случайный лес будет выглядеть примерно так:
    
    Случайный лес — случайный лес В R — Edureka
    Эта итерация выполняется 100 раз, поэтому для каждого из них создается несколько деревьев решений. дерево, вычисляющее выходные данные с использованием подмножества случайно выбранных переменных на каждом шаге.
    Наличие такого разнообразия деревьев решений в случайном лесу делает его более эффективным, чем отдельное дерево решений, созданное с использованием всех функций и всего набора данных.
    Шаг 4. Прогнозирование результата для новой точки данных
    Теперь, когда мы создали случайный лес, давайте посмотрим, как с его помощью можно предсказать, есть ли у нового пациента заболевание сердца или нет.
    На диаграмме ниже представлены данные о новом пациенте. Все, что нам нужно сделать, это прогнать эти данные по деревьям решений, которые мы приняли.
    Первое дерево показывает, что у пациента болезнь сердца, поэтому мы отслеживаем это в таблице, как показано на рисунке.
    
    Выходные данные — случайный лес В R — Edureka
    Аналогичным образом мы прогоняем эти данные по другим деревьям решений и отслеживаем класс, предсказанный каждым деревом. После обработки данных по всем деревьям в случайном лесу мы проверяем, какой класс получил большинство голосов. В нашем случае класс «Да» получил наибольшее количество голосов, поэтому очевидно, что у нового пациента болезнь сердца.
    В заключение, мы загрузили данные и использовали агрегат из всех деревьев для принятия решения, этот процесс известен как Bagging.
    Шаг 5. Оценка модели
    Наш последний шаг — оценить модель случайного леса. Ранее, когда мы создавали набор данных начальной загрузки, мы не учитывали одну запись / образец, поскольку мы дублировали другой образец. В реальной проблеме около 1/3 исходного набора данных не включается в набор данных начальной загрузки.
    На рисунке ниже показана запись, которая не попала в набор данных начальной загрузки.
    
    Образец вне пакета — Случайный лес в R — Edureka
    Этот набор данных образца, который не включается в набор данных начальной загрузки, известен как набор данных Out-Of-Bag (OOB).
    
    Набор данных Out-Of-Bag используется для проверки точности модели, поскольку модель не была создана с использованием этих OOB-данных, это даст нам хорошее представление о том, является ли модель эффективной или нет.
    В нашем случае выходной класс для набора данных OOB — «Нет». Итак, чтобы наша модель случайного леса была точной, если мы прогоним данные OOB вниз по деревьям решений, мы должны получить большинство голосов «Нет». Этот процесс выполняется для всех образцов OOB, в нашем случае у нас был только один OOB, однако в большинстве задач образцов обычно намного больше.
    Таким образом, в конечном итоге мы можем измерить точность случайного леса по доле правильно классифицированных выборок OOB.
    Доля некорректно классифицированных образцов OOB называется ошибкой Out-Of-Bag. Это был пример того, как работает Random Forest.
    Теперь давайте поработаем руками и реализуем алгоритм случайного леса для решения более сложной проблемы.
    Практическое воплощение случайного леса в рублях
    Даже люди, живущие под скалой, слышали бы о фильме под названием «Титаник». Но многие ли из вас знают, что фильм основан на реальном событии? Kaggle собрал набор данных, содержащий данные о том, кто выжил и кто погиб на Титанике.
    Постановка задачи: Для построения модели случайного леса, которая может изучить характеристики человека, находившегося на Титанике, и предсказать вероятность того, что они выжили.
    Описание набора данных: В наборе данных есть несколько переменных / характеристик для каждого человека:
    - pclass: класс пассажира (1-й, 2-й или 3-й)
    - пол
    - возраст
    - sibsp: количество братьев и сестер / Супруги на борту
    - parch: количество родителей / детей на борту
    - тариф: сколько заплатил пассажир
    - сел на борт: где они сели в лодку (C = Шербур; Q = Квинстаун; S = Саутгемптон)
    Ср. Я буду запускать приведенные ниже фрагменты кода в R с помощью RStudio, поэтому откройте RStudio.Для этой демонстрации вам необходимо установить пакет Caret и пакет randomForest.
```
install.packages ("каретка", dependencies = TRUE)
install.packages ("randomForest")
 
```
    Следующим шагом будет загрузка пакетов в рабочую среду.
```
библиотека (каретка)
библиотека (randomForest)
 
```
    Пришло время загрузить данные, мы воспользуемся для этого функцией read.table. Не забудьте указать путь к файлам (train.csv и test.csv)
```
train <- read.table ('C: / Users / zulaikha / Desktop / titanic / train.csv ', sep = ",", header = TRUE)
 
```
    Приведенная выше команда считывает файл «train.csv» с использованием разделителя «,» (который показывает, что файл является файлом CSV), включая строку заголовка в качестве имен столбцов, и назначает ее последовательности объектов R. .
    Теперь давайте прочитаем тестовые данные:
```
test <- read.table ('C: /Users/zulaikha/Desktop/titanic/test.csv', sep = ",", header = TRUE)
 
```
    Чтобы сравнить данные обучения и тестирования, давайте взглянем на первые несколько строк обучающего набора:
```
голова (поезд)
 
```
    Обучающие данные - случайный лес в R - Edureka
    Вы заметите, что в каждой строке есть столбец «Выжившие», который представляет собой вероятность от 0 до 1, если человек выжил, это значение больше 0 .5, а если нет, то ниже 0,5. Теперь сравним обучающий набор с тестовым:
```
голова (тест)
 
```
    Тестовые данные - случайный лес в R - Edureka
    Основное различие между обучающим набором и тестовым набором состоит в том, что обучающий набор помечен, а тестовый набор не помечен. Очевидно, что в наборе поезда нет столбца под названием «Выжившие», потому что мы должны предсказать это для каждого человека, который сел на «Титаник».
    Прежде чем мы продолжим, наиболее важным фактором при построении модели является выбор лучших функций для использования в модели.Речь не идет о выборе лучшего алгоритма или использовании самого сложного пакета R. Теперь «особенность» - это просто переменная.
    Итак, это подводит нас к вопросу, как выбрать наиболее значимые переменные для использования? Самый простой способ - использовать кросс-таблицы и условные ящичные диаграммы.
    Перекрестные таблицы в понятной форме представляют отношения между двумя переменными. В соответствии с нашей проблемой, мы хотим знать, какие переменные являются лучшими предикторами для «Выживших». Давайте посмотрим на перекрестные таблицы между «Выжившими» и каждой другой переменной.В R мы используем табличную функцию:
```
table (train [, c ('Выживший', 'Pclass')])
        Pclass
Выжил 1 2 3
       0 80 97 372
       1 136 87 119
 
```
    Из перекрестной таблицы мы видим, что «Pclass» может быть полезным предиктором «Выживший». Это связано с тем, что первый столбец перекрестной таблицы показывает, что из пассажиров класса 1 136 выжили и 80 умерли (т.е. 63% пассажиров первого класса выжили). С другой стороны, во втором классе 87 выжили и 97 умерли (то есть выжило только 47% пассажиров второго класса).Наконец, в классе 3 выжили 119 и 372 человека умерли (то есть выжило только 24% пассажиров третьего класса). Это означает, что существует очевидная взаимосвязь между классом пассажиров и шансами на выживание.
    Теперь мы знаем, что мы должны использовать Pclass в нашей модели, потому что он определенно имеет сильную прогнозирующую ценность для того, выжил кто-то или нет. Теперь вы можете повторить этот процесс для других категориальных переменных в наборе данных и решить, какие переменные вы хотите включить.
    Чтобы упростить задачу, давайте воспользуемся «условными» прямоугольными диаграммами для сравнения распределения каждой непрерывной переменной, обусловленной от того, выжили пассажиры или нет.Но сначала нам нужно установить пакет «fields»:
```
install.packages ("поля")
библиотека (поля)
bplot.xy (train $ Survived, train $ Age)
 
```
    Коробчатая диаграмма - Случайный лес в R - Эдурека
    Коробчатая диаграмма возраста людей, которые выжили, и которые не выжили, почти одинакова. Это означает, что возраст человека не оказал большого влияния на то, выжил он или нет. Ось Y - Возраст, а ось X - Выжившие.
    Кроме того, если обобщить, есть много НС.Итак, давайте исключим переменную Age, потому что она не оказывает большого влияния на Survived, а также потому, что NA усложняет работу.
```
сводка (поезд $ Возраст)
   Мин. 1st Qu. Среднее значение 3-го кв. Максимум. NA
   0,42 20,12 28,00 29,70 38,00 80,00 177
 
```
    На приведенной ниже диаграмме коробки для платы за проезд сильно различаются для тех, кто выжил, и тех, кто не выжил. Опять же, ось Y - это плата за проезд, а ось x - выжившие.
```
bplot.xy (поезд $ выжил, поезд $ тариф)
 
```
    Коробчатая диаграмма для ярмарки - случайный лес в R - Edureka
    Подводя итоги, вы обнаружите, что нет NA для платы за проезд.Итак, давайте включим эту переменную.
```
сводка (стоимость проезда $
   Мин. 1st Qu. Среднее значение 3-го кв. Максимум.
   0,00 7,91 14,45 32,20 31,00 512,33
 
```
    Следующим шагом является преобразование Survived в тип данных Factor, чтобы каретка построила классификацию вместо регрессионной модели. После этого мы используем простую команду train для обучения модели.
    Теперь модель обучается с использованием алгоритма случайного леса, который мы обсуждали ранее. Случайный лес идеально подходит для таких задач, потому что он выполняет множество вычислений и предсказывает результаты с высокой точностью.
```
# Преобразование & lsquo; Survived & rsquo; к фактору
train $ Survived <- factor (train $ Survived)
# Установить случайное семя
набор. семян (51)
# Обучение с использованием & lsquo; random forest & rsquo; алгоритм
модель <- поезд (Выживший ~ Pclass + Sex + SibSp +
Embarked + Parch + Fare, # Survived - это функция переменных, которые мы решили включить
data = train, # Использовать фрейм данных поезда в качестве данных обучения
method = 'rf', # Использовать алгоритм 'random forest'
trControl = trainControl (method = 'cv', # Использовать перекрестную проверку
number = 5) # Используйте 5 раз для перекрестной проверки
 
```
    Для оценки нашей модели мы будем использовать баллы перекрестной проверки.
    Перекрестная проверка используется для оценки эффективности модели с использованием обучающих данных. Вы начинаете со случайного разделения обучающих данных на 5 частей одинакового размера, называемых «складками». Затем вы обучаете модель на 4/5 данных и проверяете ее точность на 1/5 данных, которые вы пропустили. Затем вы повторяете этот процесс с каждым разделением данных. В конце концов, вы усредняете процентную точность по пяти различным разделам данных, чтобы получить среднюю точность. Карет сделает это за вас, и вы можете увидеть результаты, посмотрев на вывод модели:
```
модель
Случайный лес

891 образец
  6 предсказатель
  2 класса: «0», «1»

Без предварительной обработки
Передискретизация: перекрестная проверка (5 раз)
Сводка размеров выборки: 712, 713, 713, 712, 714
Результаты повторной выборки по параметрам настройки:

  mtry Точность Каппа
  2 0.8047116 0,5640887
  5 0,8070094 0,5818153
  8 0,8002236 0,5704306

Точность использовалась для выбора оптимальной модели с использованием наибольшего значения.
Окончательное значение, использованное для модели, было mtry = 5.
 
```
    Первое, на что следует обратить внимание, это то, где написано: «Окончательное значение, используемое для модели, было mtry = 5.» «Mtry» - это гиперпараметр модели случайного леса, который определяет, сколько переменных модель использует для разделения деревьев.
    В таблице показаны различные значения mtry и соответствующая им средняя точность при перекрестной проверке.Карет автоматически выбирает значение гиперпараметра «mtry», которое является наиболее точным при перекрестной проверке.
    На выходе при mtry = 5 средняя точность составляет 0,8170964, или около 82 процентов. Это наивысшее значение, поэтому Карет выбирает это значение за нас.
    Прежде чем мы спрогнозируем результат для тестовых данных, давайте проверим, есть ли какие-либо недостающие данные в переменных, которые мы используем для прогнозирования. Если Caret обнаружит какие-либо пропущенные значения, он вообще не вернет прогноз. Итак, мы должны найти недостающие данные, прежде чем двигаться дальше:
```
резюме (тест)
 
```
    Сводка тестовых данных - случайный лес в R - Edureka
    Обратите внимание, что переменная «Fare» имеет одно значение NA.Давайте заполним это значение средним значением столбца "Стоимость проезда". Для этого мы используем оператор if-else.
    Итак, если запись в столбце «Стоимость проезда» является NA, замените ее средним значением столбца и удалите NA, когда вы возьмете среднее значение:
```
test $ Fare <- ifelse (is.na (test $ Fare), mean (test $ Fare, na.rm = TRUE), test $ Fare)
 
```
    Теперь наш последний шаг - сделать прогнозы на тестовой выборке. Для этого вам просто нужно вызвать метод прогнозирования для обученного вами объекта модели.Давайте сделаем прогнозы по набору тестов и добавим их в новый столбец.
```
test $ Survived <- предсказать (модель, новые данные = тест)
 
```
    Наконец, он выводит прогнозы для тестовых данных,
```
test $ Выжил
 
```
    Прогнозирование результата - случайный лес в R - Edureka
    Здесь вы можете увидеть значения «Выживших» (0 или 1) для каждого пассажира. Где один означает выжившие, а 0 - умершие. Этот прогноз сделан на основе переменных «pclass» и «Fare».Вы можете использовать и другие переменные, если они каким-то образом связаны с тем, выживет ли человек, садящийся на «Титаник».
    Теперь, когда вы знаете, как работает Random Forest, я уверен, что вам интересно узнать больше о различных алгоритмах машинного обучения. Вот список блогов, в которых подробно рассматриваются различные типы алгоритмов машинного обучения.
    Итак, на этом мы подошли к концу этого блога. Я надеюсь, что вы все нашли этот блог информативным. Если у вас есть какие-либо мысли, прокомментируйте их ниже.Следите за новостями, чтобы увидеть больше подобных блогов!
    Если вы ищете структурированное онлайн-обучение по Data Science, edureka! имеет специально подобранный курс Data Science, который поможет вам получить опыт в области статистики, обработки данных, исследовательского анализа данных, алгоритмов машинного обучения, таких как кластеризация K-средних, деревья решений, случайный лес, наивный байесовский анализ. Вы познакомитесь с концепциями временных рядов, интеллектуального анализа текста, а также познакомитесь с глубоким обучением. Новые партии для этого курса скоро начнутся !!
    Случайные леса в R | DataScience +
    Ансамблевое обучение - это тип контролируемой техники обучения, в которой основная идея состоит в том, чтобы создать несколько моделей на обучающем наборе данных, а затем просто объединить (усреднить) их правила вывода или их гипотезу \ (H_x \) для создания сильной модели, которая работает очень хорошо и не переоборудует, что также уравновешивает компромисс между отклонением и отклонением.
    Идея состоит в том, что вместо создания единой сложной и сложной Модели, которая может иметь высокую дисперсию, которая приведет к переобучению или может быть слишком простой и иметь высокую систематическую ошибку, приводящую к недостаточной подгонке, мы будем генерировать множество моделей путем обучения на Установите тренировочный набор и в конце объедините их. Такой метод - это случайный лес, который является популярным методом ансамблирования, который используется для улучшения прогнозирующей способности деревьев решений за счет уменьшения дисперсии деревьев путем их усреднения.Деревья решений считаются очень простыми и легко интерпретируемыми, а также понятными методами моделирования, но их главный недостаток заключается в том, что они имеют плохую прогностическую производительность и плохое обобщение на тестовом наборе. Их также называют слабыми учащимися, то есть учащимися, которые всегда работают лучше, чем случайно, и имеют ошибку менее 50%.
    Случайные леса
    Случайные леса похожи на знаменитую ансамблевую технику под названием Bagging, но в ней есть другая настройка.В случайных лесах идея состоит в том, чтобы декоррелировать несколько деревьев, которые генерируются различными загрузочными выборками из обучающих данных. А затем мы просто уменьшаем дисперсию деревьев, усредняя их.
    Усреднение деревьев помогает нам уменьшить дисперсию, а также улучшить производительность деревьев решений на тестовом наборе и, в конечном итоге, избежать переобучения.
    Идея состоит в том, чтобы построить много Деревьев таким образом, чтобы уменьшить Корреляцию между Деревьями.
    Еще одно важное отличие состоит в том, что мы рассматриваем только случайное подмножество предикторов \ (m \) каждый раз, когда выполняем разбиение на обучающих примерах.В то время как обычно в Дереве мы находим все предикторы при выполнении разбиения и выбираем лучший из них. Обычно \ (m = \ sqrt {p} \), где \ (p \) - количество предикторов.
    Сейчас кажется безумием отбрасывать много предсказателей, но это
    Случайный лес в R - Поймите все аспекты, связанные с этим!
    Мы тщательно изучим концепцию случайного леса в R и поймем технику ансамблевого обучения и ансамблевых моделей в программировании на R. Мы также рассмотрим классификатор случайного леса и процесс разработки случайного леса на языке R.
    
    Итак, приступим.
    Введение в случайный лес в R
    Что такое случайные леса?
    Идея этой техники заключается в декоррелировании нескольких деревьев. Техника ансамбля, называемая бэггингом, похожа на случайный лес. Он генерируется на различных загрузочных выборках из обучающих данных. Затем мы уменьшаем дисперсию деревьев путем их усреднения. Следовательно, в этом подходе он создает большое количество деревьев решений в R.
    
    Освойте концепцию деревьев решений R, прежде чем продолжить
    Мы используем пакет R «randomForest» для создания случайных лесов.
    Что такое ансамблевое обучение в R?
    Это метод обучения с учителем. Основная идея заключается в том, чтобы создать множество моделей на обучающем наборе данных, а затем объединить их правила вывода.
    Мы используем его для создания множества моделей, обучаясь на обучающем наборе и комбинируя их в конце.Следовательно, мы можем использовать его для повышения прогнозирующей способности деревьев решений за счет уменьшения дисперсии деревьев путем их усреднения. Это называется методом случайного леса.
    Что такое ансамблевые модели в R?
    Это тип модели, который объединяет результаты разных моделей и обычно лучше, чем результат одной из отдельных моделей.
    
    Вот некоторые особенности случайных лесов в программировании на R:
    - Это тип модели, который работает в больших базах данных.
    - Случайные леса позволяют обрабатывать тысячи входных переменных без удаления переменных.
    - Он дает очень хорошие оценки, указывающие, какие переменные важны для классификации.
    Учебное пособие для получения опыта по классификации в программировании на R
    Классификатор случайных лесов
    Во время обучения мы можем классифицировать метод ансамблевого обучения случайного леса и, таким образом, мы можем использовать его, строя множество деревьев решений.
    Его разработали Адель Катлер и Лео Брейман. Здесь комбинация двух различных методов осуществляется с помощью идеи Лео и случайного выбора признаков , предложенного Тин Кан Хо. Он также предложил Лес случайных решений в 1995 году.
    Функции случайного леса в R
    Если количество наблюдений в обучающем наборе равно N, а выборка N случайна, каждое дерево будет расти. Таким образом, этот образец будет обучающим набором для выращивания дерева.Если имеется M входных переменных, мы указываем число m << M , так что в каждом узле m переменных выбираются случайным образом из M . Значение m постоянно во время роста леса, и, следовательно, каждое дерево растет в максимально возможной степени.
    Знаете ли вы о кластеризации на языке программирования R
    Развитие случайного леса в R
    Сначала мы импортируем важные библиотеки, такие как ggplot2 и randomForest следующим образом:
```
 #Author DataFlair
getwd ()
библиотека (ggplot2)
библиотека (randomForest)
 
```
    Выход:
    
    Мы будем использовать популярный набор данных для прогнозов выживания титаника и импортируем обучающие и тестовые наборы в наши две соответствующие переменные:
```
 setwd ("/ home / dataflair / Titanic Dataset /") #DataFlair
train_data <- читать.csv ("train.csv", stringsAsFactors = FALSE)
test_data <- read.csv ("test.csv", stringsAsFactors = FALSE)
 
```
    Выход:
    
    Вы не можете позволить себе пропустить руководство по пакету e1071 и обучающим и тестовым моделям SVM в R
    Давайте теперь посмотрим на первые шесть записей нашего импортированного набора данных для обучения и тестирования:
```
> голова (train_data) 
```
    Выход:
```
 голова (test_data)
 
```
    Выход:
    Извлечение элементов - следующий наиболее важный шаг на пути к построению нашей модели.Мы выполняем это в форме функции, называемой Feature_extraction, которая будет извлекать функции из любых входных данных, которые ей предоставляются при каждом вызове.
```
 Feature_extraction <- function (data) {
  метки <- c ("Pclass",
                "Возраст",
                "Секс",
                "Перчин",
                «СибСп», г.
                "Плата за проезд",
                «Встал»)
  особенности <- данные [, метки]
  features $ Age [is.na (features $ Age)] <- -1
  особенности $ Fare [есть.na (функции $ Fare)] <- median (функции $ Fare, na.rm = TRUE)
  особенности $ Embarked [features $ Embarked == ""] = "S"
  особенности $ Sex <- as.factor (особенности $ Sex)
  особенности $ Embarked <- as.factor (функции $ Embarked)
  возврат (особенности)
}
 
```
    Отображение кода:
    Выход:
    Позвольте нам вызвать указанную выше функцию, отобразив сводку извлеченных признаков обучающих и тестовых наборов:
```
> сводка (Feature_extraction (train_data))
> сводка (Feature_extraction (test_data))
 
```
    Выход:
    
    На следующем шаге мы реализуем нашу функцию randomForest () следующим образом:
```
> r_forest <- randomForest (Feature_extraction (train_data), как.factor (train_data $ Survived), ntree = 100, important = TRUE) #Author DataFlair
> r_forest
 
```
    Выход:
    Давайте теперь выделим некоторые из важных функций с помощью следующих строк кода:
```
> important <- important (r_forest, type = 1) #Author DataFlair
> Important_Features <- data.frame (Feature = row.names (important), Importance = important [, 1])
 
```
    Выход:
    
    На последнем этапе мы будем использовать ggplot2 для построения нашего набора важных функций:
```
 #Author DataFlair
plot_ <- ggplot (Important_Features,
    aes (x = reorder (Feature,
Важность), y = Важность)) +
geom_bar (stat = "identity",
        fill = "# 800080") +
corre_flip () +
theme_light (base_size = 20) +
xlab ("") +
ylab ("Важность") +
ggtitle ("Важные особенности случайного леса \ n") +
тема (сюжет.title = element_text (размер = 18))
ggsave ("important_features.png",
      сюжет_)
сюжет_
 
```
    Отображение кода:
    
    Выход:
    Гистограмма:
    
    Резюме
    Мы изучили различные аспекты случайного леса в R. Мы узнали об обучении ансамбля и моделях ансамбля в программировании на R, а также о классификаторе случайного леса и процессе разработки случайного леса в R.
    Теперь пора подключиться к байесовской сети в R
    Есть вопросы относительно случайного леса в R? Войдите в раздел комментариев ниже.
    деревьев случайной лесной регрессии в размере
    рандов
    Случайный лес включает в себя процесс создания нескольких деревьев решений и комбинирования их результатов. Это делается с помощью r, использующего 2/3 набора данных для разработки дерева решений. Это делается десятки, сотни и более раз. Каждое сделанное дерево создается из немного другого образца.Затем результаты всех этих деревьев усредняются вместе. Этот процесс выборки называется загрузочной агрегацией или для краткости упаковкой в пакеты.
    Пока алгоритм случайного леса разрабатывает разные выборки, он также случайным образом выбирает, какие переменные будут использоваться в каждом разрабатываемом дереве. Путем рандомизации выборки и функций, используемых в дереве, случайный лес может уменьшить как смещение, так и дисперсию в модели. Кроме того, случайный лес устойчив к выбросам и коллинеарности.Наконец, имейте в виду, что случайный лес может использоваться для деревьев регрессии и классификации
    В нашем примере мы будем использовать набор данных «Участие» из пакета «Ecdat». Мы создадим случайное дерево регрессии для прогнозирования доходов людей. Ниже приведен исходный код
```
  библиотека (randomForest); библиотека (rpart); библиотека (Ecdat)  
```
```
    данные («Участие»)
ул. (Участие)  
```
```
  ## 'data.frame': 872 obs.из 7 переменных:
## $ lfp: Фактор с 2 уровнями «нет», «да»: 1 2 1 1 1 2 1 2 1 1 ...
## $ lnnlinc: число 10,8 10,5 11 11,1 11,1 ...
## $ age: num 3 4,5 4,6 3,1 4,4 4,2 5,1 3,2 3,9 4,3 ...
## $ education: число 8 8 9 11 12 12 8 8 12 11 ...
## $ nyc: num 1 0 0 2 0 0 0 0 0 0 ...
## $ noc: num 1 1 0 0 2 1 0 2 0 2 ...
## $ foreign: множитель с двумя уровнями «нет», «да»: 1 1 1 1 1 1 1 1 1 1 ...  
```
    Теперь нам нужно подготовить данные. Нам нужно преобразовать lnnlinc из журнала зарплаты в фактическую зарплату.Кроме того, нам нужно умножить «возраст» на десять, поскольку 3,4 и 4,5 не имеют никакого смысла. Ниже код
```
  Участие, $ возраст <-10 * Участие, $ возраст
Участие $ lnnlinc <-exp (Участие $ lnnlinc)  
```
    Теперь мы создаем наши обучающие и тестовые наборы.
```
  набор. Семян (123)
ind = sample (2, nrow (Участие), replace = T, prob = c (.7, .3))
тренировать <-участие [ind == 1,]
тест <-участие [ind == 2,]  
```
    Теперь мы готовы создать нашу модель.Ниже код
```
  набор. Семян (123)
rf.pros <-randomForest (lnnlinc ~., данные = поезд)
рф.прос  
```
```
  ##
## Вызов:
## randomForest (формула = lnnlinc ~., данные = поезд)
## Тип случайного леса: регрессия
## Количество деревьев: 500
## Количество переменных, испробованных в каждом сплите: 2
##
## Среднее квадратов остатков: 529284177
##% Var объяснил: 13,74  
```
    Как вы можете видеть, позвонив в «rf.pros», объясненная дисперсия невысока - около 14%.Вывод также сообщает нам, сколько деревьев было создано. Вы должны быть осторожны, делая слишком много деревьев, так как это приведет к переоснащению. Мы можем определить, сколько деревьев является оптимальным, посмотрев на график, а затем используя which.min. Ниже приведен график количества деревьев по среднеквадратической ошибке.
```
  участок (рф.прос)  
```
    Как видите, чем больше деревьев, тем меньше ошибок до определенного момента. Кажется, хватит и 50 деревьев. Чтобы подтвердить это предположение, мы использовали файл «which.min »функция. Ниже код
```
  which.min (рф.прос $ мсе)  
```
```
  ## [1] 45  
```
    Нам нужно 45 деревьев, чтобы иметь наименьшую ошибку. Теперь мы повторно запустим модель и добавим аргумент под названием «ntrees» для указания количества деревьев, которые мы хотим сгенерировать.
```
  набор. Семян (123)
rf.pros.45 <-randomForest (lnnlinc ~., данные = поезд, ntree = 45)
рф.прос.45  
```
```
  ##
## Вызов:
## randomForest (формула = lnnlinc ~., data = train, ntree = 45)
## Тип случайного леса: регрессия
## Количество деревьев: 45
## Нет.переменных, опробованных в каждом сплите: 2
##
## Среднее квадратов остатков: 520705601
##% Var объяснил: 15,13  
```
    Эта модель еще не велика. Мы объясняем немного больше дисперсии, и ошибка немного уменьшилась. Теперь мы можем увидеть, какие из функций в нашей модели являются наиболее полезными, используя функцию «varImpPlot». Ниже приведен код.
```
  varImpPlot (рф.прос.45)  
```
    Чем выше IncNodePurity, тем важнее переменная.Как видите, важнее всего образование, за которым следует возраст, а затем количество детей постарше. Необработанные оценки для каждой переменной можно проверить с помощью функции «важности». Ниже приведен код.
```
  важность (рф.прос.45)  
```
```
  ## IncNodePurity
## lfp 16678498398
## age 66716765357
## education 72007615063
## nyc 9337131671
## noc 31951386811
## foreign 10205305287  
```
    Теперь мы готовы протестировать нашу модель с тестовым набором.2)
```
  ## [1] 381850711  
```
    Помните, что вычисленная здесь среднеквадратическая ошибка полезна только по сравнению с другими моделями. Случайный лес предоставляет способ устранения слабых мест одного дерева решений путем усреднения результатов многих. Эта форма ансамблевого обучения - один из наиболее мощных алгоритмов машинного обучения.
    Нравится:
    Нравится Загрузка ...
    Связанные
    .
    No related posts.