Сети нейронные: создание и реализация на Java

Раскрывая нейронные сети

Во-первых, термин «нейронные сети» может создать снимок мозга в вашем сознании, в частности для тех, кто ранее познакомился с ним. В действительности это правда, мы считаем мозг — большая и естественная нейронная сеть. Однако что мы можем сказать об искусственных нейронных сетях (ANN — artificial neural network)? Хорошо, он начинается с антонима естественный и первая мысль, которая приходит в нашу голову — это картинка искусственного мозга или робота учитывает термин «искусственный«. В этом случае, мы так же имеем дело с созданием структуры, похожей и вдохновленной человеческим мозгом; поэтому это названо искусственным интеллектом. Поэтому читатель, который не имел прошлого опыта с ANN, сейчас может думать, что книга учит, как строить интеллектуальные системы, включая искусственный мозг, способный эмулировать человеческое сознание, используя Java программы, не так ли? Конечно мы не будем покрывать создание искусственного мышления машин как в трилогии Матрицы; однако эта книга растолкует несколько неимоверных способностей и что могут эти структуры. Мы предоставим читателю Java исходники с определением и созданием основных нейросетевых структур, воспользоваться всеми преимуществами языка программирования Java.

Почему искусственные нейронные сети?

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

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

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

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

Таблица №1

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

Как устроены нейронные сети

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

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

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

Самый базовый элемент — искусственный нейрон

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

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

Давая жизнь нейронам — активационная функция

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

• Сигмоида(Sygmoid)
• Гиперболический тангенс(Hyberbolic tangent)
• Жесткая пороговая функция(Hard limiting threshold)
• Линейная(linear)

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

Фундаментальные величины — весы(weights)

В нейронных сетях, синапсы представляют собой соединения между нейронами и имеют возможность усиливать или смягчать нейронные сигналы, например, перемножать сигналы, таким образом улучшать их. Итак, путем модификации нейронных сетей, нейронные весы(weights) могут повлиять на нейронный вывод(output), следовательно нейронная активация может быть зависима от ввода и от весов. При условии, что inputs идут от других нейронов или от внешнего мира, весы(weights) считаются установленными нейронными соединениями между нейронами. Таким образом, с тех пор как весы являются внутренними для нейронных сетей, мы можем считать их как знания нейронных сетей, предоставленные изменения весов будут изменять возможности нейронных сетей и поэтому — действия.

Важный параметр — смещение

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

Части образующие целое — слои

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

Нейронные сети могут быть составлены из нескольких соединенных слоев, которые называются многослойными сетями. Обычные нейронные сети могут быть разделены на 3 класса: 1. Input layer; 2. Hidden layer; 3. Output layer; На практике, дополнительный нейронный слой добавляет другой уровень абстракции внешней стимуляции, тем самым повышая способность нейронных сетей представлять больше комплексных данных.

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

Изучение архитектуры нейронных сетей

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

Однослойные сети

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

Многослойные сети

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

Сети прямой связи(feedforward networks)

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

Сети обратной связи(Feedback networks)

Когда нейронная сеть имеет некоторый вид внутреннего рецидива, это значит, что сигналы вернулись обратно в нейрон или слой, который уже получил и обработал сигнал, сеть – это тип feedback-а. Посмотрите на картинку: Специальная причина добавить рекуррентность в сеть – это выработка динамического поведения, в частности когда сеть адресует проблемы, включая временные ряды или распознавание образов, которые требуют внутреннюю память для подкрепления обучающего процесса. Тем не менее, такие сети особенно трудны в тренировке, в конечном счете не в состоянии учиться. Многие feedback сети – однослойные, такие как сети Элмана(Elman) и Хопфилда(Hopfield), но возможно и построить рекуррентную многослойную сеть, такие как эхо и рекуррентные многослойные персептронные сети.

От незнания к знаниям — процесс обучения

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

Давайте начнем реализацию! Нейронные сети на практике

В этой книге мы покроем все процессы реализации нейронных сетей на Java. Java — это объектно-ориентированный язык программирования, созданный в 1990-ые маленькой группой инженеров из Sun Microsystems, позже приобретенной компанией Oracle в 2010-ых. Сегодня, Java представлена во многих устройствах, которые участвуют в нашей повседневной жизни. В объектно-ориентированном языке, таком как Java, мы имеем дело склассами и объектами. Класс — план чего-то в реальной жизни, а объект — образец такого плана, например, car(класс, ссылающийся на все машины) и my car(объект, ссылающийся на конкретную машину — мою). Java классы обычно состоят из атрибутов и методов(или функций), которые включают принципы объектно-ориентированного программирования(ООП). Мы собираемся кратко рассмотреть эти принципы без углубления в них, поскольку цель этой книги — просто спроектировать и создать нейронные сети с практической точки зрения. В этом процессе четыре принципа уместны и нуждаются в рассмотрении:

• Абстракция: Перевод проблем и правил реальной жизни в сферу программирования, рассматривая только их уместные особенности и отпуская детали, которые часто мешают разработке.
• Инкапсуляция: Аналогично инкапсуляции продукта, при которой некоторые соответствующие функции раскрыты открыто (публичные(public) методы), в то время как другие хранится скрытым в пределах своего домена (частного(private) или защищенного(protected)), избегая неправильное использование или избыток информации.
• Наследование: В реальной мире, много классов этих объектов представляют собой атрибуты и методы в иерархической манере; например, велосипед может быть супер-классом для машин и грузовиков.Таким образом, в ООП эта концепция позволяет из одного класса перенимать все свойства в другой класс, тем самым избегая переписывания кода.
• Полиморфизм: Во многом схожа с наследованием, но с изменениями в методах со схожими сигнатурами, представляющие разные поведения в разных классах.

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

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

Таблица №2

Имя класса: Neuron
Атрибуты
private ArrayList<Double> listOfWeightIn	Переменная ArrayList дробных чисел представляет список входных весов
private ArrayList<Double> listOfWeightOut	Переменная ArrayList дробных чисел представляет список выходных весов
Методы
public double initNeuron()	Инициализирует функции listOfWeightIn, listOfWeightOut с псевдослучайными числами
	Параметры: нет
	Возвращает: Псевдослучайное число
public ArrayList<Double> getListOfWeightIn()	Геттер ListOfWeightIn
	Параметры: нет
	Возвращает: список дробных чисел, сохраненной в переменной ListOfWeightIn
public void setListOfWeightIn(ArrayList<Double> listOfWeightIn)	Сеттер ListOfWeightIn
	Параметры: список дробных чисел, сохранненных в объекте класса
	Возвращает: ничего
public ArrayList<Double> getListOfWeightOut()	Геттер ListOfWeightOut
	Параметры: нет
	Возвращает: список дробных чисел, сохраненной в переменной ListOfWeightOut
public void setListOfWeightOut(ArrayList<Double> listOfWeightOut)	Сеттер ListOfWeightOut
	Параметры: список дробных чисел, сохранненных в объекте класса
	Возвращает: ничего
Реализация класса: файл

Таблица №3

Имя класса: Layer
Заметка: Этот класс абстрактный и не может быть проинициализирован.
Атрибуты
private ArrayList<Neuron> listOfNeurons	Переменная ArrayList объектов класса Neuron
private int numberOfNeuronsInLayer	Целочисленное значение для хранения количества нейронов, которая является частью слоя.
Методы
public ArrayList<Neuron> getListOfNeurons()	Геттер listOfNeurons
	Параметры: нет
	Возвращает: listOfNeurons
public void setListOfNeurons(ArrayList<Neuron> listOfNeurons)	Сеттер listOfNeurons
	Параметры: listOfNeurons
	Возвращает: ничего
public int getNumberOfNeuronsInLayer()	Геттер numberOfNeuronsInLayer
	Параметры: нет
	Возвращает: numberOfNeuronsInLayer
public void setNumberOfNeuronsInLayer(int numberOfNeuronsInLayer)	Сеттер numberOfNeuronsInLayer
	Параметры: numberOfNeuronsInLayer
	Возвращает: ничего
Реализация класса: файл

Таблица №4

Имя класса: InputLayer
Заметка: Этот класс наследует атрибуты и методы от класса Layer
Атрибуты
Нет
Методы
public void initLayer(InputLayer inputLayer)	Инициализирует входной слой с дробными псевдорандомными числами
	Параметры: Объект класса InputLayer
	Возвращает: ничего
public void printLayer(InputLayer inputLayer)	Выводит входные весы слоя
	Параметры: Объект класса InputLayer
	Возвращает: ничего
Реализация класса: файл

Таблица №5

Имя класса: HiddenLayer
Заметка: Этот класс наследует атрибуты и методы от класса Layer
Атрибуты
Нет
Методы
public ArrayList<HiddenLayer> initLayer( HiddenLayer hiddenLayer, ArrayList<HiddenLayer> listOfHiddenLayers, InputLayer inputLayer, OutputLayer outputLayer )	Инициализирует скрытый слой(и) с дробными псевдослучайными числами
	Параметры: Объект класса HiddenLayer, список объектов класса HiddenLayer, объект класса InputLayer, объект класса OutputLayer
	Возвращает: список скрытых слоев с добавленным слоем
public void printLayer(ArrayList<HiddenLayer> listOfHiddenLayers)	Выводит входные весы слоя(ев)
	Параметры: Список объектов класса HiddenLayer
	Возвращает: ничего
Реализация класса: файл

Таблица №6

Имя класса: OutputLayer
Заметка: Этот класс наследует атрибуты и методы от класса Layer
Атрибуты
Нет
Методы
public void initLayer(OutputLayer outputLayer)	Инициализирует выходной слой с дробными псевдорандомными числами
	Параметры: Объект класса OutputLayer
	Возвращает: ничего
public void printLayer(OutputLayer outputLayer)	Выводит входные весы слоя
	Параметры: Объект класса OutputLayer
	Возвращает: ничего
Реализация класса: файл

Таблица №7

Имя класса: NeuralNet
Заметка: Значения в топологии нейросети фиксированы в этом классе(два нейрона во входном слое, два скрытых слоя с тремя нейронами в каждом, и один нейрон в выходном слое). Напоминание: Это первая версия.
Атрибуты
private InputLayer inputLayer	Объект класса InputLayer
private HiddenLayer hiddenLayer	Объект класса HiddenLayer
private ArrayList<HiddenLayer> listOfHiddenLayer	Переменная ArrayList объектов класса HiddenLayer. Может иметь больше одного скрытого слоя
private OutputLayer outputLayer	Объект класса OutputLayer
private int numberOfHiddenLayers	Целочисленное значение для хранения количества слоев, что является частью скрытого слоя
Методы
public void initNet()	Инициализирует нейросеть. Слои созданы и каждый список весов нейронов созданы случайно
	Параметры: нет
	Возвращает: ничего
public void printNet()	Печатает нейросеть. Показываются каждое входное и выходное значения каждого слоя.
	Параметры: нет
	Возвращает: ничего
Реализация класса: файл

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

Показанный следующий код имеет тестовый класс, главный метод объектом класса NeuralNet, называнный n. Когда этоn метод вызывается (путем выполнения класса), он вызывает initNet () и printNet () методы из объекта n, генерирующие следующий результат, показанный на рисунке справа после кода. Он представляет собой нейронную сеть с двумя нейронами во входном слое, три в скрытом слое и один в выходном слое:

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

Что такое Нейрон

Сперва, давайте начнем с ответа на простой вопрос: Что такое Нейрон? Давайте рассмотрим формальное определение:

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

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

Эти три функции отлично сочетаются с тремя ключевыми компонентами настоящего Нейрона, посмотрите на следующий рисунок Нейрона:

Эти три компонента один к одному соответствуют основным функциям, исполняющимся Нейроном::

• Дендриты — получает сигнал и передает его в тело клетки (нейрона)
• Сома (тело) — обрабатывает сигнал (body)
• Аксон — посылает сигнал другим нейронам

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

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

Наш Первый Нейрон

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

public interface Neuron { /** * Должен быть вызван, когда Нейрон получает входной сигнал от связанного * нейрона. * К примеру, давайте рассмотрим следующую сеть: * NeuronA * \ * \ * \ * NeuronB — NeuronD * / * / * / * NeuronC * * Если NeuronA или NeuronB или NeuronC посылают сигнал в NeuronD, метод * должен быть вызван. * * @param from — Нейрон, который посылает сигнал. */ void forwardSignalReceived(Neuron from, Double value); default void connect(Neuron neuron, Double weight) { (neuron); (this, weight); } void addForwardConnection(Neuron neuron); void addBackwardConnection(Neuron neuron, Double weight); }

• Входные нейроны;
• Связанные нейроны;

public class InputNeuron implements Neuron { private Set<Neuron> connections = new HashSet<>(); @Override public void forwardSignalReceived(final Neuron from, final Double value) { (n -> (this, value)); } @Override public void addForwardConnection(final Neuron neuron) { (neuron); } @Override public void addBackwardConnection(final Neuron neuron, final Double weight) { } // No op }

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

• Интерфейс для Функции Активации;
• Нашу первую простейшую Функцию Активации;

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

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

private final ActivationFunction activationFunction; /** * Представляет соединения от нейрона к нейронам, от которых он получает * сигналы. К примеру, в следующей сети: * NeuronA ___ * \ weight1 = -0.1 * \ * weight2 = 0.1\ * NeuronB —— NeuronD * / * / * / weight3 = 0.8 * NeuronC — * backwardConnections map будет выглядеть так: * NeuronA => -0.1 * NeuronB => 0.1 * NeuronC => 0.8 */ private final Map<Neuron, Double> backwardConnections = new HashMap<>(); /** * Представляет набор Нейронов, которым текущий нейрон посылает сигнал, здесь * нет необходимости в весах. */ private final Set<Neuron> forwardConnections = new HashSet<>(); /** * inputSignals используется для хранения сигналов от других Нейронов. Ключи в * этом словаре должны быть абсолютно идентичны ключам в * {@link #backwardConnections}. Как только все сигналы получены Нейроном, * он может начинать обрабатывать их. */ private final Map<Neuron, Double> inputSignals = new HashMap<>(); /** * Количество сигналов, уже полученных. * Как только это количество достигнет размера {@link #inputSignals} словаря, * нейрон готов к обработке входных сигналов и отправке сигнала дальше. */ private volatile int signalReceived; private final double bias; /** * Хранит результаты последнего отправленного сигнала от Нейрона к другим * Нейронам. Это в основном необходимо для выходных Нейронов, * поскольку у них не хватает других Нейронов для отсылки сигнала, и в то же * время должна быть возможность получить это значение. */ private volatile double forwardResult;

К этому моменту должно стать очевидно, как работает добавление связей:

@Override public void forwardSignalReceived(final Neuron from, final Double value) { signalReceived++; (from, value); // Следующий if – проверка на то, являлся ли текущий сигнал последним // оставшимся для получения. Если это так и все входные сигналы были // получены, Нейрон может начинать их обработку и испускать сигнал сам if (() == signalReceived) { // Нейрону для обработки входных сигналов необходимо 4 шага: // 1. Посчитать input = W * X + b // 2. Посчитать output = f(input), где f – функция активации // 3. Отправить output другим нейронам // 4. Аннулировать состояние // Шаг #1 // Посчитать W * X + b – сумма всех входных сигналов, умноженных на // соответствующий ему вес. // Отклонение (bias) добавляется в конце. double forwardInputToActivationFunction = backwardConnections.entrySet().stream().mapToDouble(connection -> // inputSignals хранит сигнал, где // () дает вам // вес, на который должен умножаться сам сигнал. // Таким образом это и есть X * W. (()) * ()).sum() + bias; // Шаг #2 double signalToSend = (forwardInputToActivationFunction); forwardResult = signalToSend; // Шаг #3 Поскольку сигнал посчитан, теперь мы можем отослать // другим нейронам forwardConnections.stream().forEach(connection -> connection.forwardSignalReceived(, signalToSend)); // Шаг #4 signalReceived = 0; } }

Одна вещь, которую мы опускаем – Builder. Поскольку паттерн builder не имеет ничего общего с DeepLearning мы просто предположим, что Builder существует для нашего класса, но мы не показываем фрагмент кода здесь.

Сейчас мы можем создать нашу первую нейронную сеть (Neural Network, NN). Для начала давайте опишем нейронную сеть, которую мы собираемся построить. Наша первая NN будет предсказывать, нужно ли идти на вечеринку или нет. Для построения сети у нас должны быть данные для обучения сети. Поскольку мы не знаем, как тренировать нашу сеть, мы будем делать это вручную, наблюдая за шаблонами в наших данных и пытаясь подобрать такие веса, которые позволят сети делать верные предсказания. Итак, здесь есть то, что мы знаем о факторах, влияющих на опыт:

1. Факт того, будет ли наш лучший друг на вечеринке или нет;
2. Наличие любимого напитка (давайте назовем его «Vodka»:));
3. Погода (солнечно или нет);

Сейчас мы можем создать комбинацию всех этих факторов и желаемое поведение для каждого из них. Чтобы сделать изображение более простым, мы используем 1 или 0, чтобы представить каждый фактор. 1 будет обозначать присутствие фактора, а 0 – его отсутствие. Так как мы говорим о трех факторах, входом для нашей NN будет 3 цифры (1 или 0 каждая), например, следующий массив отображает вход с информацией о том, что наш лучший друг будет на вечеринке, но не будет любимого напитка и погода будет не солнечная, в следствии чего мы не пойдем на вечеринку:

Еще один пример с информацией об отсутствии лучшего на вечеринке, но будет напиток и солнечная погода на улице – нужно идти на вечеринку.

[1, 0, 0] => 0 [0, 1, 0] => 0 [0, 0, 1] => 0 [1, 1, 0] => 1 [1, 0, 1] => 1 [0, 1, 1] => 1 [1, 1, 1] => 1

Как наша NN будет выглядеть? На самом деле, все просто. У нас будет 3 входных нейрона и 1 выходной нейрон. Пожалуй, можно сразу перейти к изображению NN, оно проще для понимания:

Эта сеть называется «полносвязная однослойная сеть». Звучит пугающе, я думаю, что многие люди в науке сознательно пытаются создать такое впечатление:) В любом случае, мы собираемся разделить название на части и последовательно обсудить. Полносвязная просто означает, что у каждого нейрона в слое есть связь с каждым нейроном предшествующего слоя. Слой – абстракция, которой не существует в настоящем мозге, просто упрощение, позволяющее инженерам проще изображать нейронные сети. Каждый слой – коллекция нейронов, у которых нет связи друг с другом. Нейроны в слое получают сигналы только от предшествующего слоя (если такой существует) и посылают сигналы в следующий слой (если такой существует). Глядя на нашу картинку, кто-то может подумать, что это двуслойная сеть. Исторически так сложилось, что входной слой не считают (или, может быть, мы считаем от 0, тогда это имеет смысл). Если мы не считаем входной слой, эта сеть, безусловно, однослойная.

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

// Создаем три входных нейрона InputNeuron inputFriend = new InputNeuron(); InputNeuron inputVodka = new InputNeuron(); InputNeuron inputSunny = new InputNeuron(); // Наш выходной нейрон ConnectedNeuron outputNeuron // Мы не обсудили builder, впрочем, это простейший Java builder, // если необходимо, то вы можете посмотреть реализацию // в нашем репозитории. = new ().bias(bias).activationFunction(new StepFunction()).build(); // Создаем связи между нейронами (outputNeuron, 0.5); (outputNeuron, 0.5); (outputNeuron, 0.5); // Посылаем сигналы в сеть (null, 1.); (null, 1.); (null, 0.); // Получаем результат и печатаем его: double result = (); («Prediction: %3f\n», result)

В сумме

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

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

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

Вопрос: Какие библиотеки Java наиболее популярны для машинного обучения?
Ответ: Deeplearning4j, Weka, Neuroph и MOA (Massive Online Analysis) являются одними из самых известных фреймворков.

Вопрос: С чего начать написание нейросети с нуля на Java?
Ответ: Начните с реализации класса «Нейрон», затем создайте структуру «Слой» и, наконец, класс «НейроннаяСеть», который будет управлять слоями и процессом обучения.

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

Вопрос: Какую задачу лучше выбрать для первой нейросети на Java?
Ответ: Классификация ирисов Фишера или распознавание рукописных цифр (MNIST) — классические и хорошо документированные задачи для новичков.

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

Вопрос: Как реализовать функцию активации в коде?
Ответ: Обычно её реализуют как отдельный метод, принимающий сумму входов нейрона. Например, сигмоиду можно записать как return 1 / (1 + Math.exp(-x)).

Вопрос: Что такое backpropagation и сложно ли её запрограммировать на Java?
Ответ: Это алгоритм обратного распространения ошибки для обучения сетей. Его реализация требует аккуратного вычисления градиентов, что является сложной, но решаемой задачей.

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

Вопрос: Где найти готовые примеры кода нейросетей на Java для обучения?
Ответ: Исходный код библиотек с открытым исходным кодом (например, Neuroph), GitHub и специализированные форумы — лучшие источники для изучения.

Памятка: ключевые шаги для реализации нейросети на Java

1. Четко определите задачу, которую должна решать нейросеть (классификация, регрессия и т.д.).
2. Изучите математические основы: нейрон, функции активации, алгоритм обратного распространения ошибки.
3. Спроектируйте архитектуру сети: количество слоев и нейронов в каждом.
4. Создайте класс Neuron с полями для весов, смещения и методами для вычисления выхода.
5. Реализуйте класс Layer для управления группой нейронов.
6. Создайте класс NeuralNetwork, объединяющий слои и управляющий потоком данных (прямой проход).
7. Реализуйте функцию потерь (loss function) для оценки ошибки сети.
8. Напишите алгоритм обратного распространения ошибки (backpropagation) для корректировки весов.
9. Реализуйте метод обучения (train), который итеративно применяет прямой и обратный проход к данным.
10. Добавьте возможность сохранения обученных весов в файл и загрузки из него.
11. Протестируйте сеть на небольшом и понятном наборе данных (например, логическая операция XOR).
12. Визуализируйте процесс обучения (график изменения ошибки) для отладки.
13. Оптимизируйте код, уделив внимание производительности вычислений.
14. Поэкспериментируйте с разными функциями активации и архитектурами.
15. Рассмотрите возможность использования готовых библиотек для более сложных проектов.