predict keras что возвращает

Основы работы с TensorFlow и Keras на Python. Часть 3

В предыдущей статье была показана задача бинарной классификации и её решение с помощью полносвязной нейронной сети. Эта статья тоже посвящена задаче классификации, но в этот раз количество классов не 2, а 46. Мы построим модель для классификации новостей международного агентства Рейтер на 46 отдельных тем, то есть 1 новость относится только к 1 теме.

Датасет Рейтер

Датасет представляет собой набор статей по разным темам. Каждая тема представлена как минимум 10 примерами в обучающей выборке. Этот датасет так же как и датасеты IMDB и MNIST есть в Keras.

Загрузим датасет Рейтер. num_words=10000 ограничивает подвыборку 10000 наиболее часто встречающимися словами в выборке.

Обучающая выборка состоит из 8982 примеров, тестовая — 2246.

Аналогично IMDB, каждый пример состоит из списка целых чисел (индексов слов):

Для получения слов из примера #100 обучающей выборки:

Статья #100 относится к теме #20

Для получения названия темы #20, необходимо

Подготовка данных

Закодировать (векторизовать) данные можно тем же самым кодом, что и в примере с IMDB

Чтобы векторизовать заголовки (темы статей) можно пойти двумя путями: преобразовать список тем в целочисленный тензор или использовать унитарный код (one-hot encoding). Унитарный код широко применяется для кодирования категорий. Он представляет собой число, состоящее из 0 и 1. Единица ставится только в разряде, чей номер совпадает с индексом категории (темы). К примеру:

Статья №100 относится к теме №20 (interest), число 20 в унитарном коде записывается как

В Keras также есть встроенная функция унитарного кодирования

Построение модели

В этой задаче размер выходного пространства (или слоя) равен 46, поэтому для качественного обучения будем использовать промежуточные слои размером 64 (против 16 в задаче бинарной классификации)

Нужно помнить две вещи:
1. Размер выходного полносвязного (Dense) слоя равен 46. Это значит, что для каждого входного примера, сеть выведет вектор с размерностью 46.
2. Каждый i-ый элемент этого вектора output[i] содержит вероятность, с который неизвестный пример принадлежит к i-му классу. Используется функция активации softmax, то есть все вероятности в сумме равны 1.

Лучшая функция потерь для данной задачи — categorical_crossentropy. Она измеряет расстояние между выходным распределением вероятности модели и правильным распределением ответов (labels). Минимизируя расстояние между двумя этими распределениями, вы обучаете модель:

Возьмём 1000 примеров из обучающей выборки для создания проверочной выборки

Источник

Обзор 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 на одной машине.

Сперва определим модель внутри области распределенной стратегии:

Затем обучим модель на данных как обычно:

Источник

Глубокое обучение в Keras – Построение модели глубокого обучения

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

Вступление

Глубокое обучение-одно из самых интересных и перспективных направлений искусственного интеллекта (ИИ) и машинного обучения в настоящее время. Благодаря огромным достижениям в области технологий и алгоритмов в последние годы глубокое обучение открыло дверь в новую эру приложений искусственного интеллекта.

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

Определение модели

Нейронная сеть глубокого обучения-это просто нейронная сеть со многими скрытыми слоями.

Определение модели может быть разбито на несколько характеристик:

Слои Глубокого обучения

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

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

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

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

Функции Активации

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

Входные и выходные слои

В дополнение к скрытым слоям модели имеют входной слой и выходной слой:

Количество нейронов во входном слое совпадает с количеством объектов в наших данных. Мы хотим научить сеть реагировать на эти особенности. У нас есть 67 функций в фреймах данных train_df и test_df – таким образом, наш входной слой будет иметь 67 нейронов. Они станут точкой входа в наши данные.

Поскольку выход модели будет непрерывным числом, мы будем использовать функцию linear activation, чтобы ни одно из значений не было обрезано.

Определение кода модели

Мы будем использовать несколько импорта для кода вперед:

Имея в виду эти импортные данные и параметры, давайте определим модель с помощью Keras:

Здесь мы использовали Keras’ Sequential() для создания экземпляра модели. Он берет группу последовательных слоев и складывает их вместе в единую модель. В конструктор Sequential() мы передаем список, содержащий слои, которые мы хотим использовать в нашей модели.

В этой модели мы сделали несколько Плотных слоев и один Выпадающий слой. Мы сделали input_shape равным количеству объектов в наших данных. Мы определяем это на первом слое как вход этого слоя.

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

Мы быстро сократили 30% входных данных, чтобы избежать переобучения. Значение seed равно 2, поэтому мы получаем более воспроизводимые результаты. Если бы мы просто совершенно случайно отбросили их, каждая модель была бы другой.

Компиляция модели

После определения нашей модели следующим шагом является ее компиляция. Компиляция модели Keras означает настройку ее для обучения.

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

Имея это в виду, давайте скомпилируем модель:

Обучение модели

Здесь мы передали обучающие данные ( train_df ) и метки поездов ( train_labels ).

Кроме того, обучение-это итеративный процесс. Мы сказали сети пройти через этот учебный набор данных 70 раз, чтобы узнать из него как можно больше. Результаты моделей в последнюю эпоху будут лучше, чем в первую.

Эти 20% будут использоваться не для обучения, а скорее для проверки, чтобы убедиться, что он прогрессирует.

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

Закончив, мы можем посмотреть, как это делается в каждую эпоху:

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

Мы можем ясно видеть, как значения mae и потерь со временем снижаются. Это именно то, что мы хотим – модель стала более точной с предсказаниями с течением времени.

Составление прогнозов с помощью модели

Теперь, когда наша модель обучена, давайте воспользуемся ею, чтобы сделать некоторые прогнозы. Мы берем элемент из тестовых данных (в test_df ):

Это значения единицы объекта и мы будем использовать модель для прогнозирования его цены продажи:

Теперь давайте получим фактическую цену единицы измерения из test_labels :

А теперь давайте сравним прогнозируемую цену и фактическую:

Давайте попробуем другой блок из test_df :

И мы повторим тот же процесс, чтобы сравнить цены:

Оценка модели

Это заключительный этап в нашем путешествии по построению модели глубокого обучения Keras. На этом этапе мы будем использовать модель для генерации прогнозов по всем единицам наших тестовых данных ( test_df ), а затем вычислить среднюю абсолютную ошибку этих прогнозов, сравнивая их с фактическими истинными значениями ( test_labels ).

Для вашего удобства функция evaluate() позаботится об этом за нас:

Давайте запустим код и посмотрим, как он работает:

Интерпретация характеристик модели

Чтобы интерпретировать эти результаты по-другому, давайте построим прогнозы относительно фактических цен:

Если бы наша модель была на 100% точна с 0 СДЕЛАННЫМИ точками, все точки появлялись бы точно на диагональной голубой линии. Однако ни одна модель не является точной на 100%, и мы видим, что большинство точек находятся близко к диагональной линии, что означает, что прогнозы близки к фактическим значениям.

Мы можем проверить эти точки и выяснить, можем ли мы выполнить еще некоторую предварительную обработку данных и проектирование объектов, чтобы модель предсказывала их более точно.

Вывод

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

Хотя мы и не были точны на 100%, нам удалось получить очень приличные результаты с небольшим количеством выбросов.

Источник

Обучение и оценка модели с Keras

Это руководство охватывает обучение, оценку и прогнозирование (выводы) моделей в TensorFlow 2.0 в двух общих ситуациях:

Установка

Часть I: Использование встроенных циклов обучения и оценки

При передаче данных во встроенные циклы обучения модели вы должны использовать массивы Numpy (если ваши данные малы и умещаются в памяти), либо объекты Dataset tf.data. В следующих нескольких параграфах мы будем использовать набор данных MNIST в качестве массива Numpy, чтобы показать, как использовать оптимизаторы, функции потерь и метрики.

Обзор API: первый полный пример

Давайте рассмотрим следующую модель (будем строим ее с помощью Functional API, но она может быть и Sequential или субклассированной моделью):

Вот как выглядит типичный полный процесс работы, состоящий из обучения, проверки на отложенных данных, сгенерированных из исходных данных обучения, и, наконец, оценки на тестовых данных:

Определение потерь, метрик и оптимизатора

Вам нужно передать их в модель в качестве аргументов метода compile() :

Аргумент metrics задается в виде списка — ваша модель может иметь любое количество метрик.

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

Обратите внимание, что часто функции потерь и метрики задаются с помощью строковых идентификаторов:

Для последующего переиспользования поместим определение нашей модели и шаг компиляции в функции; мы будем вызывать их несколько раз в разных примерах этого руководства.

Вам доступно множество встроенных оптимизаторов, функций потерь и метрик

Как правило, вам не нужно создавать с нуля собственные функции потерь, метрики, или оптимизаторы, поскольку то, что вам нужно, скорее всего, уже является частью Keras API:

Кастомные функции потерь

Кастомные метрики

Обработка функций потерь и метрик, не соответствующих стандартной сигнатуре

В таких случаях вы можете вызвать self.add_loss(loss_value) из метода call кастомного слоя. Вот простой пример, который добавляет регуляризацию активности (отметим что регуляризация активности встроена во все слои Keras — этот слой используется только для приведения конкретного примера):

Вы можете сделать то же самое для логирования значений метрик:

Вот простой пример:

Автоматическое выделение валидационного отложенного множества

В первом полном примере, как вы видели, мы использовали аргумент validation_data для передачи кортежа массивов Numpy (x_val, y_val) в модель для оценки валидационных потерь и метрик в конце каждой эпохи.

Вот другая опция: аргумент validation_split позволяет вам автоматически зарезервировать часть ваших тренировочных данных для валидации. Значением аргумента является доля данных, которые должны быть зарезервированы для валидации, поэтому значение должно быть больше 0 и меньше 1. Например, validation_split=0.2 значит «используйте 20% данных для валидации», а validation_split=0.6 значит «используйте 60% данных для валидации».

Вы можете использовать validation_split только когда обучаете модель данными Numpy.

Обучение и оценка с tf.data Dataset

Давайте теперь рассмотрим случай, когда ваши данные поступают в форме Dataset tf.data.

tf.data API это набор утилит в TensorFlow 2.0 для загрузки и предобработки данных быстрым и масштабируемым способом.

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

Если вы хотите учиться только на определенном количестве пакетов из этого Dataset, вы можете передать аргумент `steps_per_epoch`, который указывает, сколько шагов обучения должна выполнить модель, используя этот Dataset, прежде чем перейти к следующей эпохе.

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

Использование валидационного датасета

Вы можете передать экземпляр Dataset как аргумент validation_data в fit :

В конце каждой эпохи модель будет проходить по валидационному Dataset и вычислять потери и метрики на валидации.

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

Аргумент validation_split (генерирующий отложенную выборку из тренировочных данных) не поддерживается при обучении на объектах Dataset, поскольку для этого требуется возможность индексирования элементов, что в общем невозможно в Dataset API.

Другие поддерживаемые форматы входных данных

Кроме массивов Numpy и TensorFlow Dataset-ов, можно обучить модель Keras с использованием датафрейма Pandas, или с генераторами Python которые выдают значения пакетами.

В общем, мы рекомендуем вам использовать входные данные Numpy если их количество невелико и помещается в памяти, и Dataset-ы в других случаях.

Использование весов для примеров и классов

Кроме входных данных и меток модели можно передавать веса примеров и веса классов при использовании fit :

Словарь «class weights» является более специфичным экземпляром той же концепции: он сопоставляет индексам классов веса которые должны быть использованы для элементов принадлежащих этому классу. Например, если класс «0» представлен втрое меньше чем класс «1» в ваших данных, вы можете использовать class_weight= <0: 1., 1: 0.5>.

Вот примеры Numpy весов классов и весов элементов позволяющих придать большее значение корректной классификации класса #5 (соответствующий цифре «5» в датасете MNIST).

Вот соответствующий Dataset пример:

Передача данных в модели с несколькими входами и выходами

В предыдущих примерах, мы рассматривали модель с единственным входом (тензор размера (764,) ) и одним выходом (тензор прогнозов размера (10,) ). Но как насчет моделей, у которых есть несколько входов или выходов?

Рассмотрим следующую модель, в которой на входными данными являются изображения размера (32, 32, 3) (это (height, width, channels) ) и временные ряды размера (None, 10) (это (timesteps, features) ). У нашей модели будет два выхода вычисленных из комбинации этих входов: «score» (размерности (1,) ) и вероятностное распределение по пяти классам (размерности (5,) ).

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

Во время компиляции мы можем указать разные функции потерь для разных выходов, передав функции потерь в виде списка:

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

Аналогично для метрик:

Так как мы дали имена нашим выходным слоям, мы могли бы также указать функции потерь и метрики для каждого выхода в dict:

Мы рекомендуем использовать имена и словари если у вас более 2 выходов.

Имеется возможность присвоить разные веса разным функциям потерь (например, в нашем примере мы можем захотеть отдать предпочтение потере «score», увеличив в 2 раза важность потери класса), используя аргумент loss_weights :

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

Передача данных в модель с несколькими входами и выходами в fit происходит аналогично определению функции потерь в compile : вы можете передать списки массивов Numpy (совпадающие 1:1 с выходами на которых есть функции потерь) или словари сопоставляющие имена выходов массивам Numpy тренировочных данных.

Ниже пример для Dataset: аналогично массивам Numpy, Dataset должен возвращать кортеж словарей.

Использование колбеков

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

Выполнение валидации в различных точках во время обучения (кроме встроенной валидации в конце каждой эпохи)

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

Написание собственного колбека

Вот простой пример сохранения списка значений попакетных потерь во время обучения:

Сохранение контрольных точек моделей

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

Проще всего сделать это с помощью колбека ModelCheckpoint :

Вы также можете написать собственный колбек для сохранения и восстановления моделей.

Использование графиков скорости обучения

Обычным паттерном при тренировке моделей глубокого обучения является постепенное сокращение скорости обучения по мере тренировки модели. Это общеизвестно как «снижение скорости обучения».

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

Передача расписания оптимизатору

Вы можете легко использовать график статического снижения скорости обучения передав объект расписания в качестве аргумента learning_rate вашему оптимизатору:

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

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

Визуализация потерь и метрик во время обучения

Лучший способ следить за вашей моделью во время обучения — это использовать TensorBoard — приложение на основе браузера, которое вы можете запустить локально и которое предоставляет вам:

Использование колбека TensorBoard

В простейшем случае просто укажите, куда вы хотите, чтобы колбек писал логи, и все готово:

Колбек TensorBoard имеет много полезных опций, в том числе, писать ли лог вложений, гистограмм и как часто писать логи:

Часть II: Написание собственных циклов обучения и оценки с нуля

Использование GradientTape: первый полный пример

Вызов модели внутри области видимости GradientTape позволяет получить градиенты обучаемых весов слоя относительно значения потерь. Используя экземпляр оптимизатора, вы можете использовать эти градиенты для обновления переменных (которые можно получить с помощью model.trainable_weights ).

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

Низкоуровневая обработка метрик

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

Низкоуровневая обработка дополнительных потерь

В общем вы можете захотеть учесть эти потери в своих пользовательских циклах обучения (если только вы сами не написали модель и уже знаете, что она не создает таких потерь).

Вспомните пример из предыдущего раздела, где есть слой, который создает потери регуляризации:

Когда вы вызываете модель так:

потери которые она создает во время прямого прохода добавляются в атрибут model.losses :

Чтобы учесть эти потери во время обучения, все, что вам нужно сделать, это модифицировать цикл обучения, добавив к полному значению потерь sum(model.losses) :

Это была последняя часть паззла! Вы достигли конца руководства.

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

Источник