Работать с нейронной сетью. AI: Нейронные сети

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

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

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

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

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

Искусственная нейронная сеть состоит из трех компонентов:

Входной слой;
Скрытые (вычислительные) слои;
Выходной слой.

Обучение нейросетей происходит в два этапа:

Обратное распространение ошибки.

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

Прямое распространение

Зададим начальные веса случайным образом:

Умножим входные данные на веса для формирования скрытого слоя:

h1 = (x1 * w1) + (x2 * w1)
h2 = (x1 * w2) + (x2 * w2)
h3 = (x1 * w3) + (x2 * w3)

Выходные данные из скрытого слоя передается через нелинейную функцию (функцию активации), для получения выхода сети:

y_ = fn(h1 , h2, h3)

Обратное распространение

Суммарная ошибка (total_error) вычисляется как разность между ожидаемым значением «y» (из обучающего набора) и полученным значением «y_» (посчитанное на этапе прямого распространения ошибки), проходящих через функцию потерь (cost function).
Частная производная ошибки вычисляется по каждому весу (эти частные дифференциалы отражают вклад каждого веса в общую ошибку (total_loss)).
Затем эти дифференциалы умножаются на число, называемое скорость обучения или learning rate (η).

Полученный результат затем вычитается из соответствующих весов.

В результате получатся следующие обновленные веса:

w1 = w1 — (η * ∂(err) / ∂(w1))
w2 = w2 — (η * ∂(err) / ∂(w2))
w3 = w3 — (η * ∂(err) / ∂(w3))

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

Популярный мем о том, как Карлсон стал Data Science разработчиком

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

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

Частные производные

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

Разберем необходимость частных производных на примере.

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

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

Ошибка нескольких детей может уменьшиться, но общая ошибка все еще увеличивается.

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

Гиперпараметры

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

Скорость обучения (learning rate)

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

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

Функция активации (activation function)

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

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

Функция потери (loss function)

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

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

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

Некоторые известные функции потерь:

Квадратичная (среднеквадратичное отклонение);
Кросс-энтропия;
Экспоненциальная (AdaBoost);
Расстояние Кульбака - Лейблера или прирост информации.

Cреднеквадратичное отклонение – самая простая фукция потерь и наиболее часто используемая. Она задается следующим образом:

Функция потерь в нейронной сети должна удовлетворять двум условиям:

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

Глубокие нейронные сети

Глубокое обучение (deep learning) – это класс алгоритмов машинного обучения, которые учатся глубже (более абстрактно) понимать данные. Популярные алгоритмы нейронных сетей глубокого обучения представлены на схеме ниже.

Популярные алгоритмы нейронных сетей (http://www.asimovinstitute.org/neural-network-zoo)

Более формально в deep learning:

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

Пример

Рассмотрим однослойную нейронную сеть:

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

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

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

Не следует путать с широкой нейронной сетью.

В этом случае большое число нейронов в одном слое не приводит к глубокому пониманию данных. Но это приводит к изучению большего числа признаков.

Пример:

Изучая английскую грамматику, требуется знать огромное число понятий. В этом случае однослойная широкая нейронная сеть работает намного лучше, чем глубокая нейронная сеть, которая значительно меньше.

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

Главное — баланс

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

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

Проклятье размерности

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

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

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

Компромисс

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

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

Действительно,

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

Следовательно, как правило, невозможно иметь маленькое смещение и маленькую дисперсию одновременно.

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

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

И тут возникает собственно самое важное, что вам для этого потребуется: ДАННЫЕ. Много примеров задач, которые будут подаваться на вход нейросети, и правильные ответы на эти задачи. Нейросеть будет на этом учиться самостоятельно давать эти правильные ответы.

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

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

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

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

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

Но что если бы вы смогли получить преимущества использования ИИ без необходимости нанимать этих редких и дорогостоящих специалистов? Что если этот порог входа можно понизить с помощью умного ПО? Можно ли использовать глубинное обучение с менее разнообразным набором кадров?

Стартап под названием Bonsai и целая группа похожих компаний отвечают на этот вопрос «да». Приготовьтесь к демократизации искусственного интеллекта. Когда-нибудь это движение может объединить под своими знаменами миллионы, если не миллиарды людей.

На Конференции разработчиков искусственного интеллекта О’Райли в Нью-Йорке генеральный директор Bonsai Марк Хаммонд провел презентацию своей компании. (Также он объявил о раунде инвестиций на сумму в $6 млн – не такие уж большие деньги, учитывая тот факт, что в этом году размер венчурных инвестиций в сферу ИИ уже 1,5 млрд.) Презентация включала повторение одного из самых известных достижений элитных разработчиков глубинного обучения: прохождение алгоритмом DeepMind старых игр для компьютеров Atari в реальном времени. В частности, игра под названием Breakout («Теннис»), в которой платформа отбивает квадратный «мяч», разбивающий мерцающие блоки. (Игра, выпущенная в 1976 году, была прорывом для своего времени – над ней работал сам )

37 строчек кода – вся структура нейросети, которая обучается через классическую игру Atari. Источник: Bonsai

Вариант, предложенный DeepMind, был создан лучшими в мире специалистами по ИИ, которые обучали нейросеть основам игр от Atari, и результат их работы был достоин научных публикаций мирового класса. Версия от Bonsai является упрощением. Все начинается с системы развития, которая загружена в облако. Всего один программист, пусть даже тот, кто вообще не обучался основам ИИ, может в общих чертах описать игру, а система сама выберет подходящий алгоритм обучения, чтобы задействовать нейросеть. (Бедным докторам наук из DeepMind приходилось писать эти алгоритмы самостоятельно). На этом этапе программисту нужно всего лишь за пару минут заложить основные принципы игры – например, «ловить мяч на платформу» - а затем Bonsai сама займется развитием нейросети и ее оптимизацией для получения наилучшего результата. А нейросеть на выходе уже сама будет играть в «Теннис».

Версия игры, написанная Bonsai, укладывается всего в 37 строчек кода. Но эта простота обманчива. Когда Хаммонд объясняет, что находится в основе алгоритма, он показывает рисунок с демонстрацией того, как его система строит нейросеть, способную соперничать с одним из лучших творений Google. Самому программисту даже не пришлось вникать в тонкости машинного обучения. Смотри, мам, я могу без рук докторской степени!

Так играет в «Теннис» нейросеть, обученная системой Bonsai. Источник: Bonsai

Впечатляющий трюк. «Обычно меня трудно удивить демонстрацией, - рассказывает Джордж Уильямс, научный сотрудник Курантовского института математики Нью-Йоркского университета. - Однако то, что показал мне Марк, было вполне реально и в то же время потрясающе. Он взял все достижения машинного интеллекта и создал инструменты, которые позволят разработать новое поколение систем ИИ».

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

Bonsai была рождена на пляже. Хаммонд, бывший инженер и евангелист разработки ПО, уже какое-то время раздумывал над возможностями искусственного интеллекта. После ухода из Microsoft в 2004 году он стал заниматься нейробиологией в Йеле, затем в 2010 году недолгое время проработал в Numenta – стартапе по разработке ИИ, которым владел Джефф Хокинс (сооснователь компании Palm, производителя КПК). Затем Хаммонд открыл еще одну компанию в совсем другой сфере, которую он затем продал.

Тогда, в 2012 году, Хаммонд приехал в Южную Калифорнию навестить друзей. Его маленький сын устал, и все пошли обратно к машине. Пока жена Хаммонда болтала с друзьями, а сын засыпал у него на руках, он провел мысленный эксперимент. В основе этого эксперимента лежал популярные мем из мира ИИ – концепция «мастер-алгоритма». Профессор Вашингтонского университета Педро Домингес в одноименной книге написал, что этот еще не созданный алгоритм мог бы стать панацеей для всех проблем отрасли. По идее, когда этот алгоритм все-таки изобретут, с его помощью можно будет методически внедрять системы ИИ куда угодно.

Хаммонд заключил, что нужно создать систему, которая позволит даже самому заурядному разработчику использовать инструменты ИИ Но Хаммонд видел один изъян в этой идее. «Допустим, мы нашли этот мастер-алгоритм, – говорил он себе, пока 18-месячный сын дремал у него на руках – кто станет внедрять его в бесчисленном множестве возможных сценариев?» На данный момент использовать такие инструменты под силу только настоящим адептам машинного обучения. Возможностей использования ИИ будет слишком много для ограниченного числа этих людей. Так он пришел к заключению, что нужно создать систему, которая снизит порог входа и позволит даже самому заурядному разработчику использовать эти инструменты. Такой системе не нужны будут инженеры крайне узкой специализации для обучения нейросетей. Программисты смогут сами обучать их для получения желаемого результата.

Пока Хаммонд обдумывал свои идеи, он провел аналогии с историей программирования. Изначально операторам компьютеров приходилось кропотливо писать код, который обеспечивал работу оборудования. Затем программисты взяли на вооружение набор стандартных инструкций, который был назван языком ассемблера и ускорил процесс – но вам все еще нужно было иметь очень высокий уровень подготовки, чтобы довести дело до ума. Прорыв случился, когда инженеры создали компилятор – программу, которая преобразовывала код на более удобных, так называемых языках «высокого уровня» (от самых первых BASIC и LISP до нынешних Python и C), в код на языке ассемблера. Только после этого создание мощных приложений стало доступно даже профессионалам относительно низкого уровня. Хаммонд считает, что сейчас, благодаря инструментам вроде TensorFlow от Google, системы ИИ вышли на уровень языка ассемблера, то есть инженерам уже становится легче создавать нейросети, но это все равно остается доступным тем, кто действительно понимает принцип их работы. Хаммонд хотел создать аналог компилятора, чтобы упростить все еще больше.

Этой идеей он поделился с Кином Брауном, бывшим коллегой из Microsoft, который недавно продал свой игровой стартап китайской интернет-компании. Идея ему понравилась, так как в то время он как раз пробовал заниматься машинным обучением, используя доступные на тот момент инструменты. «Вообще я человек неглупый, - говорит Браун - я приехал в Китай и выучил их язык, работал программистом в Microsoft, но даже для меня это было слишком». Он согласился стать сооснователем Bonsai. (Название было выбрано, потому что в этом японском искусстве достигается идеальный баланс между естественным и искусственным. Еще одно преимущество появилось, когда владельцы интернет-домена разрешили молодой компании зарегистрировать свой сайт по адресу bons.ai .)

Bonsai – не единственная компания, работающая над решением проблемы нехватки квалифицированных специалистов по ИИ. Некоторые из более крупных компаний поняли необходимость обучения собственных кадров и обучения обычных программистов в мастеров по нейросетям: в Google создали целую серию внутренних программ, а Apple стала обращать внимание на навыки и личные качества программистов, которые помогли бы им быстрее освоить нужные умения. Как уже говорилось выше, Google также выпустила в широкий доступ программу TensorFlow, благодаря которой ее инженерам проще создавать нейросети. Уже доступны и другие наборы инструментов для создания ИИ, и, без сомнения, таких инструментов будет становиться только больше.

«Мы открываем новые возможности для тех, кто не является ученым или программистом» В то же время другие стартапы тоже трудятся во имя демократизации ИИ. Компания Bottlenose решает проблему нехватки ученых, но для другой целевой аудитории: если Bonsai делает свой продукт в первую очередь для разработчиков ПО, Bottlenose планирует облегчить жизнь бизнес-аналитикам. Однако мотивы те же самые. «Мы открываем новые возможности для тех, кто не является ученым или программистом», - говорит генеральный директор компании Нова Спивак. Некоторые стартапы собираются затронуть еще больше пользователей: презентация компании Clarifai на конференции О’Райли называлась «Как сделать так, чтобы каждый человек на планете мог обучить и использовать ИИ».

Таким образом, хотя Bonsai, похоже, появилась в нужное время в нужном месте, сейчас индустрия ИИ настолько бурно развивается, что у стартапа Хаммонда могут возникнуть трудности с привлечением к себе внимания. Адам Чейер, специалист по ИИ, который участвовал в создании и сейчас занимает пост главного инженера , уже видел продукт Bonsai и остался очень впечатлен. Но он отмечает, что, хотя Bonsai делает ИИ доступным даже новичкам, людям все равно придется совершать умственные усилия, чтобы разобраться в их языке программирования и общем устройстве системы. «Когда новый продукт выпускает большая компания вроде Google, люди со всех ног бросаются его пробовать. Но если такой же продукт делает стартап, привлечь к нему людей намного сложнее. Хватит ли у них сил, чтобы задействовать достаточное количество пользователей и сделать свой инструмент популярным? Получится ли все у Bonsai или нет – сложно сказать прямо сейчас».

Компания создала систему из нескольких компонентов, среди которых Brain, облачная система для создания нейросетей, язык написания скриптов под названием Inkling и Mastermind, «интегрированная среда для разработки», которая предоставляет программистам все необходимые инструменты в одном месте. («Приложение для создания приложений», - объясняет Браун). Система Bonsai доступна для бета-тестирования.

Марк Хаммонд в главном офисе Bonsai в центре Беркли. Фото: Backchannel

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

Так что пока опытные инженеры систем ИИ «тренируют» сеть, сравнивая информацию на выходе с желаемым результатом (например, показывая сети фотографии собак и поощряя ее при выводе подходящих характеристик), Bonsai позволяет вам «научить» систему, просто разбив весь процесс на основные принципы. Если продолжить пример с собаками, то вы могли бы упомянуть такие вещи, как четыре лапы, морда и язык, свисающий изо рта. Вы даете только необходимую базу, а облачный «умный движок» Bonsai, в который входит и «мозг», доводит дело до конца.

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

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

«Я думаю, всегда приходится идти на компромисс, - говорит Лайла Третиков, специалист по ИИ, ранее работавшая главой фонда Wikimedia Foundation и консультировавшая Bonsai. - Результаты будут не совсем такими же, как если задействовать группу ученых. Но я не уверена, что важнее: качество или сама по себе возможность это сделать». Адам Чейер из Viv также предполагает, что код Bonsai может работать не так эффективно, как ПО, оптимизированное под конкретную задачу. «Но это все равно чертовски хороший код, и он позволяет вам не вдаваться в ненужные тонкости», - добавляет он. Чейер также говорит, что в его компании, где как раз работают столь ценные специалисты по ИИ, вряд ли будут пользоваться Bonsai - разве что для создания прототипа какой-либо из идей перед тем, как реализовать ее старым проверенным способом.

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

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

Bonsai пытается решить проблемы, которые не смогли решить даже самые могущественные компании. «Мы работаем над многими играми», - добавляет Хаммонд и объясняет, что игры решают ключевые проблемы, которые планируют разрешить в Bonsai. «Некоторые игры не поддаются даже DeepMind. Хотя они научили свой алгоритм играть во множество игр помимо «Тенниса», пока их система еще не способна играть в «Пакмена».

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

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

Мотивация: ориентируясь на личный опыт в изучении глубокого обучения, я решил создать нейронную сеть с нуля без сложной учебной библиотеки, такой как, например, . Я считаю, что для начинающего Data Scientist-а важно понимание внутренней структуры нейронной сети.

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

Что такое нейронная сеть?

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

Нейронные сети состоят из следующих компонентов:

входной слой, x
произвольное количество скрытых слоев
выходной слой, ŷ
набор весов и смещений между каждым слоем W и b
выбор функции активации для каждого скрытого слоя σ ; в этой работе мы будем использовать функцию активации Sigmoid

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

Создание класса Neural Network на Python выглядит просто:

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

Выход ŷ простой двухслойной нейронной сети:

В приведенном выше уравнении, веса W и смещения b являются единственными переменными, которые влияют на выход ŷ.

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

Каждая итерация обучающего процесса состоит из следующих шагов

вычисление прогнозируемого выхода ŷ, называемого прямым распространением
обновление весов и смещений, называемых обратным распространением

Последовательный график ниже иллюстрирует процесс:

Прямое распространение

Как мы видели на графике выше, прямое распространение - это просто несложное вычисление, а для базовой 2-слойной нейронной сети вывод нейронной сети дается формулой:

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

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

Функция потери

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

Сумма квадратов ошибок - это среднее значение разницы между каждым прогнозируемым и фактическим значением.

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

Обратное распространение

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

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

Напомним из анализа, что производная функции - это тангенс угла наклона функции.

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

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

Фух! Это было громоздко, но позволило получить то, что нам нужно - производную (наклон) функции потерь по отношению к весам. Теперь мы можем соответствующим образом регулировать веса.

Добавим функцию backpropagation (обратного распространения) в наш код на Python-е:

Проверка работы нейросети

Теперь, когда у нас есть наш полный код на Python-е для выполнения прямого и обратного распространения, давайте рассмотрим нашу нейронную сеть на примере и посмотрим, как это работает.

Идеальный набор весов

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

Давайте тренируем нейронную сеть на 1500 итераций и посмотрим, что произойдет. Рассматривая график потерь на итерации ниже, мы можем ясно видеть, что потеря монотонно уменьшается до минимума. Это согласуется с алгоритмом спуска градиента, о котором мы говорили ранее.

Посмотрим на окончательное предсказание (вывод) из нейронной сети после 1500 итераций.

Мы сделали это! Наш алгоритм прямого и обратного распространения показал успешную работу нейронной сети, а предсказания сходятся на истинных значениях.

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

Финальные размышления

Я многому научился в процессе написания с нуля своей собственной нейронной сети. Хотя библиотеки глубинного обучения, такие как TensorFlow и Keras, допускают создание глубоких сетей без полного понимания внутренней работы нейронной сети, я нахожу, что начинающим Data Scientist-ам полезно получить более глубокое их понимание.

Я инвестировал много своего личного времени в данную работу, и я надеюсь, что она будет полезной для вас!

Что мы будем делать? Мы попробуем создать простую и совсем маленькую нейронную сеть , которую мы объясним и научим что-нибудь различать. При этом не будем вдаваться в историю и математические дебри (такую информацию найти очень легко) — вместо этого постараемся объяснить задачу (не факт, что удастся) вам и самим себе рисунками и кодом.
Многие из терминов в нейронных сетях связаны с биологией, поэтому давайте начнем с самого начала:

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

Возбудитель может быть и внутренним (например, образ или идея):

А теперь взглянем на основные и упрощенные части мозга :

Мозг вообще похож на кабельную сеть.

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

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

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

И описать её формализовано с помощью графа:

Тут требуются некоторые пояснения. Кружки — это нейроны, а линии — это связи между ними, и, чтобы не усложнять на этом этапе, взаимосвязи представляют собой прямое передвижение информации слева направо . Первый нейрон в данный момент активен и выделен серым. Также мы присвоили ему число (1 — если он работает, 0 — если нет). Числа между нейронами показывают вес связи.

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

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

Когда на них направляют безопасную струю воздуха, кролики, как и люди, моргают:

Эту модель поведения можно нарисовать графами:

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

Введем еще один элемент — безопасный звуковой сигнал:

Мы можем смоделировать заинтересованность кролика так:

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

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

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

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

Для первых трех попыток схемы будут выглядеть так:

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

Мы убрали воздействие воздухом, но кролик все еще моргает, услышав звуковой сигнал! Объяснить это поведение может наша последняя схемка:

Мы обучили кролика реагировать на звук морганием.

В условиях реального эксперимента такого рода может потребоваться более 60 повторений для достижения результата.

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

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

Мы можем изобразить (схематично), что делает кнопка при нажатии следующим образом:

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

Нажмите на 3-ю кнопку, чтобы получить свой ужин.

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

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

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

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

Var inputs = ; var weights = ; // Для удобства эти векторы можно назвать

Следующий шаг — создание функции, которая собирает входные значения и веса и рассчитывает значение на выходе:

Function evaluateNeuralNetwork(inputVector, weightVector){ var result = 0; inputVector.forEach(function(inputValue, weightIndex) { layerValue = inputValue*weightVector; result += layerValue; }); return (result.toFixed(2)); } // Может казаться комплексной, но все, что она делает — это сопоставляет пары вес/ввод и добавляет результат

Как и ожидалось, если мы запустим этот код, то получим такой же результат, как в нашей модели или графике…

EvaluateNeuralNetwork(inputs, weights); // 0.00

Живой пример: Neural Net 001 . Следующим шагом в усовершенствовании нашей нейросети будет способ проверки её собственных выходных или результирующих значений сопоставимо реальной ситуации, давайте сначала закодируем эту конкретную реальность в переменную:

Чтобы обнаружить несоответствия (и сколько их), мы добавим функцию ошибки:

Error = Reality - Neural Net Output

С ней мы можем оценивать работу нашей нейронной сети:

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

Теперь мы знаем, что наша модель нейронной сети не работает (и знаем, насколько), здорово! А здорово это потому, что теперь мы можем использовать функцию ошибки для управления нашим обучением. Но всё это обретет смысл в том случае, если мы переопределим функцию ошибок следующим образом:

Error = Desired Output - Neural Net Output

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

Var input = ; var weights = ; var desiredResult = 1;

И новую функцию:

Function evaluateNeuralNetError(desired,actual) { return (desired — actual); } // After evaluating both the Network and the Error we would get: // "Neural Net output: 0.00 Error: 1"

Живой пример: Neural Net 002 . Подведем промежуточный итог . Мы начали с задачи, сделали её простую модель в виде биологической нейронной сети и получили способ измерения её производительности по сравнению с реальностью или желаемым результатом. Теперь нам нужно найти способ исправления несоответствия — процесс, который как и для компьютеров, так и для людей можно рассматривать как обучение.

Как обучать нейронную сеть?

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

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

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

Var learningRate = 0.20; // Чем больше значение, тем быстрее будет процесс обучения:)

И что это изменит?

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

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

Function learn(inputVector, weightVector) { weightVector.forEach(function(weight, index, weights) { if (inputVector > 0) { weights = weight + learningRate; } }); }

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

// Original weight vector: // Neural Net output: 0.00 Error: 1 learn(input, weights); // New Weight vector: // Neural Net output: 0.20 Error: 0.8 // Если это не очевидно, вывод нейронной сети близок к 1 (выдача курицы) — то, чего мы и хотели, поэтому можно сделать вывод, что мы движемся в правильном направлении

Живой пример: Neural Net 003 . Окей, теперь, когда мы движемся в верном направлении, последней деталью этой головоломки будет внедрение повторов .

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

Var trials = 6;

И внедрение в нашу обучающую нейросеть функции количества повторов будет выглядеть так:

Function train(trials) { for (i = 0; i < trials; i++) { neuralNetResult = evaluateNeuralNetwork(input, weights); learn(input, weights); } }

Ну и наш окончательный отчет:

Neural Net output: 0.00 Error: 1.00 Weight Vector: Neural Net output: 0.20 Error: 0.80 Weight Vector: Neural Net output: 0.40 Error: 0.60 Weight Vector: Neural Net output: 0.60 Error: 0.40 Weight Vector: Neural Net output: 0.80 Error: 0.20 Weight Vector: Neural Net output: 1.00 Error: 0.00 Weight Vector: // Chicken Dinner !

Живой пример: Neural Net 004 . Теперь у нас есть вектор веса, который даст только один результат (курицу на ужин), если входной вектор соответствует реальности (нажатие на третью кнопку). Так что же такое классное мы только что сделали?

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

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

Механизм хранения изученных весов не предусмотрен, поэтому данная нейронная сеть забудет всё, что знает. При обновлении или повторном запуске кода нужно не менее шести успешных повторов, чтобы сеть полностью обучилась, если вы считаете, что человек или машина будут нажимать на кнопки в случайном порядке… Это займет какое-то время.
Биологические сети для обучения важным вещам имеют скорость обучения 1, поэтому нужен будет только один успешный повтор.
Существует алгоритм обучения, который очень напоминает биологические нейроны, у него броское название: правило widroff-hoff , или обучение widroff-hoff .
Пороги нейронов (1 в нашем примере) и эффекты переобучения (при большом количестве повторов результат будет больше 1) не учитываются, но они очень важны в природе и отвечают за большие и сложные блоки поведенческих реакций. Как и отрицательные веса.

Заметки и список литературы для дальнейшего чтения

Я пытался избежать математики и строгих терминов, но если вам интересно, то мы построили перцептрон , который определяется как алгоритм контролируемого обучения (обучение с учителем) двойных классификаторов — тяжелая штука. Биологическое строение мозга — тема не простая, отчасти из-за неточности, отчасти из-за его сложности. Лучше начинать с Neuroscience (Purves) и Cognitive Neuroscience (Gazzaniga). Я изменил и адаптировал пример с кроликом из Gateway to Memory (Gluck), которая также является прекрасным проводником в мир графов. Еще один шикарный ресурс An Introduction to Neural Networks (Gurney), подойдет для всех ваших нужд, связанных с ИИ.
А теперь на Python! Спасибо Илье Андшмидту за предоставленную версию на Python:

Inputs = weights = desired_result = 1 learning_rate = 0.2 trials = 6 def evaluate_neural_network(input_array, weight_array): result = 0 for i in range(len(input_array)): layer_value = input_array[i] * weight_array[i] result += layer_value print("evaluate_neural_network: " + str(result)) print("weights: " + str(weights)) return result def evaluate_error(desired, actual): error = desired - actual print("evaluate_error: " + str(error)) return error def learn(input_array, weight_array): print("learning...") for i in range(len(input_array)): if input_array[i] > 0: weight_array[i] += learning_rate def train(trials): for i in range(trials): neural_net_result = evaluate_neural_network(inputs, weights) learn(inputs, weights) train(trials)

А теперь на GO! За эту версию благодарю Кирана Мэхера.

Package main import ("fmt" "math") func main() { fmt.Println("Creating inputs and weights ...") inputs:= float64{0.00, 0.00, 1.00, 0.00} weights:= float64{0.00, 0.00, 0.00, 0.00} desired:= 1.00 learningRate:= 0.20 trials:= 6 train(trials, inputs, weights, desired, learningRate) } func train(trials int, inputs float64, weights float64, desired float64, learningRate float64) { for i:= 1; i < trials; i++ { weights = learn(inputs, weights, learningRate) output:= evaluate(inputs, weights) errorResult:= evaluateError(desired, output) fmt.Print("Output: ") fmt.Print(math.Round(output*100) / 100) fmt.Print(" Error: ") fmt.Print(math.Round(errorResult*100) / 100) fmt.Print(" ") } } func learn(inputVector float64, weightVector float64, learningRate float64) float64 { for index, inputValue:= range inputVector { if inputValue > 0.00 { weightVector = weightVector + learningRate } } return weightVector } func evaluate(inputVector float64, weightVector float64) float64 { result:= 0.00 for index, inputValue:= range inputVector { layerValue:= inputValue * weightVector result = result + layerValue } return result } func evaluateError(desired float64, actual float64) float64 { return desired - actual }