Fit predict что это
Тонкая настройка и контроль процесса обучения через метод fit()
Используя пакет Keras на этих занятиях, мы с вами много раз обучали модель путем вызова метода fit(). Пришло время подробнее с ним познакомиться, увидеть его возможности и особенности.
Вначале определим тестовую модель для простой классической задачи распознавания изображений рукописных цифр:
Теперь, для запуска процесса обучения, необходимо определить оптимизатор и функцию потерь:
И, собственно, вызвать метод fit(), например, так:
Это мы делали с вами уже много раз и здесь вам, в целом, должно быть все знакомо.
У метода fit() много вспомогательных параметров, которые полезно знать для обеспечения контроля за процессом обучения нейросети. Рассмотрим наиболее значимые из них. Вначале увидим, как можно определять выборку валидации, по которой мы контролируем процесс переобучения.
Выборка валидации с массивами NumPy
Если обучающий набор данных представлен в виде NumPy-массивов, то мы можем указать долю, которая будет использована в качестве проверочной выборки. Это делается с помощью параметра:
validation_split = вещественное число (от 0 до 1)
Например, если указать:
то будут взяты последние 30% наблюденийиз массивов x_train и y_train (до их перемешивания), которые мы указываем в этом же методе для обучения. По умолчанию, метод fit() перетасовывает наблюдения выборок на каждой эпохе. Так вот, 30% наблюдений отбираются до перемешивания, а остальные 70% участвуют в обучении.
Если нас не устраивает такой встроенный механизм разбиения обучающих данных, то мы можем это сделать самостоятельно. Для простоты, возьмем первые 20% наблюдений для валидации, а остальные 80% превратим в набор обучающих данных. Вначале вычислим индекс для разбиения выборки:
А, затем, разделим наборы данных по этому индексу:
После этого, в методе fit() достаточно указать выборку для обучения и для проверки:
Как видите, здесь используется параметр validation_data для указания проверочной выборки.
Выборка валидации с tf.data.Dataset
Наборы данных для обучения модели могут быть представлены и в виде тензоров непосредственно пакета Tensorflow. Часто для этого используется специальный набор утилит в ветке:
Подробная документация по ним доступна по адресу:
В частности, можно сформировать выборку на основе уже имеющихся данных, используя метод from_tensor_slices() класса Dataset:
На выходе получим экземпляр этого класса с выборкой (x_train, y_train). Далее, мы можем перемешать наблюдения в выборке с помощью метода shuffle и разбить их по мини-батчам, например, размером 64 элемента:
Параметр buffer_size определяет число элементов в буфере, из которого случайно выбирается по одному элементу на каждой итерации при перемешивании.
Теперь, достаточно первым параметром передать объект Dataset в метод fit() и дополнительно указать число эпох:
При этом аргумент batch_size уже не имеет смысла, так как мы сделали эту разбивку ранее. Также на каждой эпохе данные будут браться с самого начала (сбрасываются), поэтому сеть будет учиться на одних и тех же наблюдениях от эпохи к эпохе (параметр shuffleздесь не применяется).
Выборка валидации с таким набором данных может быть добавлена только через параметр validation_data. Другой параметр validation_split здесь игнорируется:
Параметры steps_per_epoch и validation_steps
Если мы хотим, чтобы обучающие данные от эпохи к эпохе не сбрасывались, а последовательно проходили по мини-батчам от начала до конца, то для этого можно воспользоваться параметром
который устанавливает число батчей на эпоху, например, так:
Но, при слишком большом значении steps_per_epoch, например, 300 пакетов будет недостаточно для пяти эпох и Keras сгенерирует предупреждение с остановом процесса обучения.
Как правило, обучение запускают без этого параметра, но если вдруг потребуется более тонкая настройка для исследования процесса обучения, то полезно знать возможности метода fit().
Второй похожий параметр validation_steps задает число мини-батчей, используемых в проверочной выборке. Например, указав число пять:
в конце каждой эпохи будет использовано пять мини-батчей из выборки валидации для оценки качества работы модели на текущем этапе обучения.
Параметры class_weight и sample_weight
Как известно, входная выборка данных должна быть сбалансированной, то есть, каждый класс должен представляться примерно одинаковым числом наблюдений. Иногда это условие не выполняется, а, следовательно, обучение может пойти не самым лучшим образом. Для исправления такой ситуации в Keras можно дополнительно указывать веса для выходных значений, которые будут учитываться при вычислении функций потерь. Например, представим, что у нас есть нейросеть с N входами и M выходами:
Если обучающая выборка сбалансирована, то веса у всех выходов следует взять равными, обычно, единичными. Опишем это с помощью следующего словаря:
Здесь полагается, что M=10 (выходы с 0 до 9 – десять значений). В этом случае прогнозное значение тензора сети для функций потерь будет вычисляться как:
Обратите внимание, здесь речь идет о пересчете значений выходного тензора только для функций потерь, а не сети.
В программе мы можем указать эти веса, передавая словарь одноименному параметру class_weight метода fit():
Наверное, вы уже догадались, что если веса взять неравномерными (допустим, для первого выхода зададим вес в 1000, а остальные оставим прежними), то сеть будет обучаться, в основном, на распознавание цифры 0. И для нашей сбалансированной выборки общее качество классификации снизится до 87,7%. Поэтому такой подход полезен именно для несбалансированных выборок, где классам следует присваивать разные веса (чем меньше наблюдений, тем выше вес).
Другой параметр sample_weight позволяет устанавливать вес для отдельных наблюдений выборки. Например, написание некоторых единичек может быть похоже на написание семерок:
И нам бы хотелось, чтобы нейросеть «внимательнее», с большим весом относилась к таким изображениям. Для этого достаточно им присвоить больший вес, используя параметр sample_weight.
В нашем примере мы сделаем более простую манипуляцию – всем изображениям единичек присвоим вес 5.0, а остальным изображениям – вес 1.0. Через NumPy сделать это достаточно просто:
А, затем, в методе fit() указать этот параметр со сформированной коллекцией весов:
Обратите внимание, что веса наблюдений можно устанавливать только для массивов NumPy.
Статистика обучения
Метод fit() возвращает объект, в котором хранятся значения функций потерь для тренировочной и проверочной выборок, а также вычисляемые показатели метрик:
После выполнения программы в консоли увидим:
<'loss': [0.2670852541923523, 0.11203867942094803, 0.07508320361375809],
‘accuracy’: [0.9209374785423279, 0.9661250114440918, 0.9769583344459534],
‘val_loss’: [0.14193743467330933, 0.11101816594600677, 0.10447544604539871],
‘val_accuracy’: [0.9585000276565552, 0.9664999842643738, 0.9704166650772095]>
То есть, свойство history объекта history содержит списки соответствующих показателей качества процесса обучения. Затем, их удобно отображать в виде графиков, как это мы не раз делали в курсе по нейронным сетям.
Использование генератора выборки keras.utils.Sequence
С помощью класса keras.utils.Sequence можно реализовать свой собственный генератор последовательности для обучающей выборки. Давайте посмотрим на конкретном примере как это можно сделать.
Предположим, мы хотим создавать ограниченные наборы выборок изображений цифр. Для этого определим производный класс DigitsLimit, следующим образом:
После этого, достаточно создать экземпляр этого класса и указать его первым аргументом в метод fit():
Наконец, если требуется менять выборку после каждой эпохи в процессе обучения, то достаточно в классе дополнительно реализовать метод on_epoch_end:
Здесь мы выполняем перетасовку наблюдений выборки после каждой эпохи (фактически, повторяем работу параметра shuffle=True).
Использование обратных вызовов (callbacks)
В заключение этого занятия кратко рассмотрим возможности реализаций обратных вызовов функций в процессе обучения модели сети. Конечно, первый вопрос, что это такое и зачем они нужны?Представьте, что мы бы хотели останавливать досрочно процесс обучения, если показатель качества (функция потерь) снижается очень медленно. Возможно, мы оказались на каком-то высоком плато и алгоритм backpropagationне может выйти с этого уровня на более низкий и достичь лучших показателей при обучении. В частности, такое действие можно реализовать с помощью встроенного класса callbackEarlyStopping, следующим образом:
Смотрите, мы вначале определили коллекцию из экземпляров обратных вызовов и передали ее в метод fit через параметр callbacks. В результате, после каждой эпохи будет отслеживаться параметр loss (значение функции потерь) и если его изменение окажется меньше, чем 0,5 на протяжении одной эпохи, то процесс обучения досрочно прервется. Конечно, я здесь специально поставил такое большое значение (в 0,5), чтобы показать как сработает этот callback. В реальности, параметр min_delta составляет от 0,01 и проверяется на протяжении, как минимум, двух эпох. Здесь же приведены тестовые значения параметров.
После запуска увидим строчку:
Epoch 00002: early stopping
Это означает, что процесс обучения был прерван после второй эпохи.
Существуют и другие стандартные классы для callbacks, о которых подробно можно почитать на странице документации:
Из всего этого списка довольно часто применяется класс ModelCheckpoint для сохранения весов модели. Это полезно на случай возникновения какого-либо сбоя в процессе обучения. Представьте, что сеть обучалась в течение недели и из-за сбоя в аппаратуре, или даже банального отключения света все данные оказались потеряны. Чтобы этого не происходило, рекомендуется при таких длительных процессах создавать контрольные точки, сохраняя текущее состояние модели.
В качестве примера запишем класс ModelCheckpoint, со следующими параметрами:
После запуска программы в рабочем каталоге увидим папки с данными. Позже, сохраненную модель можно загрузить:
Создание пользовательских классов вызовов
Подробное описание по существующим методам и написанию собственных классов callback’ов смотрите в документации:
Для примера приведу класс, который сохраняет данные функции потерь по каждому мини-батчу и в конце обучения выводит информацию в консоль по первым пяти из них:
Затем, создаем список из callback’ов:
и запускаем процесс обучения:
После обучения увидим в консоли значения функции потерь для первых пяти мини-батчей.
Как видите, это достаточно полезный, простой и вместе с тем, гибкий инструмент для гибкого контроля за процессом обучения и эксплуатации нейронных сетей. На следующем занятии мы продолжим тему тонкой настройки обучения моделей и поговорим о методе compile().
Видео по теме
#1. Что такое Tensorflow? Примеры применения. Установка
#2. Тензоры tf.constant и tf.Variable. Индексирование и изменение формы
#3. Математические операции и функции над тензорами
#4. Реализация автоматического дифференцирования. Объект GradientTape
#5. Строим градиентные алгоритмы оптимизации Adam, RMSProp, Adagrad, Adadelta
#6. Делаем модель с помощью класса tf.Module. Пример обучения простой нейросети
#7. Делаем модель нейросети для распознавания рукописных цифр
#8. Декоратор tf.function для ускорения выполнения функций
#9. Введение в модели и слои бэкэнда Keras
#13. Создаем ResNet подобную архитектуру для классификации изображений CIFAR-10
#14. Тонкая настройка и контроль процесса обучения через метод fit()
#15. Тонкая настройка обучения моделей через метод compile()
#16. Способы сохранения и загрузки моделей в Keras
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Работа с текстовыми данными в scikit-learn (перевод документации) — часть 2
Данная статья представляет собой перевод главы, обучающей работе с текстовыми данными, из официальной документации scikit-learn. Начало статьи вы можете прочесть в части 1.
Обучение классификатора
Теперь, когда мы выделили признаки, можно обучать классификатор предсказывать категорию текста. Давайте начнем с Наивного Байесовского классификатора, который станет прекрасной отправной точкой для нашей задачи. scikit-learn включает в себя несколько вариантов этого классификатора. Самый подходящий для подсчета слов — это его поли номинальный вариант:
Чтобы мы могли попытаться предсказать результаты на новом документе, нужно извлечь фичи (характерные признаки), используя почти такую же последовательность как и ранее. Разница состоит в том, используется метод transform вместо fit_transform из transformers, так как они уже были применены к нашей обучающей выборке:
Создание конвейерной обработки
Чтобы с цепочкой vectorizer => transformer => classifier было проще работать, в scikit-learn есть класс Pipeline, который функционирует как составной (конвейерный) классификатор:
Название vect, tfidf and clf (классификатор) выбраны нами произвольно. Мы рассмотрим их использование ниже, в главе grid search. Теперь обучим модель с помощью всего 1 команды:
Оценка производительности при работе на тестовой выборке
Оценка точности прогноза модели достаточно проста:
Например, мы получили 83% точности. Давайте посмотрим, можем ли мы улучшить этот результат с помощью линейного метода опорных векторов (support vector machine (SVM)). Этот метод обычно считается лучшим из алгоритмов классификации текста (хотя, он немного медленнее чем наивный Байес). Мы можем сменить обучающуюся модель просто подсоединив другой объект классификации в наш конвейер:
scikit-learn также предоставляет утилиты для более детального анализа результатов:
Как и ожидалось, матрица неточностей показывает, что тексты из выборки newsgroups об атеизме и христианстве модель чаще путает друг с другом, нежели чем с текстами про компьютерную графику.
Настройка параметров для использования grid search
Некоторые параметры мы уже посчитали, такие как use_idf в функции TfidfTransformer. Классификаторы, как правило, также имеют много параметров, например, MultinomialNB включает в себя коэффициент сглаживания alpha, а SGDClassifier имеет штрафной параметр alpha (метод штрафных функций), настраиваемую потерю и штрафные члены в целевой функции (см. раздел документации или используйте функцию подсказки Python, чтобы получить дополнительную информацию).
Вместо поиска параметров различных компонентов в цепи, можно запустить поиск (методом полного перебора ) лучших параметров в сетке возможных значений. Мы опробовали все классификаторы на словах или биграммах, с или без idf, с штрафными параметрами 0,01 и 0,001 для SVM (метода опорных векторов):
Экземпляр grid search ведет себя как обычная модель scikit-learn. Давайте запустим поиск на малой части обучающей выборки, чтобы увеличить скорость обработки:
В результате применения метода fit на объекте GridSearchCV мы получим классификатор, который можно использовать для выполнения функции predict:
но с другой стороны, это очень большой и громоздкий объект. Мы можем все таки получить оптимальные параметры, изучая атрибут объекта grid_scores_, который является списком пар параметры\мера. Чтобы получить атрибуты мер, мы можем:
Упражнения
Чтобы выполнить упражнения, скопируйте содержание папки ‘skeletons’ в новую папку с названием ‘workspace’:
ВЫ можете редактировать содержимое папки workspace, не боясь потерять исходные инструкции для упражнений.
Затем откройте оболочку ipython и запустите незавершенный скрипт для упражнения:
Если было вызвано исключение, используйте %debug, чтобы запустить аварийную ipdb сессию.
Очистите реализацию и повторяйте, пока не решите задачу.
В каждом упражнении файлы skeleton содержат все необходимые инструкции импорта, шаблоны кода для загрузки данных и примеры для кода для оценки точности предсказывания модели.
Упражнения 1: Определение языка
Упражнение 2: Анализ предпочтений на основе отзывов фильмов
Упражнения 3: Утилита — текстовый классификатор в командной строке (консольное приложение)
Используя результаты предыдущих упражнений и модуль cPickle стандартной библиотеки, напишите утилиту командной строки, которая определяет язык текста в stdin (ввод с клавиатуры) и определяет полярность (положительный или отрицательный), если текст написан на английском.
predict_proba в Python не прогнозирует вероятности (и как с этим бороться)
Специалисты по анализу данных часто оценивают свои прогностические модели с точки зрения точности и погрешности, но редко спрашивают себя:
«Способна ли моя модель спрогнозировать реальные вероятности?»
Однако точная оценка вероятности чрезвычайно ценна с точки зрения бизнеса (иногда она даже ценнее погрешности). Хотите пример?
Представьте, что ваша компания продает два вида кружек: обычные белые кружки и кружки с котятами. Вам нужно решить, какую из кружек показать клиенту. Для этого нужно предсказать вероятность того, что пользовать может купить ту или другую кружку. Вы обучили пару моделей и у вас есть следующие результаты:
Итак, какую из кружек вы бы предложили пользователю?
Обе модели решили, что пользователь с наибольшей вероятностью купит обычную кружку (таким образом, у модели А и модели B одинаковая область под кривой ошибок, поскольку этот показатель оценивает только сортировку).
Но согласное модели А, вы сможете максимизировать ожидаемую прибыль, рекомендуя обычную кружку. Тогда как по модели B ожидаемая прибыль будет максимальной при выборе кружки с котенком.
В такие моменты жизненно важно выяснить, какая из моделей точнее оценивает вероятности (как визуально, так и численно) и как «подправить» имеющуюся модель, чтобы увеличить точность.
Что не так с predict_proba
У всех самых популярных библиотек машинного обучения есть метод под названием «predict_proba», это относится к Scikit-learn (например, LogisticRegression, SVC, randomForest. ), XGBoost, LightGBM, CatBoost, Keras…
Но несмотря на свое название predict_proba не совсем предсказывает вероятности. На самом деле, различные исследования (особенно это и это) показали, что самые популярные прогностические модели не откалиброваны.
Того факта, что число находится между нулем и единицей, уже достаточно, чтобы называть его вероятностью!
Но когда мы можем сказать, что число в самом деле представляет из себя вероятность?
Представьте, что вы обучили прогностическую модель, чтобы предсказать, разовьется ли у пациента рак. Допустим, что для данного пациента модель предсказывает вероятность 5%. По идее мы должны пронаблюдать одного и того же пациента в нескольких параллельных вселенных и посмотреть, действительно ли у него разовьется рак в 5% случаев.
Поскольку мы не можем идти по этому пути, лучшим прокси-сервером будет взять всех пациентов с вероятностью заболевания 5%, и подсчитать, у скольких из них развился рак. Если наблюдаемый процент на самом деле близок к 5%, мы говорим, что вероятности, выдаваемые моделью, откалиброваны.
Когда предсказанные вероятности отражают реальные базовые вероятности, они называются “откалиброванными”.
Но как проверить, откалибрована ли ваша модель?
Калибровочная кривая
Самый простой способ оценить калибровку вашей модели – это построить график, называемый «калибровочной кривой» (он же – диаграмма надежности).
Идея состоит в том, чтобы разделить наблюдения на ячейки вероятности. Таким образом, наблюдения, принадлежащие к одной и той же ячейке, имеют одинаковую вероятность. Итак, для каждой ячейки калибровочная кривая сравнивает спрогнозированное среднее (т.е. среднее значение предсказанной вероятности) с теоретическим средним (т.е. средним наблюдаемой целевой переменной).
Scikit-learn сделает все за вас с помощью функции calibration_curve :
Вам нужно только выбрать количество ячеек и (необязательно) стратегию распределения по ячейкам:
Для построения графиков лично я предпочитаю подход «quantile». На самом деле «Uniform»-распределение может дезориентировать, поскольку в некоторых ячейках может быть крайне мало наблюдений.
Функция Numpy возвращает два массива, содержащих среднюю вероятность и среднее значение целевой переменной для каждой ячейки. Поэтому все, что нам нужно сделать – это нарисовать график:
Предположим, что у вашей модели хорошая точность, тогда калибровочная кривая будет монотонно увеличиваться. Но это не значит, что модель хорошо откалибрована.
На самом деле, ваша модель хорошо откалибрована только в том случае, если калибровочная кривая очень близка к биссектрисе (т.е. серой пунктирной линии), поскольку это будет означать, что прогнозируемая вероятность в среднем близка к теоретической вероятности.
Давайте рассмотрим несколько примеров распространенных типов калибровочных кривых, которые указывают на неверную калибровку вашей модели:
Наиболее распространенными типами неправильной калибровки являются:
Систематическая переоценка. По сравнению с правильным распределением распределение прогнозируемых вероятностей смещается вправо. Так часто случается, когда вы обучаете модель на несбалансированном наборе данных с очень небольшим количеством положительных наблюдений.
Систематическая недооценка. По сравнению с правильным распределением распределение прогнозируемых вероятностей смещается влево.
Центр распределения слишком тяжелый. Так происходит, когда «такие алгоритмы, как метод опорных векторов или ускоренные деревья решений, имеют тенденцию отклонять прогнозируемые вероятности от 0 и 1» (цитата из «Прогнозирования хороших вероятностей при обучении с учителем»).
Хвосты распределения слишком тяжелые. Например, «Другие методы, такие как наивный байес, имеют противоположный уклон, и, как правило, приближают прогнозы к 0 и 1» (цитата из «Прогнозирования хороших вероятностей при обучении с учителем»).
Как исправить неправильную калибровку на Python
Допустим, вы обучили классификатор, который выдает точные, но некалиброванные вероятности. Идея калибровки вероятности состоит в том, чтобы построить вторую модель (называемую калибратором), которая способна исправлять имеющиеся вероятности до реальных.
Обратите внимание, что калибровку не следует проводить на тех же данных, которые использовались для обучения первого классификатора.
Таким образом, калибровка – это функция, которая преобразует одномерный вектор (некалиброванных вероятностей) в другой одномерный вектор (калиброванных вероятностей).
Для калибровки в основном используются два метода:
Изотоническая регрессия. Непараметрический алгоритм, который подгоняет неубывающую линию свободной формы под данные. Тот факт, что линия неубывающая, является основополагающим, поскольку так учитывается исходная сортировка.
Логистическая регрессия.
Давайте посмотрим, как использовать калибраторы на практике в Python, с помощью игрушечного набора данных.
Для начала нам нужно будет обучить классификатор. Давайте воспользуемся случайным лесом (но с любой другой моделью, у которой есть метод predict_proba, все будет в порядке).
Затем мы используем выходные данные классификатора (по данным валидации) для обучения калибратора и, наконец, для прогнозирования вероятностей по тестовым данным.
Изотоническая регрессия
Логистическая регрессия
На данный момент у нас есть три варианта прогнозирования вероятностей:
Обычный случайный лес
Случайный лес + изотоническая регрессия
Случайный лес + логистическая регрессия
Но как понять, какой из них лучше откалиброван?
Количественная оценка неправильной калибровки
Всем нравятся графики. Но помимо графика калибровки, нам нужен количественный способ измерения (неправильной) калибровки. Наиболее часто используемая метрика называется ожидаемой ошибкой калибровки. Она отвечает на вопрос: насколько далеко в среднем наша спрогнозированная вероятность от настоящей вероятности?
Возьмем, например, один классификатор:
Легко определить погрешность калибровки одной ячейки: нужно взять модуль разности среднего значения прогнозируемых вероятностей и доли положительных результатов в рамках одной ячейки.
Если подумать, то все интуитивно понятно. Возьмем одну ячейку и предположим, что среднее значение ее прогнозируемых вероятностей 25%. Таким образом, мы ожидаем, что доля положительных результатов в этой ячейке примерно равна 25%. Чем дальше имеющееся значение от 25%, тем хуже калибровка этой ячейки.
Таким образом, ожидаемая ошибка калибровки (ЕСЕ) представляет собой средневзвешенное значение ошибок калибровки отдельных ячеек, где каждая ячейка весит пропорционально количеству наблюдений, которые она содержит:
где b-определяет ячейку, а B – количество ячеек. Обратите внимание, что в знаменателе у нас просто общее число сэмплов.
Но в этой формуле остается проблема определения количества ячеек. Чтобы найти наиболее нейтральную метрику, я предпочитаю определять количество ячеек по правилу Фридмана-Диакониса (статистическое правило, предназначенное для определения количества ячеек, которое делает гистограмму максимально близкой к теоретическому распределению вероятностей).
Использовать правило Фридмана-Диакониса в Python очень просто, поскольку оно уже реализовано в функции histogram в numpy (нужно лишь передать строку « fd » в параметр « bins »).
Вот реализация ожидаемой ошибки калибровки на Python, с правилом Фридмана-Диакониса по умолчанию:
Теперь, когда у нас есть метрика для калибровки, давайте сравним калибровку трех моделей, которые у нас были выше (на тестовом наборе):
В нашем случае изотоническая регрессия обеспечила наилучший результат с точки зрения калибровки, в среднем с отклонением 1.2% от реальной вероятности. Это гигантское улучшение, если учитывать, что ECE обычного случайного леса составила 7%.
Источники
Вот несколько интересных работ, которые легли в основу этой статьи, и я их могу вам рекомендовать, если вы хотите углубиться в тему калибровки вероятности:
Всех желающих приглашаем на открытый урок «Multi-armed bandits для оптимизации AB тестирования, от теории — сразу в бой». На этом вебинаре мы разберем один из самых простых, но эффективных вариантов применения обучения с подкреплением. Посмотрим, как можно переформулировать задачу АБ тестирования в задачу байесовского вывода и получать выводы по тестам раньше, чем при классическом тестировании.