СТАТЬЯ
Начало работы с базовыми показателями
Из книги Пола Азунре Перенос обучения для обработки естественного языка
В этой статье обсуждается начало работы с базовыми линиями и обобщенными линейными моделями.
___________________________________________________________
Получите скидку 37 % на Перенос обучения для обработки естественного языка, введя fccazunre в поле кода скидки при оформлении заказа на сайте manning.com.
______________________________________________________________________
Модели нейронных сетей
Нейронные сети являются наиболее важным классом алгоритмов машинного обучения для решения проблем восприятия, таких как компьютерное зрение и НЛП. Таким образом, это самый важный класс моделей для предмета, охватываемого этой книгой.
В этом посте мы обучим две репрезентативные модели языка предварительно обученной нейронной сети на двух иллюстративных примерах задач, которые мы брали за основу в этой главе. Здесь мы рассмотрим две модели:
- ELMo — встраивания из языковых моделей и
- BERT — представление двунаправленного кодировщика от трансформаторов.
ELMo включает в себя элементы сверточных и рекуррентных (в частности, LSTM) элементов, в то время как BERT с соответствующим названием основан на преобразователе. Здесь будет использоваться простейшая форма точной настройки трансферного обучения, когда один слой плотной классификации обучается поверх соответствующего предварительно обученного встраивания поверх нашего набора меток из предыдущих разделов.
Встраивания из языковых моделей (ELMo)
Модель Embeddings from Language Models (ELMo), названная в честь популярного персонажа «Улицы Сезам», была одной из первых моделей, продемонстрировавших эффективность переноса знаний предварительно обученной языковой модели на общие задачи НЛП. Модель была обучена предсказывать следующее слово в последовательности слов, что может быть выполнено без учителя на очень больших корпусах, и показала, что веса, полученные в результате, можно обобщить на множество других задач НЛП. Мы не будем подробно обсуждать архитектуру этой модели в этом разделе — это будет сделано в соответствующей последующей главе. Здесь достаточно упомянуть, что в модели используются свертки на уровне символов для создания предварительных вложений каждого токена слова, за которыми следуют двунаправленные слои LSTM, которые вводят контекст окружающих слов в окончательные вложения, созданные моделью.
Кратко представив ELMo, давайте перейдем к его обучению для каждого из двух запущенных примеров наборов данных. Модель ELMo доступна через Tensorflow Hub, который предоставляет удобную платформу для обмена моделями Tensorflow. Мы будем использовать Keras с бэкендом Tensorflow для построения нашей модели. Чтобы сделать модель концентратора тензорного потока пригодной для использования Keras, нам нужно будет определить пользовательский слой Keras, который создает его экземпляр в правильном формате. Это достигается с помощью функции, показанной в листинге 1.
Листинг 1. Функция для создания экземпляра Tensorflow Hub ELMo в качестве пользовательского слоя Keras.
import tensorflow as tf # A
import tensorflow_hub as hub
from keras import backend as K
import keras.layers as layers
from keras.models import Model, load_model
from keras.engine import Layer
import numpy as np
sess = tf.Session() # B
K.set_session(sess)
class ElmoEmbeddingLayer(Layer): # C
def __init__(self, **kwargs):
self.dimensions = 1024
self.trainable=True
super(ElmoEmbeddingLayer, self).__init__(**kwargs)
def build(self, input_shape):
self.elmo =hub.Module('https://tfhub.dev/google/elmo/2', trainable=self.trainable,
name="{}_module".format(self.name)) # D
self.trainable_weights +=
K.tf.trainable_variables(scope="^{}_module/.*".format(self.name)) # E
super(ElmoEmbeddingLayer, self).build(input_shape)
def call(self, x, mask=None):
result = self.elmo(K.squeeze(K.cast(x, tf.string), axis=1),
as_dict=True,
signature='default',
)['default']
return result
def compute_output_shape(self, input_shape): # F
return (input_shape[0], self.dimensions)
# A Импорт необходимых зависимостей
# B Инициализировать сеанс
# C Создайте пользовательский слой, который позволит нам обновлять веса
# D Загрузите предварительно обученную модель ELMo из Tensorflow Hub
# E Извлечь обучаемые параметры — это всего 4 веса в средневзвешенном значении слоев модели ELMo, более подробную информацию см. по ссылке tf hub выше
# F Укажите форму вывода
Предположим, что доступна переменная данных raw_data — список, содержащий объединенную строку токенов слов для каждого сообщения электронной почты. Мы можем использовать код в листинге 2 для создания и обучения модели концентратора Keras ELMo TensorFlow.
Листинг 2. Функция и вызывающий скрипт для построения модели концентратора ELMo TensorFlow для Keras с использованием пользовательского слоя, определенного в листинге 1.
def build_model():
input_text = layers.Input(shape=(1,), dtype="string")
embedding = ElmoEmbeddingLayer()(input_text)
dense = layers.Dense(256, activation='relu')(embedding) # A
pred = layers.Dense(1, activation='sigmoid')(dense) # B
model = Model(inputs=[input_text], outputs=pred)
model.compile(loss='binary_crossentropy', optimizer='adam',
metrics=['accuracy']) # C
model.summary() # D
return model
# Build and fit
model = build_model()
model.fit(train_x, # E
train_y,
validation_data=(test_x, test_y),
epochs=5,
batch_size=32)
# Новый слой, выводящий 256-мерные вектора признаков
Слой классификации # B
# C потери, метрика и выбор оптимизатора
# D Показать архитектуру модели для проверки
# E Подгонка модели под 5 эпох
Здесь следует отметить несколько вещей — прежде всего, обратите внимание, что мы добавили дополнительный слой поверх предварительно обученного встраивания ELMo, создав 256-мерные векторы признаков. Мы также добавили классификационный слой выходного измерения 1. Функция активации ‘sigmoid’ преобразует свои входные данные в интервал между 0 и 1 и, по сути, представляет собой логистическую кривую. Его выход можно интерпретировать как вероятность положительного класса, и когда он превышает некоторый заранее заданный порог (обычно 0,5), соответствующий вход в сеть может быть классифицирован как указанный положительный класс.
Модель приспособлена для 5 «основных шагов» или эпох по всему набору данных. Оператор кода Keras «model.summary()’» в листинге 2 выводит сведения о модели и производит следующий вывод:
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) (None, 1) 0 _________________________________________________________________ elmo_embedding_layer_2 (Elmo (None, 1024) 4 _________________________________________________________________ dense_3 (Dense) (None, 256) 262400 _________________________________________________________________ dense_4 (Dense) (None, 2) 514 ================================================================= Total params: 262,918 Trainable params: 262,918 Non-trainable params: 0
Мы отмечаем, не вдаваясь в подробности, поскольку это будет рассмотрено в главе 4 книги, что большинство обучаемых параметров в этом случае (примерно 260 тысяч из них) исходят из слоев, которые мы добавили поверх пользовательского. Модель ЭЛМО. Другими словами, это наш первый пример трансферного обучения — изучение пары новых слоев поверх предварительно обученной модели, которой поделились создатели ELMo. Мы также отмечаем, что для большинства экспериментов с нейронными сетями важно использовать мощный графический процессор, а значение параметра batch_size, указывающего, сколько данных подается на графический процессор на каждом шаге, может быть чрезвычайно важно для скорости сходимости. . Это зависит от используемого графического процессора или его отсутствия. На практике можно увеличивать значение этого параметра до тех пор, пока скорость сходимости типичного экземпляра проблемы не выиграет от увеличения, или когда память графического процессора перестанет быть достаточно большой для размещения на ней одного пакета данных во время итерации. алгоритма, в зависимости от того, что произойдет раньше. Кроме того, при работе со сценарием с несколькими графическими процессорами были представлены некоторые доказательства того, что оптимальный график масштабирования размера пакета является линейным по количеству графических процессоров [1].
На бесплатном графическом процессоре NVIDIA Tesla K80 через ядро Kaggle (см. наш сопутствующий репозиторий github [2] для ссылок на ноутбуки Kaggle) мы достигаем производительности в нашем наборе данных электронной почты для первых 5 эпох, как показано на рисунке 1 для типичного запуска. . Мы обнаружили, что batch_size из 32 хорошо работает для нас в этом контексте.
Каждая эпоха занимает примерно 10 секунд — эта информация печатается нашим кодом. Мы видим, что точность проверки примерно 97,3% достигается на 4-й эпохе, т. е. менее чем за минуту. Эта производительность сравнима с производительностью подхода логистической регрессии, который лишь немного лучше — 97,7% (см. главу 2 книги). Отметим, что поведение алгоритма является стохастическим, т. е. от запуска к запуску он ведет себя по-разному. Таким образом, ваша собственная конвергенция будет несколько отличаться, даже на той же архитектуре, что и мы. На практике обычно пытаются запустить алгоритм несколько раз и выбирают наилучший набор параметров среди стохастических и различных полученных результатов. Наконец, мы отмечаем, что расхождение в точности обучения и проверки указывает на начало переобучения, как показано на рисунке.
Для примера IMDB код модели ELMo дает результат конвергенции, показанный на рисунке 2.
Каждая эпоха снова занимает примерно 10 секунд, а точность проверки примерно 70% достигается менее чем за минуту во 2-й эпохе. Мы увидим, как улучшить производительность в конце этой статьи (см. также Таблицу 1). Обратите внимание, что некоторые признаки переобучения можно наблюдать на 3-й и более поздних эпохах, поскольку точность обучения продолжает улучшаться, т. Е. Подгонка к данным улучшается, а точность проверки остается ниже.
Представления двунаправленного кодировщика от трансформаторов (BERT)
Модель Bidirectional Encoder Representations from Transformers (BERT) также была названа в честь популярного персонажа «Улицы Сезам» в знак уважения к тенденции, начатой ELMo. На момент написания этой книги его варианты достигли наилучших результатов в переносе знаний предварительно обученной языковой модели на последующие задачи НЛП. Аналогичным образом модель была обучена предсказывать слова в последовательности слов, хотя точная процедура маскирования несколько отличается. Это также можно сделать без присмотра на очень больших корпусах, и полученные веса аналогичным образом обобщаются для множества других задач НЛП. Возможно, чтобы ознакомиться с трансферным обучением в НЛП, необходимо ознакомиться с BERT.
Как и в случае с ELMo, мы снова не будем подробно обсуждать архитектуру этой модели глубокого обучения в этом разделе — это будет сделано в соответствующей главе книги. Здесь достаточно упомянуть, что в модели используются свертки на уровне символов для создания предварительных вложений токенов слов, за которыми следуют кодировщики на основе преобразователей со слоями внутреннего внимания, которые обеспечивают модель контекстом окружающих слов. Трансформатор функционально заменил роль двунаправленных LSTM, используемых ELMo. Вспоминая из предыдущей главы, что Transformers имеют некоторые преимущества по сравнению с LSTM в отношении масштабируемости обучения, мы видим некоторую мотивацию этой модели. Опять же, мы будем использовать Keras с бэкендом Tensorflow для построения нашей модели.
Кратко представив BERT, давайте приступим к его обучению для каждого из двух запущенных примеров наборов данных. Модель BERT также доступна через Tensorflow Hub. Чтобы сделать модель концентратора пригодной для использования Keras, мы аналогичным образом определяем пользовательский слой Keras, который создает его экземпляр в правильном формате, как показано в листинге 3.
Листинг 3. Функция для создания экземпляра Tensorflow Hub BERT в качестве пользовательского слоя Keras.
import tensorflow as tf
import tensorflow_hub as hub
from bert.tokenization import FullTokenizer
from tensorflow.keras import backend as K
# Initialize session
sess = tf.Session()
class BertLayer(tf.keras.layers.Layer):
def __init__(
self,
n_fine_tune_layers=10, # A
pooling="mean", # B
bert_path="https://tfhub.dev/google/bert_uncased_L-12_H-768_A-12/1", # C
**kwargs,
):
self.n_fine_tune_layers = n_fine_tune_layers
self.trainable = True
self.output_size = 768 # D
self.pooling = pooling
self.bert_path = bert_path
super(BertLayer, self).__init__(**kwargs)
def build(self, input_shape):
self.bert = hub.Module(
self.bert_path, trainable=self.trainable, name=f"{self.name}_module"
)
trainable_vars = self.bert.variables # E
if self.pooling == "first":
trainable_vars = [var for var in trainable_vars if not "/cls/" in var.name]
trainable_layers = ["pooler/dense"]
elif self.pooling == "mean":
trainable_vars = [
var
for var in trainable_vars
if not "/cls/" in var.name and not "/pooler/" in var.name
]
trainable_layers = []
else:
raise NameError("Undefined pooling type”)
)
for i in range(self.n_fine_tune_layers): # F
trainable_layers.append(f"encoder/layer_{str(11 - i)}")
trainable_vars = [
var
for var in trainable_vars
if any([l in var.name for l in trainable_layers])
]
for var in trainable_vars: # G
self._trainable_weights.append(var)
for var in self.bert.variables:
if var not in self._trainable_weights:
self._non_trainable_weights.append(var)
super(BertLayer, self).build(input_shape)
def call(self, inputs):
inputs = [K.cast(x, dtype="int32") for x in inputs]
input_ids, input_mask, segment_ids = inputs
bert_inputs = dict(
input_ids=input_ids, input_mask=input_mask, segment_ids=segment_ids # H
)
if self.pooling == "first":
pooled = self.bert(inputs=bert_inputs, signature="tokens", as_dict=True)[
"pooled_output"
]
elif self.pooling == "mean":
result = self.bert(inputs=bert_inputs, signature="tokens", as_dict=True)[
"sequence_output"
]
mul_mask = lambda x, m: x * tf.expand_dims(m, axis=-1) # I
masked_reduce_mean = lambda x, m: tf.reduce_sum(mul_mask(x, m), axis=1) / (
tf.reduce_sum(m, axis=1, keepdims=True) + 1e-10)
input_mask = tf.cast(input_mask, tf.float32)
pooled = masked_reduce_mean(result, input_mask)
else:
raise NameError("Undefined pooling type")
return pooled
def compute_output_shape(self, input_shape):
return (input_shape[0], self.output_size)
# A Количество верхних слоев по умолчанию, которое нужно разморозить для обучения
# B Выбор типа регуляризации
# C Предварительно обученная модель для использования, это большая исходная версия модели без оболочки
Размерность внедрения # D BERT, т. е. размер результирующих выходных семантических векторов
# E Удалить неиспользуемые слои
# F Принудительно указать количество незамороженных слоев для точной настройки
# G обучаемых весов
# H Входные данные для BERT имеют очень специфическую триплетную форму, мы покажем, как ее сгенерировать в следующем листинге
# I BERT «маскирует» некоторые слова, а затем пытается предсказать их как цель обучения
В отличие от ELMo, нам нужно преобразовать входной список строк в 3 массива — идентификаторы ввода, маски ввода и идентификаторы сегментов — перед их подачей. модели BERT. Код для этого показан в листинге 4. Преобразовав данные в нужный формат, мы используем оставшийся код в том же листинге 4 для построения и обучения модели концентратора Keras BERT Tensorflow.
Листинг 4. Код для преобразования данных в форму, ожидаемую моделью хаба BERT, дополнительно для ее построения и обучения.
def build_model(max_seq_length): # A
in_id = tf.keras.layers.Input(shape=(max_seq_length,), name="input_ids")
in_mask = tf.keras.layers.Input(shape=(max_seq_length,), name="input_masks")
in_segment = tf.keras.layers.Input(shape=(max_seq_length,), name="segment_ids")
bert_inputs = [in_id, in_mask, in_segment]
bert_output = BertLayer(n_fine_tune_layers=0)(bert_inputs) # B
dense = tf.keras.layers.Dense(256, activation="relu")(bert_output)
pred = tf.keras.layers.Dense(1, activation="sigmoid")(dense)
model = tf.keras.models.Model(inputs=bert_inputs, outputs=pred)
model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
model.summary()
return model
def initialize_vars(sess): # C
sess.run(tf.local_variables_initializer())
sess.run(tf.global_variables_initializer())
sess.run(tf.tables_initializer())
K.set_session(sess)
bert_path = "https://tfhub.dev/google/bert_uncased_L-12_H-768_A-12/1"
tokenizer = create_tokenizer_from_hub_module(bert_path) # D
train_examples = convert_text_to_examples(train_x, train_y) # E
test_examples = convert_text_to_examples(test_x, test_y)
# Convert to features
(train_input_ids,train_input_masks,train_segment_ids,train_labels) = convert_examples_to_features(tokenizer, train_examples, max_seq_length=maxtokens) # F
(test_input_ids,test_input_masks,test_segment_ids,test_labels) = convert_examples_to_features(tokenizer, test_examples, max_seq_length=maxtokens)
model = build_model(maxtokens) # G
initialize_vars(sess) # H
history = model.fit([train_input_ids, train_input_masks, train_segment_ids],# I
train_labels,validation_data=([test_input_ids, test_input_masks,
test_segment_ids],test_labels), epochs=5, batch_size=32)
# Функция построения модели
# B Мы не переобучаем какие-либо слои BERT, а используем предварительно обученную модель в качестве встраивания и переобучаем несколько новых слоев поверх нее
# Вызовы инициализации тензорного потока C Vanilla
# D Создать совместимый токенизатор с помощью функции в исходном репозитории BERT
# E Преобразование данных в формат «InputExample» с помощью функции в исходном репозитории BERT
# F Преобразовать формат InputExample в окончательный входной формат триплета BERT, используя функцию в исходном репозитории BERT
# G Создайте модель
# H Создать экземпляр переменных
# Модель поезда I
Подобно модели ELMo, которую мы построили в предыдущем подразделе, мы помещаем пару слоев поверх предварительно обученной модели и обучаем только те, что составляет около 200 тысяч параметров. С гиперпараметрами, установленными на сопоставимые значения, была достигнута точность проверки примерно 77% и 71% для задач классификации электронной почты и обзоров фильмов соответственно (в течение 5 эпох).
Оптимизация производительности
Взглянув на результаты производительности различных алгоритмов из предыдущих разделов, у нас может возникнуть соблазн сразу же сделать выводы о том, какой алгоритм лучше всего работает для каждой рассмотренной нами проблемы.
Мы должны помнить, что мы знаем, что это верно только при тех гиперпараметрах настройках, при которых мы изначально оценивали алгоритмы, т. е. Nsamp = 1000, maxtokens = 50, maxtokenlen = 20, в дополнение к любому алгоритму- конкретные значения параметров по умолчанию. Это количество выборок на класс в обучающих данных, максимальное количество токенов на выборку и максимальная длина токена соответственно. Чтобы иметь возможность делать общие утверждения, нам необходимо более тщательно изучить пространство гиперпараметров, оценив производительность всех алгоритмов при множестве настроек гиперпараметров. Этот процесс обычно называется настройкой или оптимизацией гиперпараметров. . Может случиться так, что лучшая производительность, найденная в этом процессе для каждого алгоритма, изменяет их рейтинг производительности, и в целом это помогает нам достичь большей точности в интересующих нас задачах.
Ручная настройка гиперпараметров
Настройка гиперпараметров часто изначально выполняется вручную, руководствуясь интуицией. Мы описываем такой подход здесь для гиперпараметров Nsamp, maxtokens and maxtokenlen, которые являются общими для всех рассмотренных нами алгоритмов.
Давайте сначала предположим, что начальный объем данных, с которыми мы тренировались, то есть с Nsamp=1000, — это все данные, которые у нас есть. Мы предполагаем, что если мы увеличим количество маркеров в данных для каждого документа, т. е. maxtokens, и увеличим максимальную длину любого такого маркера, т. е. maxtokenlen, мы можем увеличить количество сигналов для принятия решения о классификации и, таким образом, результирующая точность.
Для задачи классификации электронной почты мы сначала увеличиваем оба значения со значений 50 и 20 соответственно до 100 каждое. Результаты точности выполнения этого для логистической регрессии (LR), машин опорных векторов (SVM), случайных лесов (RF), машин повышения градиента (GBM), ELMo и BERT показаны во второй строке данных таблицы 1. Кроме того, мы увеличиваем maxtokens далее до 200, чтобы получить результаты в третьей строке данных таблицы 1.
Основываясь на этом, мы видим, что, хотя SVM явно является худшим классификатором для этой проблемы, логистическая регрессия, ELMo и BERT могут обеспечить почти идеальную производительность. Обратите внимание, что ELMo является явным победителем при наличии большего количества сигнала, что мы бы упустили без шага оптимизации. Простота и скорость логистической регрессии, вероятно, привели бы к тому, что она была выбрана в качестве предпочтительного классификатора для этой проблемы классификации электронной почты.
Теперь мы повторяем аналогичную последовательность шагов тестирования гиперпараметров для задачи классификации рецензий фильмов на IMDB, т. е. сначала увеличиваем maxtokens и maxtokenlen до 100 каждое, а затем увеличиваем maxtokens до 200. Результирующие характеристики алгоритма перечислены в таблице 2 вместе с производительность при начальных настройках гиперпараметров.
BERT оказался лучшей моделью для решения этой проблемы по всем направлениям, за ним следуют ELMo и логистическая регрессия. Обратите внимание, что эта проблема имеет больше возможностей для улучшения, что согласуется с нашим предыдущим наблюдением, что это более сложная проблема, чем классификация электронной почты. Это приводит нас к гипотезе о том, что предварительно обученная передача знаний более эффективна для более сложных задач, что интуитивно понятно. Это также согласуется с общим советом, который гласит, что модели нейронных сетей, вероятно, предпочтительнее других подходов, когда доступны значительные размеченные данные, при условии, что решаемая проблема достаточно сложна для того, чтобы в первую очередь потребовались дополнительные данные.
Систематическая настройка гиперпараметров
Существует ряд инструментов для более систематического и исчерпывающего поиска гиперпараметров в диапазонах гиперпараметров. К ним относятся методы Python GridSearchCV, которые выполняют исчерпывающий поиск по заданной сетке параметров, и HyperOpt, which does a random search over parameter ranges. Здесь мы представляем код для использования GridSearchCV для настройки выбранного алгоритма в качестве иллюстративного примера. Обратите внимание, что в этом упражнении мы настраиваем только некоторые внутренние гиперпараметры, специфичные для алгоритма, а общие гиперпараметры, которые мы настроили в последнем подразделе, фиксируются для простоты иллюстрации.
Мы выбираем классификацию электронной почты с RF при начальных общих настройках гиперпараметра в качестве нашего иллюстративного примера. Причина такого выбора заключается в том, что для каждой подгонки этого алгоритма к этой задаче требуется около секунды, и поскольку поиск по сетке выполняет много подгонок, это пример, который можно выполнить быстро для наибольшей обучающей ценности для читателя. .
Сначала мы импортируем требуемый метод и проверяем, какие гиперпараметры RF доступны для настройки:
from sklearn.model_selection import GridSearchCV # A
print("Available hyper-parameters for systematic tuning available with RF:")
print(clf.get_params()) # B
# Оператор импорта GridSeachCV scikit-learn
# B clf — классификатор RF из листинга 2.13
Это дает результат:
{'bootstrap': True, 'class_weight': None, 'criterion': 'gini', 'max_depth': None, 'max_features': 'auto', 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_impurity_split': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'n_estimators': 10, 'n_jobs': 1, 'oob_score': False, 'random_state': 0, 'verbose': 0, 'warm_start': False}
Мы выбираем три из этих HP для поиска и указываем три значения для каждого из них:
param_grid = {
'min_samples_leaf': [1, 2, 3],
'min_samples_split': [2, 6, 10],
'n_estimators': [10, 100, 1000]
}
Затем мы выполняем поиск по сетке, используя следующий код, обязательно распечатывая окончательную точность теста и лучшие значения гиперпараметров:
grid_search = GridSearchCV(estimator = clf, param_grid = param_grid,
cv = 3, n_jobs = -1, verbose = 2) # A
grid_search.fit(train_x, train_y) # B
print("Best parameters found:") # C
print(grid_search.best_params_)
print("Estimated accuracy is:")
acc_score = accuracy_score(test_y, grid_search.best_estimator_.predict(test_x))
print(acc_score)
# A Определить объект поиска по сетке с указанной сеткой гиперпараметров
# B Подогнать поиск по сетке к данным
# C Показать результаты
Этот эксперимент потребовал обучения классификатора на 3 * 3 * 3 = 27 точек, потому что каждая из трех сеток гиперпараметров имеет три запрошенных точки. Общий эксперимент занял менее пяти минут и дал точность 95,7%. Это улучшение более чем на один процент по сравнению с исходной оценкой в 94,5%. Необработанный вывод кода показан ниже с указанием лучших значений HP:
Best parameters found:
{'min_samples_leaf': 2, 'min_samples_split': 10, 'n_estimators': 1000}
Estimated accuracy is:
0.9566666666666667
Действительно, когда мы выполнили общую настройку всех классификаторов, мы обнаружили, что можем повысить производительность каждого из них на 1–2%, не влияя на выводы о лучшем классификаторе для задачи, сделанной в предыдущем подразделе.
Это все для этой статьи. Если вы хотите узнать больше о книге, вы можете ознакомиться с ней в нашей браузерной читалке liveBook здесь.
Эта статья изначально была размещена здесь: https://freecontent.manning.com/getting-started-with-baselines/
[1] с. Гоял и др., Точная, большая мини-пакетная обработка SGD: обучение ImageNet за 1 час, 2018 г.
