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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Мы можем использовать функцию 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