Нейросеть на java: Быстрая нейронная сеть для каждого / Хабр

Нейронки за 5 минут / Хабр

Давайте я за 5-10 минут чтения и понимания коротенькой статьи добавлю вам в резюме строчки «машинное обучение» и «нейронные сети»? Тем, кто далек от программирования, я развею все мифы о сложности ИИ и покажу, что большая часть всех проектов на машинном обучении строится на предельно простых принципах. Поехали — у нас всего пять минут.

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

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

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

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

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

У каждого ввода слева есть значение: 0 или 1, да или нет. Давайте добавим эти значения вводу, предположим, что на вечеринке не будет водки, будут друзья да будет идти дождь:

Так, с этим разобрались. Что делаем дальше? А вот тут и возникает веселуха: давайте воспользуемся самым старым способом выставления начального состояния нейронок — великий рандом:

Цифры, которые мы расставили — это веса связей. Помните, что нейроны — это туфта пустая? Так вот, связи — это именно то, из чего и состоит нейронная сеть. Но что за веса связей? Это те штуки, на которые мы умножаем вводные значения и временно храним в пустых нейронах. На самом деле не храним, но для удобства представим, что в нейроны что-то можно положить:

Как вам математика? Смогли произвести умножение? Погодите, самое «сложное» только началось! Дальше мы складываем значения (в одной из реализаций перцептронов):

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

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

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

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

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

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

Дальше все просто: вместо одного слоя нейронов мы делаем два и снова все перебираем по точно тем же самым принципам, только уже все нейроны отдают значения другим нейронам. Если сначала у нас было только 3 связи, то теперь 3 + 9 связей с весами. А потом три слоя, четыре, рекурсивные слои, зацикленные на себе и тому подобная дичь:

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

Что, если на входе у вас картинка и нужно категоризировать все картинки на собачек и кошечек? Картинки-то по 512х512 размерам, каждый пиксель ведь ввод — это ж мы сколько по нейронам будем гонять значения? Для этого есть сверточные нейроны! Это такая шняга, которая берет 9 пикселей рядом друг с другом, например, и усредняет их значения RGB. Получается, сжимает картинку для более быстрой обработки. Либо, например, вообще избавляется от красного цвета в картинке, так как он не важен (ищем, например, только зелено-синие платья). Это сверточные сети — дополнительный слой «нейронов» на входе, которые обрабатывают ввод для понятного и упрощенного для сети вида.

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

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

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

Ну, вот и все — я дал вам фундамент для понимания, что такое нейронные сети. Так же я, надеюсь, показал вам, что не так страшен черт, как его малюют — все оказалось невероятно просто, на уровне умножения и сложения. Дальше советую начать смотреть туториалы на YouTube или Udemy — там чуваки офигенно круто все объясняют.

В следующий раз, когда с вас попросят денег на проект с машинным обучением, трясите с попрошаек наброски работы нейронных сетей — какие слои, как они организованы, зачем и почему вот тут так, а там не так. Все это на уровне, максимум, 11 класса будет (это про интегралы и дифференциалы) — и то встретится в описании раз, может, два. Пока этой модели у проекта нет (какие слои и как расположены) — у проекта нет продукта, потому что вот эта структура — это первые 2-4 недели специалиста по машинному обучению.

P.S., пример для объяснения я нагло стянул с одного великолепного видео про нейронные сети. Очень советую посмотреть — спасибо ребятам! подписчики помогли восстановить ссылку на оригинал видео, пример из которого я пытался восстановить из памяти. Если кому интересно, как задачу выше закодить, то приглашаю вас посмотреть вот этот ролик. Спасибо большое авторам!

11 JavaScript-библиотек для машинного обучения

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

1. Brain.js

Brain.js — Javascript библиотека для искусственных нейронных сетей, заменяющая «мозговую» библиотеку, которая предлагает разные типы сетей в зависимости от конкретных задач. Используется с Node.js или в браузере. Здесь представлено демо тренировки сети для распознавания цветовых контрастов.

Обучение Brain.js распознавать цветовые контрасты

2. Synaptic

Synaptic — Javascript библиотека для нейронных сетей для node.js и браузера, которая позволяет обучать архитектуры нейронных сетей первого и второго порядков. Проект содержит несколько встроенных архитектур  — многослойный перцептрон, многослойная сеть долгой краткосрочной памяти, LSM (liquid state machine) и тренер (trainer), способный обучать сети.

Фильтрация изображения с помощью перцептрона Synaptic

3. Neataptic

Эта библиотека предоставляет возможность быстро осуществлять нейроэволюцию и обратное распространение для браузера и Node.js. Библиотека содержит несколько встроенных сетей — перцептрон, LSTM, GRU, Nark и другие. Для новичков есть туториал, помогающий реализовать тренировку сети.

Демо поиска цели на Neaptic

4. Conventjs

Эта популярная библиотека, разработанная PhD студентом из Стэнфорда Андреем Карпатым, который сейчас работает в Tesla. Хотя она не поддерживается последние 4 года, Conventjs остается одним из самых интересных проектов в этом списке. Conventjs представляет из себя написанную на Javascript реализацию нейронных сетей, поддерживающую  распространенные модули — классификацию, регрессию, экспериментальный модуль обучения с подкреплением. С помощью этой библиотеки можно даже обучать сверточную нейросеть для обработки изображений.

Задача двумерной классификации при помощи двухслойной нейросети на Convent.js

5. Webdnn

Webdnn — японская библиотека, созданная для быстрой работы с предобученными глубокими нейросетевыми моделями в браузере. Хотя запуск DNN (Глубокой нейронная сети) в браузере требует больших вычислительных ресурсов, этот фреймворк оптимизирует DNN модель так, что данные модели сжимаются, а исполнение ускоряется при помощи JavascriptAPI, таких как WebAssembly и WebGPU.

Пример трансфера стиля

6. Tensorflow.js

Библиотека от Google (преемница популярной deeplearnjs) дает возможность обучать нейронные сети в браузере или запускать предобученные модели в режиме вывода. Создатели библиотеки утверждают, что она может быть использована как NumPy для веба. Tensorflow.js с простым в работе API может быть использована в разнообразных полезных приложениях. Библиотека также активно поддерживается.

7. TensorFlow Deep Playground

Deep playground  — инструмент для интерактивной визуализации нейронных сетей, написанный на TypeScript с использованием d3.js. Хотя этот проект в основном содержит самую базовую площадку для tensorflow, он может быть использован для различных целей, например, в качестве очень выразительного обучающего инструмента.

Игровая площадка Tensorflow

8. Compromise

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

Compromise напоминает, как в действительности выглядит английский

9. Neuro.js

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

Беспилотное авто с Neuro.js

10. mljs

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

Проект mljs на GitHub

11. Mind

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

Достойны упоминания:

Natural

Активно поддерживаемая библиотека для Node.js, которая обеспечивает: токенизацию, стемминг (сокращение слова до необязательно морфологического корня), классификацию, фонетику, tf-idf, WordNet и другое.

Incubator-mxnet

MXnet от Apache — фреймворк глубокого обучения, который позволяет на лету смешивать символьное и императивное программирование со слоем оптимизации графа для достижения результата. MXnet.js обеспечивает API для глубокого обучения в браузере.

Keras JS

Эта библиотека запускает модели Keras в браузере с поддержкой GPU при помощи технологии WebGL.  Так как Keras использует в качестве бэк-енда различные фреймворки, модели могут быть обучены в TensorFlow, CNTK, а также и в других фреймворках.

Deepforge

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

Land Lines

Land Lines — не столько библиотека, сколько очень занимательная веб-игра на основе эксперимента Chrome от Google. Нельзя сказать, для чего нужна эта штука, но она позабавит хотя бы 15 минут.

Что дальше?

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

10 примеров машинного обучения на JS

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

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

В последнее время веб-экосистема достигла большого прогресса, и хотя JavaScript и Node.js все же менее эффективны, чем Python и Java, они достаточно мощны, чтобы справляться с многочисленными проблемами машинного обучения. Веб-языки также обладают тем преимуществом, они являются супер доступными — все, что вам нужно для запуска проекта JavaScript ML, — это ваш веб-браузер.

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

Brain — это библиотека, которая позволяет легко создавать нейронные сети, а затем обучать их на основе входных / выходных данных. Поскольку обучение потребляет множество ресурсов, предпочтительнее запускать библиотеку в среде Node.js, хотя версию браузера CDN также можно загрузить непосредственно на веб-страницу. На их сайте есть крошечное demo, которое можно обучить распознаванию цветового контраста.

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

FlappyLearning — это проект JavaScript, который содержит примерно 800 строк кода, позволяет создать библиотеку машинного обучения и реализовать ее в веселой форме, которая учит играть в Flappy Bird, как виртуоз. Методика искусственного интеллекта, используемая в этой библиотеке, называется Neuroevolution и применяет алгоритмы, основанные на нервных системах, обнаруженных в природе, динамически обучающихся от успеха или неудачи каждой итерации. Демонстрационный пример очень прост в запуске — просто откройте index.html в браузере.

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

Land Lines — интересный веб-эксперимент Chrome, который находит спутниковые снимки Земли, похожие на каракули, сделанные пользователем. Приложение не выполняет серверных вызовов: оно работает полностью в браузере и благодаря умному использованию машинного обучения и WebGL имеет отличную производительность даже на мобильных устройствах. Вы можете проверить исходный код на GitHub или ознакомиться с полным исследованием здесь.

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

Thing Translator — это веб-эксперимент, который позволит вашему телефону распознать реальные объекты и назвать их на разных языках. Приложение создано полностью с помощью веб-технологий и использует два API машинного обучения: от Google — Cloud Vision для распознавания образов и Translate API для перевода на естественный язык.

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

Другая библиотека, которая позволяет нам настраивать и обучать нейронные сети, используя только JavaScript. Она очень проста в установке как в Node.js, так и на клиентской стороне, и имеет чистый API, который будет удобен для разработчиков любой квалификации. Библиотека предоставляет множество примеров, которые реализуют популярные алгоритмы, помогая вам понять основные принципы машинного обучения.

DeepForge — удобная среда разработки для работы с глубинным обучением. Она позволяет вам проектировать нейронные сети, используя простой интерфейс, поддерживает обучающие модели на удаленных машинах и имеет встроенный контроль версий. Проект запускается в браузере и основан на Node.js и MongoDB, делая процесс установки очень знакомым большинству веб-разработчиков.

Отличная серия статей в блоге от Бурака Канбера, которая описывает некоторые основы машинного обучения. Учебники хорошо написаны, понятны и ориентированы именно на разработчиков JavaScript. Отличный ресурс, если вы хотите более глубоко изучить машинное обучение.

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

Машинное обучение за год

6 приложений, использующих глубокое обучение, для начинающих

Пощупать нейросети или конструктор нейронных сетей / Хабр

Я давно интересовался нейросетями, но только с позиции зрителя – следил за новыми возможностями, которые они дают по сравнению с обычным программированием. Но никогда не лез ни в теорию, ни в практику. И вдруг (после сенсационной новости о AlphaZero) мне захотелось сделать свою нейросеть. Посмотрев несколько уроков по этой теме на YouTube, я немного врубился в теорию и перешёл к практике. В итоге я сделал даже лучше, чем свою нейросеть. Получился конструктор нейросетей и наглядное пособие по ним (то есть можно смотреть, что творится внутри нейросети). Вот как это выглядит:

А теперь немного подробнее. С помощью этого конструктора можно создавать сети прямого распространения (Feedforward neural network) до 8 скрытых слоёв (плюс слой входов и слой выходов, итого 10 слоёв (обычно 4-х слоёв более чем достаточно)) в каждом слое до 30 нейронов (ограничение связано с тем, что всё это одновременно отображается на экране, если будут просьбы в комментариях выпущу версию без ограничений и визуализации). Функция активации всех нейронов – сигмоид на основе логистической функции. Также можно обучать получившиеся сети методом обратного распространения ошибки градиентным спуском по заданным примерам. И, самое главное, можно посмотреть на каждый нейрон в каждом отдельном случае (какое значение он передаёт дальше, его смещение (поправку, bias) – нейроны с отрицательным смещением белые, с положительным – ярко-зелёные), связи нейронов в зависимости от их веса помечены красным – положительные, синим – отрицательные, а также отличаются по толщине – чем больше модуль веса, тем толще. А если навести мышку на нейрон, то можно ещё посмотреть какой сигнал на него приходит, и какое конкретно у него смещение. Это полезно, чтобы понять, как работает конкретная сеть или показать студентам принцип работы сетей прямого распространения. Но самое главное – свою сеть можно сохранить в файл и поделиться с миром.

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

Как пользоваться конструктором

Для начала скачайте архив отсюда.
(Добавил в архив исходники, удалил сеть 4-5, теперь точно нет вирусов нигде)

Распакуйте в корень диска D:\

(Если нет D:\ отключите в диспетчере устройств дисковод, в Управление дисками создайте виртуальный D:\ — инициализируйте, создайте том)

Запустите NeuroNet.exe

Можете попробовать «Загрузить» какую-нибудь сеть, посмотреть на неё, нажать «Обучение», увидеть её точность, потыкать стрелки влево, вправо (по бокам), чтобы посмотреть различные варианты входных (левый столбец нейронов) и выходных (правый) данных, нажать «Стоп» и попробовать ввести свои входные данные (разрешены любые значения от 0 до 1, учитывайте это при создании своих сетей и нормализуйте входные и выходные данные).

Теперь как строить свои сети. Первым делом необходимо задать архитектуру сети (количество нейронов в каждом слое через запятую), нажать «Построить» (или сначала «Снести», затем построить, если у Вас на экране уже отображается другая сеть), нажать «Обучающая выборка», «Удалить всё» и ввести свои обучающие примеры, согласно инструкции на экране.

Например, если входные данные — это два нейрона со значениями 0.25(используем точку вместо запятой) и 0, а выходные — 1 и 0.01(все значения нормализуем от 0 до 1), то обучающий пример будет «0.25,0,1,0.01»

Также можно указать на вход и на выход маленькие квадратные картинки (максимум 5х5 пикселей), из которых будут определены нормализованные значения яркости пикселей (не учитывая их цвет), для чего нужно нажать на «in» и «out» соответственно. Нажать «Добавить пример», повторить процедуру нужное количество раз. Нажать «Готово», «Обучение» и как точность станет удовлетворительной (обычно 98%), нажать «Стоп», иконку в виде дискеты (сохранить), дать сети имя и радоваться, что Вы сами создали нейросеть. Дополнительно можете устанавливать скорость обучения ползунком «Точнее/Быстрее», а также визуализировать не каждый 50й шаг, а каждый 10й или 300й, как Вам угодно.

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

Чтобы использовать свои нейросети в собственных проектах, я создал отдельное приложение doNet.exe, которое нужно запускать с параметрами: «D:\NeuroNet\doNet.exe <название сети> <входные данные через пробел>», дождаться завершения работы приложения, после чего считать выходные данные из D:\NeuroNet\temp.txt

Для примера создано приложение 4-5.exe, использующее сеть «4-5» (об этой и других сетях ниже). В этом приложении подробно расписано как правильно запускать doNet.exe

Разбор сетей, идущих в комплекте

Начнём с классики – «XOR(Полусумматор)». Среди прочих, в частности, эту задачу – сложение по модулю 2 – в 1969 году приводили в качестве примера ограниченности нейросетей (а именно однослойных перцептронов). В общем, имеется два входа (со значениями либо 0, либо 1 у каждого), наша же задача — ответить 1, если значения входов разные, 0 – если одинаковые.

Далее «Количество-единиц». Три входа (0 либо 1 на каждом). Требуется посчитать, сколько было подано единиц. Реализовано как задача классификации – четыре выхода на каждый вариант ответа (0,1,2,3 единицы). На каком выходе максимальное значение, соответственно таков и ответ.

«Умножение» – Два входа (вещественные от 0 до 1), на выход их произведение.

«4-5» – На вход подаются нормализованные значения яркости пикселей картинки 4х4, на выходе имеем нормализованные значения яркости пикселей картинки 5х5.

Сеть задумывалась, как увеличение качества большой картинки на 25%, вышел же интересный фильтр для фото:

UPD: В архив добавлено приложение NeuroNet2.exe (тот же конструктор, но без визуализации (благодаря чему работает в 2 раза быстрее) и ограничений на количество нейронов в слое (до 1024 вместо 30), также в обучающей выборке на вход и выход можно подавать квадратные картинки до 32х32). Также добавлен график обучения. Ускорена загрузка и в обучающую выборку можно закладывать большой объём данных.

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

Вот собственно и всё, жду комментариев.

P.S. Если вылезает ошибка, попробуйте зарегистрировать от администратора с помощью regsvr32 файлы comdlg32, которые также есть в архиве.

Нейросетевое программное обеспечение —

Нейронные сети

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

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

• Alyuda NeuroIntelligence — Нейросетевое программное обеспечение и расширение для Excel, предназначенное для прогнозирования и анализа данных. Поддерживает несколько алгоритмов. Доступна trial-версия.
• Amygdala — Программное обеспечение с открытым исходным кодом для моделирования нейронных сетей, написанное на C++.
• Annie — Нейросетевая библиотека для C + + (Windows и Linux) с открытым исходным кодом. Поддерживает MLP, RBF и сети Хопфилда. Наличие интерфейсов для Matlab’s Neural Network Toolbox.
• Artificial Intelligence Recurrent Asymmetric Networks (NARIA) — Открытый проект о симуляции человеко-подобного интеллекта с помощью нейронных сетей.
• Cortex — Приложение, реализующее нейронные сети обратного распространения.
• DELVE — Стандартная среда для оценки эффективности методов обучения. Включает в себя набор данных и архив методов обучения.
• EasyNN — Нейросетевое программное обеспечение для Windows с числовыми, текстовыми и графичискими функциями.
• ECANSE — Предоставляет среду разработки для проектирования, моделирования и тестирования нейронных сетей и их применения для производства оптимизированного программного решения.
• FANN — Нейросетевая библиотека исполняемая в ANSI C. Создает многослойные сети прямого распространения с поддержкой как полносвязных и и сетей со структурными связями. Поддерживает выполнение в фиксированной точке для быстрой работы на системах, как IPAQ.
• Fann Neural Network for Mathematica — Бесплатная интерактивная среда для Mathematica, включающая распознавание образов и предсказания временных рядов.
• Genesis —  Платформа для моделирования сложных нейронных систем.
• Java library — Java-библиотека с открытыым кодом, реализующая сети прямого распространения такие как:  многослойные персептроны, обобщенные и модульные сети прямого распространения.
• Joone — (Java Object Oriented Neural Engine)  — свободно распространяемый нейросетевой фреймворк на Java. Может быть расширен новыми модулями.
• libF2N2 — Нейросетевая библиотека с открытым исходным кодом. Реализует нейронные сети прямого распространения на C++ и PHP.
• Lightweight Neural Network++ — Свободно распространяемое программное обоеспечение. Реализует нейронные сети прямого распространения  и неккоторые мтеоды обучения.
• LTF-Cimulator — Симулятор LTF-C нейронных сетей для решения задач классификации.
• Netlab — Библиотека MATLAB- функций для моделирования нейросетевых алгоритмов, основанных на книге «Neural Networks for Pattern Recognition» Chris Bishop.
• NetMaker — Моделирует MLP, RMLP and каскадно-корреляционные сети с динамической подстройкой архитектуры. Включает различные учебные данные, ошибки и активационные функции.
• Neurak — бесплатная среда для разработки и применения искусственных нейронных сетей.
• Neural Network Framework — Фреймворк для создания нейронных сетей с произвольной топологией и смешанного типа нейронов. Включает в себя техническую информацию и почтовые рассылки.
• Neural Network Leaves Recognition — Нейронная сеть, предназначенная для распознования. Написана на Java.  Java-Applet также доступен.
• Neural Network Models in Excel — Бесплатное программное обеспечение, реализующее нейронные сети для решения задач прогнозирования и классификации в Excel. Используется обратное распространение. Может обрабатывать пропущенные значения и категориальные данные.
• Neural Network Toolbox for MATLAB — среда для исследований нейронных сетей, проектирования и моделирования их в MATLAB.
• Neural Networks at your Fingertips — Нейросетевой симулятор, реализующий 8 различный архитектур со встроенным примером приложений запрограммированных на ANSI C.
• NeuralWorks — Professional II/PLUS является средой для разработки нейронных сетей для Windows и Unix. Predict — нейросетевой инструмент для решения задач прогнозирования и классификации для Unix или как надстройка Excel для Windows.
• NeuroBox -dotNET-библиотека, реализованная на  C# для создания, распространения и обучения сложных нейронных сетей прямого распространения.
• Neuromat — Программное обеспечение для разработки байесовских нейронных сетей.
• NeuroMine — Нейрсетевые  COM+ компонены и среда разработки для предсказания и анализа данных. Поддерживает несколько алгоритмов. Доступна trial-версия.
• Neuropilot Project — Набор демо java-апплетов, реализующих обученные нейронные сети для пилотирования лунно-посадочного модуля на ландшафты различной сложности.
• NeuroShell Predictor — Программное обеспечени для прогнозирования и оценки на основе нейронные сетей. Доступна демо-версия.
• NeuroSolutions — Среда раработки нейронных сетей с графичиским интерфейсом. Поддерживает несколько типо сетей и алгоритмов обучения. Доступна trial-версия.
• NeuroXL — MS Excel надстройки на основе нейронных сетей. Предназначены для предсказания, классификации и финансового прогнозирования.
• NNSYSID Toolbox — Набор инструментов для MATLAB, реализующий  нейронные сети для идентификации нелинейных динамических систем.
• Penguinwerks — Нейросетевая библиотека с открытым исходным кодом на C# для создания многослойных персептронов.
• Pythia — Программное обеспечение для моделирования нейронных сетей с обратным распространением. Доступна ознакомительная версия.
• Simbrain — Бесплатный Java-набор для моделирования нейронных сетей.
• Stuttgart Neural Network Simulator — На сайте представлено описание возможностей симулятора для Unix и X11, а также информация о том, как можно получить SNNS и онлайн руководство пользователя.
• Temporal Difference Learning Project — Java-исходники, реализующие обучение методом случайного поиска и Tic Tac Toe.
• Tiberius — Нейросетевое программное обеспечение для решения задач классификации и регрессии. Поддерживает ODBC и Excel.
• Torch — Библиотека, реализующая современные алгоритмы машинного обучения. A library of state-of-the-art machine learning algorithms. Лицензия GPL. Работает в Unix and Linux средах.
• Tradecision — Нейросетевое программное обеспечение для технического анализа и торговли на фондовом рынке. Доступна демо-версия.
• Xerion — Симулятор нейронной сети на C и Tcl. Состоит из библиотек на C для создания сетей.
• Prediction with neural network — Учебник, который включает в себя Java-апплет для проведения экспериментов предсказания в режиме онлайн.
• Neuroph — Нейросетевой фреймворк на Java с открытым исходным кодом, который может быть использован для создания и обучения основных типов нейронных сетей. Сайт содержит полный исходных код, документацию и информацию о проекте.
• University of Hertfordshire Neural Network Software — Нейросетевое программное обеспечение написанное на Java с полным исходным кодом.

Предыдущая статьяИстория искусственного интеллектаСледующая статьяDEEPGRAM: Нейросеть для поиска по тексту в аудио и видео файлах

Обучаем нейросеть играть в «Змейку» и пишем сервер для соревнований / Хабр

• В этот раз выбрана игра «Змейка».
• Создана библиотека для нейросети на языке Go.
• Найден принцип обучения, зависимый от «глубины» памяти.
• Написан сервер для игры между разработчиками.

Суть игры

Возможно, многие помнят игру «Змейка», которая шла стандартным приложением на телефонах Nokia. Суть её такова: по полю движется змейка, которая уменьшается, если не находит еду, либо увеличатся, если находит. Если змейка врезается в препятствие, то она погибает.

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

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

За основу взят эксперимент со змейками кибер-биолога Михаила Царькова.

Нейросеть

В рамках задачи была написана библиотека для нейросети на языке Go. Изучая работу нейросети, я использовать видео-дневник foo52ru и книгу Тарика Рашида – Создаём нейронную сеть.

Функция CreateLayer(L []int) создает нейронную сеть с необходимым количеством слоев и их размером. На каждом слое, кроме последнего, добавляется нейрон смещения. На первый слой подаем данные, а из последнего слоя получаем результат.

Пример:

CreateLayer([]int{9, 57, 3, 1})

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

Библиотека позволяет:

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

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

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

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

Для обозначения препятствий и других змеек я использовал значения от -1 до 0 (не включительно). Пустые клетки обозначались значением 0.01, а еда 0.99.

На выходе нейросети использовалось 5 нейронов для действий:

1. двигаться влево по оси Х;
2. вправо;
3. вверх по оси Y;
4. вниз;
5. делиться пополам.

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

Шаг 0. Рандомайзер

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

Шаг 1. Обучение без использования памяти

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

Для обучения подавались следующие значения:

• нашел еду: 0.99
• сделал движение в любом направлении: 0.5
• потерял клетку тела не найдя еду (для этого даётся 10 ходов): 0.2
• стоит на месте (ударился о препятствие или застрял): 0.1
• стоит на месте, имея одну клетку тела: 0.01

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

А/Б тестирование

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

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

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

Шаг 2. Обучение с использованием памяти

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

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

Шаг 3. Снижение коэффициента корректировки в зависимости от глубины памяти

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

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

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

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

Сервер для ботов

Как выяснилось, улучшать уровень «прокачки» ботов можно бесконечно. И я решил создать сервер, где могли бы соревноваться разработчики между собой (независимо от языка программирования) в написании эффективного алгоритма для Змеек.

Протокол

Для авторизации нужно отправить GET запрос к каталогу «game» и указать имя пользователя, например:

.../game/?user=masterdak

Вместо «…» нужно указать адрес сайта и порт, где развернут сервер.

Далее сервер выдаст ответ в формате JSON с указанием сессии:

{"answer":"Hellow, masterdak!","session":"f4f559d1d2ed97e0616023fb4a84f984"}

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

.../game/?user=masterdak&session=f4f559d1d2ed97e0616023fb4a84f984

Сервер выдаст примерно такой ответ:

{
    "answer": "Sent game data.",
    "data": {
        "area": [
            ["...большой числовой массив..."]
        ],
        "snakes": [
            {
                "num": 0,
                "body": [
                    {
                        "x": 19,
                        "y": 24
                    },
                    {
                        "x": 19,
                        "y": 24
                    },
					{
                        "x": 19,
                        "y": 24
                    }
                ],
                "energe": 4,
                "dead": false
            }
        ]
    }
}

В поле area будет указано состояние игрового поля с такими значениями:

0	//пустое поле
-1	//еда
-2	//стена
2	//голова змейки
1	//тело змейки

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

Тело змейки находится в массиве body. Как видно все тело змейки (включая голову — первая ячейка) в начале находятся на одной позиции «x»: 19, «y»: 24. Это связано с тем, что в начале игры змейки вылазят из норы, которая на поле определяется одной клеткой. Далее, координаты тела и головы будут отличаться.

Следующие структуры (пример на языке Go) определяют все варианты ответа сервера:

type respData struct {
	Answer  string
	Session string
	Data    struct {
		Area   [][]int
		Snakes []struct {
			Num    int
			Body   []Cell
			Energe int
			Dead   bool
		}
	}
}
type Cell struct {
	X int
	Y int
}

Далее необходимо отправить ход, который делает змейка, добавив move к GET запросу, например:

...&move=u

u — означает команду вверх;
d — вниз;
l — влево;
r — вправо;
/ — деление пополам.

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

...&move=ud/urld

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

Поле обновляется с интервалом 150 мс. Если в течение 60 секунд не поступит ни одной команды, сервер закроет соединение.

Ссылки

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

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

1. Библиотека для нейронной сети вместе с игрой «Крестики-нолики»
2. Snake Master – Server
3. Snake Master – Bot
4. SnakeWorld2

UPD

Временно выкладываю IP адрес сервера. Сейчас там запущен только один бот-рандомайзер (SnakeBot0). Надеюсь, сервер упадет не так быстро.

Нейросеть в 11 строчек на Python / Хабр

О чём статья

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

Дайте код!

X = np.array([ [0,0,1],[0,1,1],[1,0,1],[1,1,1] ])
y = np.array([[0,1,1,0]]).T
syn0 = 2*np.random.random((3,4)) - 1
syn1 = 2*np.random.random((4,1)) - 1
for j in xrange(60000):
    l1 = 1/(1+np.exp(-(np.dot(X,syn0))))
    l2 = 1/(1+np.exp(-(np.dot(l1,syn1))))
    l2_delta = (y - l2)*(l2*(1-l2))
    l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1))
    syn1 += l1.T.dot(l2_delta)
    syn0 += X.T.dot(l1_delta)

Слишком сжато? Давайте разобьём его на более простые части.

Часть 1: Небольшая игрушечная нейросеть

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

Вход  	 		Выход
0 	0 	1 	0
1 	1 	1 	1
1 	0 	1 	1
0 	1 	1 	0

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

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

Нейросеть в два слоя

import numpy as np

# Сигмоида 
def nonlin(x,deriv=False):
    if(deriv==True):
        return f(x)*(1-f(x))
    return 1/(1+np.exp(-x))
    
# набор входных данных
X = np.array([  [0,0,1],
                [0,1,1],
                [1,0,1],
                [1,1,1] ])
    
# выходные данные            
y = np.array([[0,0,1,1]]).T

# сделаем случайные числа более определёнными
np.random.seed(1)

# инициализируем веса случайным образом со средним 0
syn0 = 2*np.random.random((3,1)) - 1

for iter in xrange(10000):

    # прямое распространение
    l0 = X
    l1 = nonlin(np.dot(l0,syn0))

    # насколько мы ошиблись?
    l1_error = y - l1

    # перемножим это с наклоном сигмоиды 
    # на основе значений в l1
    l1_delta = l1_error * nonlin(l1,True) # !!!

    # обновим веса
    syn0 += np.dot(l0.T,l1_delta) # !!!

print "Выходные данные после тренировки:"
print l1

Выходные данные после тренировки:
[[ 0.00966449]
 [ 0.00786506]
 [ 0.99358898]
 [ 0.99211957]]

Переменные и их описания.

X — матрица входного набор данных; строки – тренировочные примеры

y – матрица выходного набора данных; строки – тренировочные примеры

l0 – первый слой сети, определённый входными данными

l1 – второй слой сети, или скрытый слой

syn0 – первый слой весов, Synapse 0, объединяет l0 с l1.

«*» — поэлементное умножение – два вектора одного размера умножают соответствующие значения, и на выходе получается вектор такого же размера

«-» – поэлементное вычитание векторов

x.dot(y) – если x и y – это вектора, то на выходе получится скалярное произведение. Если это матрицы, то получится перемножение матриц. Если матрица только одна из них – это перемножение вектора и матрицы.

И это работает! Рекомендую перед прочтением объяснения поиграться немного с кодом и понять, как он работает. Он должен запускаться прямо как есть, в ipython notebook. С чем можно повозиться в коде:

• сравните l1 после первой итерации и после последней
• посмотрите на функцию nonlin.
• посмотрите, как меняется l1_error
• разберите строку 36 – основные секретные ингредиенты собраны тут (отмечена !!!)
• разберите строку 39 – вся сеть готовится именно к этой операции (отмечена !!!)

Разберём код по строчкам

import numpy as np

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

def nonlin(x,deriv=False):

Наша нелинейность. Конкретно эта функция создаёт «сигмоиду». Она ставит в соответствие любое число значению от 0 до 1 и преобразовывает числа в вероятности, а также имеет несколько других полезных для тренировки нейросетей свойств.

if(deriv==True):

Эта функция также умеет выдавать производную сигмоиды (deriv=True). Это одно из её полезных свойств. Если выход функции – это переменная out, тогда производная будет out * (1-out). Эффективно.

X = np.array([  [0,0,1], …

Инициализация массива входных данных в виде numpy-матрицы. Каждая строка – тренировочный пример. Столбцы – это входные узлы. У нас получается 3 входных узла в сети и 4 тренировочных примера.

y = np.array([[0,0,1,1]]).T

Инициализирует выходные данные. «.T» – функция переноса. После переноса у матрицы y есть 4 строки с одним столбцом. Как и в случае входных данных, каждая строка – это тренировочный пример, и каждый столбец (в нашем случае один) – выходной узел. У сети, получается, 3 входа и 1 выход.

np.random.seed(1)

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

syn0 = 2*np.random.random((3,1)) – 1

Матрица весов сети. syn0 означает «synapse zero». Так как у нас всего два слоя, вход и выход, нам нужна одна матрица весов, которая их свяжет. Её размерность (3, 1), поскольку у нас есть 3 входа и 1 выход. Иными словами, l0 имеет размер 3, а l1 – 1. Поскольку мы связываем все узлы в l0 со всеми узлами l1, нам требуется матрица размерности (3, 1).

Заметьте, что она инициализируется случайным образом, и среднее значение равно нулю. За этим стоит достаточно сложная теория. Пока просто примем это как рекомендацию. Также заметим, что наша нейросеть – это и есть эта самая матрица. У нас есть «слои» l0 и l1, но они представляют собой временные значения, основанные на наборе данных. Мы их не храним. Всё обучение хранится в syn0.

for iter in xrange(10000):

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

l0 = X

Первый слой, l0, это просто данные. В X содержится 4 тренировочных примера. Мы обработаем их все и сразу – это называется групповой тренировкой [full batch]. Итого мы имеем 4 разных строки l0, но их можно представить себе как один тренировочный пример – на этом этапе это не имеет значения (можно было загрузить их 1000 или 10000 без всяких изменений в коде).

l1 = nonlin(np.dot(l0,syn0))

Это шаг предсказания. Мы позволяем сети попробовать предсказать вывод на основе ввода. Затем мы посмотрим, как это у неё получается, чтобы можно было подправить её в сторону улучшения.

В строке содержится два шага. Первый делает матричное перемножение l0 и syn0. Второй передаёт вывод через сигмоиду. Размерности у них следующие:

(4 x 3) dot (3 x 1) = (4 x 1)

Матричные умножения требуют, чтобы в середине уравнения размерности совпадали. Итоговая матрица имеет количество строк, как у первой, а столбцов – как у второй.

Мы загрузили 4 тренировочных примера, и получили 4 догадки (матрица 4х1). Каждый вывод соответствует догадке сети для данного ввода.

l1_error = y - l1

Поскольку в l1 содержатся догадки, мы можем сравнить их разницу с реальностью, вычитая её l1 из правильного ответа y. l1_error – вектор из положительных и отрицательных чисел, характеризующий «промах» сети.

 l1_delta = l1_error * nonlin(l1,True)

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

Первая часть: производная

nonlin(l1,True)

l1 представляет три этих точки, а код выдаёт наклон линий, показанных ниже. Заметьте, что при больших значениях вроде x=2.0 (зелёная точка) и очень малые, вроде x=-1.0 (фиолетовая) линии имеют небольшой уклон. Самый большой угол у точки х=0 (голубая). Это имеет большое значение. Также отметьте, что все производные лежат в пределах от 0 до 1.

Полное выражение: производная, взвешенная по ошибкам

l1_delta = l1_error * nonlin(l1,True)

Математически существуют более точные способы, но в нашем случае подходит и этот. l1_error – это матрица (4,1). nonlin(l1,True) возвращает матрицу (4,1). Здесь мы поэлементно их перемножаем, и на выходе тоже получаем матрицу (4,1), l1_delta.

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

syn0 += np.dot(l0.T,l1_delta)

Мы готовы к обновлению сети. Рассмотрим один тренировочный пример. В нём мы будем обновлять веса. Обновим крайний левый вес (9.5)

weight_update = input_value * l1_delta

Для крайнего левого веса это будет 1.0 * l1_delta. Предположительно, это лишь незначительно увеличит 9.5. Почему? Поскольку предсказание было уже достаточно уверенным, и предсказания были практически правильными. Небольшая ошибка и небольшой наклон линии означает очень небольшое обновление.

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

Понаблюдав за обновлением сети, вернёмся к нашим тренировочным данным. Когда и вход, и выход равны 1, мы увеличиваем вес между ними. Когда вход 1, а выход – 0, мы уменьшаем вес.

Вход              	Выход
0 	0 	1 	0
1 	1 	1 	1
1 	0 	1 	1
0 	1 	1 	0

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

Часть 2: задачка посложнее

Вход 	        Выход
0 	0 	1 	0
0 	1 	1 	1
1 	0 	1 	1
1 	1 	1 	0

Попробуем предсказать выходные данные на основе трёх входных столбцов данных. Ни один из входных столбцов не коррелирует на 100% с выходным. Третий столбец вообще ни с чем не связан, поскольку в нём всю дорогу содержатся единицы. Однако и тут можно увидеть схему – если в одном из двух первых столбцов (но не в обоих сразу) содержится 1, то результат также будет равен 1.

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

Интересно, что распознавание образов является очень похожей задачей. Если у вас есть 100 картинок одинакового размера, на которых изображены велосипеды и курительные трубки, присутствие на них определённых пикселей в определённых местах не коррелирует напрямую с наличием на изображении велосипеда или трубки. Статистически их цвет может казаться случайным. Но некоторые комбинации пикселей не случайны – те, что формируют изображение велосипеда (или трубки).

Стратегия

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

Вход  (l0) 	Скрытые веса (l1)	Выход (l2)
0 	0 	1 	0.1 	0.2 	0.5 	0.2 	0
0 	1 	1 	0.2 	0.6 	0.7 	0.1 	1
1 	0 	1 	0.3 	0.2 	0.3 	0.9 	1
1 	1 	1 	0.2 	0.1 	0.3 	0.8 	0

Случайным образом назначив веса, мы получим скрытые значения для слоя №1. Интересно, что у второго столбца скрытых весов уже есть небольшая корреляция с выходом. Не идеальная, но есть. И это тоже является важной частью процесса тренировки сети. Тренировка будет только усиливать эту корреляцию. Она будет обновлять syn1, чтобы назначить её соответствие выходным данным, и syn0, чтобы лучше получать данные со входа.

Нейросеть в три слоя

import numpy as np

def nonlin(x,deriv=False):
	if(deriv==True):
           return f(x)*(1-f(x))

	return 1/(1+np.exp(-x))
    
X = np.array([[0,0,1],
            [0,1,1],
            [1,0,1],
            [1,1,1]])
                
y = np.array([[0],
			[1],
			[1],
			[0]])

np.random.seed(1)

# случайно инициализируем веса, в среднем - 0
syn0 = 2*np.random.random((3,4)) - 1
syn1 = 2*np.random.random((4,1)) - 1

for j in xrange(60000):

	# проходим вперёд по слоям 0, 1 и 2
    l0 = X
    l1 = nonlin(np.dot(l0,syn0))
    l2 = nonlin(np.dot(l1,syn1))

    # как сильно мы ошиблись относительно нужной величины?
    l2_error = y - l2
    
    if (j% 10000) == 0:
        print "Error:" + str(np.mean(np.abs(l2_error)))
        
    # в какую сторону нужно двигаться?
    # если мы были уверены в предсказании, то сильно менять его не надо
    l2_delta = l2_error*nonlin(l2,deriv=True)

    # как сильно значения l1 влияют на ошибки в l2?
    l1_error = l2_delta.dot(syn1.T)
    
    # в каком направлении нужно двигаться, чтобы прийти к l1?
    # если мы были уверены в предсказании, то сильно менять его не надо
    l1_delta = l1_error * nonlin(l1,deriv=True)

    syn1 += l1.T.dot(l2_delta)
    syn0 += l0.T.dot(l1_delta)

Error:0.496410031903
Error:0.00858452565325
Error:0.00578945986251
Error:0.00462917677677
Error:0.00395876528027
Error:0.00351012256786

Переменные и их описания

X — матрица входного набор данных; строки – тренировочные примеры
y – матрица выходного набора данных; строки – тренировочные примеры
l0 – первый слой сети, определённый входными данными
l1 – второй слой сети, или скрытый слой
l2 – финальный слой, это наша гипотеза. По мере тренировки должен приближаться к правильному ответу
syn0 – первый слой весов, Synapse 0, объединяет l0 с l1.
syn1 – второй слой весов, Synapse 1, объединяет l1 с l2.
l2_error – промах сети в количественном выражении
l2_delta – ошибка сети, в зависимости от уверенности предсказания. Почти совпадает с ошибкой, за исключением уверенных предсказаний
l1_error – взвешивая l2_delta весами из syn1, мы подсчитываем ошибку в среднем/скрытом слое
l1_delta – ошибки сети из l1, масштабируемые по увеернности предсказаний. Почти совпадает с l1_error, за исключением уверенных предсказаний

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

l1_error = l2_delta.dot(syn1.T)

Использует ошибки, взвешенные по уверенности предсказаний из l2, чтобы подсчитать ошибку для l1. Получаем, можно сказать, ошибку, взвешенную по вкладам – мы подсчитываем, какой вклад в ошибки в l2 вносят значения в узлах l1. Этот шаг и называется обратным распространением ошибок. Затем мы обновляем syn0, используя тот же алгоритм, что и в варианте с нейросетью из двух слоёв.

Java Neural Network Framework Neuroph

.

Java Neural Network Framework Neuroph

Документация

Техническая документация

Документация API
Документация, сгенерированная Javadoc для библиотечных классов

Схема каркаса Neuroph
Это «общая картина» фреймворка, которая поможет вам понять, каковы его основные компоненты и как она организована.

Основные концепции в рамках Neuroph
На этой картинке показаны основные концепции Neuroph framework.

Диаграммы классов UML
Базовая диаграмма классов
Базовая диаграмма классов
Правила обучения Диаграмма классов

Учебники

Примечание: Некоторые инструкции в этих руководствах относятся к более старым версиям Neuroph (до 2.6), однако принципы те же. Мы работаем над их обновлением.

Начало работы с Neuroph 2.7.pdf
Краткое вводное руководство.

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

http://www.certpal.com/blogs/2010/04/java-neural-networks-and-neuroph-a-tutorial/
Базовое руководство Neuroph на CertPal

Распознавание изображений HOWTO
Как использовать Multi Layer Perceptron от Neuroph для распознавания изображений

Создание приложения для распознавания образов Android с помощью NetBeans, NbAndroid и Neuroph
Как сделать распознавание изображений на Android с помощью Neuroph

Прогнозирование временных рядов с помощью нейронных сетей с прямой связью [pdf]
Как использовать многослойный персептрон от Neuroph для прогнозирования и аппроксимации функций

Прогноз фондового рынка
Как использовать Multi Layer Perceptron от Neuroph для прогнозирования фондового рынка.

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

Прогноз акций на Android
Пример приложения для прогнозирования акций Android от Christos Tzoumakis.

Простое обнаружение мошенничества (на немецком языке) с источниками

http://www.certpal.com/NeuralWeb/index.html
http: //www.certpal.com / blogs / 2010/07 / java-neuroph-tutorial-the-code-classifier /
Приложение-классификатор кода и руководство

Neuroph: интеллектуальные Java-приложения с нейронными сетями
Во второй части интервью на DZone дается очень краткое руководство по Neuroph GUI.

NeurophRM: интеграция фреймворка Neuroph в RapidMiner 1
Как интегрировать Neuroph с Rapid Miner

Synergy of Neuroph framework и RapidMiner 2
Как использовать Neuroph с Rapid Miner

Адалин
Как создать и обучить простую нейронную сеть Adaline с помощью правила обучения LMS.

Персептрон
Как создать и обучить базовый персептрон.

Многослойный Персептрон
Как создать и обучить многослойный персептрон с правилом обучения обратному распространению — пример XOR.

Хопфилд
Как создать и обучить простую нейронную сеть Хопфилда — пример TH.

MaxNet
Как создать и обучить сеть MaxNet

Хеббийская сеть
Как создать и обучить сеть с помощью Hebbian Learning

.

Neuroph: интеллектуальные Java-приложения с нейронными сетями (часть 1)

Нейронные сети могут научиться сопоставлять входные данные с выходными и используются для таких задач, как автоматическая классификация, прогнозирование и создание игровых персонажей с искусственным интеллектом. Команда NetBeans взяла интервью у Зорана Севарака, который работает над Neuroph, фреймворком нейронных сетей с открытым исходным кодом. Мы говорим о том, как выглядят нейронные сети, как они творит свое волшебство и почему IDE NetBeans стала естественным выбором для команды разработчиков Neuroph.Во второй части интервью мы более подробно рассмотрим варианты использования нейронных сетей и то, что они могут сделать для Java-разработчиков, таких как я и вы.

Привет, Зоран, представьтесь, пожалуйста, и своей команде!

Меня зовут Зоран Севарак, я научный сотрудник Лаборатории искусственного интеллекта Белградского университета. Мои основные исследовательские интересы — нейронные сети, нечеткая логика, генетические алгоритмы и гибридные системы.

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

В настоящий момент я работаю над Neuroph, фреймворком нейронной сети с открытым исходным кодом, вместе с такими людьми, как Иван Голоскокович и Джон Тейт.Иван уговорил меня разместить созданный мной фреймворк нейронной сети на Source Forge, и так начался проект. Джон был первым, кто успешно использовал фреймворк для реального приложения. После этого он присоединился к проекту и во многом помог нам улучшить фреймворк.

Чем занимается Neuroph?

Neuroph — это общая структура нейронной сети Java. Она обеспечивает простой способ использования нейронных сетей в программах на Java благодаря своей библиотеке классов Java с простым в использовании API нейронной сети.Он также поставляется с редактором графического интерфейса (называемым easyNeurons) для создания и обучения нейронных сетей.

Что такое нейронные сети?

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

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

Как выглядит нейронная сеть?

Каждая нейронная сеть состоит из связанных между собой основных процессоров, называемых нейронами. Сеть обучается, изменяя веса связи между нейронами в процессе обучения. На рисунке ниже показана простая нейронная сеть, созданная с помощью easyNeurons.Этот тип сети называется Multi Layer Perceptron и является одной из наиболее часто используемых сетей.

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

Кто использует нейронные сети?

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

Стоит упомянуть интересный проект Neuro-Evolving Robotic Operatives (NEROgame), в котором вы развиваете свою собственную армию роботов, настраивая искусственный мозг для выполнения сложных задач, а затем заставляете их сражаться против другой команды!

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

Какой формат ввода / вывода может обрабатывать нейронная сеть?

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

Это просто вопрос преобразования реальных значений в числовую форму, используемую нейронной сетью — многомерные векторы со значениями в [0, 1] или [-1, 1].

Сложно обучить сеть?

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

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

Почему вы выбрали IDE NetBeans?

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

Вы бы что-нибудь улучшили?

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

Какие у тебя планы на будущее?

Я видел учебные пособия по платформе NetBeans, и они великолепны, именно то, что я искал. Некоторая будущая версия GUI для Neuroph определенно будет основана на платформе NetBeans. В будущем мы хотели бы организовать учебные курсы по платформе NetBeans в моем университете, и я думаю, это поможет вам продвигать NetBeans в академическом сообществе.

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

Ссылки по теме

.

Java Neural Network Framework Neuroph

Примеры проектов

Эта страница содержит различные образцы студенческих проектов, созданных с использованием Neuroph, и наборов данных из репозитория машинного обучения UCI
Проекты включают классификацию, прогнозирование, распознавание, контрольные задачи, примеры приложений и многое другое. Проекты создавались как рабочее задание во время курса «Интеллектуальные системы» на факультете организационных наук Белградского университета.
Если вы сделаете что-то подобное, дайте нам знать и отправьте нам свою работу, чтобы разместить ее здесь.

Распознавание алфавита Брайля с помощью нейронных сетей

Управление посадкой челнока
Обучающая нейронная сеть для управления посадкой шаттла

Управление посадкой челнока — Часть 2
Анализ обучения

Классификация музыки по жанрам с использованием нейронных сетей

Распознавание лиц с помощью нейронной сети

Концептуальное обучение и классификация — набор данных Hayes-Roth

Прогнозирование покерных рук с помощью нейронных сетей

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

Прогнозирование выживаемости пациентов — набор данных Habermans
Прогнозирование выживаемости пациентов, перенесших операцию по поводу рака груди.

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

Классификация видов животных с помощью нейронной сети
Классификация видов животных с помощью нейронной сети 2
Классификация видов животных с помощью нейронной сети 3
Классификация видов животных по 17 булевозначным признакам

Классификация видов животных, анализ обучения

Оценка автомобилей с использованием нейронных сетей

Классификация линз с использованием нейронных сетей

Классификация шкалы баланса с использованием нейронных сетей
Использование Neuroph для задачи классификации шкалы баланса

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

Прогнозирование результата футбольного матча с помощью нейронных сетей

Прогнозирование удобоукладываемости высокопроизводительного бетона

Испытание бетона на прочность при сжатии

Идентификация стекла с помощью нейронных сетей

Оценка помощника учителя

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

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

Прогнозирование площади лесных пожаров с помощью нейронных сетей

Классификация вин с использованием нейронных сетей 1
Классификация вин с использованием нейронных сетей 2
Классификация вин с использованием нейронных сетей 3

NeurophRM: интеграция фреймворка Neuroph в RapidMiner

.