Как вручную оптимизировать гиперпараметры модели машинного обучения

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

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

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

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

---

Оптимизация гиперпараметров вручную

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

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

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

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

• Случайный поиск. Определите пространство поиска как ограниченную область значений гиперпараметров и произвольно выбирайте точки в этой области.

• Поиск по сетке. Определите пространство поиска как сетку значений гиперпараметров и оцените каждую позицию в сетке.

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

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

Оптимизация гиперпараметров с помощью случайного поиска и поиска по сетке

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

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

Оптимизация гиперпараметров перцептрона

Алгоритм перцептрона — простейший тип искусственной нейронной сети.

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

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

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

Мы можем использовать функцию make_classification() для определения задачи двоичной классификации с 1000 строками и пятью входными переменными.

В приведённом ниже примере создаётся набор данных и определяется форма данных.

# define a binary classification dataset from sklearn.datasets import make_classification # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # summarize the shape of the dataset print(X.shape, y.shape)

При выполнении примера выводится форма созданного набора данных, что подтверждает наши ожидания.

(1000, 5) (1000,)

Scikit-learn предоставляет реализацию модели персептрона через класс Perceptron.

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

Мы будем оценивать модель, используя передовой опыт многократной стратифицированной k-кратной перекрестной проверки с помощью класса RepeatedStratifiedKFold.

Полный пример оценки модели персептрона с гиперпараметрами по умолчанию в нашем наборе данных синтетической двоичной классификации приведён ниже.

# perceptron default hyperparameters for binary classification from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from sklearn.linear_model import Perceptron # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # define model model = Perceptron() # define evaluation procedure cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) # evaluate model scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) # report result print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

Запуск примеров позволяет оценить модель и сообщить среднее значение и стандартное отклонение точности классификации.

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

В этом случае мы видим, что модель с гиперпараметрами по умолчанию достигла точности классификации около 78,5 %.

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

Mean Accuracy: 0.786 (0.069)

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

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

• скорость обучения (eta0);

• регуляризация (alpha).

Скорость обучения контролирует количество обновлений модели на основе ошибок прогнозирования и контролирует скорость обучения. Значение по умолчанию для eta — 1,0. Разумные значения — больше нуля (например, больше 1e-8 или 1e-10) и, вероятно, меньше 1,0.

По умолчанию Perceptron не использует регуляризацию, но мы включим регуляризацию «elastic net», которая применяет регуляризацию L1 и L2 во время обучения. Это будет стимулировать модель искать небольшие веса модели и, в свою очередь, даст более высокую производительность.

Мы настроим гиперпараметр “альфа”, который контролирует вес регуляризации, например степень её влияния на обучение. Если установлено значение 0,0, то это означает, что регуляризация не используется. Разумные значения находятся между 0,0 и 1,0.

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

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

# objective function def objective(X, y, cfg): 	# unpack config 	eta, alpha = cfg 	# define model 	model = Perceptron(penalty='elasticnet', alpha=alpha, eta0=eta) 	# define evaluation procedure 	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) 	# evaluate model 	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 	# calculate mean accuracy 	result = mean(scores) 	return result

Далее нам нужна функция, которая сделает шаг в области поиска.

Область поиска определяется двумя переменными (eta и alpha). Шаг в области поиска должен иметь какое-то отношение к предыдущим значениям и должен быть привязан к разумным значениям (например, между 0 и 1).

Мы будем использовать гиперпараметр «step size», который контролирует, насколько далеко алгоритму разрешено отойти от существующей конфигурации. Новая конфигурация будет выбрана вероятностно с использованием гауссова распределения с текущим значением в качестве среднего значения распределения и размером шага в качестве стандартного отклонения распределения.

Мы можем использовать функцию NumPy randn() для генерации случайных чисел с распределением Гаусса.

Приведённая ниже функция step() реализует это и делает шаг в области поиска и генерирует новую конфигурацию, используя существующую конфигурацию.

# take a step in the search space def step(cfg, step_size): 	# unpack the configuration 	eta, alpha = cfg 	# step eta 	new_eta = eta + randn() * step_size 	# check the bounds of eta 	if new_eta <= 0.0: 		new_eta = 1e-8 	# step alpha 	new_alpha = alpha + randn() * step_size 	# check the bounds of alpha 	if new_alpha < 0.0: 		new_alpha = 0.0 	# return the new configuration 	return [new_eta, new_alpha]

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

Поиск сначала генерирует случайное начальное решение, в данном случае со значениями eta и alpha в диапазоне от 0 до 1. Начальное решение затем оценивается и принимается как текущее наилучшее рабочее решение.

... # starting point for the search solution = [rand(), rand()] # evaluate the initial point solution_eval = objective(X, y, solution)

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

... # take a step candidate = step(solution, step_size) # evaluate candidate point candidate_eval = objective(X, y, candidate)

Если новое решение лучше текущего рабочего решения, оно принимается как новое текущее рабочее решение.

... # check if we should keep the new point if candidate_eval >= solution_eval: 	# store the new point 	solution, solution_eval = candidate, candidate_eval 	# report progress 	print('>%d, cfg=%s %.5f' % (i, solution, solution_eval))

В конце поиска возвращаются лучшее решение и его производительность.

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

# hill climbing local search algorithm def hillclimbing(X, y, objective, n_iter, step_size): 	# starting point for the search 	solution = [rand(), rand()] 	# evaluate the initial point 	solution_eval = objective(X, y, solution) 	# run the hill climb 	for i in range(n_iter): 		# take a step 		candidate = step(solution, step_size) 		# evaluate candidate point 		candidate_eval = objective(X, y, candidate) 		# check if we should keep the new point 		if candidate_eval >= solution_eval: 			# store the new point 			solution, solution_eval = candidate, candidate_eval 			# report progress 			print('>%d, cfg=%s %.5f' % (i, solution, solution_eval)) 	return [solution, solution_eval]

Затем мы можем вызвать алгоритм и сообщить о результатах поиска.

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

... # define the total iterations n_iter = 100 # step size in the search space step_size = 0.1 # perform the hill climbing search cfg, score = hillclimbing(X, y, objective, n_iter, step_size) print('Done!') print('cfg=%s: Mean Accuracy: %f' % (cfg, score))

Ниже приведён полный пример ручной настройки алгоритма персептрона.

# manually search perceptron hyperparameters for binary classification from numpy import mean from numpy.random import randn from numpy.random import rand from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from sklearn.linear_model import Perceptron  # objective function def objective(X, y, cfg): 	# unpack config 	eta, alpha = cfg 	# define model 	model = Perceptron(penalty='elasticnet', alpha=alpha, eta0=eta) 	# define evaluation procedure 	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) 	# evaluate model 	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 	# calculate mean accuracy 	result = mean(scores) 	return result  # take a step in the search space def step(cfg, step_size): 	# unpack the configuration 	eta, alpha = cfg 	# step eta 	new_eta = eta + randn() * step_size 	# check the bounds of eta 	if new_eta <= 0.0: 		new_eta = 1e-8 	# step alpha 	new_alpha = alpha + randn() * step_size 	# check the bounds of alpha 	if new_alpha < 0.0: 		new_alpha = 0.0 	# return the new configuration 	return [new_eta, new_alpha]  # hill climbing local search algorithm def hillclimbing(X, y, objective, n_iter, step_size): 	# starting point for the search 	solution = [rand(), rand()] 	# evaluate the initial point 	solution_eval = objective(X, y, solution) 	# run the hill climb 	for i in range(n_iter): 		# take a step 		candidate = step(solution, step_size) 		# evaluate candidate point 		candidate_eval = objective(X, y, candidate) 		# check if we should keep the new point 		if candidate_eval >= solution_eval: 			# store the new point 			solution, solution_eval = candidate, candidate_eval 			# report progress 			print('>%d, cfg=%s %.5f' % (i, solution, solution_eval)) 	return [solution, solution_eval]  # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # define the total iterations n_iter = 100 # step size in the search space step_size = 0.1 # perform the hill climbing search cfg, score = hillclimbing(X, y, objective, n_iter, step_size) print('Done!') print('cfg=%s: Mean Accuracy: %f' % (cfg, score))

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

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

В этом случае мы видим, что лучший результат связан с использованием скорости обучения немного выше 1 при 1,004 и веса регуляризации около 0,002, что обеспечивает среднюю точность около 79,1 %, что лучше, чем конфигурация по умолчанию, которая достигла точности около 78,5 %.

>0, cfg=[0.5827274503894747, 0.260872709578015] 0.70533 >4, cfg=[0.5449820307807399, 0.3017271170801444] 0.70567 >6, cfg=[0.6286475606495414, 0.17499090243915086] 0.71933 >7, cfg=[0.5956196828965779, 0.0] 0.78633 >8, cfg=[0.5878361167354715, 0.0] 0.78633 >10, cfg=[0.6353507984485595, 0.0] 0.78633 >13, cfg=[0.5690530537610675, 0.0] 0.78633 >17, cfg=[0.6650936023999641, 0.0] 0.78633 >22, cfg=[0.9070451625704087, 0.0] 0.78633 >23, cfg=[0.9253366187387938, 0.0] 0.78633 >26, cfg=[0.9966143540220266, 0.0] 0.78633 >31, cfg=[1.0048613895650054, 0.002162219228449132] 0.79133 Done! cfg=[1.0048613895650054, 0.002162219228449132]: Mean Accuracy: 0.791333

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

Оптимизация гиперпараметров XGBoost

XGBoost — это сокращение от Extreme Gradient Boosting и является эффективной реализацией алгоритма машинного обучения стохастического градиентного повышения.

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

Сначала необходимо установить библиотеку XGBoost.

Вы можете установить её с помощью pip:

sudo pip install xgboost

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

# xgboost import xgboost print("xgboost", xgboost.__version__)

Запустив код, вы должны увидеть номер версии библиотеки.

xgboost 1.0.1

Хотя у библиотеки XGBoost есть собственный API Python, мы можем использовать модели XGBoost с API scikit-learn через класс оболочки XGBClassifier.

Экземпляр модели можно создать и использовать так же, как любой другой класс scikit-learn для оценки модели. Например:

... # define model model = XGBClassifier()

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

Мы будем использовать тот же набор данных синтетической бинарной классификации из предыдущего раздела и ту же программу тестирования многократной стратифицированной k-кратной перекрёстной проверки.

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

# xgboost with default hyperparameters for binary classification from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from xgboost import XGBClassifier # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # define model model = XGBClassifier() # define evaluation procedure cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) # evaluate model scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) # report result print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

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

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

В этом случае мы видим, что модель с гиперпараметрами по умолчанию достигла точности классификации около 84,9 %.

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

Mean Accuracy: 0.849 (0.040)

Затем мы можем адаптировать стохастический алгоритм поиска восхождением к вершине, чтобы настроить гиперпараметры модели XGBoost.

Имеется много гиперпараметров, которые мы можем оптимизировать для модели XGBoost.

Обзор того, как настроить модель XGBoost, см. в руководстве:

Как настроить алгоритм повышения градиента.

Мы сосредоточимся на четырёх ключевых гиперпараметрах; вот они:

• скорость обучения (learning_rate);

• количество деревьев (n_estimators);

• процент подвыборки (subsample);

• глубина дерева (max_depth).

Скорость обучения контролирует вклад каждого дерева в ансамбль. Разумные значения меньше 1,0 и немного больше 0,0 (например, 1e-8).

Количество деревьев контролирует размер ансамбля, и часто, чем больше деревьев, тем лучше до точки уменьшения отдачи. Разумные значения лежат между 1 деревом и сотнями или тысячами деревьев.

Проценты подвыборки определяют размер случайной выборки, используемый для обучения каждого дерева, определяемый как процент от размера исходного набора данных. Значения находятся в диапазоне от немного выше 0,0 (например, 1e-8) до 1,0.

Глубина дерева — это количество уровней в каждом дереве. Более глубокие деревья более специфичны для обучающего набора данных и, возможно, переоснащены. Деревья, меньшие по размеру, часто лучше обобщают. Разумные значения находятся в диапазоне от 1 до 10 или 20.

Во-первых, мы должны обновить функцию objective(), чтобы распаковать гиперпараметры модели XGBoost, настроить её, а затем оценить среднюю точность классификации.

# objective function def objective(X, y, cfg): 	# unpack config 	lrate, n_tree, subsam, depth = cfg 	# define model 	model = XGBClassifier(learning_rate=lrate, n_estimators=n_tree, subsample=subsam, max_depth=depth) 	# define evaluation procedure 	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) 	# evaluate model 	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 	# calculate mean accuracy 	result = mean(scores) 	return result

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

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

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

Выбранные размеры шага произвольны, выбраны после недолгих проб и ошибок.

Обновлённая функция step() приведена ниже.

# take a step in the search space def step(cfg): 	# unpack config 	lrate, n_tree, subsam, depth = cfg 	# learning rate 	lrate = lrate + randn() * 0.01 	if lrate <= 0.0: 		lrate = 1e-8 	if lrate > 1: 		lrate = 1.0 	# number of trees 	n_tree = round(n_tree + randn() * 50) 	if n_tree <= 0.0: 		n_tree = 1 	# subsample percentage 	subsam = subsam + randn() * 0.1 	if subsam <= 0.0: 		subsam = 1e-8 	if subsam > 1: 		subsam = 1.0 	# max tree depth 	depth = round(depth + randn() * 7) 	if depth <= 1: 		depth = 1 	# return new config 	return [lrate, n_tree, subsam, depth]

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

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

... # starting point for the search solution = step([0.1, 100, 1.0, 7])

Объединивший всё это вместе, полный пример ручной настройки гиперпараметров алгоритма XGBoost с использованием стохастического алгоритма поиска восхождением к вершине приведён ниже.

# xgboost manual hyperparameter optimization for binary classification from numpy import mean from numpy.random import randn from numpy.random import rand from numpy.random import randint from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from xgboost import XGBClassifier  # objective function def objective(X, y, cfg): 	# unpack config 	lrate, n_tree, subsam, depth = cfg 	# define model 	model = XGBClassifier(learning_rate=lrate, n_estimators=n_tree, subsample=subsam, max_depth=depth) 	# define evaluation procedure 	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) 	# evaluate model 	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 	# calculate mean accuracy 	result = mean(scores) 	return result  # take a step in the search space def step(cfg): 	# unpack config 	lrate, n_tree, subsam, depth = cfg 	# learning rate 	lrate = lrate + randn() * 0.01 	if lrate <= 0.0: 		lrate = 1e-8 	if lrate > 1: 		lrate = 1.0 	# number of trees 	n_tree = round(n_tree + randn() * 50) 	if n_tree <= 0.0: 		n_tree = 1 	# subsample percentage 	subsam = subsam + randn() * 0.1 	if subsam <= 0.0: 		subsam = 1e-8 	if subsam > 1: 		subsam = 1.0 	# max tree depth 	depth = round(depth + randn() * 7) 	if depth <= 1: 		depth = 1 	# return new config 	return [lrate, n_tree, subsam, depth]  # hill climbing local search algorithm def hillclimbing(X, y, objective, n_iter): 	# starting point for the search 	solution = step([0.1, 100, 1.0, 7]) 	# evaluate the initial point 	solution_eval = objective(X, y, solution) 	# run the hill climb 	for i in range(n_iter): 		# take a step 		candidate = step(solution) 		# evaluate candidate point 		candidate_eval = objective(X, y, candidate) 		# check if we should keep the new point 		if candidate_eval >= solution_eval: 			# store the new point 			solution, solution_eval = candidate, candidate_eval 			# report progress 			print('>%d, cfg=[%s] %.5f' % (i, solution, solution_eval)) 	return [solution, solution_eval]  # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # define the total iterations n_iter = 200 # perform the hill climbing search cfg, score = hillclimbing(X, y, objective, n_iter) print('Done!') print('cfg=[%s]: Mean Accuracy: %f' % (cfg, score))

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

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

В этом случае мы видим, что лучший результат связан с использованием скорости обучения около 0,02, 52 деревьев, частоты подвыборки около 50 % и глубины 53 уровня.

Эта конфигурация привела к средней точности около 87,3 %, что лучше, чем конфигурация по умолчанию, которая достигла точности около 84,9 %.

>0, cfg=[[0.1058242692126418, 67, 0.9228490731610172, 12]] 0.85933 >1, cfg=[[0.11060813799692253, 51, 0.859353656735739, 13]] 0.86100 >4, cfg=[[0.11890247679234153, 58, 0.7135275461723894, 12]] 0.86167 >5, cfg=[[0.10226257987735601, 61, 0.6086462443373852, 17]] 0.86400 >15, cfg=[[0.11176962034280596, 106, 0.5592742266405146, 13]] 0.86500 >19, cfg=[[0.09493587069112454, 153, 0.5049124222437619, 34]] 0.86533 >23, cfg=[[0.08516531024154426, 88, 0.5895201311518876, 31]] 0.86733 >46, cfg=[[0.10092590898175327, 32, 0.5982811365027455, 30]] 0.86867 >75, cfg=[[0.099469211050998, 20, 0.36372573610040404, 32]] 0.86900 >96, cfg=[[0.09021536590375884, 38, 0.4725379807796971, 20]] 0.86900 >100, cfg=[[0.08979482274655906, 65, 0.3697395430835758, 14]] 0.87000 >110, cfg=[[0.06792737273465625, 89, 0.33827505722318224, 17]] 0.87000 >118, cfg=[[0.05544969684589669, 72, 0.2989721608535262, 23]] 0.87200 >122, cfg=[[0.050102976159097, 128, 0.2043203965148931, 24]] 0.87200 >123, cfg=[[0.031493266763680444, 120, 0.2998819062922256, 30]] 0.87333 >128, cfg=[[0.023324201169625292, 84, 0.4017169945431015, 42]] 0.87333 >140, cfg=[[0.020224220443108752, 52, 0.5088096815056933, 53]] 0.87367 Done! cfg=[[0.020224220443108752, 52, 0.5088096815056933, 53]]: Mean Accuracy: 0.873667

Дальнейшее чтение

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

Туториалы

• Hyperparameter Optimization With Random Search and Grid Search.

• How to Configure the Gradient Boosting Algorithm.

• How To Implement The Perceptron Algorithm From Scratch In Python.

APIs

• sklearn.datasets.make_classification APIs.

• sklearn.metrics.accuracy_score APIs.

• numpy.random.rand API.

• sklearn.linear_model.Perceptron API.

Статьи

• Perceptron, Wikipedia.

• XGBoost, Wikipedia.

Вывод

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

В частности, вы узнали:

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

Как использовать стохастический алгоритм поиска восхождением к вершине для настройки гиперпараметров алгоритма перцептрона.

Как вручную оптимизировать гиперпараметры алгоритма повышения градиента XGBoost.

И о том, что прокачать себя в машинном обучении можно на нашем курсе по machine learning и его углубленной версии «Machine Learning и Deep Learning».

Узнайте, как прокачаться в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering

Другие профессии и курсы

ПРОФЕССИИ

• Профессия Fullstack-разработчик на Python

• Профессия Java-разработчик

• Профессия QA-инженер на JAVA

• Профессия Frontend-разработчик

• Профессия Этичный хакер

• Профессия C++ разработчик

• Профессия Разработчик игр на Unity

• Профессия Веб-разработчик

• Профессия iOS-разработчик с нуля

• Профессия Android-разработчик с нуля

КУРСЫ

• Курс по Machine Learning

• Курс «Machine Learning и Deep Learning»

• Курс «Математика для Data Science»

• Курс «Математика и Machine Learning для Data Science» 

• Курс «Python для веб-разработки»

• Курс «Алгоритмы и структуры данных»

• Курс по аналитике данных

• Курс по DevOps