Как попасть в топ 2% соревнования Kaggle

26 ноября 2018
kaggle competition

Как попасть в топ 2% соревнования Kaggle

Статья основана на реальном опыте участия в соревнованиях на Kaggle, автор — Abhay Pawar. Ссылка на оригинал в подвале статьи.  Участвовать в соревнованиях Kaggle весело и захватывающе! За последние пару лет…

Статья основана на реальном опыте участия в соревнованиях на Kaggle, автор — Abhay Pawar. Ссылка на оригинал в подвале статьи. 

Участвовать в соревнованиях Kaggle весело и захватывающе! За последние пару лет я разработал несколько простых способов создания более совершенных моделей машинного обучения. Эти простые, но мощные методы помогли мне попасть в топ 2% соревнования Instacart Market Basket Analysis, и я также использую их вне Kaggle. Давайте рассмотрим методы поближе.

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

график признаков

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

  1. Понимание признаков;
  2. Поиск признаков с большими шумами (самая интересная часть!);
  3. Разработка признаков;
  4. Важность признаков;
  5. Отладка признаков;
  6. Обнаружение утечек;
  7. Мониторинг модели.

Чтобы вы легко могли попробовать сами, я решил включить эти методы в пакет featexp на Python, и в этой статье мы увидим, как их можно использовать для исследования признаков. Мы будем использовать датасет из соревнования Kaggle Home Credit Default Risk. Задача конкурса — предсказать неплательщиков по известным данным о клиентах.

Понимание признаков

понимание признаков - kaggle соревнование
График зависимости признака от цели ничего не дает

Если зависимая переменная (цель) является двоичной, строить графики бессмысленно, потому что все точки имеют значение либо 0, либо 1. Для цели с непрерывной областью значений большое количество точек затрудняет понимание взаимосвязи цели и признаки. Featexp создает более полезные графики. Посмотрим на них:

Зависимость признака от цели
Зависимость признака от цели — DAYS_BIRTH (возраст)

Featexp создает бины (ось X) признака. Затем он вычисляет среднее значение цели в каждом бине и отображает его на рисунке слева. Из графика следует, что у клиентов с высокими отрицательными значениями для DAYS_BIRTH (с большим возрастом) более низкие ставки. Это имеет смысл, поскольку молодые люди обычно чаще просрочивают платежи. Эти графики помогают нам понять, что свойство может сказать о клиентах и ​​как это повлияет на модель. Участок справа показывает количество клиентов в каждом бине.

Поиск признаков с большим шумом

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

решение для соревнований kaggle
Сравнение признака при обучении и при проверке

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

  1. Корреляция тренда (показана на графике проверки): если признак ведет себя по-разному при обучении и при проверке, это может приводить к перегрузке модели. Так происходит, потому что модель обучается тому, что не применимо на тестовых данных. Коррекция тренда помогает понять, насколько схоже поведение признака при обучении и при проверке. Признак на графике выше имеет корреляцию 99%. Это не «шумящее» свойство!
  2. Изменения тренда: внезапные и повторяющиеся изменения тренда могут означать наличие шумов. Но такое изменение тренда может произойти, потому что у данного бина совсем другое количество значений в других признаках и, следовательно, его частота не может сравниваться с другими бинами.

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

Пример функции с большими шумами

Отключение хорошо работает, если есть много связанных друг с другом признаков. Это приводит к меньшей перегрузке, а другие признаки позволяют избежать потери информации. Также важно не отключать слишком много важных признаков, поскольку это может привести к снижению производительности. То, что признак является важным, не значит, что он не может быть «шумным» — и в этом случае его нельзя отключать!

Используйте тестовые данные на другом интервале времени. Тогда вы будете уверены, что тренд не меняется со временем.

Функция get_trend_stats() в featexp возвращает таблицу с корреляцией тренда и изменением каждого признака.

участие в соревновании Kaggle
Результат, возвращаемый функцией get_trend_stats()

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

AUC при включении различных признаков с использованием корреляции тренда

Можно видеть: чем выше порог корреляции тренда, тем выше AUC. Не отключая важные признаки, можно добиться увеличения LB AUC до 0,74. Интересно, что AUC не меняется так сильно, как LB AUC. Важно правильно выбрать стратегию проверки: так, чтобы локальный тест AUC совпадал с LB AUC. Весь код можно найти в featexp_demo.

Разработка признаков

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

Зависимость признака от цели EXT_SOURCE_1
Зависимость признака от цели EXT_SOURCE_1

Клиенты с высоким значением EXT_SOURCE_1 имеют низкие ставки. Но первый бин (ставка ~ 8%) не соответствует тренду признака (идет вверх, а затем вниз). Он имеет только отрицательные значения вблизи -99.985 и большое количество единиц в бине. Это, вероятно, подразумевает, что это специальные значения. К счастью, нелинейные модели не будут испытывать проблемы с обучением этим связям. Но для линейных моделей, таких как логистическая регрессия, такие специальные значения и нули (которые будут показаны как отдельный бин) должны быть поданы в значение из бина с аналогичной ставкой вместо простой подачи со средним значением признака.

Важность признаков

Featexp также помогает определить относительную важность того или иного признака. DAYS_BIRTH и EXT_SOURCE_1 имеют хорошую линию тренда. Но большинство единиц EXT_SOURCE_1 сосредоточено в специальном бине значений, что означает, что признак почти одинаков для большинства клиентов и, следовательно, не может хорошо их дифференцировать. Это говорит о том, что признак может быть не так важен, как DAYS_BIRTH. Основываясь на модели важности признаков XGBoost, DAYS_BIRTH на самом деле важнее EXT_SOURCE_1.

Отладка признаков

Глядя на графики Featexp, можно находить ошибки в сложных кодах, делая следующие две вещи:

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

Обнаружение утечек

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

Признак с утечкой
Признак с утечкой

Приведенный выше признак имеет частоту 0% в бине нулей и 100% во всех других бинах. Ясно, что это предельный случай утечки. Этот признак имеет значение только тогда, когда клиент неплатежеспособен. Нужно выяснить, почему так происходит: либо есть ошибка, либо признак действительно реагирует только на неплатежеспособных клиентов (и тогда его нужно отключить). Разобравшись, почему признак приводит к утечке, можно быстрее исправить проблему.

Мониторинг модели

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

Эти простые проверки часто помогали мне в создании лучших моделей в реальных задачах и в Kaggle. С featexp требуется 15 минут, чтобы посмотреть на графики, и это определенно стоит того.

BERT от Google AI: open source модель обработки естественного языка

12 ноября 2018

BERT от Google AI: open source модель обработки естественного языка

Разработчики Google AI выложили в открытый доступ исходный код BERT (Bidirectional Encoder Representations from Transformers). Модель предназначена для предварительного обучения алгоритмов обработки естественного языка. После тренировки на больших наборах данных,…

Разработчики Google AI выложили в открытый доступ исходный код BERT (Bidirectional Encoder Representations from Transformers). Модель предназначена для предварительного обучения алгоритмов обработки естественного языка. После тренировки на больших наборах данных, модели смогут лучше справляться с последующими специфическими задачами.

Особенности BERT

В блоге компании отмечают, что BERT позволит разработчикам обучить NLP-модель за 30 минут на Google Cloud TPU или за несколько часов с помощью одного графического процессора. Обработка BERT является двунаправленной, т.е. учитывает прошлый и будущий контекст во время анализа предложений. Кроме того, подход основан на обучении без учителя, поэтому модель способна работать с неразмеченными и неклассифицированными данными.

В тестировании на наборе данных для ответов на вопросы Stanford Question (SQuAD), точность работы BERT составила 93,2%. На контрольном тесте GLUE он достиг точности 80,4%.

Результаты в сравнении с другими моделями

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

Azure ML туториал: создание простой модели машинного обучения

23 октября 2018
azure ml туториал что это

Azure ML туториал: создание простой модели машинного обучения

Перед вами пошаговое руководство по созданию модели машинного обучения с использованием Microsoft Azure ML, перевод статьи «Tutorial – Build a simple Machine Learning Model using AzureML«. Ссылка на оригинал — в…

Перед вами пошаговое руководство по созданию модели машинного обучения с использованием Microsoft Azure ML, перевод статьи «Tutorial – Build a simple Machine Learning Model using AzureML«. Ссылка на оригинал — в подвале статьи.

Насколько тяжело построить модель машинного обучения на языках программирования R или Python? Для начинающих это геркулесов труд. Программистам среднего уровня и синьорам для этого требуется лишь достаточный объем памяти системы, осознание поставленной задачи и немного времени.

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

Что такое Azure ML?

azure ml туториал

Хорошая новость — освоить машинное обучение сегодня стало намного проще, чем, например, в 2014 году. Как новичок в этом деле, ты можешь начать познавать машинное обучение с помощью фреймворка Microsoft Azure ML.

Azure ML представляет собой реализацию алгоритма машинного обучения через графический интерфейс от Microsoft.

Какие ресурсы доступны на AzureML

Давайте познакомимся с арсеналом этого инструмента.

  1. Примеры датасетов: мне нравится тестировать инструменты, которые имеют множество встроенных наборов данных. Это упрощает процесс тестирования мощности инструмента. Azure ML поставляется с длинным списком встроенных наборов данных. Список датасетов.
  2. Средства машинного обучения: Azure ML имеет в наличии почти все популярные алгоритмы машинного обучения и формулы оценочных показателей.
  3. Преобразование данных: в Azure ML есть все параметры фильтрации, параметры преобразования, параметры суммирования и варианты расчета матрицы.
  4. Параметры преобразования формата данных: А  что если вы хотите добавить свой собственный набор данных? Azure ML имеет несколько опций для добавления наборов данных из вашей локальной системы. Вот эти варианты:

формат экспорта данных из azure ml

Создание модели

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

Здесь вы начинаете — нажмите на “Создать новый эксперимент”.

Вы получаете пустую таблицу экспериментов:

поле для экспериментов

Теперь вы можете выбрать pallete:

список датасетов azure ml

Шаг 1. Выберите набор данных. Это могут быть ваши примеры данных или же вы можете загрузить их. В этом уроке я буду использовать «Данные о раке молочной железы» из встроенных наборов данных. Просто перетащите эти данные в главное окно.

машинное обучение с azure ml

Шаг 2. Выберите инструмент деления. Вы можете использовать опцию поиска в палитре, чтобы найти «split data». Поместите «split data» под свой набор данных и присоедините.

датасеты

Теперь вы видите две точки на ячейке «split data». Это означает, что у вас есть два набора данных, готовых к работе. С правой стороны у вас есть возможность выбрать тип деления.

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

датасет

Вы можете заметить восклицательный знак в узле тренировки модели. Это означает, что вам нужно указать целевую переменную. Выберем целевую переменную, щелкнув по ней. Теперь вы увидите окно с правой стороны. Выберите «Launch column slector».

тренировка модели

Я выбрал «Класс» в качестве целевой переменной.

Шаг 4. Теперь вы оцениваете модель: см. Следующий рисунок

model training azure ml

Шаг 5. Наконец, производите вычисления

Запускаете модель!

Визуализация датасета и вывода

Чтобы визуализировать любой узел, вы просто переходите к узлу, нажимаете на него правой кнопкой мыши, затем выбираете “визуализировать”.

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

визуализация данных в azure ml

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

Так выглядит подсчитанная модель:

azure машинное обучение

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

Наконец, вот как выглядят графики:

azure ml туториал

azure ml туториал

Заключение

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

Считаете ли вы эту статью полезной ? Поделитесь с нами своим опытом работы с Azure ML.


Интересные статьи по теме:

Туториал по PyTorch: от установки до готовой нейронной сети

22 октября 2018
pytorch туториал

Туториал по PyTorch: от установки до готовой нейронной сети

Если вы уже пробовали создавать собственные глубокие нейронные сети с помощью TensorFlow и Keras, то, вероятно, знакомы с чувством разочарования при отлаживании этих библиотек. Хотя они имеют API на Python,…

Если вы уже пробовали создавать собственные глубокие нейронные сети с помощью TensorFlow и Keras, то, вероятно, знакомы с чувством разочарования при отлаживании этих библиотек. Хотя они имеют API на Python, всё еще трудно выяснить, что именно пошло не так при ошибке. Они также плохо работают вместе с библиотеками numpy, scipy, scikit-learn, Cython и другими. Библиотека глубокого обучения PyTorch имеет заявленное преимущество — хорошо работает с Python и создана для апологетов Python. Кроме того, приятное свойство PyTorch — построение вычислительного динамического графа, противоположно статическим вычислительным графам, представленным в TensorFlow и Keras. PyTorch сейчас находится на подъеме и используется в разработке Facebook, Twitter, NVIDIA и другими компаниями. Давайте обратимся к туториалу по использованию PyTorch.

цукерберг pytorch facebook

Перед вами перевод статьи «A PyTorch tutorial – deep learning in Python», ссылка на оригинал — в подвале статьи.

Первый вопрос для рассмотрения — действительно ли PyTorch лучше TensorFlow? Это субъективно, так как с точки зрения производительности нет больших различий. В любом случае, PyTorch стал серьезным соперником в соревновании между библиотеками глубокого обучения. Давайте начнем изучать библиотеку, оставив для размышлений вопрос о том, что же лучше.

Основы PyTorch

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

Полносвязная нейронная сеть
Полносвязная нейронная сеть

Установка на Windows

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

Вычислительные графы

Первое, что необходимо понять о любой библиотеке глубокого обучения — идея вычислительных графов. Вычислительный граф — набор вычислений, которые называются узлами, и которые соединены в прямом порядке вычислений. Другими словами, выбранный узел зависит от узлов на входе, который в свою очередь производит вычисления для других узлов. Ниже представлен простой пример вычислительного графа для вычисления выражения a = (b + c) * (c + 2). Можно разбить вычисление на следующие шаги:

Вычислительный графы
Простой вычислительный граф

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

Тензоры

Тензоры — подобные матрице структуры данных, которые являются неотъемлемыми компонентами в библиотеках глубокого обучения и используются для эффективных вычислений. Графические процессоры (GPU) эффективны при вычислении операций между тензорами, что стимулировало волну возможностей в глубоком обучении. В PyTorch тензоры могут определяться несколькими способами:

import torch
x = torch.Tensor(2, 3)

Этот код создает тензор размера (2,3), заполненный нулями. В данном примере первое число — количество рядов, второе — количество столбцов:

0 0 0
0 0 0
[torch.FloatTensor of size 2x3]

Мы также можем создать тензор, заполненный случайными float-значениями:

x = torch.rand(2, 3)

Умножение тензоров, сложение друг с другом и другие алгебраические операции просты:

x = torch.ones(2,3)
y = torch.ones(2,3) * 2
x + y

Код возвращает:

3 3 3
3 3 3
[torch.FloatTensor of size 2x3]

Также доступна работа с функцией slice в numpy. Например y[:,1]:

y[:,1] = y[:,1] + 1

Которая возвращает:

2 3 2
2 3 2
[torch.FloatTensor of size 2x3]

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

Автоматическое дифференцирование в PyTorch

В библиотеках глубокого обучения есть механизмы вычисления градиента ошибки и обратного распространения ошибки через вычислительный граф. Этот механизм, называемый автоградиентом в PyTorch, легко доступен и интуитивно понятен. Переменный класс — главный компонент автоградиентной системы в PyTorch. Переменный класс обертывает тензор и позволяет автоматически вычислять градиент на тензоре при вызове функции .backward(). Объект содержит данные из тензора, градиент тензора (единожды посчитанный по отношению к некоторому другому значению, потеря) и содержит также ссылку на любую функцию, созданную переменной (если это функция созданная пользователем, ссылка будет пустой).

Создадим переменную из простого тензора:

x = Variable(torch.ones(2, 2) * 2, requires_grad=True)

В объявлении переменной используется двойной тензор размера 2х2 и дополнительно указывается, что переменной необходим градиент. При использовании этой переменной в нейронных сетях, она становится способна к обучению. Если последний параметр будет равен False, то переменная не может использоваться для обучения. В этом простом примере мы ничего не будем тренировать, но хотим запросить градиент для этой переменной, как будет показано ниже.

Далее, давайте создадим новую переменную на основе x.

z = 2 * (x * x) + 5 * x

Чтобы вычислить градиент этой операции по x, dz/dx, можно аналитически получить 4x + 5. Если все элементы x — двойки, то градиент dz/dx — тензор размерности (2,2), заполненный числами 13. Однако, сначала необходимо запустить операцию обратного распространения .backwards(), чтобы вычислить градиент относительно чего-либо. В нашем случае инициализируется единичный тензор (2,2), относительно которого считаем градиент. В таком случаем вычисление — просто операция d/dx:

z.backward(torch.ones(2, 2))
print(x.grad)

Результатом кода является следующее:

Variable containing:
13 13
13 13
[torch.FloatTensor of size 2x2]

Заметим, это в точности то, что мы предсказывали вначале. Отметим, градиент хранится в переменной x в свойстве .grad.

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

Создание нейронной сети в PyTorch

Этот раздел — основной в туториале. Полный код туториала лежит в этом репозитории на GitHub. Здесь мы создадим простую нейронную сеть с 4 слоями, включая входной и два скрытых слоя, для классификации рукописных символов в датасете MNIST. Архитектура, которую мы будем использовать, показана на картинке:

Архитектура полносвязной нейронной сети
Архитектура полносвязной нейронной сети

Входной слой состоит из 28 х 28 = 784 пикселей с оттенками серого, которые составляют входные данные в датасете MNIST. Входные данные далее проходят через два скрытых слоя, каждый из которых содержит 200 узлов, использующих линейную выпрямительную функцию активации (ReLU). Наконец, мы имеем выходной слой с десятью узлами, соответствующими десяти рукописным цифрам от 0 до 9. Для такой задачи классификации будем использовать выходной softmax-слой.

Класс для построения нейронной сети

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

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.fc1 = nn.Linear(28 * 28, 200)
       self.fc2 = nn.Linear(200, 200)
       self.fc3 = nn.Linear(200, 10)

В таком определении можно видеть наследование базового класса nn.Module. В первой строке инициализации класса def __init__(self)  мы имеем требуемую super() функцию языка Python, которая создает объект базового класса. В следующих трех строках создаем полностью соединенные слои как показано на диаграмме архитектуры. Полностью соединенный слой нейронной сети представлен объектом nn.Linear, в котором первый аргумент — определение количества узлов в i-том слое, а второй — количество узлов в i+1 слое. Из кода видно, первый слой принимает на входе 28×28 пикселей и соединяется с первым скрытым слоем с 200 узлами. Далее идет соединение с другим скрытым слоем с 200 узлами. И, наконец, соединение последнего скрытого слоя с выходным слоем с 10 узлами.

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

def forward(self, x):
   x = F.relu(self.fc1(x))
   x = F.relu(self.fc2(x))
   x = self.fc3(x)
   return F.log_softmax(x)

Для метода forward() берем входные данные x в качестве основного аргумента. Далее, загружаем всё в в первый полностью соединенный слой self.fc1(x) и применяем активационную функцию ReLU для узлов в этом слое, используя F.relu(). Из-за иерархической природы этой нейронной сети, заменяем x на каждой стадии и отправляем на следующий слой. Делаем эту процедуру на трех соединенных слоях, за исключением последнего. На последнем слое возвращаем не ReLU, а логарифмическую softmax активационную функцию. Это, в комбинации с функцией потери отрицательного логарифмического правдоподобия, дает многоклассовую на основе кросс-энтропии функцию потерь, которую мы будет использовать для тренировки сети.

Мы определили нейронную сеть. Следующим шагом будет создание экземпляра (instance) этой архитектуры:

net = Net()
print(net)

При выводе экземпляра класса Net получаем следующее:

Net (
(fc1): Linear (784 -> 200)
(fc2): Linear (200 -> 200)
(fc3): Linear (200 -> 10)
)

Что очень удобно, так как подтверждает структуру нашей нейронной сети.

Тренировка сети

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

# Осуществляем оптимизацию путем стохастического градиентного спуска
optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9)
# Создаем функцию потерь
criterion = nn.NLLLoss()

В первой строке создаем оптимизатор на основе стохастического градиентного спуска,  устанавливая скорость обучения (learning rate; в нашем случае определим этот показатель на уровне 0.01) и momentum. Еще в оптимизаторе необходимо определить все остальные параметры сети, но это делается легко в PyTorch благодаря методу .parameters() в базовом классе nn.Module, который наследуется из него в новый класс Net.

Далее устанавливается метрика контроля качества — функция потерь отрицательного логарифмического правдоподобия. Такой вид функции в комбинации с логарифмической softmax-функцией на выходе нейронной сети дает эквивалентную кросс-энтропийную потерю для 10 классов задачи классификации.

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

# запускаем главный тренировочный цикл
for epoch in range(epochs):
   for batch_idx, (data, target) in enumerate(train_loader):
       data, target = Variable(data), Variable(target)
# изменим размер с (batch_size, 1, 28, 28) на (batch_size, 28*28)
       data = data.view(-1, 28*28)
       optimizer.zero_grad()
       net_out = net(data)
       loss = criterion(net_out, target)
       loss.backward()
       optimizer.step()
       if batch_idx % log_interval == 0:
           print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                   epoch, batch_idx * len(data), len(train_loader.dataset),
                          100. * batch_idx / len(train_loader), loss.data[0]))

Внешний тренировочный цикл проходит по количеству эпох, а внутренний тренировочный цикл проходит через все тренировочные данные в партиях, размер которых задается в коде как batch_size. На следующей линии конвертируем данные и целевую переменную в переменные PyTorch. Входной датасет MNIST, который находится в пакете torchvision (который вам необходимо установить при помощи pip), имеет размер (batch_size, 1, 28, 28) при извлечении из загрузчика данных. Такой четырехмерный тензор больше подходит для архитектуры сверточной нейронной сети, чем для нашей полностью соединенной сети. Тем не менее, необходимо уменьшить размерность данных с (1,28,28)  до одномерного случая для 28 х 28 = 784 входных узла.

Функция .view() работает с переменными PyTorch и преобразует их форму. Если мы точно не знаем размерность данного измерения, можно использовать ‘-1’ нотацию в определении размера. Поэтому при использование data.view(-1,28*28) можно сказать, что второе измерение должно быть равно 28 x 28, а первое измерение должно быть вычислено из размера переменной оригинальных данных. На практике это означает, что данные теперь будут размера (batch_size, 784). Мы можем пропустить эту партию входных данных в нашу нейросеть, и магический PyTorch сделает за нас тяжелую работу, эффективно выполняя необходимые вычисления с тензорами.

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

net_out = net(data)
loss = criterion(net_out, target)

Первая строка, в которой подаем порцию данных на вход нашей модели, вызывает метод forward() в классе Net. После запуска строки переменная net_out будет иметь логарифмический softmax-выход из нашей нейронной сети для заданной партии данных.  Это одна из самых замечательных особенностей PyTorch, так как можно активировать любой стандартный отладчик Python, который вы обычно используете, и мгновенно узнать, что происходит в нейронной сети. Это противоположно другим библиотекам глубокого обучения, TensorFlow и Keras, в которых требуется  производить сложные отладочные действия, чтобы узнать, что ваша нейронная сеть действительно создает. Надеюсь, вы поиграете с кодом для этого туториала и поймете, насколько в PyTorch удобный отладчик.

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

Давайте посмотрим на следующие две строки:

loss.backward()
optimizer.step()

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

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

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

if batch_idx % log_interval == 0:
   print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                   epoch, batch_idx * len(data), len(train_loader.dataset),
                          100. * batch_idx / len(train_loader), loss.data[0]))

Эта функция выводит наш прогресс на протяжении эпох тренировки и показывает ошибку нейросети в этот момент. Отметим, что доступ к потерям находится в свойстве .data у переменной PyTorch, которая в данном случае будет массивом с единственным значением. Получаем скалярную потерю используя loss.data[0].

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

Train Epoch: 9 [52000/60000 (87%)] Loss: 0.015086

Train Epoch: 9 [52000/60000 (87%)] Loss: 0.015086

Train Epoch: 9 [54000/60000 (90%)] Loss: 0.030631

Train Epoch: 9 [56000/60000 (93%)] Loss: 0.052631

Train Epoch: 9 [58000/60000 (97%)] Loss: 0.052678

После 10 эпох, значение потери по величине должно получиться меньше 0.05.

Тестирование сети

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

test_loss = 0
correct = 0
for data, target in test_loader:
   data, target = Variable(data, volatile=True), Variable(target)
   data = data.view(-1, 28 * 28)
   net_out = net(data)
# Суммируем потери со всех партий
   test_loss += criterion(net_out, target).data[0]
   pred = net_out.data.max(1)[1]  # получаем индекс максимального значения
   correct += pred.eq(target.data).sum()

test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
       test_loss, correct, len(test_loader.dataset),
       100. * correct / len(test_loader.dataset)))

Этот цикл совпадает с тренировочным циклом до строки test_loss. Здесь мы извлекаем потери сети используя свойство .data[0] как и раньше, но только все в одной строке. Далее в строке pred используется метод data.max(1), который возвращает индекс наибольшего значения в определенном измерении тензора. Теперь выход нашей нейронной сети будет иметь размер (batch_size, 10), где каждое значение из второго измерения длины 10 — логарифмическая вероятность, которую нейросеть приписывает каждому выходному классу (то есть это логарифмическая вероятность принадлежности картинки к символу от 0 до 9). Поэтому для каждого входного образца в партии net_out.data будет выглядеть следующим образом:

[-1.3106e+01, -1.6731e+01, -1.1728e+01, -1.1995e+01, -1.5886e+01, -1.7700e+01, -2.4950e+01, -5.9817e-04, -1.3334e+01, -7.4527e+00]

Значение с наибольшей логарифмической вероятностью — цифра от 0 до 9, которую нейронная сеть распознает на входной картинке. Иначе говоря, это лучшее предсказание для заданного входного объекта. В примере net_out.data таким лучшим предсказанием является значение -5.9817e-04, которое соответствует цифре “7”. Поэтому для этого примера нейросеть предскажет знак  “7”. Функция .max(1) определяет это максимальное значение во втором пространстве (если мы хотим найти максимум в первом пространстве, мы должны аргумент функции изменить с 1 на 0) и возвращает сразу и максимальное найденное значение, и индекс ему соответствующий. Поэтому эта конструкция имеет размер (batch_size, 2). В данном случае, нас интересует индекс максимального найденного значения, к которому мы получаем доступ с помощью вызова .max(1)[1].

Теперь у нас есть предсказание нейронной сети для каждого примера в определенной партии входных данных, и можно сравнить его с настоящей меткой класса из тренировочного датасета. Это используется для подсчета количества правильных ответов. Чтобы сделать это в PyTorch, необходимо воспользоваться функцией .eq(), которая сравнивает значения в двух тензорах и при совпадении возвращает единицу. В противном случае, функция возвращает 0:

correct += pred.eq(target.data).sum()

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

test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
       test_loss, correct, len(test_loader.dataset),
       100. * correct / len(test_loader.dataset)))

После тренировки сети за 10 эпох получаем следующие результаты на тестовой выборке:

Test set: Average loss: 0.0003, Accuracy: 9783/10000 (98%)

Мы получили точность 98%. Весьма неплохо!

В туториале рассмотрены базовые принципы PyTorch, начиная c тензоров до функции автоматического дифференцирования (autograd) и заканчивая пошаговым руководством, как создать полностью соединенную нейронную сеть при помощи nn.Module.


Интересные статьи:

Как создать чат-бота с нуля на Python: подробная инструкция

4 октября 2018
как создать чат бота на python

Как создать чат-бота с нуля на Python: подробная инструкция

Аналитики Gartner утверждают, что к 2020 году 85% взаимодействий клиентов с сервисами сведется к общению с чат-ботами. В 2018 году они уже обрабатывают около 30% операций. В этой статье мы расскажем, как создать…

Аналитики Gartner утверждают, что к 2020 году 85% взаимодействий клиентов с сервисами сведется к общению с чат-ботами. В 2018 году они уже обрабатывают около 30% операций. В этой статье мы расскажем, как создать своего чат-бота на Python.

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

Несмотря на то что Duolingo позволяет изучить новый язык, у пользователей сервиса возникла проблема. Они почувствовали, что не развивают разговорные навыки, так как обучаются самостоятельно. Пользователи неохотно обучались в парах из-за смущения. Эта проблема не осталась незамеченной для разработчиков.

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

чат-бот пример

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

Итак, что такое чат-бот?

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

  • предоставление информации о рейсе;
  • предоставление пользователям доступа к информации об их финансах;
  • служба поддержки.

Возможности безграничны.

История чат-ботов восходит к 1966 году, когда Джозеф Вейценбаум разработал компьютерную программу ELIZA. Программа подражает манере речи психотерапевта и состоит лишь из 200 строк кода. Пообщаться с Элизой можно до сих пор на сайте.

Как работает чат-бот?

Существует два типа ботов: работающие по правилам и самообучающиеся.

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

В поисковых ботах используются эвристические методы для выбора ответа из библиотеки предопределенных реплик. Такие чат-боты используют текст сообщения и контекст диалога для выбора ответа из предопределенного списка. Контекст включает в себя текущее положение в древе диалога, все предыдущие сообщения и сохраненные ранее переменные (например, имя пользователя). Эвристика для выбора ответа может быть спроектирована по-разному: от условной логики «или-или» до машинных классификаторов.

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

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

Создание бота на Python

Предполагается, что вы умеете пользоваться библиотеками scikit и NLTK. Однако, если вы новичок в обработке естественного языка (NLP), вы все равно можете прочитать статью, а затем изучить соответствующую литературу.

Обработка естественного языка (NLP)

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

Краткое введение в NLKT

NLTK (Natural Language Toolkit) — платформа для создания программ на Python для работы с естественной речью. NLKT предоставляет простые в использовании интерфейсы для более чем 50 корпораций и лингвистических ресурсов, таких как WordNet, а также набор библиотек для обработки текста в целях классификации, токенизации, генерации, тегирования, синтаксического анализа и понимания семантики, создания оболочки библиотек NLP для коммерческого применения.

Книга Natural Language Processing with Python  — практическое введение в программирование для обработки языка. Рекомендуем ее прочитать, если вы владеете английским языком.

Загрузка и установка NLTK

  • Установите NLTK: запустите pip install nltk.
  • Тестовая установка: запустите python, затем введите import nltk.

Инструкции для конкретных платформ смотрите здесь.

Установка пакетов NLTK

Импортируйте NLTK и запустите nltk.download(). Это откроет загрузчик NLTK, где вы сможете выбрать версию кода и модели для загрузки. Вы также можете загрузить все пакеты сразу.

Предварительная обработка текста с помощью NLTK

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

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

Пакет NLTK включает в себя предварительно обученный токенизатор Punkt для английского языка.

  • Удаление шума, то есть всего, что не является цифрой или буквой;
  • Удаление стоп-слов. Иногда из словаря полностью исключаются некоторые крайне распространенные слова, которые, как считается, не имеют большого значения для формирования ответа на вопрос пользователя. Эти слова называются стоп-словами (междометия, артикли, некоторые вводные слова);
  • Cтемминг: приведение слова к коренному значению. Например, если нам нужно провести стемминг слов «стемы», «стемминг», «стемированный» и «стемизация», результатом будет одно слово — «стем».
  • Лемматизация. Лемматизация — немного отличающийся от стемминга метод. Основное различие между ними заключается в том, что стемминг часто создает несуществующие слова, тогда как лемма — это реально существующее слово. Таким образом, ваш исходный стем, то есть слово, которое получается после стемминга, не всегда можно найти в словаре, а лемму — можно. Пример лемматизации: «run» — основа для слов «running» или «ran», а «better» и «good» находятся в одной и той же лемме и потому считаются одинаковыми.

Набор слов

После первого этапа предварительной обработки нужно преобразовать текст в вектор (или массив) чисел. «Набор слов» — это представление текста, описывающего наличие слов в тексте. «Набор слов» состоит из:

  • словаря известных слов;
  • частот, с которыми каждое слово встречается в тексте.

Почему используется слово «набор»? Это связано с тем, что информация о порядке или структуре слов в тексте отбрасывается, и модель учитывает только то, как часто определенные слова встречаются в тексте, но не то, где именно они находятся.

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

Например, если словарь содержит слова {Learning, is, the, not, great} и мы хотим составить вектор предложения “Learning is great”, получится вектор (1, 1, 0, 0, 1).

Метод TF-IDF

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

Один из подходов к решению этих проблем состоит в том, чтобы вычислять частоту появления слова не в одном тексте, а во всех сразу. За счет этого вклад, например, артиклей «a» и «the» будет нивелирован. Такой подход называется TF-IDF (Term Frequency-Inverse Document Frequency) и состоит из двух этапов:

  • TF — вычисление частоты появления слова в одном тексте
TF = (Число раз, когда слово "t" встречается в тексте)/(Количество слов в тексте)
  • IDF — вычисление того, на сколько редко слово встречается во всех текстах
IDF = 1+log(N/n), где N - общее количество текстов, n - во скольких текстах встречается "t"

Коэффициент TF-IDF — это вес, часто используемый для обработки информации и интеллектуального анализа текста. Он является статистической мерой, используемой для оценки важности слова для текста в некотором наборе текстов.

Пример

Рассмотрим текст, содержащий 100 слов, в котором слово «телефон» появляется 5 раз. Параметр TF для слова «телефон» равен (5/100) = 0,05.

Теперь предположим, что у нас 10 миллионов документов, и слово телефон появляется в тысяче из них. Коэффициент вычисляется как 1+log(10 000 000/1000) = 4. Таким образом, TD-IDF равен 0,05 * 4 = 0,20.

TF-IDF может быть реализован в scikit так:

from sklearn.feature_extraction.text import TfidfVectorizer

Коэффициент Отиаи

TF-IDF — это преобразование, применяемое к текстам для получения двух вещественных векторов в векторном пространстве. Тогда мы можем получить коэффициент Отиаи любой пары векторов, вычислив их поэлементное произведение и разделив его на произведение их норм. Таким образом, получается косинус угла между векторами. Коэффициент Отиаи является мерой сходства между двумя ненулевыми векторами. Используя эту формулу, можно вычислить схожесть между любыми двумя текстами d1 и d2.

Cosine Similarity (d1, d2) =  Dot product(d1, d2) / ||d1|| * ||d2||

Здесь d1, d2 — два ненулевых вектора.

Подробное объяснение и практический пример TF-IDF и коэффициента Отиаи приведены в посте по ссылке.

Пришло время перейти к решению нашей задачи, то есть созданию чат-бота. Назовем его «ROBO».


Обучение чат-бота

В нашем примере мы будем использовать страницу Википедии в качестве текста. Скопируйте содержимое страницы и поместите его в текстовый файл под названием «chatbot.txt». Можете сразу использовать другой текст.

Импорт необходимых библиотек

import nltk
import numpy as np
import random
import string # to process standard python strings

Чтение данных

Выполним чтение файла corpus.txt и преобразуем весь текст в список предложений и список слов для дальнейшей предварительной обработки.

f=open('chatbot.txt','r',errors = 'ignore')
raw=f.read()
raw=raw.lower()# converts to lowercase
nltk.download('punkt') # first-time use only
nltk.download('wordnet') # first-time use only
sent_tokens = nltk.sent_tokenize(raw)# converts to list of sentences 
word_tokens = nltk.word_tokenize(raw)# converts to list of words

Давайте рассмотрим пример файлов sent_tokens и word_tokens

sent_tokens[:2]
['a chatbot (also known as a talkbot, chatterbot, bot, im bot, interactive agent, or artificial conversational entity) is a computer program or an artificial intelligence which conducts a conversation via auditory or textual methods.',
 'such programs are often designed to convincingly simulate how a human would behave as a conversational partner, thereby passing the turing test.']
word_tokens[:2]
['a', 'chatbot', '(', 'also', 'known']

Предварительная обработка исходного текста

Теперь определим функцию LemTokens, которая примет в качестве входных параметров токены и выдаст нормированные токены.

lemmer = nltk.stem.WordNetLemmatizer()
#WordNet is a semantically-oriented dictionary of English included in NLTK.
def LemTokens(tokens):
    return [lemmer.lemmatize(token) for token in tokens]
remove_punct_dict = dict((ord(punct), None) for punct in string.punctuation)
def LemNormalize(text):
    return LemTokens(nltk.word_tokenize(text.lower().translate(remove_punct_dict)))

Подбор ключевых слов

Определим реплику-приветствие бота. Если пользователь приветствует бота, бот поздоровается в ответ. В ELIZA используется простое сопоставление ключевых слов для приветствий. Будем использовать ту же идею.

GREETING_INPUTS = ("hello", "hi", "greetings", "sup", "what's up","hey",)
GREETING_RESPONSES = ["hi", "hey", "*nods*", "hi there", "hello", "I am glad! You are talking to me"]
def greeting(sentence):
 
    for word in sentence.split():
        if word.lower() in GREETING_INPUTS:
            return random.choice(GREETING_RESPONSES)

Генерация ответа

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

  • Импортируйте векторизатор TFidf из библиотеки, чтобы преобразовать набор необработанных текстов в матрицу свойств TF-IDF.
    from sklearn.feature_extraction.text import TfidfVectorizer
  • Кроме того, импортируйте модуль коэффициента Отиаи из библиотеки scikit
from sklearn.metrics.pairwise import cosine_similarity

Этот модуль будет использоваться для поиска в запросе пользователя ключевых слов. Это самый простой способ создать чат-бота.

Определим функцию отклика, которая возвращает один из нескольких возможных ответов. Если запрос не соответствует ни одному ключевому слову, бот выдает ответ «Извините! Я вас не понимаю».

def response(user_response):
    robo_response=''
TfidfVec = TfidfVectorizer(tokenizer=LemNormalize, stop_words='english')
    tfidf = TfidfVec.fit_transform(sent_tokens)
    vals = cosine_similarity(tfidf[-1], tfidf)
    idx=vals.argsort()[0][-2]
    flat = vals.flatten()
    flat.sort()
    req_tfidf = flat[-2]
    if(req_tfidf==0):
        robo_response=robo_response+"I am sorry! I don't understand you"
        return robo_response
    else:
        robo_response = robo_response+sent_tokens[idx]
        return robo_response

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

flag=True
print("ROBO: My name is Robo. I will answer your queries about Chatbots. If you want to exit, type Bye!")
while(flag==True):
    user_response = input()
    user_response=user_response.lower()
    if(user_response!='bye'):
        if(user_response=='thanks' or user_response=='thank you' ):
            flag=False
            print("ROBO: You are welcome..")
        else:
            if(greeting(user_response)!=None):
                print("ROBO: "+greeting(user_response))
            else:
                sent_tokens.append(user_response)
                word_tokens=word_tokens+nltk.word_tokenize(user_response)
                final_words=list(set(word_tokens))
                print("ROBO: ",end="")
                print(response(user_response))
                sent_tokens.remove(user_response)
    else:
        flag=False
        print("ROBO: Bye! take care..")

Вот и все. Мы написали код нашего первого бота в NLTK. Здесь вы можете найти весь код вместе с текстом. Теперь давайте посмотрим, как он взаимодействует с людьми:


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

Заключение

Хотя наш примитивный бот едва ли обладает когнитивными навыками, это был неплохой способ разобраться с NLP и узнать о работе чат-ботов. «ROBO», по крайней мере, отвечает на запросы пользователя. Он, конечно, не обманет ваших друзей, и для коммерческой системы вы захотите рассмотреть одну из существующих бот-платформ или фреймворки, но этот пример поможет вам продумать архитектуру бота.


Интересные статьи:

Как стирается граница между цифровой камерой и лидаром

14 сентября 2018
lidar

Как стирается граница между цифровой камерой и лидаром

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

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

Ouster — старт-ап из Сан-Франциско, конструирующий 3D-сенсоры, которые сделают мир будущего намного безопаснее. По крайней мере, так утверждают сами разработчики.

Как работает лидар

Лидар — активный дальномер оптического диапазона, который формирует трёхмерную картину окружающего пространства. Работает по принципу эхолота. На открытых пространствах в качестве излучателя используется лазер, в закрытых помещениях достаточно обычного светодиода. Лидары разрабатываются с 1960-х годов.

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

lidar изображение
Данные с лидара — улица в Сан-Франциско

Разработчики Ouster решили взять только лучшее от камер и лидаров, объединив это в одном устройстве. Лидар Ouster OS-1 выдает изображения с фиксированной разрешающей способностью. Слои данных пространственно коррелированы, без временных несоответствий или шаттер эффектов, имеют 16 бит на пиксель и линейную фотоотраженность.

лидар и камера
Одновременные уровни изображения в реальном времени выводятся из OS-1. То, что вы видите сверху донизу, это данные окружающего мира, интенсивности, дальности и облака точек — ВСЕ от лидара. Обратите внимание, что окружающее изображение захватывает облачное небо и тени от деревьев и транспортных средств

Оптическая система OS-1 имеет большую диафрагму, чем большинство DSLR, а разработанный метод подсчета фотонов ASIC настроен на повышенную чувствительность, поэтому окружающие изображения получаются детальными даже в условиях низкой освещенности. OS-1 фиксирует как прямые сигналы, так и скрытые данные (ambient data) в ближнем инфракрасном диапазоне, поэтому данные напоминают видимые освещенные изображения тех же сцен. Поэтому есть вероятность, что алгоритмы, разработанные для камер, хорошо будут работать с данными из лидара.

Open source визуализатор

Также разработчики обновляют open-source драйвер для лидара OS-1, чтобы он выдавал слои данных в фиксированном разрешении с панорамным обзором в 360. Помимо этого создатели представляют новый, встроенный в VTK, кросс-платформенный инструмент для визуализации, для просмотра, записи и воспроизведения, как изображений, так и облаков точек. Выходные данные сенсора не требуют пост-процессинга, чтобы показывать заявленную функциональность, все происходит в аппаратной части, а драйвер просто собирает потоки пакетов данных в изображения.

 Our new open source visualizer. Full drive video: https://www.youtube.com/watch?v=LcnbOCBMiQM
Новый open-source визуализатор

Обучение нейросети на данных с лидара

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

Как один из примеров, исследователи натренировали попиксельный семантичесский классификатор, который определяет дорогу, транспорт, пешеходов и велосипедистов по набору кадров глубин и интенсивностей. Итоговая нейросеть была запущена на NVIDIA GTX 1060 в реальном времени и показала впечатляющие результаты, особенно, если учитывать, что это первая попытка.

Семантическая сегментация данных с лидара
Семантическая сегментация данных с лидара: https://www.youtube.com/watch?v=JxR9MasA9Yc

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

3d_label_2.gif

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

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

 Full video: https://www.youtube.com/watch?v=igsJxrbaejw При внимательном обзоре, становится понятно, то нейросеть выделяет разные ключевые точки на каждом изображении. Тот, кто работал над лидарной и визуальной одометриями, поймет ценность избыточности, воплощенной в этом результате. Лидарная одометрия используется в геометрически однородных средах, например туннелях, тогда как визуальная одометрия применяется в открытых или плохо освещенных средах. Камера-лидар предоставляет мультимодальное решение для этой задачи.

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


Ссылки:

1. Видео


Интересные статьи:

Анализ данных на Python — построение модели фондового рынка со Stocker

3 сентября 2018
Stock market prediction python

Анализ данных на Python — построение модели фондового рынка со Stocker

В Data Science легко увлечься разнообразием данных и бесплатными инструментами с открытым исходным кодом. Проведя немного времени с финансовой библиотекой quandl и библиотекой прогнозирования Prophet, я решил попробовать исследовать несколько…

В Data Science легко увлечься разнообразием данных и бесплатными инструментами с открытым исходным кодом. Проведя немного времени с финансовой библиотекой quandl и библиотекой прогнозирования Prophet, я решил попробовать исследовать несколько простых курсов акций. Парочка дней и 1000 строк кода Python привели меня к полноценному инструменту анализа и прогнозирования рынка. Хотя я и недостаточно смелый (или глупый!), чтобы применить его для инвестиций в настоящие акции, в процессе я узнал многое о Python, и в духе open-source хочу поделиться своими результатами и кодом с вами — может кому пригодится.

Введение

В этой статье будет показано, как использовать Stocker, инструмент для анализа и прогнозирования рынка, реализованный в виде класса Python. Название было изначально произвольным, но потом оказалось, что оно хорошо подходит для «исследователя рынка» («stock» (англ.) = «акция», прим.). Несколько раз я пытался одолеть классы, основу объектно-ориентированного программирования на Python, но, как и большинство разделов программирования, они не имели смысла, пока я только читал книги. Только когда я погрузился в реальный проект, в котором возникла проблема, которую я раньше не решал, лишний раз убедился, что практика > теория! Помимо рассмотрения Stocker, мы затронем некоторые важные темы, включая основы классов Python и аддитивных моделей. Для тех, кто хочет использовать Stocker, весь код можно найти в GitHub вместе с документацией. Программа специально  разрабатывалась так, чтобы быть простой в использовании (даже для тех, кто не знаком с Python), и я рекомендую всем читающим статью опробовать ее.

Перейдем к возможностям Stocker!

Stocker и Python

Начало работы со Stocker

После установки необходимых библиотек первое, что нужно сделать — импортировать класс Stocker в сессию Python. Сделать это можно из интерактивного режима, или же в Jupyter Notebook, запущенного в каталоге со скриптом.

from stocker import Stocker

Теперь класс Stocker есть в нашей сессии, и мы можем использовать его для создания экземпляра класса. В Python экземпляры класса называются объектами, а акт создания объекта называют конструированием. Чтобы создать объект Stocker, нам нужно передать действительный идентификатор (stock ticker), в нашем случае, 'MSFT'. Жирным шрифтом будем обозначать вывод программы.

microsoft = Stocker('MSFT')

MSFT Stocker Initialized. Data covers 1986-03-13 to 2018-01-16.

Теперь у нас есть объект microsoft со всеми свойствами класса Stocker. Stocker построен на базе данных Quandl WIKI, которая дает нам доступ к более чем 3000 наборам данных рынков США с известными ежедневными ценами в течение многих лет (полный список здесь). В этом примере мы будем использовать акции Microsoft. Хотя эту компанию рассматривают как противников open-source, недавно она стала меняться и внушать оптимизм: Microsoft начали развивать сообщество с открытым исходным кодом (включая Python).

Преимущества Python

Класс в Python состоит из двух основных частей: полей и методов. Не вдаваясь в подробности, поля (или атрибуты) — значения или данные, связанными либо с классом в целом, либо с конкретными экземплярами (объектами) класса. Методы — это функции, содержащиеся в классе, которые могут взаимодействовать с этими данными. Одно из полей объекта Stocker — это история рынка для конкретной компании, значение которого связывается с объектом при его создании. Чтобы проверить это, мы можем получить доступ к атрибуту и ​​присвоить его значение другой переменной:

# Stock - это атрибут объекта microsoft
stock_history = microsoft.stock
stock_history.head()
рынок акций
Данные по акциям Microsoft

Преимущество класса Python заключается в том, что функции и данные, на которые они действуют, связаны с одним и тем же объектом. Мы можем использовать функцию объекта Stocker для построения всей истории курса:

# у функции нужно писать скобки
microsoft.plot_stock()

Maximum Adj. Close = 89.58 on 2018-01-12.
Minimum Adj. Close = 0.06 on 1986-03-24.
Current Adj. Close = 88.35.

python analysis

По умолчанию значение, которое рисуется — это скорректированная цена закрытия, т.к. акции могут разделить («Stock split». Например, акция начнет стоит 1/2 от предыдущей цены, но и количество акций удвоится. Это делается, чтобы акции стали доступны для мелких инвесторов).

Это довольно простой график, который мы легко бы нашли самостоятельно в поиске Google, но так приятно сделать это самому несколькими строками на Python! Функция plot_stockимеет ряд необязательных аргументов. По умолчанию этот метод отображает скорректированную цену закрытия за весь доступный промежуток времени, можно задавать диапазон дат, желаемую статистику для графика и тип графика. Например, если мы хотим сравнить ежедневное изменение цены со скорректированным объемом (количеством акций), то укажите их в вызове функции.

microsoft.plot_stock(start_date = '2000-01-03',  end_date = '2018-01-16', 
                   stats = ['Daily Change', 'Adj. Volume'],  plot_type='pct')

Maximum Daily Change = 2.08 on 2008-10-13.
Minimum Daily Change = -3.34 on 2017-12-04.
Current Daily Change = -1.75.

Maximum Adj. Volume = 591052200.00 on 2006-04-28.
Minimum Adj. Volume = 7425503.00 on 2017-11-24.
Current Adj. Volume = 35945428.00.

анализ данных Python

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

Ежедневное изменение цены предсказать невозможно

Преобразовав в процентное изменение, мы можем посмотреть на оба набора данных в аналогичном масштабе. На графике показано, что нет никакой корреляции между объемом торгов и ежедневным изменением цены. Это удивительно, поскольку мы могли ожидать, что больше акций будет продаваться в дни с большими изменениями цен, поскольку люди спешат воспользоваться преимуществами колебаний. Тем не менее, единственной тенденцией, по-видимому, является то, что объем торговли с течением времени уменьшается. 4 декабря 2017 года также произошло значительное снижение цены, и мы могли бы попытаться соотнести с новостями о Microsoft. Быстрый поиск новостей за 3 декабря выдает следующее:

Надежность этих источников вызывает вопросы
Надежность этих источников вызывает вопросы

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

Построим графики на любой вкус

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

Давайте притворимся, что однажды у нас хватило ума инвестировать в 100 акций Microsoft при первоначальном публичном размещении (IPO) компании. Насколько стали бы мы богаче?

microsoft.buy_and_hold(start_date='1986-03-13',
                      end_date='2018-01-16', nshares=100)

MSFT Total buy and hold profit from 1986-03-13 to 2018-01-16 for 100 shares = $8829.11

Красивый график на Python

Использование этих результатов позволит планировать наши «перемещения» во времени назад, чтобы максимизировать прибыль.

Изменим временной промежуток и сравним полученный результат:

microsoft.buy_and_hold(start_date='1999-01-05',
                     end_date='2002-01-03', nshares=100)

MSFT Total buy and hold profit from 1999-01-05 to 2002-01-03 for 100 shares = $-56.92

Удивительно, но на фондовом рынке можно потерять деньги!

Аддитивные модели

Аддитивные модели — мощный инструмент анализа и предсказания временных рядов, одного из наиболее распространенных типов данных. Концепция проста: временные ряды представляют как комбинацию некоторых шаблонов в разных временных масштабах и общий тренд. Мы знаем, что тренд для акций Microsoft — постоянный рост, но также могут быть закономерности на ежегодной или ежедневной основе, такие как рост каждый вторник, что выгодно знать инвестору. Prophet — потрясающая библиотека разработанная Facebook, для анализа временных рядов с ежедневными наблюдениями (например, цены акций) (“prophet” (англ.) = “пророк”, прим.). Stocker делает моделирование с Prophet под капотом, остается вызвать метод для создания и проверки модели:

model, model_data = microsoft.create_prophet_model()

Моделирование цены акций на Python

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

# model и model_data из предыдущего вызова функций
model.plot_components(model_data)
plt.show()

зависимости найденные Stocker

Общая тенденция — рост в последние три года (первый график). Также заметна годовая зависимость (нижний график), когда цены снижаются в сентябре и октябре и достигают пика в ноябре и январе. По мере уменьшения масштаба времени данные становятся более шумными. В течение типичного месяца сигнала больше, чем шума! Если мы предполагаем существование недельной зависимости, добавим ее в модель, изменив атрибут weekly_seasonality объекта Stocker:

print(microsoft.weekly_seasonality)
microsoft.weekly_seasonality = True
print(microsoft.weekly_seasonality)

False
True

Значение по умолчанию для weekly_seasonality — False, но мы изменили значение, чтобы включить «недельную сезонность» в нашу модель. Затем сделаем еще один вызов create_prophet_model и отобразим полученные компоненты. Ниже приведена зависимость новой модели.

некрасивый график Stocker
У меня не получилось заставить график выглядеть хорошо

Мы можем игнорировать выходные дни, потому что цена меняется только в течение рабочей недели (на самом деле также незначительно меняется во время after-hours trading (OTC), но это не влияет на наш анализ). К сожалению, на недельном графике нелья выделить тенденцию, поэтому  отключим недельную сезонность. Такое поведение ожидаемо: по мере уменьшения масштаба времени шум начинает подавлять сигнал. На ежедневной основе движение акций непредсказуемо, тренды видны только за счет увеличения масштаба до годового. Надеюсь, это послужит напоминанием о том, почему не стоит играть на ежедневных колебаниях курса!

Контрольные точки

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

microsoft.changepoint_date_analysis()

Changepoints sorted by slope rate of change (2nd derivative):

         Date Adj. Close     delta
48  2015-03-30   38.238066 2.580296
337 2016-05-20   48.886934 2.231580
409 2016-09-01   55.966886 -2.053965
72  2015-05-04   45.034285 -2.040387
313 2016-04-18   54.141111 -1.936257

экстремумы цены найденные с помощью Python

Контрольные точки имеют тенденцию находиться на пиках и провалах в ценах акций. «Пророк» находит точки смены только на первых 80% данных, но эти результаты все равно полезны, поскольку их можно сопоставить с событиями и новостями. Мы могли бы повторить то, что делали ранее — вручную искать новости Google, происходившие в эти даты. Но было бы предпочтительнее, если бы Stocker сделал это вместо нас. Возможно, вы знаете инструмент Google Search Trends, который показывает относительную популярность поискового запроса с течением времени в результатах поиска Google. Stocker автоматически извлекает информацию об указанном запросе, и выводит результат поверх исходных данных. Чтобы найти и рассчитать частоту поисковых запросов, модифицируем предыдущий вызов функции:

# тот же метод, но с поисковыми запросами
microsoft.changepoint_date_analysis(search = 'Microsoft profit')

Top Related Queries:

                 query value
0  microsoft non profit    100
1      microsoft office     55
2                 apple     30
3         microsoft 365     30
4  microsoft office 365     20

Rising Related Queries:

                  query value
0          microsoft 365    120
1   microsoft office 365     90
2  microsoft profit 2014     70

акции Microsoft и зависимость

Помимо графического отображения относительной частоты поиска, Stocker отображает близкие связанные и набирающие популярность для диапазона дат графика запросы. На графике ось y нормализуется между 0 и 1, деля значения по их максимумам, позволяя сравнивать две переменные с разными шкалами. Из рисунка, похоже, следует, что корреляции между поисками «прибыль Microsoft» и ценой акций Microsoft нет.

Зависимость: прямая, обратная или случайная?

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

microsoft.changepoint_date_analysis(search = 'Microsoft Office')

анализ <span class=данных Python и Stocker» width=»570″ height=»386″ data-mce-src=»https://neurohive.io/wp-content/uploads/2018/08/1_6aJKZOdBN7Fs3EYTxU3LjA-570×386.png» ><=»» p=»»>

Похоже, что уменьшение количества поисковых запросов «Microsoft Office» приводит к росту цен на акции. Кто-то должен сказать Microsoft об этом.

Предсказания цены акций на Python

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

О предсказании — во второй части статьи. Или вы можете разобраться самостоятельно (см. подробную документацию). Для поддержания интереса оставлю вам еще одну картинку:

# specify number of days in future to make a prediction
model, future = microsoft.create_prophet_model(days=180)

Predicted Price on 2018-07-15 = $97.67

предсказание цены акций Python

Хотя все возможности Stocker уже давно общедоступны и известны, процесс создания этого инструмента для меня был приятным и, что более важно, дал мне больше знаний о Data Science, Python и фондовом рынке, чем обучающие курсы. Мы живем в невероятном мире свободных знаний, где каждый может узнать о программировании или даже о современных областях, таких как машинное обучение, без лишних формальностей. Если у вас есть идея для проекта, но вы считаете, что знаний для ее реализации недостаточно, или что она уже была реализована раньше — не позволяйте этому останавливать вас. Ваше решение может оказаться лучшим, и даже если окажется не так, вы все равно узнаете гораздо больше, чем если бы вы никогда не попробовали!

Как всегда, я приветствую конструктивную критику и обратную связь (en). Меня можно найти в Twitter на @koehrsen_will.

Оригинал


Больше статей о машинном обучении на Python:

DeepLabCut — новый инструмент для оценки позы и захвата движений

30 августа 2018
DeepLabCut

DeepLabCut — новый инструмент для оценки позы и захвата движений

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

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

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

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

Как работает DeepLabCut

DeepLabCut позволяет автоматически выполнять оценку позы и отслеживать движения. Для работы сначала загружаются размеченные изображения интересующего объекта, например, белки или крысы, и видео с тем, как она двигается. После этого загружают видео с нужной активностью (например, белка грызёт орех). Программа разметит части тела белки и будет отслеживать движения автоматически. Даже когда обозначено ~ 200 кадров, алгоритм обеспечивает отслеживаемость, которая сопоставима с точностью человеческой разметки.

Крыса

odortrail

detect

Муха

animals detection movements

Лошадь

horse1

Человек

human movements

Команда обучила нейросеть выполнять оценку позы и определять части тела на сотнях изображений из набора ImageNet, используя графические процессоры NVIDIA GeForce GTX 1080 Ti и NVIDIA TITAN Xp с расширенной cuDNN и библиотеку TensorFlow.

Инструмент доступен open source.

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

7 августа 2018
введение в машинное обучение примеры и модели для новичков

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

Перевод статьи разработчика алгоритмов машинного обучения, бизнес-консультанта и популярного автора Ганта Лаборде «Machine Learning: from Zero to Hero».  Начнешь c “Зачем?”, придешь к “Я готов!” Если вы мало знаете об…

Перевод статьи разработчика алгоритмов машинного обучения, бизнес-консультанта и популярного автора Ганта Лаборде «Machine Learning: from Zero to Hero». 

Начнешь c “Зачем?”, придешь к “Я готов!”

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

Почему машинное обучение сейчас в тренде

Искусственный интеллект (далее ИИ) всегда имел применение, начиная от перемещения ракетки в пинг понге и заканчивая выполнением комбо в Street Fighter.

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

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

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

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

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

Зачем следует использовать машинное обучение?

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

Во-вторых, если не влияете на мир, мир повлияет на вас. Компании инвестируют в ML, и эти инвестиции уже меняют мир. Лидеры мысли предупреждают, что нельзя позволить алгоритмам машинного обучения быть в тени. Представьте себе, если бы монополия из нескольких корпораций контролировала Интернет. Если мы не “возьмемся за оружие”, наука не будет нашей.

Christian Heilmann высказал правильную мысль в беседе о машинном обучении:

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

Хорошо, теперь я заинтересован…

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

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

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

введение в машинное обучение

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

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

обучение нейронной сети
Обучение нейронной сети Ирисы

Готовы стать Эйнштейном новой эры? Прорывы происходят каждый день, поэтому начинайте сейчас.

С чего мне начать?

Доступных ресурсов много. Я рекомендую два подхода.

Основы

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

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

машинное обучение введение для новичков

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

Гонщик

Если вы не заинтересованы в написании алгоритмов, но хотите использовать их для создания сайтов и приложений, то используйте TensorFlow и погрузитесь в crash course.

TensorFlow — это библиотека с открытым исходным кодом для машинного обучения. Ее можно использовать любым способом, даже с JavaScript. А вот crash source.

Услуги ML

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

Предупреждаю, что нет гарантии, что ваши данные будут в безопасности или вообще останутся вашими, но предложения услуг по ML очень привлекательны, если вы заинтересованы в результате и имеете возможность загрузить данные на Amazon/Microsoft/Google.

Давайте быть созидателями

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

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

Надеюсь, эта статья вдохновила вас и ваше окружение изучать ML!