Этот пост вдохновлен курсом Kevin Markham Введение в машину обучения с Scikit-Learn на школе данных. Если вы начинаете начать работу с машиной, обучения с помощью Scikit-Suart, я бы очень рекомендую этот курс, чтобы получить все необходимые основополагающие навыки.
Всего за несколько часов вы сможете понять и построить базовую регрессию и модели классификации с оптимальными гиперпараметрами.
📌 Если это звучит интересно, пожалуйста, не забудьте проверить курс на Это связь.
Тем не менее, мы охватим следующее в этом посте.
- Как использовать перекрестную проверку для оценки модели обучения машины
- Как использовать перекрестную проверку для поиска лучшего модели HyperParameters
- Как использовать сетку поиска гиперпараметра поиска
- Как искать гиперпараметры более эффективно с использованием рандомизированного поиска
Как использовать перекрестную проверку для оценки модели обучения машины
Как мы подтверждаем модель обучения машины?
При оценке модели обучения машины обучение и тестирование на одном наборе данных не является отличной идеей. Почему? Давайте нарисуем относищуюсяную аналогию.
С учебными днями мы давали экзамены, а как наши экзамены разработаны?
- Ну, они были разработаны так, чтобы проверить наше понимание концепций, а не нашей способности запомнить!
- Та же аналогия может быть перенесена на нашу модель обучения машины, а также!
Вот ответ на вопрос «Почему мы можем не оценить модель на одни и те же данные, на которых она обучена?
Это потому, что этот процесс по своей природе поощряет модель запоминать данные тренировки. Итак, модель выполняет чрезвычайно хорошо на учебных данных.
Тем не менее, это Обобщает довольно плохо к данным, которые он никогда не видел раньше.
Что делает urch_test_split?
В качестве характеристики модели о данных о том, что она никогда не наблюдалась, является более надежной оценкой ее производительности, мы обычно проверяем модель, проверяя, как она выполняет данные о внесении данных, то есть на данных, которые она никогда не видела раньше Отказ
Если вы помните, именно по этой причине мы используем rain_test_split Метод, в нашей очень дружелюбной и нефте библиотеке, Scikit – учиться.
Это rain_test_split Разделяет доступные данные на два набора: поезд и тестовые наборы в определенных пропорциях.
Например, поезд на 70% имеющихся данных и тестируйте оставшиеся 30% данных. Таким образом, мы можем гарантировать, что каждая запись в наборе данных может быть либо в наборе обучения, либо набором теста, но не оба!
И при этом мы уверены, что мы проверим производительность модели на невидимые данные.
Но это достаточно хорошо? Или мы берем это с щепоткой соли?
Давайте тренируем простой KneighborsClassifier В Scikit – узнайте на наборе данных ириса.
▶ Необходимый импорт Как показано ниже, мы импортируем необходимые модули.
from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn import metrics
▶ Загрузите данные Давайте загрузим данные ирис и отделите Особенности (Длина сепый, ширина сепый, лепестка и летальная ширина) и цель Переменные, которые являются классовыми этикетками, указывающими тип Iris. (Setosa, Versicolour, и Вирджина)
# read in the iris data iris = load_iris() # create X (features) and y (response) X = iris.data y = iris.target
▶ Создать urt_test_split. Давайте создадим поезд и тестовые наборы с Random_state = 4 Отказ Установка Random_state обеспечивает воспроизводимость.
В этом случае он гарантирует, что записи, которые попадают в поезд и тестовые наборы, остаются неизменными каждый раз, когда наш код работает.
# use train/test split with different random_state values X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 4)
▶ Проверьте точность классификации Сейчас мы создаем создание KneighborsClassifier с n_neighbors = 9 И установите классификатор на наборе обучения и предсказать на тестовом наборе.
knn = KNeighborsClassifier(n_neighbors=9) knn.fit(X_train, y_train) y_pred = knn.predict(X_test) print(metrics.accuracy_score(y_test, y_pred)) # Output 0.9736842105263158
Теперь, давайте изменим Random_state к другому значению. Как вы думаете, что оценка точности будет?
Ну, пожалуйста, не стесняйтесь вставить свой любимый номер в Random_state и проверьте сами. Это было бы другой точностью на этот раз.
Установка Random_state На другой ценность мы получим еще одно значение для оценки точности.
Полученные таким образом оценки, полученные таким образом, подвержены для Высокая дисперсия Отказ
- Оценка точности может сильно зависеть от того, какие точки данных в конечном итоге в наборе обучения и которые в конечном итоге в тестовом наборе.
- Таким образом, оценка точности может быть значительно отличаться в зависимости от того, как выполняется разделение. Очевидно, что это не похоже на самую лучшую способ проверки производительности нашей модели!
Как мы достиваем консенсуса о том, как рассчитать счет точности?
Одна очень естественная вещь, которую нужно сделать, было бы создание Несколько поездов/тестовые расщепления Рассчитайте точность для каждого такого разделения, и вычисляйте среднее значение всех полученных таким результатом точности. Это определенно похоже на лучшую оценку точности, не так ли?
Это именно сущность кроссвидиции, которую мы увидим в последующем разделе.
Понимание кросс-проверки K-Fold
Шаги в K-Fold Cross-Vailation
- Разделите набор данных в K равные разделы (или «складки»).
- Используйте Fold 1 для тестирования и объединения других складок в качестве учебного набора.
- Рассчитайте точность на набор тестов.
- Повторите шаги 2 и 3 k раз, используя различную складку для тестирования каждый раз.
- Используйте среднюю точность на разных тестовых установках, как оценка точности вне выборки.
Давайте попробуем визуализировать это, расщепляя набор данных из 25 наблюдений на 5 равных складок, как показано ниже.
Набор данных содержит 20 наблюдений (пронумерован 0 по 24). 5-кратная перекрестная проверка работает на 5 итераций.
Давайте посмотрим, как создаются сгибы
# simulate splitting a dataset of 25 observations into 5 folds
from sklearn.model_selection import KFold
kf = KFold(n_splits=5, shuffle = False).split(range(25))
# print the contents of each training and testing set
print('{} {:^61} {}'.format('Iteration', 'Training set observations', 'Testing set observations'))
for iteration, data in enumerate(kf, start=1):
print('{:^9} {} {:^25}'.format(iteration, data[0], str(data[1])))
# Output
Iteration Training set observations Testing set observations
1 [ 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] [0 1 2 3 4]
2 [ 0 1 2 3 4 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] [5 6 7 8 9]
3 [ 0 1 2 3 4 5 6 7 8 9 15 16 17 18 19 20 21 22 23 24] [10 11 12 13 14]
4 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 20 21 22 23 24] [15 16 17 18 19]
5 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19] [20 21 22 23 24]
Мы наблюдаем следующее:
- Для каждой итерации каждое наблюдение либо в учебном наборе, либо набором тестирования, но не обоих.
- Каждое наблюдение находится в тесте, установленном ровно один раз.
- Каждая складка используется в качестве тестового набора ровно один раз и в учебном наборе (K – 1) раз.
- Полученная таким образом средняя точность является более точной оценкой точности выборки.
Этот процесс использует данные более эффективно, поскольку каждое наблюдение используется как для обучения, так и для тестирования.
Рекомендуется использовать Стратифицированная выборка Для создания складок, как это гарантирует, что Все этикетки класса представлены в равные пропорции в каждая складка . И Scikit-Learn’s cross_val_score делает это по умолчанию.
На практике мы можем даже сделать следующее:
- «Держи» часть данных перед началом процесса строительства модели.
- Найдите лучшую модель, используя перекрестную проверку в оставшихся данных и проверьте его с помощью набора HOLD-OUT.
- Это дает более надежную оценку производительности вне пробы, поскольку комплект проживания действительно выходит из образца.
Как использовать перекрестную проверку для поиска лучшего модели HyperParameters
Перекрестная проверка для гиперпараметрической настройки
Для классификатора KNN на DataSet Iris, возможно, мы можем использовать перекрестную проверку, чтобы найти оптимальное значение для K ? То есть искать оптимальное значение n_neighbors ?
Помните, К В KNN Classifier – это количество соседей ( n_neighbors ), которые мы учитываем для прогнозирования классовой этикетки тестового образца. Не путать с К в K-Fold Cross-Vavilation.
from sklearn.model_selection import cross_val_score # 10-fold cross-validation with K=5 for KNN (the n_neighbors parameter) knn = KNeighborsClassifier(n_neighbors=5) scores = cross_val_score(knn, X, y, cv=10, scoring='accuracy') print(scores) # Output [1. 0.93333333 1. 1. 0.86666667 0.93333333 0.93333333 1. 1. 1. ] # use average accuracy as an estimate of out-of-sample accuracy print(scores.mean()) # Output 0.9666666666666668
Теперь мы будем запускать Cross-Vavyation k Fold для моделей с разными значениями n_neighbors , как показано ниже.
# search for an optimal value of K for KNN k_range = list(range(1, 31)) k_scores = [] for k in k_range: knn = KNeighborsClassifier(n_neighbors=k) scores = cross_val_score(knn, X, y, cv=10, scoring='accuracy') k_scores.append(scores.mean()) print(k_scores) # Output k_scores [0.96, 0.9533333333333334, 0.9666666666666666, 0.9666666666666666, 0.9666666666666668, 0.9666666666666668, 0.9666666666666668, 0.9666666666666668, 0.9733333333333334, 0.9666666666666668, 0.9666666666666668, 0.9733333333333334, 0.9800000000000001, 0.9733333333333334, 0.9733333333333334, 0.9733333333333334, 0.9733333333333334, 0.9800000000000001, 0.9733333333333334, 0.9800000000000001, 0.9666666666666666, 0.9666666666666666, 0.9733333333333334, 0.96, 0.9666666666666666, 0.96, 0.9666666666666666, 0.9533333333333334, 0.9533333333333334, 0.9533333333333334]
Позвольте нам построить ценности, чтобы получить лучшую идею.
import matplotlib.pyplot as plt
%matplotlib inline
# plot the value of K for KNN (x-axis) versus the cross-validated accuracy (y-axis)
plt.plot(k_range, k_scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Cross-Validated Accuracy')
Мы видим, что n_neighbors (k) Значения от 13 до 20 выходят более высокую точность, особенно К = 13,18 и 20.as большего значения К дает менее сложной модели, мы выбираем К =20.
Этот процесс поиска оптимальных значений гиперпараметров называется HyperParameter Tuning Отказ
В этом примере мы выбрали значения K Это привело к более высокой средней точности точности при 10-кратном перекрестной проверке.
Это то, как можно использовать перекрестную проверку для поиска лучших гиперпараметров, и это может быть сделано гораздо более эффективно в Scikit – учиться.
В Knn Classifiers установить очень маленькую ценность для К сделает модель ненужной сложной, и очень большая ценность K приведет к модели с высокой смещением, которая дает неоптимальную производительность.
Как К = 13,18 и 20 дали высочайшую оценку точности, недалеко от 0,98, мы решили выбрать К = 20 в качестве большего значения K даст менее сложной модели.
Хотя для цикла нет особо трудно, мы понимаем, что нам придется часто делать это.
Поэтому было бы хорошо иметь более удобный способ выполнения поиска гипепараметра, без необходимости писать цикл каждый раз и идентифицировать лучший параметр через проверку.
Класс поиска сетки в Scikit – учиться помогает нам сделать это все более легко. Давайте узнаем об этом в следующем разделе.
Как использовать сетку поиска гиперпараметра поиска
▶ Импорт GridSearchCV класса
from sklearn.model_selection import GridSearchCV
▶ Определите сетку параметра
Теперь мы определяем Параметр Grid ( param_grid ), Словарь Python, ключ которого является именем гиперпараметра, лучшее значение которого мы пытаемся найти, и значение – это список возможных значений, которые мы хотели бы искать для гиперпараметра.
# define the parameter values that should be searched
k_range = list(range(1, 31))
# create a parameter grid: map the parameter names to the values that should be searched
param_grid = dict(n_neighbors=k_range)
print(param_grid)
# param_grid
{'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]}
Сейчас мы создаем экземпляр Gridsearchcv Отказ Обратите внимание, что указываем param_grid . вместо n_neighbors аргумент, который мы указали на cross_val_score ранее.
Почему это действительно?
Помните, что параметр сетки, param_grid . это словарь, ключ которого является n_neighbors И значение является список возможных значений n_neighbors Отказ Поэтому указывая param_grid . гарантирует, что значение по индексу Я получает ценность n_neighbors В I_th Run.
▶ Золкости, установите сетку и просмотрите результаты
# instantiate the grid grid = GridSearchCV(knn, param_grid, cv=10, scoring='accuracy', return_train_score=False)
Теперь мы идем вперед и соответствую сетке с данными и доступа к CV_RESULTS_ Атрибут, чтобы получить среднюю оценку точности после 10-кратного кросс-проверки, стандартное отклонение и значения параметров.
Для удобства мы можем хранить результаты в DataFrame PandaS. Среднее и стандартное отклонение баллов точности для n_neighbors = 1-10 показан ниже.
# fit the grid with data
grid.fit(X, y)
# view the results as a pandas DataFrame
import pandas as pd
pd.DataFrame(grid.cv_results_)[['mean_test_score', 'std_test_score', 'params']]
# Output
mean_test_score std_test_score params
0 0.960000 0.053333 {'n_neighbors': 1}
1 0.953333 0.052068 {'n_neighbors': 2}
2 0.966667 0.044721 {'n_neighbors': 3}
3 0.966667 0.044721 {'n_neighbors': 4}
4 0.966667 0.044721 {'n_neighbors': 5}
5 0.966667 0.044721 {'n_neighbors': 6}
6 0.966667 0.044721 {'n_neighbors': 7}
7 0.966667 0.044721 {'n_neighbors': 8}
8 0.973333 0.032660 {'n_neighbors': 9}
9 0.966667 0.044721 {'n_neighbors': 10}
При использовании cross_val_score Мы попробовали глазные яблочные баллы точности, чтобы определить лучшие гиперпараметры, и чтобы облегчить, мы нанесели значение HyperParameters против соответствующих поперечных достоверных баллов!
Звучит хорошо, но, похоже, не очень отличный вариант!
Как только мы завершили поиск сетки, следующие атрибуты могут быть очень полезными! Мы можем выбрать изучить: ☑ Best_score_ , Наибольшая перекрестная проверка точности ☑. Best_Params_ , Оптимальное значение для гиперпараметров и ☑ Best_estimator_ , что является Лучшая модель что имеет Лучший гиперпараметр Отказ
Давайте теперь рассмотрим их для нашего примера. ▶ Осмотрите лучший результат и лучшие гиперпараметры
# examine the best model
print(grid.best_score_)
print(grid.best_params_)
print(grid.best_estimator_)
# Output
0.9800000000000001
{'n_neighbors': 13}
KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
metric_params=None, n_jobs=None, n_neighbors=13, p=2,
weights='uniform')
К = 13 был выбран, помните, помните, К = 13 был одним из ценностей К Это дало высочайшую поперечную оценку точности. ✔ Все идет нормально!
Поиск нескольких гиперпараметров
В этом примере единственный гиперпараметр, который мы искали, было n_neighbors Отказ
Что если бы было много таких гиперпараметров? Мы можем подумать, «Почему бы не настроить каждый гиперпараметр самостоятельно?»
Ну, мы можем самостоятельно найти оптимальные значения для каждого из гиперпараметров; Но Модель может работать лучше всего по некоторым значениям параметров, которые сильно отличаются от индивидуальных лучших значений Отказ
Итак, мы должны искать Сочетание параметров что Оптимизирует производительность а не отдельные лучшие параметры.
Давайте построим на тот же пример KnClassifier.
В дополнение к n_neighbors Давайте ищем оптимальную весовую стратегию.
- Опция веса по умолчанию –
«Униформа»где все точки усушены одинаково и«Расстояние»Опция веса указывает на обратное расстояние.
В этом случае ближе соседей из точек запроса будет Большее влияние чем соседи, которые находятся далеко.
▶ Определите сетку параметра
# define the parameter values that should be searched
k_range = list(range(1, 31))
weight_options = ['uniform', 'distance']
# create a parameter grid: map the parameter names to the values that should be searched
param_grid = dict(n_neighbors=k_range, weights=weight_options)
print(param_grid)
# param_grid
{'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
'weights': ['uniform', 'distance']}
Дайте нам создавать и соответствовать результатам сетки и просмотра, как и раньше.
# instantiate and fit the grid
grid = GridSearchCV(knn, param_grid, cv=10, scoring='accuracy', return_train_score=False)
grid.fit(X, y)
# view the results
pd.DataFrame(grid.cv_results_)[['mean_test_score', 'std_test_score', 'params']]
# Results
mean_test_score std_test_score params
0 0.960000 0.053333 {'n_neighbors': 1, 'weights': 'uniform'}
1 0.960000 0.053333 {'n_neighbors': 1, 'weights': 'distance'}
2 0.953333 0.052068 {'n_neighbors': 2, 'weights': 'uniform'}
3 0.960000 0.053333 {'n_neighbors': 2, 'weights': 'distance'}
4 0.966667 0.044721 {'n_neighbors': 3, 'weights': 'uniform'}
5 0.966667 0.044721 {'n_neighbors': 3, 'weights': 'distance'}
6 0.966667 0.044721 {'n_neighbors': 4, 'weights': 'uniform'}
7 0.966667 0.044721 {'n_neighbors': 4, 'weights': 'distance'}
8 0.966667 0.044721 {'n_neighbors': 5, 'weights': 'uniform'}
9 0.966667 0.044721 {'n_neighbors': 5, 'weights': 'distance'}
10 0.966667 0.044721 {'n_neighbors': 6, 'weights': 'uniform'}
11 0.966667 0.044721 {'n_neighbors': 6, 'weights': 'distance'}
12 0.966667 0.044721 {'n_neighbors': 7, 'weights': 'uniform'}
13 0.966667 0.044721 {'n_neighbors': 7, 'weights': 'distance'}
14 0.966667 0.044721 {'n_neighbors': 8, 'weights': 'uniform'}
15 0.966667 0.044721 {'n_neighbors': 8, 'weights': 'distance'}
16 0.973333 0.032660 {'n_neighbors': 9, 'weights': 'uniform'}
17 0.973333 0.032660 {'n_neighbors': 9, 'weights': 'distance'}
18 0.966667 0.044721 {'n_neighbors': 10, 'weights': 'uniform'}
Мы видим, что у нас есть модели. (Как у нас было 30 возможных значений для N_Neighbors и 2 возможных значения для весов) Как мы выбрали 10-кратную перекрестную проверку, появятся предсказывания!
Время посмотреть на лучший балл и параметры нашей модели, которые принесли лучший результат. ▶ Осмотрите лучший результат и лучшие гиперпараметры
# examine the best model
print(grid.best_score_)
print(grid.best_params_)
# best score and best parameters
0.9800000000000001
{'n_neighbors': 13, 'weights': 'uniform'}
Мы получаем тот же самый лучший поперечный показатель точности 0,98, с n_neighbors = 13. а также Вес = «Униформа».
Теперь допустим, мы должны настроить 4 гиперпараметра, и у нас есть список из 10 возможных значений для каждого из гиперпараметров.
Этот процесс создает 000 моделей и когда мы проводим 10-кратную перекрестную проверку , есть 100 000 предсказаний.
Очевидно, что все масштабируются очень быстро и могут вскоре стать вычислительно невыполнимыми.
Как искать гиперпараметры более эффективно с использованием рандомизированного поиска
Теперь мы попытаемся перефразировать ограничения поиска сетки, более официальным образом.
- Скажи, что мы должны искать
Мпараметры; Пустьp_1, p_2, p_3, ..., p_mбытьМПараметры. - Пусть количество значений, которые мы хотели бы искать для
P_1бытьN1, дляP_2бытьN2и так далее, снмЗначения дляP_MОтказ
Поиск сетки считает Все возможные настройки гиперпараметра (комбинации) во внимание и создают модель для каждой возможной настройки, чтобы выбрать лучшую модель с оптимальными гиперпараметрами.
- Чтобы лучше понять, предположим, что из
МПараметры, мы решили заморозить значения всех гиперпараметров, кроме одного, скажем, параметр m_thвечера. Итак, поиск сетки включает поиск через списокнмЗначения для гиперпараметра M_th; Инммодели созданы. - Предположим, мы теперь замораживаем значения всех гиперпараметров, кроме двух, скажем, два последних (
P_MиP_ (M-1)). Теперь мы должны искать все возможные комбинацииP_MиP_ (M-1)каждый имеетнмиn_ (м-1)Возможные значения, которые мы могли бы искать. - Теперь мы сделаем шаг назад и заморозив ценность
P_M-1и искать все значения дляP_M; Для учета всех возможных комбинаций мы должны повторить процедуру для всехn_m-1Значения дляP_M-1Отказ Итак, этот процесс оставил нас сn_ (м-1) * нммодели.
Надеюсь, понятно, как можно взять масштабы сложности с увеличением количества ценностей, может принимать каждый гиперпараметр.
- Для приведенного выше примера с
Мгиперпараметры, у нас бы быN1 * N2 * N3 * ... * N_Mмодели. Вот почему мы сказали, что все могут быстро расширить и стать вычислительно неразрешимыми с поиском сетки.
С этой мотивацией сделать поиск гиперпараметра вычислительно более эффективным, давайте продолжим понять рандомизированные поиски.
Понимание RandomizedSearchCV.
В отличие от Gridsearchcv , не все значения параметров опробоваются в RandomedSearchCV , а скорее фиксированное количество параметров параметров выбирается из указанных распределений/список параметров.
Если некоторые из гиперпараметров, которые мы ищем непрерывны, то мы должны указать распределение, а не список значений, определяя сетку параметров. Как мы определим фиксированное количество настроек параметров?
Количество параметров настроек, которые пробовали, дается n_iter Отказ Существует качество VS вычислительная стоимость компромисса в сборе n_iter Отказ
Очень маленькая стоимость
n_iterПодразумевалось бы, что мы более склонны к тому, чтобы найти неоптимальное решение, потому что мы на самом деле рассматриваем слишком мало комбинаций.Очень высокое значение n_iter будет означать, что мы в идеале можем быть ближе к поиску лучших гиперпараметров, которые дают лучшую модель, но это снова с высокой стоимостью вычислений, как и раньше.
На самом деле, если мы установим
n_iter = n1 * n2 * n3 * ... * n_mИз предыдущего примера мы по сути, мы рассматриваем все возможные комбинации гиперпараметра, а теперь рандомизированные поисковые и сетки поиска эквивалентны.
Давайте построим на одном примере KnClassifier из предыдущего раздела.
Давайте искать оптимальную весовую стратегию и n_neighbors Отказ И теперь, давайте реализуем рандомизированные поиски в Scikit – узнайте и выполняем следующие шаги, поскольку мы сделали для поиска сетки. ▶ Импорт RandomizedSearchCV класса
from sklearn.model_selection import RandomizedSearchCV
▶ Определите сетку параметра
# specify "parameter distributions" rather than a "parameter grid" param_dist = dict(n_neighbors=k_range, weights=weight_options)
▶ Создавать сетку; Установить, установить сетку и вид результаты, достижения
# n_iter controls the number of searches
rand = RandomizedSearchCV(knn, param_dist, cv=10, scoring='accuracy', n_iter=10, random_state=5, return_train_score=False)
rand.fit(X, y)
pd.DataFrame(rand.cv_results_)[['mean_test_score', 'std_test_score', 'params']]
#DataFrame
mean_test_score std_test_score params
0 0.973333 0.032660 {'weights': 'distance', 'n_neighbors': 16}
1 0.966667 0.033333 {'weights': 'uniform', 'n_neighbors': 22}
2 0.980000 0.030551 {'weights': 'uniform', 'n_neighbors': 18}
3 0.966667 0.044721 {'weights': 'uniform', 'n_neighbors': 27}
4 0.953333 0.042687 {'weights': 'uniform', 'n_neighbors': 29}
5 0.973333 0.032660 {'weights': 'distance', 'n_neighbors': 10}
6 0.966667 0.044721 {'weights': 'distance', 'n_neighbors': 22}
7 0.973333 0.044222 {'weights': 'uniform', 'n_neighbors': 14}
8 0.973333 0.044222 {'weights': 'distance', 'n_neighbors': 12}
9 0.973333 0.032660 {'weights': 'uniform', 'n_neighbors': 15}
▶ Осмотрите лучший результат и лучшие гиперпараметры
# examine the best model
print(rand.best_score_)
print(rand.best_params_)
# Output
0.9800000000000001
{'weights': 'uniform', 'n_neighbors': 18}
▶ Параметры лучшей модели
- Удивительно, мы видим, что самая высокая оценка точности, полученная в этом случае, где мы только смотрели на 10 различных параметров настроек вместо 60 в поисках сетки, то же самое, что и раньше: 0,98 ✔
- И значение для
n_neighbors = 18, который также является одним из оптимальных значений, которые мы получили, когда изначально искали оптимальное значениеn_neighborsОтказ
Может быть, нам просто повезло? Какова гарантия, что мы всегда будем получать лучшие результаты? Ах, этот вопрос имеет смысл, не так ли?
Давайте сделаем следующее сейчас: давайте запустим RandomedSearchCV На несколько раз и посмотрим, сколько раз мы действительно заставляем повезло!
➡️run RandomizedSearchCV 20 раз и посмотрите, что происходит; Мы регистрируем Best_score_ для каждого запуска.
# run RandomizedSearchCV 20 times (with n_iter=10) and record the best score best_scores = [] for _ in range(20): rand = RandomizedSearchCV(knn, param_dist, cv=10, scoring='accuracy', n_iter=10, return_train_score=False) rand.fit(X, y) best_scores.append(round(rand.best_score_, 3)) Let us examine all the 20 best scores now. print(best_scores) # Output: Best Scores [0.973, 0.98, 0.98, 0.98, 0.973, 0.98, 0.98, 0.973, 0.98, 0.973, 0.973, 0.98, 0.98, 0.98, 0.98, 0.973, 0.98, 0.98, 0.98, 0.973]
После изучения лучших результатов выше для всех 20 прогонов мы видим, что мы получаем лучшую оценку точности 0,98 примерно в 13 раз.
Похоже, нам действительно повезло! Как насчет других 7 раз, когда мы не совсем получили лучшую оценку точности? Эти оценки точности составляют около 0,973, что довольно близко к 0,98.
Это наблюдение убеждает нас, что даже несмотря на рандомизированные поиски не всегда дают гиперпарамутерам наилучшей модели выполнения, модели, полученные с помощью этих гиперпараметров Не выполняйте намного хуже по сравнению с лучшей моделью Получено из поиска сетки.
Это означает, что полученные таким образом лучшие модели с гиперпараметрами из рандомизированного поиска явно очень близки к оптимальной модели.
По сути, эти не может быть лучшими гиперпараметрами , но, безусловно, близко к лучшим гиперпарамутерам, за исключением того, что они находятся в условиях ограниченных ресурсов настроек.
Надеюсь, вы все поняли, как мы могли бы использовать рандомизированные поиск настраивания гиперпараметра.
Надеюсь, вам все наслаждались читать этот пост. 😀
Счастливое обучение! До скорого! ✨
использованная литература
[1] https://courses.dataschool.io/courses/introduction-To-machine-learning-with-scikit- learn [2] http://scikitlearn.org/stable/modules/cross_validation.html [3] http://scikitlearn.org/stable/modules/generated/sklearn.model_selection.gridsearchcv.html [4] http://scikitlearn.org/stable/modules/generated/sklearn.model_selection.randomizedsearchcv.html.
Обложка Изображение: Фото Росс Sneddon на Бессмысленно
Примечание : Этот пост является всеобъемлющим сообщением для понимания оценки модели и поиска гиперпараметра. Это скомпилированная и улучшена версия нескольких моих более коротких постов.
Оригинал: “https://dev.to/balapriya/cross-validation-and-hyperparameter-search-in-scikit-learn-a-complete-guide-5ed8”