Дерево решений для углубленного обучения (2)

машинное обучение

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

Деревья решений в задачах регрессии

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

вn- количество образцов в листе,Yiявляется значением целевой переменной. Вкратце, минимизируя дисперсию вокруг среднего, мы ищем признаки, которые делят обучающую выборку таким образом, что значение целевого признака в каждом листе примерно равно.

пример

Давайте сгенерируем некоторые данные, назначенные функцией, с некоторым шумом.

Затем мы обучим на нем дерево и отобразим прогнозы, которые оно делает.

n_train = 150        
n_test = 1000       
noise = 0.1
def f(x):
    x = x.ravel()
    return np.exp(-x ** 2) + 1.5 * np.exp(-(x - 2) ** 2)
def generate(n_samples, noise):
    X = np.random.rand(n_samples) * 10 - 5
    X = np.sort(X).ravel()
    y = np.exp(-X ** 2) + 1.5 * np.exp(-(X - 2) ** 2) + \
    np.random.normal(0.0, noise, n_samples)
    X = X.reshape((n_samples, 1))
    return X, y
X_train, y_train = generate(n_samples=n_train, noise=noise)
X_test, y_test = generate(n_samples=n_test, noise=noise)
from sklearn.tree import DecisionTreeRegressor
reg_tree = DecisionTreeRegressor(max_depth=5, random_state=17)
reg_tree.fit(X_train, y_train)
reg_tree_pred = reg_tree.predict(X_test)
plt.figure(figsize=(10, 6))
plt.plot(X_test, f(X_test), "b")
plt.scatter(X_train, y_train, c="b", s=20)
plt.plot(X_test, reg_tree_pred, "g", lw=2)
plt.xlim([-5, 5])
plt.title("Decision tree regressor, MSE = %.2f" % np.sum((y_test - reg_tree_pred) ** 2))
plt.show()

Мы видим, что деревья решений аппроксимируют данные кусочно-постоянными функциями.

3. Метод ближайшего соседа

метод ближайшего соседа(k-ближайшие соседи, или k-NN) — еще один очень популярный метод классификации, который также иногда используется для задач регрессии. Как и деревья решений, это один из самых простых для понимания методов классификации. Лежащая в основе интуиция состоит в том, что вы похожи на своего соседа. Более формально метод следует предположению о компактности: похожие примеры с большей вероятностью принадлежат к одному и тому же классу, если расстояние между примерами измерено достаточно хорошо.

Согласно методу ближайшего соседа зеленый шар будет классифицироваться как «синий», а не как «красный».

В качестве другого примера, если вы не знаете, как пометить наушники bluetooth в онлайн-листинге, вы можете найти 5 похожих наушников, если 4 из них отмечены как «Аксессуары» и только 1 отмечены как «Технологии», тогда вы это также будет отмечен в разделе «Аксессуары».

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

  1. Рассчитайте расстояние для каждого образца в обучающем наборе.
  2. Выбрать из тренировочного наборакобразец с наименьшим расстоянием.
  3. Классы тестовых образцов будут такимикСамая распространенная категория в ближайших соседях.

Метод очень легко адаптировать к задачам регрессии: на шаге 3 вместо возврата класса он возвращает число — среднее (или медиану) целевой переменной между соседями.

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

Метод ближайшего соседа хорошо изучен. Есть много важных теорем, утверждающих, что это лучший метод классификации «бесконечного» набора данных. Авторы классической книги «Элементы статистического обучения» считают k-NN теоретически идеальным алгоритмом, использование которого ограничено только вычислительной мощностью ипроклятие размерностипредел.

Методы ближайших соседей в реальных приложениях

  • В некоторых случаях k-NN может быть хорошей отправной точкой (базовой линией);
  • В соревнованиях Kaggle k-NN часто используется для создания мета-функций (т. е. прогнозов k-NN в качестве входных данных для других моделей) или для суммирования/смешивания;
  • Подход ближайшего соседа распространяется и на другие задачи, такие как рекомендательные системы. Первоначальное решение может быть в человеке, которого мы хотим посоветоватьближайший соседРекомендации популярных товаров (или услуг);
  • На практике на больших наборах данных часто используются методы приближенного поиска ближайших соседей. Есть много библиотек с открытым исходным кодом, которые реализуют такие алгоритмы, взгляните на библиотеку Spotify.Annoy.

Качество классификации/регрессии с использованием k-NN зависит от нескольких параметров:

  • количество соседейk.
  • Мера расстояния между образцами (обычными являются расстояния Хэмминга, Евклида, косинуса и расстояния Минковского). Обратите внимание, что для большинства этих показателей требуется масштабирование данных. Проще говоря, мы не хотим, чтобы функция «зарплата» (в тысячах) влияла на расстояние больше, чем «возраст», который обычно меньше 100.
  • Вес соседей (каждый сосед может вносить свой вклад, например, чем дальше выборка, тем меньше вес).

Класс KNeighborsClassifier в Scikit Learn

Основные параметры классаsklearn.neighbors.KNeighborsClassifierДа:

  • Веса:(uniformвсе веса равны)distance(вес обратно пропорционален расстоянию до испытуемого образца) или любая другая определяемая пользователем функция;
  • Алгоритм (необязательно):brute,ball_tree,KD_treeилиauto. В первом случае ближайшие соседи для каждого теста вычисляются с помощью поиска по сетке на обучающем наборе. Во втором и третьем случаях расстояния между примерами сохраняются в дереве для ускорения поиска ближайших соседей. Если этот параметр установлен вauto, правильный метод поиска соседей будет выбран автоматически на основе обучающей выборки.
  • leaf_size (необязательный): порог переключения на поиск по сетке, если алгоритм поиска соседей BallTree или KDTree;
  • показатель:minkowski,manhattan,euclidean,chebyshevили другие.

4. Выберите параметры модели и перекрестную проверку

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

Обычно это делается одним из двух способов:

  • Отложите часть набора данных (удерживать / удерживать набор). Мы сохраняем небольшую часть обучающего набора (обычно от 20% до 40%), обучаем модель на оставшихся данных (60-80% исходного набора) и вычисляем показатели производительности (например, точность) для модели. набор.
  • Перекрестная проверка. Самый распространенный случай здесьk-кратная перекрестная проверка.

При k-кратной перекрестной проверке модель отличается от исходного набора данных (K-1) обученный на подмножествахK(белый) и проверьте оставшиеся подмножества (каждый раз другое подмножество, обозначенное оранжевым цветом, как показано выше). мы получилиKОценка качества модели, как правило, подразумевает получение общего среднего качества классификации/регрессии.

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

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

5. Примеры применения и сложные случаи

Дерево решений и метод ближайших соседей в задаче прогнозирования оттока клиентов

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

df = pd.read_csv('../../data/telecom_churn.csv')
df['International plan'] = pd.factorize(df['International plan'])[0]
df['Voice mail plan'] = pd.factorize(df['Voice mail plan'])[0]
df['Churn'] = df['Churn'].astype('int')
states = df['State']
y = df['Churn']
df.drop(['State', 'Churn'], axis=1, inplace=True)

Давайте тренироваться (X_train,y_train) выделяет 70% набора, для зарезервированного набора (X_holdout,y_holdout) выделить 30%. Удерживающее устройство не участвует в настройке параметров модели. Мы воспользуемся им после завершения настройки, чтобы оценить качество финальной модели. Обучим 2 модели: дерево решений и k-NN. Мы не знаем, какие параметры хороши, поэтому примем случайные параметры: глубину дерева 5 и количество ближайших соседей 10.

from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
X_train, X_holdout, y_train, y_holdout = train_test_split(df.values, y, 
                                                          test_size=0.3, random_state=17)
tree = DecisionTreeClassifier(max_depth=5, random_state=17)
knn = KNeighborsClassifier(n_neighbors=10)
tree.fit(X_train, y_train)
knn.fit(X_train, y_train)

Давайте оценим прогностическое качество набора задержек простой метрикой — долей правильных ответов (точность). Деревья решений работают лучше — процент правильных ответов составляет около 94% (дерево решений) против 88% (k-NN). Обратите внимание, что эта производительность достигается за счет использования случайных параметров.

from sklearn.metrics import accuracy_score
tree_pred = tree.predict(X_holdout)
print(accuracy_score(y_holdout, tree_pred)) # 0.94
knn_pred = knn.predict(X_holdout)
print(accuracy_score(y_holdout, knn_pred)) # 0.88

Теперь воспользуемся перекрестной проверкой для определения параметров дерева. Мы будем регулировать максимальную глубину и максимальное количество функций, используемых в каждом разделении. Вот суть того, как работает GridSearchCV: для каждой уникальной пары значенийmax_depthиmax_featuresПроизводительность модели рассчитывалась с использованием 5-кратной перекрестной проверки, а затем выбиралась наилучшая комбинация параметров.

from sklearn.model_selection import GridSearchCV, cross_val_score

tree_params = {'max_depth': range(1,11),
               'max_features': range(4,19)}

tree_grid = GridSearchCV(tree, tree_params,
cv=5, n_jobs=-1,
verbose=True)

tree_grid.fit(X_train, y_train)

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

print(tree_grid.best_params_) # {'max_depth': 6, 'max_features': 17}
print(tree_grid.best_score_) # 0.942
print(accuracy_score(y_holdout, tree_grid.predict(X_holdout))) # 0.946

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

dot_data = StringIO()
export_graphviz(tree_grid.best_estimator_, feature_names=df.columns, 
                out_file=dot_data, filled=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
Image(value=graph.create_png())

Теперь настроим соседей k-NNkколичество:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
knn_pipe = Pipeline([('scaler', StandardScaler()), 
                     ('knn', KNeighborsClassifier(n_jobs=-1))])
knn_params = {'knn__n_neighbors': range(1, 10)}
knn_grid = GridSearchCV(knn_pipe, knn_params,
                        cv=5, n_jobs=-1, verbose=True)
knn_grid.fit(X_train, y_train)
print(knn_grid.best_params_, knn_grid.best_score_)
# ({'knn__n_neighbors': 7}, 0.886)

Здесь дерево оказалось лучше алгоритма ближайшего соседа: точность 94,2%/94,6% для перекрестной проверки и удержания соответственно. Деревья решений работают очень хорошо, даже случайные леса (сейчас давайте подумаем о них как о группе деревьев, которые лучше работают вместе) в этом примере, несмотря на то, что обучение занимает больше времени, не могут достичь лучшей производительности (95,1% / 95,3%).

from sklearn.ensemble import RandomForestClassifier

forest = RandomForestClassifier(n_estimators=100, n_jobs=-1, 
                                random_state=17)
print(np.mean(cross_val_score(forest, X_train, y_train, cv=5))) # 0.949

forest_params = {'max_depth': range(1, 11), 'max_features': range(4, 19)}

forest_grid = GridSearchCV(forest, forest_params,
                           cv=5, n_jobs=-1, verbose=True)

forest_grid.fit(X_train, y_train)

print(forest_grid.best_params_, forest_grid.best_score_) 
# ({'max_depth': 9, 'max_features': 6}, 0.951)

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

Чтобы продолжить обсуждение плюсов и минусов родственных методов, давайте рассмотрим простую задачу классификации, в которой дерево работает хорошо, но слишком сложно. Создадим набор точек (2 объекта) на плоскости, каждая точка будет одного из двух классов (+1 для красного, -1 для желтого). Если вы думаете об этом как о проблеме классификации, она выглядит довольно просто: классы разделены линией.

def form_linearly_separable_data(n=500, x1_min=0, x1_max=30, 
                                 x2_min=0, x2_max=30):
    data, target = [], []
    for i in range(n):
        x1 = np.random.randint(x1_min, x1_max)
        x2 = np.random.randint(x2_min, x2_max)
        if np.abs(x1 - x2) > 0.5:
            data.append([x1, x2])
            target.append(np.sign(x1 - x2))
    return np.array(data), np.array(target)

X, y = form_linearly_separable_data()

plt.scatter(X[:, 0], X[:, 1], c=y, cmap='autumn', edgecolors='black');

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

tree = DecisionTreeClassifier(random_state=17).fit(X, y)
xx, yy = get_grid(X)
predicted = tree.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
plt.pcolormesh(xx, yy, predicted, cmap='autumn')
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, 
cmap='autumn', edgecolors='black', linewidth=1.5)
plt.title('Easy task. Decision tree complexifies everything');

Хотя решение - это просто прямая линияx1 = x2, но мы получаем эту чрезмерно сложную структуру.

dot_data = StringIO()
export_graphviz(tree, feature_names=['x1', 'x2'], 
                out_file=dot_data, filled=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
Image(value=graph.create_png())

Метод ближайшего соседа хуже, чем дерево, но все же не так хорош, как линейный классификатор (нашследующая тема).

knn = KNeighborsClassifier(n_neighbors=1).fit(X, y)
xx, yy = get_grid(X)
predicted = knn.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
plt.pcolormesh(xx, yy, predicted, cmap='autumn')
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, 
cmap='autumn', edgecolors='black', linewidth=1.5);
plt.title('Easy task, kNN. Not bad');

Деревья решений и k-NN в задаче распознавания рукописных цифр MNIST

Теперь давайте посмотрим, как эти два алгоритма выполняют задачи в реальном мире. мы будемsklearnИспользуйте встроенные наборы данных для рукописных цифр. Эта задача является примером того, где k-NN работает очень хорошо.

Картинка здесь представляет собой матрицу 8x8 (интенсивность белого для каждого пикселя). Каждая такая матрица затем «разворачивается» в вектор длиной 64, и мы получаем характеристику объекта.

Давайте нарисуем несколько рукописных цифр. Мы видим, что они различимы.

from sklearn.datasets import load_digits
data = load_digits()
X, y = data.data, data.target
f, axes = plt.subplots(1, 4, sharey=True, figsize=(16, 6)) 
for i in range(4): 
    axes[i].imshow(X[i,:].reshape([8,8]), cmap='Greys');

Далее проведем тот же эксперимент, что и в предыдущей задаче, но на этот раз изменим диапазон настраиваемых параметров.

Выберем для обучения 70% набора данных (X_train,y_train) и 30% на обучение (X_holdout,y_holdout). Набор задержек не участвует в настройке параметров модели, мы будем использовать его в конце для проверки качества полученной модели.

X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.3,
                                                          random_state=17)

Давайте обучим дерево решений и k-NN со случайными параметрами и сделаем прогнозы на нашем наборе задержек. Мы видим, что k-NN работает лучше, но учтите, что это случайный параметр.

tree = DecisionTreeClassifier(max_depth=5, random_state=17)
knn = KNeighborsClassifier(n_neighbors=10)
tree.fit(X_train, y_train)
knn.fit(X_train, y_train)
tree_pred = tree.predict(X_holdout)
knn_pred = knn.predict(X_holdout)
print(accuracy_score(y_holdout, knn_pred), 
      accuracy_score(y_holdout, tree_pred)) 
# (0.97, 0.666)

Теперь давайте используем перекрестную проверку для настройки параметров нашей модели, как и раньше, но теперь мы учтем, что у нас больше возможностей, чем в предыдущей задаче: 64.

tree_params = {'max_depth': [1, 2, 3, 5, 10, 20, 25, 30, 40, 50, 64],
               'max_features': [1, 2, 3, 5, 10, 20 ,30, 50, 64]}
tree_grid = GridSearchCV(tree, tree_params, cv=5, n_jobs=-1,
                         verbose=True)
tree_grid.fit(X_train, y_train)

Давайте посмотрим на лучшую комбинацию параметров и соответствующую точность для перекрестной проверки:

print(tree_grid.best_params_, tree_grid.best_score_) 
# ({'max_depth': 20, 'max_features': 64}, 0.844)

Это более 66%, но не 97%. k-NN лучше работает с этим набором данных. В случае с одним ближайшим соседом мы смогли достичь 99% предположений при перекрестной проверке.

print(np.mean(cross_val_score(KNeighborsClassifier(n_neighbors=1), 
                              X_train, y_train, cv=5))) # 0.987

Давайте обучим случайный лес на том же наборе данных, он превосходит k-NN на большинстве наборов данных. Но здесь у нас есть исключение.

print(np.mean(cross_val_score(RandomForestClassifier(random_state=17), 
                              X_train, y_train, cv=5))) # 0.935

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

CV и Holdout — это средние доли правильных ответов в выборке проверки модели и выборке удержания. DT обозначает дерево решений, k-NN обозначает k ближайших соседей, RF обозначает случайный лес.

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

Сложный случай ближайшего соседа

Рассмотрим еще один простой пример. В задаче классификации один из признаков будет пропорционален вектору отклика, но это не помогает с методами ближайшего соседа.

def form_noisy_data(n_obj=1000, n_feat=100, random_seed=17):
    np.seed = random_seed
    y = np.random.choice([-1, 1], size=n_obj)

    # first feature is proportional to target
    x1 = 0.3 * y

    # other features are noise

    x_other = np.random.random(size=[n_obj, n_feat - 1])

    return np.hstack([x1.reshape([n_obj, 1]), x_other]), y

X, y = form_noisy_data()

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

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

X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.3,
random_state=17)
from sklearn.model_selection import cross_val_score
cv_scores, holdout_scores = [], []
n_neighb = [1, 2, 3, 5] + list(range(50, 550, 50))
for k in n_neighb:
    knn = KNeighborsClassifier(n_neighbors=k)
    cv_scores.append(np.mean(cross_val_score(knn, X_train, y_train, cv=5)))
    knn.fit(X_train, y_train)
    holdout_scores.append(accuracy_score(y_holdout, knn.predict(X_holdout)))
plt.plot(n_neighb, cv_scores, label='CV')
plt.plot(n_neighb, holdout_scores, label='holdout')
plt.title('Easy task. kNN fails')
plt.legend();

И наоборот, деревья решений легко «обнаруживают» скрытые зависимости в данных, несмотря на ограничение максимальной глубины.

tree = DecisionTreeClassifier(random_state=17, max_depth=1)
tree_cv_score = np.mean(cross_val_score(tree, X_train, y_train, cv=5))
tree.fit(X_train, y_train)
tree_holdout_score = accuracy_score(y_holdout, tree.predict(X_holdout))
print(‘Decision tree. CV: {}, holdout: {}’.format(tree_cv_score, 
                                                  tree_holdout_score)) 
# Decision tree. CV: 1.0, holdout: 1.0

Во втором примере дерево решило задачу полностью, а k-NN столкнулась с трудностями. Однако это менее полезно для метода, чем использование евклидова расстояния. Это не позволяет нам выявить, что одна функция намного лучше, чем другие.

6. Преимущества и недостатки дерева решений и метода ближайшего соседа

Плюсы и минусы деревьев решений

преимущество:

  • Создавайте явные, понятные человеку правила классификации, такие как «Если возраст
  • Деревья решений можно легко визуализировать, т.е. «объяснить» как саму модель (дерево), так и предсказания некоторого тестового объекта (путь в дереве).
  • Быстрое обучение и предсказание.
  • Несколько параметров модели.
  • Поддерживаются числовые и категориальные функции.

недостаток:

  • Деревья очень чувствительны к шуму во входных данных, если немного изменить обучающую выборку, может измениться вся модель (например, удалить один признак, добавить несколько объектов). Это ставит под угрозу интерпретируемость модели.
  • Граница разделения, построенная деревьями решений, имеет свои ограничения — она состоит из гиперплоскости, перпендикулярной одной из осей, и на практике ее качество ниже, чем у некоторых других методов.
  • Нам нужно настроить, чтобы избежать переобучения, установив минимальное количество выборок в каждом листе или определив максимальную глубину для дерева. Обратите внимание, что переобучение является проблемой для всех методов машинного обучения.
  • нестабильный. Небольшие изменения в данных могут кардинально изменить деревья решений. Ансамбль деревьев решений решает эту проблему (обсуждается далее).
  • Задача поиска оптимального дерева решений является NP-полной. На практике используются некоторые эвристики, такие как жадный поиск признаков с максимальным приростом информации, но не гарантируется нахождение глобально оптимального дерева.
  • Сложность поддержки пропущенных значений в данных. По оценке Фридмана, около 50% кода используется для поддержки пробелов в данных в CART (была реализована улучшенная версия алгоритма).sklearn).
  • Модель может только интерполировать, но не экстраполировать (то же самое касается случайных лесов и бустинга деревьев). То есть дерево решений делает постоянные прогнозы для объектов, которые лежат за пределами ограничивающей рамки, установленной обучающим набором в пространстве признаков. В нашем примере с желтыми и синими шарами это означает, что модель дает одинаковый прогноз для всех шаров с позициями > 19 или

Плюсы и минусы метода ближайшего соседа

преимущество:

  • Простая реализация.
  • Легко учить.
  • В общем, этот метод является не только хорошим первым решением для классификации или регрессии, но и рекомендацией.
  • Его можно адаптировать к проблеме, выбрав правильную метрику или ядро ​​(короче говоря, ядро ​​может установить операцию подобия для сложных объектов, таких как графы, сохраняя при этом подход k-NN). Кстати,Alexander Dyakonov, бывший топ-1 kaggler, любит простейший k-NN, но имеет меру подобия скорректированного объекта.
  • хорошая интерпретируемость. Есть исключения: если количество соседей велико, интерпретируемость ухудшается («Мы не дали ему кредит, потому что у него было 350 таких же клиентов, 70 из которых были плохими, что на 12% выше, чем в среднем по набору данных»).

недостаток:

  • Считается быстрым подходом по сравнению с комбинацией алгоритмов, но в реальной жизни количество соседей, используемых для классификации, обычно велико (100-150), и в этом случае алгоритм не будет работать так же быстро, как дерево решений.
  • Если в наборе данных много переменных, может быть сложно найти правильные веса и определить, какие признаки не важны для классификации/регрессии.
  • Зависит от выбранной метрики расстояния между объектами. Выбор по умолчанию евклидова расстояния, как правило, необоснован. Вы можете найти хорошее решение с параметрами поиска по сетке, но это требует много времени при работе с большими наборами данных.
  • Нет теоретического способа выбрать количество соседей — только поиск по сетке (хотя это справедливо для всех гиперпараметров всех моделей). В случае нескольких соседей метод чувствителен к выбросам, т. е. склонен к переобучению.
  • Обычно это плохо работает, когда много функций из-за "проклятия размерности". Профессор Педро Домингос, известный член сообщества машинного обучения, рассказывает об этом в своей популярной статье «Несколько полезных вещей в машинном обучении».маленький; существуетэта глава«Проклятие размерности» также описано в книге «Глубокое обучение».

Информации много, но, надеюсь, эта статья будет вам полезна на долгое время :)

Нажмите на оригинальную английскую ссылку

Для получения дополнительных статей, пожалуйста, посетите: www.apexyun.com

Общедоступный номер: Galaxy № 1

Контактный адрес электронной почты: public@space-explore.com

(Пожалуйста, не перепечатывайте без разрешения)

WeChat сканирует и следит за публичной учетной записью


Категории