Embedding keras что это

Эмбеддинги признаков и повышение точности ML-моделей

Прим. Wunder Fund: короткая статья о том, как эмбеддинги могут помочь при работе с категориальными признаками и сетками. А если вы и так умеете в сетки — то мы скоро открываем набор рисерчеров и будем рады с вами пообщаться, stay tuned.

Создание эмбеддингов признаков (feature embeddings) — это один из важнейших этапов подготовки табличных данных, используемых для обучения нейросетевых моделей. Об этом подходе к подготовке данных, к сожалению, редко говорят в сферах, не связанных с обработкой естественных языков. И, как следствие, его почти полностью обходят стороной при работе со структурированными наборами данных. Но то, что его, при работе с такими данными, не применяют, ведёт к значительному ухудшению точности моделей. Это стало причиной появления заблуждения, которое заключается в том, что алгоритмы градиентного бустинга, вроде того, что реализован в библиотеке XGBoost, это всегда — наилучший выбор для решения задач, предусматривающих работу со структурированными наборами данных. Нейросетевые методы моделирования, улучшенные за счёт эмбеддингов, часто дают лучшие результаты, чем методы, основанные на градиентном бустинге. Более того — обе группы методов показывают серьёзные улучшения при использовании эмбеддингов, извлечённых из существующих моделей.

Эта статья направлена на поиск ответов на следующие вопросы:

Что такое эмбеддинги признаков?

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

Если использование эмбеддингов — это столь мощная методика — почему она недостаточно широко распространена?

Как создавать эмбеддинги?

Как использовать существующие эмбеддинги для улучшения других моделей?

Эмбеддинги признаков

Нейросетевые модели испытывают сложности при необходимости работы с разреженными категориальными признаками. Эмбеддинги — это возможность уменьшения размерности таких признаков ради повышения производительности модели. Прежде чем говорить о структурированных наборах данных, полезно будет разобраться с тем, как обычно используются эмбеддинги. В сфере обработки естественных языков (Natural Language Processing, NLP) обычно работают со словарями, состоящими из тысяч слов. Эти словари обычно вводят в модель с использованием методики быстрого кодирования (One-Hot Encoding), что, в математическом смысле, равносильно наличию отдельного столбца для каждого из слов. Когда слово передаётся в модель, в соответствующем столбце оказывается единица, в то время как во всех остальных выводятся нули. Это ведёт к появлению очень сильно разреженных наборов данных. Решение этой проблемы заключается в создании эмбеддинга.

Визуализация, выполненная с помощью TensorFlow Embedding Projector

По сути дела, речь идёт о том, что эмбеддинг, на основе обучающего текста, группирует слова со сходным значением и возвращает их местоположение. Например — значение эмбеддинга слова «fun» может быть подобно значениям эмбеддингов слов «humor» и «dancing», или словосочетания «machine learning». На практике нейронные сети демонстрируют значительное улучшение производительности при применении подобных репрезентативных свойств.

Эмбеддинги и структурированные данные

Структурированные наборы данных тоже часто содержат разреженные категориальные признаки. В вышеприведённой таблице, содержащей данные о продажах, имеются столбцы с почтовым индексом и идентификатором магазина. Так как в этих столбцах могут присутствовать сотни или тысячи уникальных значений, использование этих столбцов приведёт к появлению тех же проблем с производительностью, о которых мы говорили ранее в применении к NLP-моделям. Почему бы тут, по вышеописанной схеме, не воспользоваться эмбеддингами?

Проблема заключается в том, что сейчас мы имеем дело более чем с одним признаком. В данном случае это два отдельных разреженных категориальных столбца ( zip_code и store_id ), а так же другие ценные признаки, вроде общего объёма продаж конкретному клиенту. Мы просто не можем заложить все эти признаки в эмбеддинг. Но мы, однако, можем подготовить эмбеддинги в первом слое модели и добавить в модель, вместе с эмбеддингами, и обычные признаки. Это не только приведёт к преобразованию почтового индекса и идентификатора магазина в ценные признаки, но и позволит не «размывать» другие ценные признаки тысячами столбцов.

Пример эмбеддинга

Почему эмбеддингам не уделяют достаточно внимания?

В крупнейших компаниях, занимающихся машинным обучением (Machine Learning, ML), эта техника работы с данными, бесспорно, применяется. Проблема заключается в том, что подавляющее большинство дата-сайентистов, находящихся за пределами таких компаний, никогда даже и не слышали о таком способе использования эмбеддингов. Почему это так? Хотя я и не сказал бы, что эти методы чрезвычайно сложно реализовать, они сложнее того, чему учат на типичных онлайн-курсах. Большинство начинающих ML-практиков просто не научили тому, как использовать эмбеддинги вместе с другими некатегориальными признаками. В результате признаки вроде почтовых индексов и идентификаторов магазинов просто выбрасывают из модели. Но это — важные данные!

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

Создание эмбеддингов

Самое сложное при работе с эмбеддингами — разобраться с наборами данных TensorFlow. И хотя устроены они совсем не так понятно, как датафреймы Pandas, научиться работать с ними весьма полезно. В частности — полезно для того, кто хотя бы задумывается о том, чтобы его модели работали бы с огромными наборами данных, и для того, кто стремится к созданию более сложных нейросетевых моделей, чем те, которые он уже разрабатывает.

В этом примере мы воспользуемся гипотетической таблицей продаж, фрагмент которой приведён выше. Наша цель заключается в прогнозировании целевых месячных продаж. Мы, ради краткости и простоты, опустим то, что имеет отношение к дата-инжинирингу, и начнём с предварительно подготовленных датафреймов Pandas. При работе с более крупными наборами данных, скорее всего, работа начнётся не с датафреймов, но это — тема для отдельной статьи.

Первый шаг заключается в преобразовании датафреймов Pandas в наборы данных TensorFlow:

Здесь стоит обратить внимание на то, что наборы данных TensorFlow и результаты дальнейших преобразований данных не хранятся в памяти так же, как хранятся датафреймы Pandas. Они, по сути, представляют собой конвейер. Через него, пакет за пакетом, походят данные, что позволяет модели эффективно обучаться на наборах данных, которые слишком велики для размещения их в памяти. Именно поэтому мы преобразуем в наборы данных словари датафреймов, а не реальные данные. Обратите внимание на то, что мы, кроме прочего, задаём сейчас, а не во время обучения модели, размер пакета данных, поступая не так, как обычно поступают при использовании API Keras.

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

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

6 столбцам эмбеддинга). Но это — один из тех параметров, которые можно настраивать в собственной модели.

Теперь создадим простую модель:

Поздравляю! Вы только что обучили модель, в которой используются эмбеддинги. А как извлечь эмбеддинги из модели для использования их в других моделях? Достаточно просто взять из модели веса:

Обратите внимание на то, что порядок слоёв эмбеддингов может меняться, поэтому проверьте соответствие длины слоя весов количеству уникальных значений, объявленных выше. Это позволит вам убедиться в том, что вы взяли данные из правильного слоя. Теперь веса можно сохранить в датафрейме:

Итоги

Теперь, когда эмбеддинги сохранены, их можно включить в состав исходного набора данных. Можно даже ввести их в другие наборы данных, используя те же категориальные признаки. Я пока не встречался с ситуациями, когда использование расширенных наборов данных не приводило бы к росту точности моделей. Попробуйте эмбеддинги — и я обещаю, что их применение станет частью вашей обычной работы в сфере машинного обучения.

О, а приходите к нам работать? 😏

Мы в wunderfund.io занимаемся высокочастотной алготорговлей с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.

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

Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.

Источник

Делаем прогноз слов рекуррентной сетью Embedding слой

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

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

Каждое слово, затем, будет кодироваться one-hot вектором в соответствии с его номером в словаре:

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

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

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

По идее, мы здесь могли бы и не задавать максимальное число слов, тогда эта величина была бы определена автоматически при парсинге текста. Но данный параметр имеет один существенный плюс: из всех найденных слов мы оставляем 999 наиболее часто встречаемых (то есть maxWordsCount-1), то есть, мы имеем возможность отбросить редкие слова, которые особо не нужны при обучении НС.

Конечно, в данном случае, останутся все найденные слова, т.к. их общее число меньше 1000. Вообще, этот параметр устанавливается с позиции «здравого смысла». Например, при большой обучающей выборке, скорее всего, мы будем иметь дело с большинством слов (и их форм) русского языка. Какой лексический запас слов у среднестатистического человека? Около 10 000. Значит, для большой выборки можно указать значение

и это будет хорошим выбором.

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

Здесь отображаются кортежи со словом и его частотой встречаемости в тексте.

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

На выходе получим массив чисел объекта numpy:

Осталось закодировать числа массива data в one-hot векторы. Для этого мы воспользуемся методом to_categorical пакета Keras:

На выходе получим двумерную матрицу, состоящую из One-hot векторов:

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

И, далее, сформируем входной тензор и прогнозные значения также, как мы это делали с символами:

Все, у нас есть обучающая выборка и требуемые выходные значения. Осталось создать модель рекуррентной сети. Мы ее возьмем из предыдущего занятия с числом нейронов скрытого слоя 128 и maxWordsCount нейронами на выходе с функцией активации softmax:

Готово. Запускаем процесс обучения:

И давайте теперь посмотрим, что у нас получилось. Запишем функцию для формирования текста из спрогнозированных слов:

И вызовем ее с тремя первыми словами:

Получим вот такой результат:

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

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

Embedding-слой

Однако в такой реализации есть один существенный недостаток: входной тензор, что мы получили, занимает в памяти очень много места. Представьте, если решается реальная задача с числом слов 20 000. Тогда тензора будет содержать:

элементов

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

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

И отсюда хорошо видно, что если передавать на вход не такие расширенные векторы, а последовательность с порядковыми номерами слов в словаре:

То на входе НС можно реализовать простой алгоритм, который бы подавал 1 на нейрон с соответствующим номером этого слова, а остальные суммы приравнивались бы нулю. В итоге, мы существенно экономим память при хранении обучающей выборки, а результат получаем тот же самый. Именно такую операцию и выполняет Embedding слой. На выходах его слоя формируются выходные значения, равные весам связей для переданной 1:

Далее, эти значения весов подаются уже на следующий слой нейронной сети.

В Keras такой слой можно создать с помощью одноименного класса:

Есть и другие параметры, подробно о них можно почитать на странице документации по ссылке:

Этот слой можно создавать только как входной и в нашем случае мы его определим так:

Здесь 256 – это число выходов в Embedding-слое. В качестве входной обучающей выборки мы теперь можем использовать одномерный массив:

А выходные значения остаются прежними – двумерным массивом из One-hot векторов, так как у нас на выходе 1000 нейронов.

Далее, абсолютно также проводим обучение и немного модифицируем функцию buildPhrase:

И запускаем процесс прогнозирования слов. Как видите, использование Embedding слоя значительно упрощает и саму программу и размер используемой памяти.

Видео по теме

Нейронные сети: краткая история триумфа

Структура и принцип работы полносвязных нейронных сетей | #1 нейросети на Python

Ускорение обучения, начальные веса, стандартизация, подготовка выборки | #4 нейросети на Python

Функции активации, критерии качества работы НС | #6 нейросети на Python

Как нейронная сеть распознает цифры | #9 нейросети на Python

Оптимизаторы в Keras, формирование выборки валидации | #10 нейросети на Python

Batch Normalization (батч-нормализация) что это такое? | #12 нейросети на Python

Как работают сверточные нейронные сети | #13 нейросети на Python

Делаем сверточную нейронную сеть в Keras | #14 нейросети на Python

Примеры архитектур сверточных сетей VGG-16 и VGG-19 | #15 нейросети на Python

Теория стилизации изображений (Neural Style Transfer) | #16 нейросети на Python

Делаем перенос стилей изображений с помощью Keras и Tensorflow | #17 нейросети на Python

Как нейронная сеть раскрашивает изображения | #18 нейросети на Python

Введение в рекуррентные нейронные сети | #19 нейросети на Python

Как рекуррентная нейронная сеть прогнозирует символы | #20 нейросети на Python

Делаем прогноз слов рекуррентной сетью Embedding слой | #21 нейросети на Python

Как работают RNN. Глубокие рекуррентные нейросети | #22 нейросети на Python

Как делать сентимент-анализ рекуррентной LSTM сетью | #24 нейросети на Python

Рекуррентные блоки GRU. Пример их реализации в задаче сентимент-анализа | #25 нейросети на Python

Двунаправленные (bidirectional) рекуррентные нейронные сети | #26 нейросети на Python

Автоэнкодеры. Что это и как работают | #27 нейросети на Python

Вариационные автоэнкодеры (VAE). Что это такое? | #28 нейросети на Python

Делаем вариационный автоэнкодер (VAE) в Keras | #29 нейросети на Python

Расширенный вариационный автоэнкодер (CVAE) | #30 нейросети на Python

Что такое генеративно-состязательные сети (GAN) | #31 нейросети на Python

Делаем генеративно-состязательную сеть в Keras и Tensorflow | #32 нейросети на Python

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

Источник

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

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

МОДЕЛИ

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

ПРИМЕРЫ

Functional API: руководство

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

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

Давайте рассмотрим несколько простых примеров.

Первый пример: полносвязная сеть

Модель Sequential, вероятно, является лучшей реализацией подобной сети, но нам просто нужно начать с чего-то действительно простого.

from keras.layers import Input, Dense

from keras.models import Model

# Этот код вернет тензор

# Экземпляр слоя применяется к тензору и возвращает новый тензор

output_1 = Dense(64, activation=’relu’)(inputs)

output_2 = Dense(64, activation=’relu’)(output_1)

predictions = Dense(10, activation=’softmax’)(output_2)

# Мы создали модель, включающую

# один входной слой и три Dense слоя

model = Model(inputs=inputs, outputs=predictions)

model.fit(data, labels) # Старт обучения

Все модели могут вызываться как слои

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

# Это сработает и вернет 10мерный-softmax вектор, который мы определили выше.

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

from keras.layers import TimeDistributed

# Входной тензор для последовательности из 20 кадров

# каждый из которых содержит 784-мерный вектор

input_sequences = Input(shape=(20, 784))

# Применяем нашу предыдущую модель к каждому кадру во входной последовательности.

# Выход предыдущей модели был 10-мерный softmax вектор

# Поэтому на выходе новой модели будет последовательность из 20 10-мерных векторов

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

Рассмотрим хороший пример использования функционального API: модель с несколькими входами и несколькими выходами. Функциональное API позволяет легко управлять большим количеством пересекающихся потоков данных.

Давайте рассмотрим следующую модель. Мы попробуем предсказать сколько ретвитов и лайков будут получать заголовки новостей в Twitter. Основным входом в модель будет сам заголовок в виде последовательности слов. Помимо этого, наша модель будет иметь вспомогательный вход, на который будут подаваться дополнительные данные, такие как время публикации заголовка и т.п. Модель будет также иметь две функции ошибки. Использование основной функции ошибки ранее в модели является хорошим механизмом регуляризации для глубоких моделей.

Вот как выглядит наша модель:

Давайте реализуем это с помощью функционального API.

Основной вход получит заголовок в виде последовательности целых чисел (каждое целое число кодирует слово). Целые числа будет в интервале от 1 до 10000 (словарь из 10 тыс. слов), а последовательности будут длиной 100 слов.

from keras.layers import Input, Embedding, LSTM, Dense

from keras.models import Model

import numpy as np

np.random.seed(0) # Зададим случайное число для генератора

# Вход заголовка: предназначен для получения последовательности

# из 100 чисел в диапазоне от 1 до 10000

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

#указав его в параметре name

main_input = Input(shape=(100,), dtype=’int32′, name=’main_input’)

# Слой Embedding будет кодировать входную последовательность

#в последовательность 512-мерных векторов

x = Embedding(output_dim=512, input_dim=10000, input_length=100)(main_input)

# LSTM преобразует векторную последовательность в один вектор,

# содержащий информацию обо всей последовательности

Здесь мы добавим вспомогательные ошибки, что позволит плавно обучать LSTM и E,bedding-слой, даже если ошибки основной модели будут намного выше.

auxiliary_output = Dense(1, activation=’sigmoid’, name=’aux_output’)(lstm_out)

На этом шаге мы вводим в модель дополнительные данные, объединяя их с выходом LSTM:

auxiliary_input = Input(shape=(5,), name=’aux_input’)

x = keras.layers.concatenate([lstm_out, auxiliary_input])

# Вначале располагаем полносвязную сеть из 3 Dense-слоев

x = Dense(64, activation=’relu’)(x)

x = Dense(64, activation=’relu’)(x)

x = Dense(64, activation=’relu’)(x)

# И в завершении добавляем основной слой логистической регрессии

main_output = Dense(1, activation=’sigmoid’, name=’main_output’)(x)

Определяем модель с двумя входами и двумя выходами:

model = Model(inputs=[main_input, auxiliary_input], outputs=[main_output, auxiliary_output])

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

# Обучаем модель

Для вывода используйте:

pred = model.predict([headline_data, additional_data])

Общие слои

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

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

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

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

Давайте построим это с помощью функционального API. Возьмем за вход для твита двоичную матрицу формы (280, 256), т.е. последовательность из 280 векторов размера 256, где каждое измерение в 256-мерном векторе кодирует наличие/отсутствие символа (из алфавита, состоящего из 256 частых символов).

import kerasfrom keras.layers import Input, LSTM, Densefrom keras.models import Model

tweet_a = Input(shape=(280, 256))

tweet_b = Input(shape=(280, 256))

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

# Этот слой может принять за вход матрицу# и вернет вектор размера 64

# Когда мы повторно используем один и тот же экземпляр слоя# несколько раз, вес слоя# также повторно используется# (это фактически *один и тот же* слой).

# Затем мы сможем соединить два вектора. #

merged_vector = keras.layers.concatenate([encoded_a, encoded_b], axis=-1)

# И добавить логистическую регрессию сверху.

predictions = Dense(1, activation=’sigmoid’)(merged_vector)

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

model = Model(inputs=[tweet_a, tweet_b], outputs=predictions)

model.fit([data_a, data_b], labels, epochs=10)

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

Понятие «узел слоя»

При каждом вызове слоя на каком-либо входе создается новый тензор (выход слоя) и добавляется «узел» к слою, связывая входной тензор с выходным тензором. При многократном вызове одного и того же слоя этому слою принадлежат несколько узлов с индексами 0, 1, 2…

В предыдущих версиях Keras можно было получить выходной тензор экземпляра слоя с помощью layer.get_output() или его выходную форму с помощью layer.output_shape. И все же можно (за исключением того, что функция get_output() была заменена на выходное свойство). Но что делать, если слой подключен к нескольким входам?

a = Input(shape=(280, 256))

assert lstm.output == encoded_a

Not so if the layer has multiple inputs:

a = Input(shape=(280, 256))

b = Input(shape=(280, 256))

>> AttributeError: Layer lstm_1 has multiple inbound nodes,

hence the notion of «layer output» is ill-defined.

Use `get_output_at(node_index)` instead.

Ну ладно. Следующее:

assert lstm.get_output_at(0) == encoded_aassert lstm.get_output_at(1) == encoded_b

Достаточно просто, да?

То же самое справедливо и для свойств input_shape и output_shape: до тех пор, пока у слоя есть только один узел или пока все узлы имеют одну и ту же форму входа/выхода, тогда понятие «форма выхода/входа слоя» четко определено, и одна форма будет возвращена слоем.output_shape/layer.input_shape. Но если, например, применить один и тот же слой Conv2D к входу формы (32, 32, 3), а затем к входу формы (64, 64, 3), то слой будет иметь несколько форм входа/выхода, и нужно будет получить их, указав индекс узла, к которому они принадлежат:

a = Input(shape=(32, 32, 3))

b = Input(shape=(64, 64, 3))

conv = Conv2D(16, (3, 3), padding=’same’)

# Пока только один вход, далее:

assert conv.input_shape == (None, 32, 32, 3)

conved_b = conv(b)# теперь свойство `.input_shape` не сработает, но сработает следующее:

assert conv.get_input_shape_at(0) == (None, 32, 32, 3)assert conv.get_input_shape_at(1) == (None, 64, 64, 3)

Другие примеры

Примеры кода все еще являются лучшим способом начать, так что вот еще несколько.

Начальный модуль

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

from keras.layers import Conv2D, MaxPooling2D, Input

input_img = Input(shape=(256, 256, 3))

tower_1 = Conv2D(64, (1, 1), padding=’same’, activation=’relu’)(input_img)

tower_1 = Conv2D(64, (3, 3), padding=’same’, activation=’relu’)(tower_1)

tower_2 = Conv2D(64, (1, 1), padding=’same’, activation=’relu’)(input_img)

tower_2 = Conv2D(64, (5, 5), padding=’same’, activation=’relu’)(tower_2)

tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding=’same’)(input_img)

tower_3 = Conv2D(64, (1, 1), padding=’same’, activation=’relu’)(tower_3)

output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis=1)

Остаточное соединение на сверточном слое

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

from keras.layers import Conv2D, Input

# входной тензор для 3-канального изображения 256×256

x = Input(shape=(256, 256, 3))# 3×3 conv с 3 выходными каналами (так же, как и входные каналы)

y = Conv2D(3, (3, 3), padding=’same’)(x)# возвращает x + y.

z = keras.layers.add([x, y])

Модель общего видения

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

from keras.layers import Conv2D, MaxPooling2D, Input, Dense, Flattenfrom keras.models import Model

# Сначала определите модули видения

digit_input = Input(shape=(27, 27, 1))

x = Conv2D(64, (3, 3))(digit_input)

x = MaxPooling2D((2, 2))(x)

vision_model = Model(digit_input, out)

# Тогда определите модель tell-digits-apart.

digit_a = Input(shape=(27, 27, 1))

digit_b = Input(shape=(27, 27, 1))

# Модель видения будет общей, веса и все все остальное.

concatenated = keras.layers.concatenate([out_a, out_b])

out = Dense(1, activation=’sigmoid’)(concatenated)

classification_model = Model([digit_a, digit_b], out)

Визуальная модель ответа на вопрос

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

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

from keras.layers import Conv2D, MaxPooling2D, Flattenfrom keras.layers import Input, LSTM, Embedding, Densefrom keras.models import Model, Sequential

# Сначала определим модель видения, используя Sequential model.# Эта модель будет кодировать изображение в вектор.

vision_model.add(Conv2D(64, (3, 3), activation=’relu’, padding=’same’, input_shape=(224, 224, 3)))

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

vision_model.add(Conv2D(128, (3, 3), activation=’relu’, padding=’same’))

vision_model.add(Conv2D(128, (3, 3), activation=’relu’))

vision_model.add(Conv2D(256, (3, 3), activation=’relu’, padding=’same’))

vision_model.add(Conv2D(256, (3, 3), activation=’relu’))

vision_model.add(Conv2D(256, (3, 3), activation=’relu’))

# Теперь давайте возьмем тензор с выходом нашей модели видения:

image_input = Input(shape=(224, 224, 3))

# Далее определим языковую модель для кодирования вопроса в вектор.# Каждый вопрос будет длиной не более 100 слов,# и будем индексировать слова как целые числа от 1 до 9999.

question_input = Input(shape=(100,), dtype=’int32′)

embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input)

# Соединим вектор вопроса и вектор изображения:

merged = keras.layers.concatenate([encoded_question, encoded_image])

# И давайте тренировать логистическую регрессию более чем на 1000 слов сверху:

output = Dense(1000, activation=’softmax’)(merged)

# Это наша последняя модель:

vqa_model = Model(inputs=[image_input, question_input], outputs=output)

# Следующим этапом будет обучение этой модели фактическим данным.

Видео модель ответа на вопрос

from keras.layers import TimeDistributed

video_input = Input(shape=(100, 224, 224, 3))# Это наше видео, закодированное с помощью ранее обученной модели vision_model (веса повторно используются).

encoded_frame_sequence = TimeDistributed(vision_model)(video_input) # на выходе будет последовательность векторов

encoded_video = LSTM(256)(encoded_frame_sequence) # на выходе будет векторный

# Это представление кодировщика вопросов на уровне модели с повторным использованием тех же весов, что и раньше:

question_encoder = Model(inputs=question_input, outputs=encoded_question)

# Давайте используем его для кодирования вопроса:

video_question_input = Input(shape=(100,), dtype=’int32′)

# И это наша видео-модель, отвечающая на вопросы:

merged = keras.layers.concatenate([encoded_video, encoded_video_question])

output = Dense(1000, activation=’softmax’)(merged)

video_qa_model = Model(inputs=[video_input, video_question_input], outputs=output)

Источник