Размещено на http://www.allbest.ru/

Анализ диалогов социальных сетей при помощи рекуррентных нейронных сетей

Введение

В современном мире интернет играет огромную роль в жизни человека. Около 50% населения Российской Федерации являются пользователями интернета для различных нужд и это число растет с каждым днем.

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

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

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

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

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

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

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

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

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

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

Для этого были поставлены следующие задачи:

1. Разработать алгоритм предсказания интенции собеседника на основе анализа предыдущих интенций

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

1. Предсказание следующего элемента последовательности

алгоритм интенция нейронный сеть

Основной задачей в данной работе является предсказание мотива (интенции) следующего сообщения n+1 из цепочки сообщений длины n.

С математической точки зрения цепочку сообщений, где каждое сообщение имеет свой определенный и конечный эмоциональный окрас, можно представить как последовательность S = {s1, s2, …, sn} конечного алфавита I = {i1, i2, …, im }, где si I (1 . Пусть существует Т = { s1, s2, …, st } - набор обучающих последовательностей, использующихся для построения модели предсказания М. Тогда задача сводится к предсказанию следующего элемента последовательности sn+1 данной последовательности {s1, s2, …, sn} с использованием модели предсказания М.

Задача предсказания следующего элемента последовательности достаточно известна и имеет множество различных подходов к решению. Классические подходы, такие как методики контекстно-зависимого моделирования и анализа графа зависимостей (алгоритмы Prediction by Partial Matching, Dependency Graph) показали достаточно низкие результаты на тестовых выборках данных[2], поэтому в данной работе решено было сделать выбор в сторону более продвинутых техник анализа, таких как рекуррентные нейронные сети.

Далее будет рассмотрена выбранная топология сети с более детальным объяснением данного выбора.

1.1 Рекуррентные нейронные сети

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

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

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

Рекуррентные нейронные сети (Recurrent Neural Networks, RNN) в свою очередь позволяют решить проблему сохранения информации за счёт наличия обратных связей.

Рис. 1

Рекуррентную сеть можно рассматривать, как несколько копий одной и той же сети, каждая из которых передает информацию последующей копии (рис.1).

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

Стандартная версия RNN имеет существенный недостаток: сеть теряет способность связывать информацию при наличии долговременных зависимостей. Хотя с теоретической точки зрения проблем с обработкой долговременных зависимостей у RNN быть не должно, на практике обучить RNN этим параметрам оказалось невозможным [3,4].

Однако существует модификация рекуррентной нейронной сети, позволяющая решить проблему долгосрочных зависимостях: LSTM (Long Short-Term Memory).

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

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

1.2 Сети LSTM

Долгая краткосрочная память (Long short-term memory; LSTM) - особая разновидность архитектуры рекуррентных нейронных сетей, способная к обучению долговременным зависимостям. Они были представлены Зеппом Хохрайтер и Юргеном Шмидхубером (Jьrgen Schmidhuber) в 1997 году [5], а затем усовершенствованы и популярно изложены в работах многих других исследователей. Они прекрасно решают целый ряд разнообразных задач и в настоящее время широко используются.

LSTM разработаны специально, чтобы избежать проблемы долговременной зависимости.

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

Рис.2

Каждый модуль состоит из четырех взаимодействующих слоев (Рис.2).

Первый шаг в LSTM - определить, какую информацию можно выбросить из состояния ячейки. Это решение принимает сигмоидальный слой, называемый “слоем фильтра забывания” (forget gate layer). Он смотрит на ht?1 и xt и возвращает число от 0 до 1 для каждого числа из состояния ячейки Ct?1. 1 означает “полностью сохранить”, а 0 - “полностью выбросить”.

Второй шаг - решить, какая новая информация будет храниться в состоянии ячейки. Сначала сигмоидальный слой под названием “слой входного фильтра” (input layer gate) определяет, какие значения следует обновить, а затем tanh-слой строит вектор новых значений-кандидатов C~t, которые можно добавить в состояние ячейки.

Третий шаг - заменить старое состояние ячейки Ct?1 на новое состояние Ct: умножить старое состояние на ft, забывая то, что решено было забыть, а затем прибавить it?C~t. Это новые значения-кандидаты, умноженные на t - на сколько требуется обновить каждое из значений состояния.

Финальный шаг: определить информацию на выходе. Сначала применяется сигмоидальный слой, который решает, какую информацию из состояния ячейки требуется выводить. Затем значения состояния ячейки проходят через tanh-слой, чтобы получить на выходе значения из диапазона от -1 до 1, и перемножаются с выходными значениями сигмоидального слоя, что позволяет выводить только требуемую информацию.

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

2. Определение интенции собеседника

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

2.1 Типы интенций

Интенция или мотив собеседника - это намерение, эмоциональная окраска сообщения. Исследования в области психологии и анализа социальных сетей вывели, что существует конечное число видов интенций, определяющих окрас сообщения и направление беседы. Олешковым М.Ю. и Радиной Н.К были выведены следующие тезисы [6, 7]: все интенции можно разделить на 25 категорий, которые в свою очередь входят в 5 «супер-категорий». Олешков М.Ю. предложил типизировать не речевые акты, а коммуникативную стратегию как основную цель речевого акта, а в свою очередь Радина Н.К. разделила 25 полученных категорий на 5 «супертипов» по общей направленности сообщения. При классификации авторы пользовались идеями Юргена Хабермаса (р. 1929) -- немецкого социолога, автора теории коммуникативного действия, которая является синтезом рациональности социального действия и интеракции.

Далее приведена таблица классификаций интенций. Каждая буква представляет собой отдельный вид интенции. В рамках данной работы последовательностью интенций называется конечная направленная последовательность элементов Таблицы 1, а предсказанием интенции будет являться так же один из элементов Таблицы 1. Для сравнения результаты предсказания нужно сравнивать как по обычным типам (25 типов), так и среди супертипов (5 типов).

Таблица 1 Классификация интенций по Хабермасу:

1. Информативно- воспроизводящий тип, Воспроизвести в речи наблюдаемое	2. Эмотивно-консолидирующий тип, Предложение собственной картины мира для кооператив- ного взаимодействия	3. Манипулятивный тип, Со- циальное доминирование, установление иерархии	4. Волюнтивно-директивный тип, Побудить адресата к действию, внести изменения в фрагмент действитель- ности	5. Контрольно- реактивный тип, Выразить оценочную реак- цию на ситуацию
А Удивление Вопрос	Е Самопрезентация	Л Оскорбление	Р Поощрение к положительным действиям Рекомендации	Х Одобрение Похвала
Б Несогласие Сомнение	Ж Привлечение внимания Риторические вопросы	М Запугивание, Угрозы	С Подстрекательство к отрицательному	Ц Сарказм Злорадство
В Согласие Поддержка	З Успокоение аудитории Подбадривание	Н Дискредитация (нарушение полномочий)	Т Обвинение	Ч Критика
Г Непринятие Отказ от общения	И Прогнозы	О Демонстрация силы (без прямых угроз)	У Предупреждение о последствиях	Ш Ирония
Д Сострадание Симпатия	К Обоснование (как самооправдание, например, без обвинений)	П Морализация, проповедь	Ф Отвод обвинений (ес- ли обвиняют)	Щ Разоблачение

2.2 Классификация типов интенции при помощи машинного обучения

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

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

Карпов Н.В. и Демидовский А.В. сильно упростили процесс классификации при помощи рекуррентных нейронных сетей [8].

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

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

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

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

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

3. Предсказание интенции собеседника

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

алгоритм интенция нейронный сеть

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

GML (Graph Modelling Language) - иерархический формат файлов для описания графов, основанный на ASCII.

Каждый граф представляет собой один пост в социальной сети “Вконтакте” и цепочки ответов пользователей на него. Пользователи могут отвечать как на первоначальный пост, так и на уже существующие в посте ответы, порождая тем самым древовидную структуру переписки.

Визуально подобную переписку можно представить в виде дерева (рис. 3).

Рис.3

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

3.2 Архитектура сети LSTM

Для экспериментов использовалась достаточно простая архитектура LSTM сети, представляющая из себя некоторое конфигурируемое количество слоев LSTM cells (производились эксперименты с различным количеством LSTM слоев) и конфигурируемое количество Dense Layers (плотных слоев).

Отличительной чертой данной сети является конфигурируемый параметр TIME_STEP. Данный параметр отвечает за длину хранимой в ячейке LSTM информации или же, говоря более простыми словами, на сколько шагов назад будет смотреть сеть, выполняя предсказание. TIME_STEP = 10 означает, что для каждого предсказания мы должны представить ячейке LSTM 10 «исторических точек» данных.

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

Предположим, у нас есть последовательность S = [1, 2, 3, 4, 5] и TIME_STEP =3.

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

X = [[1, 2, 3], [2, 3, 4]] - обучающая выборка

Y = [4, 5] - правильное значение для последнего элемента каждой подпоследовательности.

3.3 Алгоритм предсказания последовательности

Из вышеописанных шагов складывается следующий алгоритм предсказания последовательности:

1. Разделить исходные данные на набор последовательностей Sn = {s1, s2, …, sn} конечного алфавита I = {i1, i2, …, i25 }, где Si - действительное число, соответствующее определенному символу алфавита I, а n - количество веток в дереве

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

3. Полученный набор данных использовать для обучения модели LSTM

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

Тестирование проводилось как для полного набора интенций (25 типов) так и для обобщенной выборки из «супертипов» (5 штук). Как показатель точности использовались такие метрики как precision (hitpoint, точность попадания) и MSE (mean-square error, среднеквадратичное отклонение). В рамках данного исследования было произведено большое количество экспериментов с топологией сети и ее входными параметрами. Далее будут рассмотрены полученные результаты.

3.4 Результаты

В данной таблице (Таблица 2) приведены результаты обучения LSTM сети с различными вариантами параметров для последовательностей 25 видов интенций:

Таблица 2

Experiment #	1	2	3
TIME_STEP	2	5	10
RNN_LAYERS	5	5	10
DENSE_LAYERS	[10, 10]	[10,10]	None
TRAINING_STEPS	500000	500000	500000
Precision	0.26	0.01	0.038
MSE	37.091499	51.019249	66.865

3.5 Результаты для «супертипов» интенций

В данной таблице (Таблица 3) приведены результаты обучения LSTM сети с различными вариантами параметров для последовательностей «супертипов» интенций:

Таблица 3

Experiment #	1	2	3
TIME_STEP	2	5	10
RNN_LAYERS	5	5	10
DENSE_LAYERS	[10, 10]	[10,10]	None
TRAINING_STEPS	500000	500000	500000
Precision	0.58	0.52	0.24
MSE	1.07	1.16	1.89

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

3.6 Сравнение результата с алгоритмами PPM, DG, CPT+

Прошлые исследования показали, что такие алгоритмы предсказания следующего элемента последовательности, как Prediction By Partial Matching (PPM), Dependency Graph (DG) и CPT+ (Compact Prediction Tree +) дают средние показатели производительности и точности.

Таблица № 4 содержит сравнительные показатели точности для представленных алгоритмов в сравнении с алгоритмом, основанном на сети LSTM для 25 и 5 классов:

Алгоритм	Точность для 25 классов	Точность для 5 классов
PPM	0,26582	0,3563
DG	0,2345679	0,37837
CPT+	0,48	0,666
LSTM	0.26	0.58

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

3.7 Общие выводы

К сожалению, полученные результаты далеки от идеала, но дают возможность сделать следующие выводы:

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

2. Предсказание супертипов дает результаты во много раз превышающие предсказание обычных типов интенций

Одной из возможных причин неточности предсказания интенций может являться сама выборка данных. При создании данной выборки результаты точности для 25 типов интенций были показательно низкими [8], что в свою очередь могло так же привести и к низким показателям предсказывания следующего элемента.

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

Заключение

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

Улучшение показателей можно добиться за счёт:

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

- Использования сети другой топологии - при отсутствии долгосрочных зависимостей использование LSTM сетей является избыточным

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

Список литературы

1. Boyd, D. and Ellison, N. Social Network Sites: Definition, History, and Scholarship (англ.) // Journal of Computer-Mediated Communication. -- 2007. -- Vol. 13, no. 1. -- P. 210-230. -- ISSN 10836101

2. Мартиросян, А.Г. Разработка алгоритма предсказания интенции собеседника в диалоге, НИУ ВШЭ, 2017г.

3. Sepp Hochreiter, Yoshua Bengio, Paolo Frasconi, Juergen Schmidhuber. Gradient flow in recurrent nets: the difficulty of learning long-term dependencies. In S. C. Kremer and J. F. Kolen, eds., A Field Guide to Dynamical Recurrent Neural Networks. IEEE press, 2001.

4. Y. Bengio, P. Frasconi, P. Simard, "The problem of learning long-term dependencies in recurrent networks", IEEE International Conference on Neural Networks 1993.

5. Long short-term memory. S Hochreiter, J Schmidhuber - Neural computation, 1997 - MIT Press

6. Radina Nadezhda K. Intent alysis of online discussions (using examples from the internet portal inosmi.ru). Mediascope, (4), 2016.

7. M. Yu. Oleshkov. Simulation of the communication process: monograph. Nizhny Tagil gos.sots.-ped.akademiya (et al.), 2006.

8. Nikolay Karpov, Alexander Demidovskij, and Alexey Malafeev. “Development of a Model to Predict Intention Using Deep Learning”, National Research University Higher School of Economics, Russia.

9. F. A. Gers; J. Schmidhuber; F. Cummins. Learning to forget: continual prediction with LSTM, 1999 Ninth International Conference on Artificial Neural Networks ICANN 99. (Conf. Publ. No. 470)

10. Duyu Tang, Bing Qin, and Ting Liu. Document modeling with gated recurrent neural network for sentiment classification. In EMNLP, pages 1422-1432, 2015.

11. Latynov V.V., Cepcov V.A., and Alexeev K.I. Words in action: Intent-analysis of political discourse. 2000.

Приложение

Исходный код

Lstm.py

# -*- coding: utf-8 -*-

from __future__ import absolute_import, division, print_function

import tensorflow as tf

from tensorflow.python.framework import dtypes

from tensorflow.contrib import learn as tflearn

from tensorflow.contrib import layers as tflayers

def lstm_model(num_units, rnn_layers, dense_layers=None, learning_rate=0.1, optimizer='Adagrad'):

"""

Creates a deep model based on:

* stacked lstm cells

* an optional dense layers

:param num_units: the size of the cells.

:param rnn_layers: list of int or dict

* list of int: the steps used to instantiate the `BasicLSTMCell` cell

* list of dict: [{steps: int, keep_prob: int}, ...]

:param dense_layers: list of nodes for each layer

:return: the model definition

def lstm_cells(layers):

if isinstance(layers[0], dict):

return [tf.contrib.rnn.DropoutWrapper(

tf.contrib.rnn.BasicLSTMCell(

layer['num_units'], state_is_tuple=True

),

layer['keep_prob']

) if layer.get('keep_prob') else tf.contrib.rnn.BasicLSTMCell(

layer['num_units'],

state_is_tuple=True

) for layer in layers

]

return [tf.contrib.rnn.BasicLSTMCell(steps, state_is_tuple=True) for steps in layers]

def dnn_layers(input_layers, layers):

if layers and isinstance(layers, dict):

return tflayers.stack(input_layers, tflayers.fully_connected,

layers['layers'],

activation=layers.get('activation'),

dropout=layers.get('dropout'))

elif layers:

return tflayers.stack(input_layers, tflayers.fully_connected, layers)

else:

return input_layers

def _lstm_model(X, y):

stacked_lstm = tf.contrib.rnn.MultiRNNCell(lstm_cells(rnn_layers), state_is_tuple=True)

x_ = tf.unstack(X, axis=1, num=num_units)

output, layers = tf.contrib.rnn.static_rnn(stacked_lstm, x_, dtype=dtypes.float32)

output = dnn_layers(output[-1], dense_layers)

prediction, loss = tflearn.models.linear_regression(output, y)

train_op = tf.contrib.layers.optimize_loss(

loss, tf.contrib.framework.get_global_step(), optimizer=optimizer,

learning_rate=learning_rate)

return prediction, loss, train_op

return _lstm_model

sequence_processing.py

import numpy as np

def prepareSeqs(all_seq, TIMESTEPS):

prepared_seqs = []

for seq in all_seq:

if len(seq) <= TIMESTEPS:

prepared_seqs.append(prepareSeq(seq, TIMESTEPS))

else:

prepared_seqs.append(seq)

return prepared_seqs

def prepareSeq(seq, timesteps):

fullSeq = []

for i in range(0, timesteps - len(seq)+1):

fullSeq.append(seq[0])

fullSeq = fullSeq + seq

return fullSeq

def splitToSubContext(seqs, timesteps, labels):

data = []

for seq in seqs:

rnn_df = []

for i in range(len(seq) - timesteps):

if labels:

try:

seq_list = [seq[i + timesteps]]

rnn_df.append(np.array(seq_list, dtype=np.float32))

except AttributeError:

rnn_df.append(seq[i + timesteps])

else:

data_ = seq[i: i + timesteps]

data_ = np.array(data_, dtype=np.float32)

data_ = data_.reshape((timesteps, 1))

rnn_df.append(data_)

data.append(np.array(rnn_df, dtype=np.float32))

return data

def prepare_data(data, time_steps, labels=False, val_size=0.1, test_size=0.1):

"""

Given the number of `time_steps` and some data,

prepares training, validation and test data for an lstm cell.

"""

df_train, df_val, df_test = split(data, val_size, test_size)

return (splitToSubContext(df_train, time_steps, labels=labels),

splitToSubContext(df_val, time_steps, labels=labels),

splitToSubContext(df_test, time_steps, labels=labels))

def split_d(data, timesteps):

train_x, val_x, test_x = prepare_data(data, timesteps)

train_y, val_y, test_y = prepare_data(data, timesteps, labels=True)

return dict(train=train_x, val=val_x, test=test_x), dict(train=train_y, val=val_y, test=test_y)

def split(data, val_size=0.1, test_size=0.1):

"""

splits data to training, validation and testing parts

"""

ntest = int(round(len(data) * (1 - test_size)))

nval = int(round(len(data[:ntest]) * (1 - val_size)))

df_train, df_val, df_test = data[:nval], data[nval:ntest], data[ntest:]

return df_train, df_val, df_test

predict.py

import datetime

import numpy as np

import pandas as pd

import tensorflow as tf

from igraph import *

from sklearn.metrics import mean_squared_error

from tensorflow.contrib import learn

from lstm import lstm_model

from sequence_processing import *

tf.logging.set_verbosity(tf.logging.INFO)

import os, shutil

LOG_DIR = './ops_logs/lstm_seqs'

TIMESTEPS = 10

RNN_LAYERS = [{'num_units': 10}]

DENSE_LAYERS = None

USE_SUPERTYPES = False

TRAINING_STEPS = 500000

BATCH_SIZE = 1000

PRINT_STEPS = TRAINING_STEPS / 100

ALPHABET_PATH = "alphabet.txt"

DATA_PATH = "./data/"

#RNN_LAYERS = [{'num_units': 10}, {'num_units': 5}]

#DENSE_LAYERS = None

data_in = DATA_PATH + "test1.gml"

data_ascii = DATA_PATH + "test-no-ascii2.gml"

alphabet = {0: ""}

supertypes = {0: ""}

all_seq = []

def getSupertypeValue(intent):

if intent == "":

return 0

for supertype, intentList in supertypes.items():

if intent in intentList:

return supertype

def traverse(graph, vertex, sequence):

if sequence == None:

current_seq = []

else:

current_seq = list(sequence)

if USE_SUPERTYPES == False:

intent_num_value = alphabet.get(vertex["intent"])

else:

intent_num_value = getSupertypeValue(vertex["intent"])

if intent_num_value == None:

intent_num_value = 0

current_seq.append(intent_num_value)

neightbors = graph.neighbors(vertex.index, mode='OUT')

if len(neightbors) > 0:

for n in neightbors:

neightbor = graph.vs[n]

traverse(graph, neightbor, current_seq)

else:

all_seq.append(current_seq)

def get_all_seqs(graph):

traverse(graph, graph.vs[0], None)

# print(all_seq)

def load_russian_alphabet(path, dict):

with open(path, 'r', encoding='utf8') as alphabet_file:

i = 1.0

for line in alphabet_file:

line = line.rstrip('\n')

dict[line] = i

i = i + 1

def splitToSupertypes(supertypesdict):

st1 = {"а", "б", "в", "г", "д"}

st2 = {"е", "ж", "з", "и", "к"}

st3 = {"л", "м", "н", "о", "п"}

st4 = {"р", "с", "т", "у", "ф"}

st5 = {"х", "ц", "ч", "ш", "щ"}

supertypesdict[1] = st1

supertypesdict[2] = st2

supertypesdict[3] = st3

supertypesdict[4] = st4

supertypesdict[5] = st5

def load_weather_frame(filename):

# load the weather data and make a date

data_raw = pd.read_csv(filename, dtype={'Time': str, 'Date': str})

data_raw['WetBulbCelsius'] = data_raw['WetBulbCelsius'].astype(float)

times = []

for index, row in data_raw.iterrows():

_t = datetime.time(int(row['Time'][:2]), int(row['Time'][:-2]), 0) # 2153

_d = datetime.datetime.strptime(row['Date'], "%Y%m%d") # 20150905

times.append(datetime.datetime.combine(_d, _t))

data_raw['_time'] = pd.Series(times, index=data_raw.index)

df = pd.DataFrame(data_raw, columns=['_time', 'WetBulbCelsius'])

return df.set_index('_time')

def processSequences(all_seq, TIMESTEPS):

prepared_seqs = prepareSeqs(all_seq, TIMESTEPS)

return split_d(prepared_seqs, TIMESTEPS)

def mergeSeq(trainx):

return np.concatenate(trainx)

def mergeSeqs(X, y):

return dict(train=mergeSeq(X['train']), val=mergeSeq(X['val']), test=mergeSeq(X['test'])), dict(

train=mergeSeq(y['train']), val=mergeSeq(y['val']), test=mergeSeq(y['test']))

def clearLogFolder():

for the_file in os.listdir(LOG_DIR):

file_path = os.path.join(LOG_DIR, the_file)

try:

if os.path.isfile(file_path):

os.unlink(file_path)

elif os.path.isdir(file_path):

shutil.rmtree(file_path)

except Exception as e:

print(e)

def main():

clearLogFolder()

load_russian_alphabet(ALPHABET_PATH, alphabet)

if USE_SUPERTYPES:

splitToSupertypes(supertypes)

g = Graph()

g = g.Read(data_in)

get_all_seqs(g)

if len(all_seq) > 0:

print("Parsingsequences")

X, y = processSequences(all_seq, TIMESTEPS)

print("Merging sequences")

Xm, ym = mergeSeqs(X, y)

print("Create regressor")

regressor = learn.SKCompat(learn.Estimator(

model_fn=lstm_model(

TIMESTEPS,

RNN_LAYERS,

DENSE_LAYERS, optimizer="Adam"

),

model_dir=LOG_DIR

))

# create a lstm instance and validation monitor

validation_monitor = learn.monitors.ValidationMonitor(Xm['val'], ym['val'],

every_n_steps=PRINT_STEPS,

early_stopping_rounds=1000)

print("fit regressor")

regressor.fit(Xm['train'], ym['train'],

monitors=[validation_monitor],

batch_size=BATCH_SIZE,

steps=TRAINING_STEPS)

print("predicting")

predicted = regressor.predict(Xm['test'])

# rmse = np.sqrt(((predicted - ym['test']) ** 2).mean(axis=0))

score = mean_squared_error(predicted, ym['test'])

hited = hitpoint(predicted, ym['test'])

print("MSE: %f" % score)

print("hitpoint:", hited)

# print (predicted)

def hitpoint(predicted, test):

hited = 0

i = 0

for predicion in predicted:

roundedPredicion = int(math.ceil(predicion))

testValue = test[i][0]

if testValue == int(roundedPredicion):

hited = hited + 1

i = i + 1

hitpoint = hited / len(predicted)

return hitpoint

if __name__ == "__main__":

main()

Размещено на Allbest.ru

...