model fit keras параметры
Train a Keras model
Trains the model for a fixed number of epochs (iterations on a dataset).
Arguments
Vector, matrix, or array of training data (or list if the model has multiple inputs). If all inputs in the model are named, you can also pass a list mapping input names to data. x can be NULL (default) if feeding from framework-native tensors (e.g. TensorFlow data tensors).
Vector, matrix, or array of target (label) data (or list if the model has multiple outputs). If all outputs in the model are named, you can also pass a list mapping output names to data. y can be NULL (default) if feeding from framework-native tensors (e.g. TensorFlow data tensors).
Verbosity mode (0 = silent, 1 = progress bar, 2 = one line per epoch).
List of callbacks to be called during training.
Float between 0 and 1. Fraction of the training data to be used as validation data. The model will set apart this fraction of the training data, will not train on it, and will evaluate the loss and any model metrics on this data at the end of each epoch. The validation data is selected from the last samples in the x and y data provided, before shuffling.
Optional named list mapping indices (integers) to a weight (float) value, used for weighting the loss function (during training only). This can be useful to tell the model to «pay more attention» to samples from an under-represented class.
Integer, Epoch at which to start training (useful for resuming a previous training run).
Total number of steps (batches of samples) before declaring one epoch finished and starting the next epoch. When training with input tensors such as TensorFlow data tensors, the default NULL is equal to the number of samples in your dataset divided by the batch size, or 1 if that cannot be determined.
Only relevant if steps_per_epoch is specified. Total number of steps (batches of samples) to validate before stopping.
Value
A history object that contains all information collected during training.
Русские Блоги
[Глубокое обучение] Как использовать fit и fit_generator в Керасе
Введение
Библиотека глубокого обучения Keras включает модели, которые можно использовать для собственного обучения:
Если вы новичок в Keras и глубоком обучении, вы можете немного почувствовать, пытаясь определить, какую функцию вам следует использовать.В убыток. Если вам нужно использовать ваши собственные данные, эта путаница только усложняется.
Чтобы помочь разрушить облако функций Keras fit и fit_generator, я проведу этот урок, обсуждая:
Как использовать Keras fit и fit_generator
Я покажу вам пример «нестандартного» набора данных изображения, который вообще не содержит никаких реальных изображений PNG, JPEG и т. Д.! Вместо этого весь набор данных изображения представлен двумя файлами CSV, один для обучения, а второй для оценки.
Наконец, мы обучим и оценим нашу сеть.
Когда использовать функции Keras fit, fit_generator и train_on_batch?
Эти три функции могут в основном выполнять одну и ту же задачу, но способы их выполнения сильно различаются.
Давайте рассмотрим эти функции одну за другой, рассмотрим примеры вызовов функций, а затем обсудим различия между ними.
Здесь вы можете увидеть предоставленные нами данные обучения ( trainX ) И обучающая метка ( trainY ）。
Затем мы инструктируем Кераса разрешить обучение нашей модели 50 Эпоха, а размер партии 32 。
Вместо этого наша сеть будет обучаться на необработанных данных.
Сами исходные данные поместятся в памяти, нам не нужно перемещать старые пакетные данные из ОЗУ и перемещать новые пакетные данные в ОЗУ.
Кроме того, мы не будем использовать увеличение данных для динамического управления данными обучения.
Функция keras fit_generator
При глубоком обучении наши данные обычно очень большие, даже в случае использования графического процессора, если мы считываем все данные (например, изображения) в память процессора одновременно, память, вероятно, выйдет из строя. Вероятно, это произойдет в реальных проектах.
Эти наборы данных обычно не являются сложными и не требуют улучшения данных.
Однако наборы данных из реального мира редко бывают такими простыми:
генератор: функция генератора, выходной сигнал генератора должен быть:
Кортеж в форме (входы, цели)
Кортеж формы (входы, цели, sample_weight). Все возвращаемые значения должны содержать одинаковое количество выборок. Генератор будет бесконечно зацикливаться на наборе данных. Каждая эпоха достигается количеством образцов, прошедших через модель samples_per_epoch Когда вспомни конец эпохи
steps_per_epoch: целое число, когда генератор возвращает steps_per_epoch Когда одна эпоха закончилась, выполняется следующая эпоха
эпохи: целое число, количество раундов итерации данных
подробный: отображение журнала, 0 означает, что информация журнала не выводится в стандартном потоке вывода, 1 означает вывод записи индикатора выполнения, 2 означает вывод одной строчной записи для каждой эпохи
validation_data: имеет одну из следующих трех форм
Генератор для создания набора для проверки
Кортеж в форме (входы, цели)
Кортеж в форме (входы, цели, sample_weights)
validation_steps: когда validation_data является генератором, этот параметр указывает, сколько раз генератор набора проверки возвращает
class_weight: словарь, который определяет веса категорий, сопоставляет категории с весами и часто используется для устранения дисбаланса выборки.
sample_weight: numpy массив весов, используемый для настройки функции потерь во время обучения (только для обучения). Вы можете передать одномерный вектор той же длины, что и выборка, чтобы взвесить выборки от 1 до 1, или при обращении к данным временного ряда передать матрицу в форме (samples, sequence_length) для каждого временного шага Образцам присваивается разный вес. В этом случае не забудьте добавить sample_weight_mode=’temporal’ 。
рабочие: максимальное количество процессов. При использовании потоков на основе процессов максимальное количество процессов, которые необходимо запустить.
max_q_size: максимальная емкость очереди генератора
initial_epoch: начать обучение с эпохи, указанной в этом параметре, что полезно при продолжении предыдущего обучения.
Официальный демонстрационный код:
Официальная демонстрация не реализует batch_size, и демонстрация может извлекать только один образец за раз.
Для вышеупомянутого набора данных, реализация итератора извлечения данных batch_size, код выглядит следующим образом:
Сначала мы инициализируем эпоху и размер пакета обучаемой сети.
В соответствии с ImageDataGenerator Параметры настраиваются случайным образом с каждой партией новых данных.
Сама функция являетсяГенератор Python。
Зачем нам нужен steps_per_epoch ？
Имейте в виду, что генератор данных Keras означает бесконечный цикл, он никогда не вернется или не выйдет.
Поскольку эта функция предназначена для бесконечного цикла, Keras не может определить, когда начинается эпоха и когда начинается новая эпоха.
Поэтому мы делим общее количество обучающих данных на размер пакета, как результат steps_per_epoch Стоимость. Как только Керас достигнет этой точки, он будет знать, что это новая эпоха.
Тонкая настройка и контроль процесса обучения через метод 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 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Обзор Keras для TensorFlow
Перевод обзорного руководства с сайта Tensorflow.org. Это руководство даст вам основы для начала работы с Keras. Чтение займет 10 минут.
Импортируйте tf.keras
Для начала, импортируйте tf.keras как часть установки вашей TensorFlow:
tf.keras может выполнять любой Keras-совместимый код, но имейте ввиду:
Постройте простую модель
Последовательная модель
Построим простую полносвязную сеть (т.е. многослойный перцептрон):
Настройте слои
Обучение и оценка
Настройка обучения
После того как модель сконструирована, настройте процесс ее обучения вызовом метода compile :
tf.keras.Model.compile принимает три важных аргумента:
Обучение на данных NumPy
Для небольших датасетов используйте помещающиеся в память массивы NumPy для обучения и оценки модели. Модель «обучается» на тренировочных данных, используя метод `fit`:
tf.keras.Model.fit принимает три важных аргумента:
Обучение с использованием наборов данных tf.data
Используйте Datasets API для масштабирования больших баз данных или обучения на нескольких устройствах. Передайте экземпляр `tf.data.Dataset` в метод fit :
Датасеты могут быть также использованы для валидации:
Оценка и предсказание
Вот так можно оценить потери в режиме вывода и метрики для предоставленных данных:
А вот как предсказать вывод последнего уровня в режиме вывода для предоставленных данных в виде массива NumPy:
Построение сложных моделей
The Functional API
Модель tf.keras.Sequential это простой стек слоев с помощью которого нельзя представить произвольную модель. Используйте Keras functional API для построения сложных топологий моделей, таких как:
Создайте экземпляр модели с данными входами и выходами.
Сабклассинг моделей
Сабклассинг модели особенно полезен когда включен eager execution, поскольку он позволяет написать прямое распространение императивно.
Ключевой момент: Используйте правильный API для работы. Хоть сабклассинг модели обеспечивает гибкость, за нее приходится платить большей сложностью и большими возможностями для пользовательских ошибок. Если это возможно выбирайте functional API.
Следующий пример показывает сабклассированную модель tf.keras.Model использующую пользовательское прямое распространение, которое не обязательно выполнять императивно:
Создайте экземпляр класса новой модели:
Пользовательские слои
Создайте пользовательский слой сабклассингом tf.keras.layers.Layer и реализацией следующих методов:
Создайте модель с использованием вашего пользовательского слоя:
Колбеки
Колбек это объект переданный модели чтобы кастомизировать и расширить ее поведение во время обучения. Вы можете написать свой пользовательский колбек или использовать встроенный tf.keras.callbacks который включает в себя:
tf.keras.callbacks.ModelCheckpoint : Сохранение контрольных точек модели за регулярные интервалы.
tf.keras.callbacks.LearningRateScheduler : Динамичное изменение шага обучения.
tf.keras.callbacks.EarlyStopping : Остановка обучения в том случае когда результат при валидации перестает улучшаться.
tf.keras.callbacks.TensorBoard: Мониторинг поведения модели с помощью
TensorBoard
Сохранение и восстановление
Сохранение только значений весов
Сохраните и загрузите веса модели с помощью tf.keras.Model.save_weights :
По умолчанию веса модели сохраняются в формате TensorFlow checkpoint. Веса могут быть также сохранены в формате Keras HDF5 (значение по умолчанию для универсальной реализации Keras):
Сохранение только конфигурации модели
Конфигурация модели может быть сохранена — это сериализует архитектуру модели без всяких весов. Сохраненная конфигурация может восстановить и инициализировать ту же модель, даже без кода определяющего исходную модель. Keras поддерживает форматы сериализации JSON и YAML:
Восстановление модели (заново инициализированной) из JSON:
Сериализация модели в формат YAML требует установки `pyyaml` перед тем как импортировать TensorFlow:
Восстановление модели из YAML:
Внимание: сабклассированные модели не сериализуемы, потому что их архитектура определяется кодом Python в теле метода `call`.
Сохранение всей модели в один файл
Вся модель может быть сохранена в файл содержащий значения весов, конфигурацию модели, и даже конфигурацию оптимизатора. Это позволит вам установить контрольную точку модели и продолжить обучение позже с точно того же положения даже без доступа к исходному коду.
Eager execution
Eager execution — это императивное программирование среда которая выполняет операции немедленно. Это не требуется для Keras, но поддерживается tf.keras и полезно для проверки вашей программы и отладки.
Все строящие модели API `tf.keras` совместимы eager execution. И хотя могут быть использованы `Sequential` и functional API, eager execution особенно полезно при сабклассировании модели и построении пользовательских слоев — эти API требуют от вас написание прямого распространения в виде кода (вместо API которые создают модели путем сборки существующих слоев).
Распределение
Множественные GPU
Следующий пример распределяет tf.keras.Model между множеством GPU на одной машине.
Сперва определим модель внутри области распределенной стратегии:
Затем обучим модель на данных как обычно: