Verbose keras что это

Библиотеки для глубокого обучения: Keras

Привет, Хабр! Мы уже говорили про Theano и Tensorflow (а также много про что еще), а сегодня сегодня пришло время поговорить про Keras.

Изначально Keras вырос как удобная надстройка над Theano. Отсюда и его греческое имя — κέρας, что значит «рог» по-гречески, что, в свою очередь, является отсылкой к Одиссее Гомера. Хотя, с тех пор утекло много воды, и Keras стал сначала поддерживать Tensorflow, а потом и вовсе стал его частью. Впрочем, наш рассказ будет посвящен не сложной судьбе этого фреймворка, а его возможностям. Если вам интересно, добро пожаловать под кат.

Начать стоит от печки, то есть с оглавления.

Установка

Установка Keras чрезвычайно проста, т.к. он является обычным питоновским пакетом:

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

ВНИМАНИЕ: Чтобы работать с Keras, у вас уже должен быть установлен хотя бы один из фреймворков — Theano или Tensorflow.

Бэкенды

Бэкенды — это то, из-за чего Keras стал известен и популярен (помимо прочих достоинств, которые мы разберем ниже). Keras позволяет использовать в качестве бэкенда разные другие фреймворки. При этом написанный вами код будет исполняться независимо от используемого бэкенда. Начиналась разработка, как мы уже говорили, с Theano, но со временем добавился Tensorflow. Сейчас Keras по умолчанию работает именно с ним, но если вы хотите использовать Theano, то есть два варианта, как это сделать:

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

Также существует MXNet Keras backend, который пока не обладает всей функциональностью, но если вы используете MXNet, вы можете обратить внимание на такую возможность.

Еще существует интересный проект Keras.js, дающий возможность запускать натренированные модели Keras из браузера на машинах, где есть GPU.

Так что бэкенды Keras ширятся и со временем захватят мир! (Но это неточно.)

Практический пример

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

Данные

Обучение любой модели в машинном обучении начинается с данных. Keras содержит внутри несколько обучающих датасетов, но они уже приведены в удобную для работы форму и не позволяют показать всю мощь Keras. Поэтому мы возьмем более сырой датасет. Это будет датасет 20 newsgroups — 20 тысяч новостных сообщений из групп Usenet (это такая система обмена почтой родом из 1990-х, родственная FIDO, который, может быть, чуть лучше знаком читателю) примерно поровну распределенных по 20 категориям. Мы будем учить нашу сеть правильно распределять сообщения по этим новостным группам.

Вот пример содержания документа из обучающей выборки:

From: lerxst@wam.umd.edu (where’s my thing)
Subject: WHAT car is this!?
Nntp-Posting-Host: rac3.wam.umd.edu
Organization: University of Maryland, College Park
Lines: 15

I was wondering if anyone out there could enlighten me on this car I saw
the other day. It was a 2-door sports car, looked to be from the late 60s/
early 70s. It was called a Bricklin. The doors were really small. In addition,
the front bumper was separate from the rest of the body. This is
all I know. If anyone can tellme a model name, engine specs, years
of production, where this car is made, history, or whatever info you
have on this funky looking car, please e-mail.

Препроцессинг

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

На выходе у нас получились бинарные матрицы вот таких размеров:

Первое число — количество документов в выборке, а второе — размер нашего словаря (одна тысяча в этом примере).

Еще нам понадобится преобразовать метки классов к матричному виду для обучения с помощью кросс-энтропии. Для этого мы переведем номер класса в так называемый one-hot вектор, т.е. вектор, состоящий из нулей и одной единицы:

На выходе получим также бинарные матрицы вот таких размеров:

Как мы видим, размеры этих матриц частично совпадают с матрицами данных (по первой координате — числу документов в обучающей и тестовой выборках), а частично — нет. По второй координате у нас стоит число классов (20, как следует из названия датасета).

Все, теперь мы готовы учить нашу сеть классифицировать новости!

Модель

Модель в Keras можно описать двумя основными способами:

Sequential API

Первый — последовательное описание модели, например, вот так:

Functional API

Некоторое время назад появилась возможность использовать функциональное API для создания модели — второй способ:

Это позволяет сохранять модели в человеко-читаемом виде, а также инстанциировать модели из такого описания:

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

Визуализация модели

Нельзя обойти стороной визуализацию. Keras имеет встроенную визуализацию для моделей:

Этот код сохранит под именем model.png вот такую картинку:

Пакет graphviz в Ubuntu ставится так (в других дистрибутивах Linux аналогично):

На MacOS (используя систему пакетов HomeBrew):

Инструкцию установки на Windows можно посмотреть здесь.

Подготовка модели к работе

Итак, мы сформировали нашу модель. Теперь нужно подготовить ее к работе:

Custom loss

Здесь y_true и y_pred — тензоры из Tensorflow, поэтому для их обработки используются функции Tensorflow.

Обучение и тестирование

Наконец, пришло время для обучения модели:

Возвращает этот метод history — это история ошибок на каждом шаге обучения.

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

Callbacks

Нужно также сказать несколько слов о такой важной особенности Keras, как колбеки. Через них реализовано много полезной функциональности. Например, если вы тренируете сеть в течение очень долгого времени, вам нужно понять, когда пора остановиться, если ошибка на вашем датасете перестала уменьшаться. По-английски описываемая функциональность называется «early stopping» («ранняя остановка»). Посмотрим, как мы можем применить его при обучении нашей сети:

Проведите эксперимент и проверьте, как быстро сработает early stopping в нашем примере?

Tensorboard

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

Там можно посмотреть, например, как менялась целевая метрика на валидационной выборке:

(Кстати, тут можно заметить, что наша сеть переобучается.)

Продвинутые графы

Теперь рассмотрим построение чуть более сложного графа вычислений. У нейросети может быть множество входов и выходов, входные данные могут преобразовываться разнообразными отображениями. Для переиспользования частей сложных графов (в частности, для transfer learning ) имеет смысл описывать модель в модульном стиле, позволяющем удобным образом извлекать, сохранять и применять к новым входным данным куски модели.

Рассмотрим этот подход на примере модели Siamese Network. Схожие модели активно используются на практике для получения векторных представлений, обладающих полезными свойствами. Например, подобная модель может быть использована для того, чтобы выучить такое отображение фотографий лиц в вектор, что вектора для похожих лиц будут близко друг к другу. В частности, этим пользуются приложения поиска по изображениям, такие как FindFace.

Иллюстрацию модели можно видеть на диаграмме:

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

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

Будем описывать модель в коде соответствующим образом, максимально упростив извлечение и переиспользование частей нейросети.

Сначала определим на Keras функцию, отображающую входной вектор.

Теперь в переменных processed_a и processed_b лежат векторные представления, полученные путем применения сети, определенной ранее, к входным данным.

Отлично, мы получили расстояние между внутренними представлениями, теперь осталось собрать входы и расстояние в одну модель.

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

Загрузим данные и приведем картинки размера 28×28 к плоским векторам.

Отобразим картинки с помощью извлеченной ранее модели:

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

Полноценный пример сиамской сети можно увидеть здесь.

Заключение

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

Пришло время обсудить плюсы и минусы Keras. К очевидным плюсам можно отнести простоту создания моделей, которая выливается в высокую скорость прототипирования. Например, авторы недавней статьи про спутники использовали именно Keras. В целом этот фреймворк становится все более и более популярным:

Keras за год догнал Torch, который разрабатывается уже 5 лет, судя по упоминаниям в научных статьях. Кажется, своей цели — простоты использования — Франсуа Шолле (François Chollet, автор Keras) добился. Более того, его инициатива не осталась незамеченной: буквально через несколько месяцев разработки компания Google пригласила его заниматься этим в команде, разрабатывающей Tensorflow. А также с версии Tensorflow 1.2 Keras будет включен в состав TF (tf.keras).

Также надо сказать пару слов о недостатках. К сожалению, идея Keras о универсальности кода выполняется не всегда: Keras 2.0 поломал совместимость с первой версией, некоторые функции стали называться по-другому, некоторые переехали, в общем, история похожа на второй и третий python. Отличием является то, что в случае Keras была выбрана только вторая версия для развития. Также код Keras работает на Tensorflow пока медленнее, чем на Theano (хотя для нативного кода фреймворки, как минимум, сравнимы).

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

Практически весь код из статьи есть в виде одного ноутбука здесь. Также очень рекомендуем вам документацию по Keras: keras.io, а так же официальные примеры, на которых эта статья во многом основана.

Пост написан в сотрудничестве с Wordbearer.

Источник

Обучение и оценка модели с 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) :

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

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

Источник

Боковая панель

НАЧАЛО РАБОТЫ

МОДЕЛИ

ПРЕДОБРАБОТКА

ПРИМЕРЫ

Sequential model: руководство

Модель Sequential представляет собой линейный стек слоев.

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

Указание размерности входных данных

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

Таким образом, следующие примеры эквивалентны:

Компиляция

Перед обучением модели необходимо настроить сам процесс. Это выполняется с помощью метода compile(). Он получает три аргумента:

# Задача бинарной классификации
model.compile(optimizer=’rmsprop’, loss=’binary_crossentropy’, metrics=[‘accuracy’])

# Среднеквадратичная ошибка регрессии
model.compile(optimizer=’rmsprop’, loss=’mse’)

# Пользовательская метрика
import keras.backend as K
def mean_pred(y_true, y_pred):
return K.mean(y_pred)
model.compile(optimizer=’rmsprop’, loss=’binary_crossentropy’, metrics=[‘accuracy’, mean_pred])

Обучение

Модели Keras обучаются на Numpy-массивах, содержащих набор исходных данных и метки. Для обучения обычно используется функция fit(). Документация по этой функции здесь.

# Модель с одномерными входными данными и бинарной классификацией

model.add(Dense(32, activation=’relu’, input_dim=100))

# Генерируем случайные данные

import numpy as np

data = np.random.random((1000, 100))

labels = np.random.randint(2, size=(1000, 1))

# Обучаем модель, перебирая данные в пакетах по 32 примера

model.fit(data, labels, epochs=10, batch_size=32)

# Модель с одномерными входными данными и 10 классами

model.add(Dense(32, activation=’relu’, input_dim=100))

# Генерируем случайные данные

import numpy as np

data = np.random.random((1000, 100))

labels = np.random.randint(10, size=(1000, 1))

# Преобразуем метки в OHE (one-hot encoding)

one_hot_labels = keras.utils.to_categorical(labels, num_classes=10)

# Обучаем модель, перебирая данные в пакетах по 32 примера

model.fit(data, one_hot_labels, epochs=10, batch_size=32)

Примеры

Вот несколько примеров, с которых можно начать!

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

Многослойный персептрон (MLP) для мультиклассовой классификаци (softmax):

import keras

from keras.models import Sequential

from keras.layers import Dense, Dropout, Activation

from keras.optimizers import SGD

# Генерируем случайные данные

import numpy as np

x_train = np.random.random((1000, 20))

y_train = keras.utils.to_categorical(
np.random.randint(10, size=(1000, 1)), num_classes=10)

x_test = np.random.random((100, 20))

y_test = keras.utils.to_categorical(
np.random.randint(10, size=(100, 1)), num_classes=10)

# Dense(64) — это полносвязный слой с 64 скрытыми нейронами.

# в первом слое вы должны указать размерность входных данных:

# здесь, это векторы длинной 20.

model.add(Dense(64, activation=’relu’, input_dim=20))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

score = model.evaluate(x_test, y_test, batch_size=128)

MLP для бинарной классификации:

import numpy as np

from keras.models import Sequential

from keras.layers import Dense, Dropout

# Генерируем случайные данные

x_train = np.random.random((1000, 20))

y_train = np.random.randint(2, size=(1000, 1))

x_test = np.random.random((100, 20))

y_test = np.random.randint(2, size=(100, 1))

model.add(Dense(64, input_dim=20, activation=’relu’))

score = model.evaluate(x_test, y_test, batch_size=128)

VGG-подобная сверточная сеть:

import numpy as np

import keras

from keras.models import Sequential

from keras.layers import Dense, Dropout, Flatten

from keras.layers import Conv2D, MaxPooling2D

from keras.optimizers import SGD

# Генерируем случайные данные

x_train = np.random.random((100, 100, 100, 3))

y_train = keras.utils.to_categorical(
np.random.randint(10, size=(100, 1)), num_classes=10)

x_test = np.random.random((20, 100, 100, 3))

y_test = keras.utils.to_categorical(
np.random.randint(10, size=(20, 1)), num_classes=10)

# применим здесь сверточный слой с 32 нейронами и ядром свертки (3, 3)

model.add(Conv2D(32, (3, 3), activation=’relu’,
input_shape=(100, 100, 3)))

model.add(Conv2D(32, (3, 3), activation=’relu’))

model.add(Conv2D(64, (3, 3), activation=’relu’))

model.add(Conv2D(64, (3, 3), activation=’relu’))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

model.fit(x_train, y_train, batch_size=32, epochs=10)

score = model.evaluate(x_test, y_test, batch_size=32)

Классификация последовательностей с помощью LSTM:

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.layers import Embedding

from keras.layers import LSTM

model.fit(x_train, y_train, batch_size=16, epochs=10)

score = model.evaluate(x_test, y_test, batch_size=16)

Классификация последовательностей с помощью одномерной свертки:

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.layers import Embedding

from keras.layers import Conv1D, GlobalAveragePooling1D, MaxPooling1D

model.add(Conv1D(64, 3, activation=’relu’,
input_shape=(seq_length, 100)))

model.add(Conv1D(64, 3, activation=’relu’))

model.add(Conv1D(128, 3, activation=’relu’))

model.add(Conv1D(128, 3, activation=’relu’))

model.fit(x_train, y_train, batch_size=16, epochs=10)

score = model.evaluate(x_test, y_test, batch_size=16)

Классификация последовательностей с помощью LSTM с памятью:

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

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

from keras.models import Sequential

from keras.layers import LSTM, Dense

import numpy as np

# ожидаемая размерность входных данных:
# (batch_size, timesteps, data_dim)

model.add(LSTM(32, return_sequences=True,

input_shape=(timesteps, data_dim)))
# возвращает последовательность векторов длинной 32

model.add(LSTM(32, return_sequences=True))

# возвращает последовательность векторов длинной 32

model.add(LSTM(32)) # возвращает одиночный векторов длинной 32

# Генерируем случайные данные

x_train = np.random.random((1000, timesteps, data_dim))

y_train = np.random.random((1000, num_classes))

# Генерируем случайные проверочные данные

x_val = np.random.random((100, timesteps, data_dim))

y_val = np.random.random((100, num_classes))

LSTM с передачей состояния

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

from keras.models import Sequential

from keras.layers import LSTM, Dense

import numpy as np

# ожидаемая размерность входных данных:
# (batch_size, timesteps, data_dim)

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

# данных batch_input_shape, так как это сеть с состоянием

# i-тый пример в k-ом пакете является продолжением

# i-того примера в k-1-ом пакете

model.add(LSTM(32, return_sequences=True, stateful=True,

batch_input_shape=(batch_size, timesteps, data_dim)))

model.add(LSTM(32, return_sequences=True, stateful=True))

model.add(LSTM(32, stateful=True))

# Генерируем случайные данные

x_train = np.random.random((batch_size * 10, timesteps, data_dim))

y_train = np.random.random((batch_size * 10, num_classes))

# Генерируем случайные проверочные данные

x_val = np.random.random((batch_size * 3, timesteps, data_dim))

y_val = np.random.random((batch_size * 3, num_classes))

batch_size=batch_size, epochs=5, shuffle=False,

Источник