Как сделать нейронную сеть в excel?

Пишем вместе с нуля простейшую Нейронную Сеть с Сигмоидой в Excel #94

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

Для начала нам придётся открыть Excel и как в прошлый раз нажать Alt+F11. В открывшемся окне создадим новый модуль для класса (правый клик где-нибудь слева => insert => Class Module) . И в него будем последовательно вставлять весь тот код, что будет ниже. Его я буду сопровождать своими комментариями.

Dim c(0 To 3) As Double ‘Коэффициенты
Dim tc(0 To 3) As Double ‘Пробные коэффициенты
Dim dc(0 To 3) As Double ‘Пробные изменения
Dim dy(0 To 3) As Double ‘Результаты изменения коэффициентов
Const st = 0.2 ‘Скорость обучения

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

Sub init() ‘Инициализация случайных значений коэффициентов сигмоиды
For i = 0 To 3
c(i) = Rnd() * 2 — 1
Next i
End Sub

Сигмоида у нас задаётся четырьмя параметрами. Первый коэффициент стоит, как множитель ко всей функции в целом. Второй коэффициент — перед иксом. Третий — прибавляется к иксу. Четвёртый — прибавляется ко всей функции в целом. И все эти коэффициенты задаются случайным образом от минус единицы до плюс единицы. F(x)=c1/e^(-c2*(x+c3))+c4

Таким подходом мы задаём всё многообразие сигмоид.

Sub NewC(De As Double, n As Integer) ‘Генерируем новый тестовый вес
For i = 0 To 3
If n = i Then
dc(i) = De * st
End If
tc(i) = c(i) + IIf(n = i, dc(i), 0)
Next i
End Sub

Передаём значение, на которое ошиблась наша функция и номер коэффициента, который хотим изменить. Изменяем этот коэффициент с учётом скорости обучения и нашей ошибки.

Sub SaveC(d As Worksheet, r As Integer) ‘Сохраняем веса
For i = 0 To 3
d.Cells(r, 8 + i) = c(i)
Next i
End Sub Sub LoadC(d As Worksheet, r As Integer) ‘Загружаем веса
For i = 0 To 3
c(i) = d.Cells(r, 8 + i)
Next i
End Sub

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

Sub FixC() ‘Сохраняем тестовые веса
Dim my As Double
Dim j As Integer
j = 1
my = dy(0)
For i = 1 To 3 ‘Определяем максимальное изменение y
If dy(i) > my Then
my = dy(i)
j = i
End If
Next i
For i = 0 To 3 ‘Для максимального изменения y вес меняем полностью, для остальных в зависимости от величины изменения
c(i) = c(i) + dy(i) / my * dc(i)
Next i
End Sub

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

Function res(x As Double, T As Boolean) As Double ‘Расчёт значения функции
c1 = IIf(T, tc(0), c(0))
c2 = IIf(T, tc(1), c(1))
c3 = IIf(T, tc(2), c(2))
c4 = IIf(T, tc(3), c(3))
ie = -c2 * (x + c3)
If ie > 40 Then ‘Если число в знаменателе очень большое, можно считать значение нулём
res = c4
ElseIf ie

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

Sub TryC(x As Double, y As Double, n As Integer) ‘Пробуем изменить конкретный вес. Если стало лучше, фиксируем это
Dim De As Double
De = Abs(y — res(x, False))
Call NewC(De, n)
Dim NDe As Double
NDe = Abs(y — res(x, True))
If NDe >= De Then
Call NewC(-De, n)
NDe = Abs(y — res(x, True))
End If
If NDe

Пробуем изменить тестовые коэффициенты. Если ошибка уменьшилась, фиксируем это, чтобы в будущем изменить уже боевые коэффициенты.

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

Sub Chng(x As Double, y As Double)
For i = 0 To 3 ‘Обнуляем значения
dy(i) = 0
dc(i) = 0
Next i
Dim tw() As String
tw = Split(MakeRnd(4), «,»)
For i = 0 To UBound(tw)
Call TryC(x, y, Val(tw(i)))
Next i
Call FixC
End Sub

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

Теперь заполним какими-нибудь данными нашу функцию. Я в первом столбце перечислил значения аргументов, в третьем — значение целевой функции. А четвёртый столбец остаётся для занесения результатов расчёта сети, чтобы сравнить с целевой функцией. Ну и отдельно посчитал среднюю квадратичную ошибку. Вышло примерно так:

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

Sub run()
Dim cr As Integer ‘текущая строка
Dim y As Sgm
Set y = New Sgm
Call y.init
Dim mr As Integer
Dim d As Worksheet
Set d = ThisWorkbook.Sheets(4)
‘Call y.LoadC(d, 1)
i = 2
While d.Cells(i, 1) <> 0
i = i + 1
Wend
mr = i — 1 ‘Определяем максимальную заполненную строчку
For i = 1 To 100000
cr = Rnd() * (mr — 1) + 2 ‘Генерируем случайную строку для подстановки в нейрон для обучения
Call y.Chng(d.Cells(cr, 1), d.Cells(cr, 3)) ‘Обучаем нейрон на случайной строке
Next i
i = 2
While d.Cells(i, 1) <> 0 ‘Заполняем значениями для визуализации результатов работы
d.Cells(i, 4) = y.res(d.Cells(i, 1), False)
i = i + 1
Wend
‘Call y.SaveC(d, 1)
End Sub

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

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

А теперь давайте попробуем аппроксимировать смещённую экспоненту:

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

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

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

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

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

Пишем нейросеть прямого распространения с нуля | Как создать свою нейросеть

Время чтения: 8 минут

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

Читать еще:  Как сделать файл vcf из excel?

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

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

Более простыми словами, это некий чёрный ящик, который превращает входные данные в выходные, или, говоря более математическим языком, является отображением пространства входных признаков X в пространство выходных признаков Y: X → Y. То есть мы хотим найти какую-то функцию F, которая сможет выполнять это преобразование. Для начала этой информации нам будет достаточно. Для более подробного ознакомления рекомендуем ознакомиться с этой статьёй на хабре.

Коротко об искусственном нейроне

Чаще всего в подобных статьях начинают расписывать про устройство биологического нейрона, связь с его искусственной моделью и прочую лирику. Мы же этого делать не будем, а сразу перейдём к сути. Искусственный нейрон — это всего лишь взвешенная сумма значений входного вектора элементов, которая передаётся на нелинейную функцию активации f: z = f(y), где y = w·x + w1·x1 + . + wm — 1·xm — 1 . Здесь w, . wm — 1 — коэффициенты, веса каждого элемента вектора, x, . xm — 1 — значения входного вектора X, y — взвешенная сумма элементов X, а z — результат применения функции активации. Мы вернёмся к функции активации немного позднее, а пока давайте придумаем, как вместо одного выходного значения получить n.

Нейронный слой

Один нейрон способен входной вектор превратить в одну точку, однако по условию мы хотим получить несколько точек, так как выходной вектор Y может иметь произвольную размерность, определяемую лишь конкретной ситуацией (один выход для XOR, 10 выходов для определения принадлежности к одному из 10 классов и т.д.). Как же нам получить n точек, преобразуя элементы входного вектора X? Оказывается, всё довольно просто: для того, чтобы получить n выходных значений, необходимо использовать не один нейрон, а n. Тогда для каждого из элементов выходного вектора Y будет использовано ровно n различных взвешенных сумм от вектора X. То есть мы получаем, что zi = f(yi) = f(wi0·x + wi1·x1 + . + wim — 1·xm — 1)

Если внимательно посмотреть, то оказывается, что написанная выше формула является определением умножения матрицы на вектор. И действительно, если взять матрицу W размера n на m и умножить её на вектор X размерности m, то получится другой вектор размерности n, то есть ровно то, что нам и нужно. Таким образом, получение выходного вектора по входному для n нейронов можно записать в более удобной матричной форме: Y = W·X , где W — матрица весовых коэффициентов, X — входной вектор и Y — выходной вектор. Однако полученный вектор является неактивированным состоянием (промежуточным, невыходным) всех нейронов, а чтобы получить выходное значение,, необходимо каждое неактивированное значение подать на вход функции активации. Результат её применения и будет выходным значением слоя.

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

Функция активации

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

  • Сигмоида: f(x) = 1 / (1 + e -x )
  • Гиперболический тангенс: f(x) = tanh(x)
  • ReLU: f(x) = max(x,0)

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

Хватит бла бла, давайте писать код

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

  1. Вектор (входные, выходные);
  2. Матрица (каждый слой содержит матрицу весовых коэффициентов);
  3. Нейросеть.
  • Вектор можно создавать из количества элементов (длины);
  • Вектор можно создавать из перечисления вещественных чисел;
  • Можно получать значения по индексу i.
  • Можно изменять значения по индексу i.
  • Матрицу можно создавать из числа строк, столбцов и генератора случайных чисел для заполнения случайными значениями;
  • Можно получать значения по индексам i и j;
  • Можно изменять значения по индексам i и j;

3. Сама нейросеть:

Сеть есть, но её ответы случайны. Как обучать?

На данный момент мы имеем случайную (необученную) нейронную сеть, которая может по входному вектору input выдать случайный ответ, однако нам требуется ответы, удовлетворяющие конкретной задаче. Чтобы добиться этого нашу сеть необходимо обучить. Для этого нам необходима база тренировочных примеров, то есть множество пар векторов X — Y, на которых будет обучаться сеть. Обучать нейросеть мы будем с помощью алгоритма обратного распространения ошибки. Если кратко, то он работает следующим образом:

  • Подать на вход сети обучающий пример (один входной вектор)
  • Распространить сигнал по сети вперёд (получить выход сети)
  • Вычислить ошибку (разница получившегося и ожидаемого векторов)
  • Распространить ошибку на предыдущие слои
  • Обновить весовые коэффициенты для уменьшения ошибки

Сам же алгоритм обучения выглядит так:

Обучаем нейронную сеть

Для обратного распространения ошибки нам потребуется знать значения входов, выходов и значения производных функции активации сети на каждом из слоёв, поэтому создадим структуру LayerT, в которой будет 3 вектора: x — вход слоя, z — выход слоя, df — производная функции активации. Также для каждого слоя потребуются векторы дельт, поэтому добавим в наш класс ещё и их. С учётом вышесказанного наш класс станет выглядеть так:

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

Перейдём к обратному распространению ошибки. В качестве функции оценки сети E(W) возьмём среднее квадратичное отклонение: E = 0.5 · Σ(y1i — y2i) 2 . Чтобы найти значение ошибки E, нам нужно найти сумму квадратов разности значений вектора, который выдала сеть в качестве ответа, и вектора, который мы ожидаем увидеть при обучении. Также нам потребуется найти дельту для каждого слоя, причём для последнего слоя она будет равна вектору разности полученного и ожидаемого векторов, умноженному (покомпонентно) на вектор значений производных последнего слоя: δlast = (zlast — d)·f’last , где zlast — выход последнего слоя сети, d — ожидаемый вектор сети, f’last — вектор значений производной функции активации последнего слоя.

Теперь, зная дельту последнего слоя, мы можем найти дельты всех предыдущих слоёв. Для этого нужно умножить транспонированную матрицы текущего слоя на дельту текущего слоя и затем умножить полученный вектор на вектор производных функции активации предыдущего слоя: δk-1 = W T k·δk·f’k .

Что ж, давайте реализуем это в коде:

Изменение весов

Для того, чтобы уменьшить ошибку сети нужно изменить весовые коэффициенты каждого слоя. Как же именно нужно менять весовые коэффициенты матриц на каждом слое? Оказывается, всё довольно просто. Для этого используется метод градиентного спуска, а значит нам необходимо вычислить градиент по весам и сделать шаг в отрицательную сторону от этого градиента. На этапе прямого распространения мы зачем-то запоминали входные сигналы, а при обратном распространении ошибки мы вычисляли дельты в каждом слое. Именно их мы и будем сейчас использовать для нахождения градиента! Градиент по весам равен перемножению входного вектора и вектора дельт (не покомпонентно). Поэтому, чтобы обновить весовые коэффициенты и уменьшить тем самым ошибку сети нужно всего лишь вычесть из матрицы весов результат перемножения дельт и входных векторов, умноженный на скорость обучения. Это можно записать в таком виде: Wt+1 = Wt — η·δ·X , где Wt+1 — новая матрица весов, Wt — текущая матрица весов, X — входное значение слоя, δ — дельта этого слоя. Почему именно так с математической точки зрения хорошо описано в этой статье.

Читать еще:  Как сделать ссылку на ячейку из другого документа в excel?

Обучение сети

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

Сеть готова. Давайте же её чему-нибудь научим!

Тренируем нейросеть на функции XOR

Почему функция XOR так интересна? Просто потому, что её невозможно получить одним нейроном: 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1, 1 ^ 1 = 0. Однако она легко получается увеличением числа нейронов. Мы же попробуем выполнить обучение сети с 3 нейронами в скрытом слое и 1 выходным (так как выход у нас всего один). Для этого нам необходимо создать массив векторов X и Y с обучающими данными и саму нейросеть:

После чего запустим обучение со следующими параметрами: скорость обучения — 0.5, число эпох — 100000, величина ошибки — 1e-7:

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

В результате вывод может быть таким:

Проверять результаты на тренировочной же выборке довольно скучно, ведь как никак на ней мы сеть обучали, но, увы, для XOR проблемы ничего другого не остаётся. В качестве более серьёзного примера рекомендуем выполнить задачу распознавания картинок с рукописными цифрами MNIST. Это база содержит 60000 картинок написанных от руки цифр размером 28 на 28 пикселей и используется как один из основных датасетов для начала изучения машинного обучения. Не смотря на простоту нашей сети, при грамотном выборе параметров (число нейронов, число слоёв, скорость обучения, число эпох. ) можно получить точность распознавания до 98%! Проверить свою сеть вы можете, поучаствовав в соревновании на сайте Kaggle. Нашей команде удалось достичь точности в 98.171%! А вы сможете больше? 🙂

В заключение

Мы написали с вами нейронную сеть прямого распространения и даже обучили её функции XOR. При этом мы позаботились об универсальности, благодаря чему нейросеть может быть обучена на любых данных, главное только подготовить два массива обучающих векторов X и Y, подобрать параметры обучения и запустить само обучение, после чего наблюдать за процессом. Важно помнить, что при использовании сигмоидальной функции активации, выходные значения сети не будут превышать 1, а значит, для обучения данным, которые значительно больше 1 необходимо отнормировать их, то есть привести к отрезку [0, 1].

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

Студент МГУ им. М.В. Ломоносова

Программист, соосновательница programforyou.ru, рукодельница, всегда готова придти на помощь и помочь во всём разобраться

Студентка МГТУ им. Н.Э. Баумана

А Вы знаете, что мы пишем программы на C, C++, C#, Pascal и Python?

Так что если Вам нужно написать программу на C/C++, C#, Pascal или Python — мы с радостью поможем с этим!

В том числе мы занимаемся репетиторством по информатике и программированию, а также готовим к ОГЭ и ЕГЭ!

Почему именно мы?

  • Более 1800 выполненных заказов;
  • Более 170 отзывов;
  • Качественное решение
  • Короткие сроки и привлекательные цены
  • Различные акции и скидки

Как с нами связаться?

  • группа Вконтакте: vk.com/programforyou
  • наша почта: order@programforyou.ru

Programforyou — позвольте нам писать код для вас и вы получите качественное решение в короткие сроки по привлекательной цене!

Как сделать нейронную сеть в excel?

Внимание. Это старая версия нашего сайта, новая версия находится здесь

NeuroShell Run-Time Server версия 2.0

Средства Автономного Использования Нейронных Сетей

NeuroShell Run-Time Server дает возможность использовать нейронные сети, созданные с помощью NeuroShell Predictor или NeuroShell Classifier , в Ваших собственных программах, пользуясь простым интерфейсом или из рабочих листов Microsoft® Excel™.

В состав NeuroShell Run-Time Server входят шесть самостоятельных программ:

  1. NeuroShell Fire — программа NSFIRE.EXE
  2. NeuroShell Fire — надстройка Excel NSFIRE.XLA
  3. NeuroShell Run — надстройка Excel NSRUN.XLA (можно распространять с собственными программами)
  4. NeuroShell OLE DLL Run — динамическая библиотека NSRUN.DLL (можно распространять с собственными программами)
  5. NeuroShell Run ActiveX Control — элемент управления NSRUN.OCX (можно распространять с собственными программами)
  6. NeuroShell Run Wrapper DLL — динамическая библиотека, реализующая класс-оболочку NSWRAP.DLL (можно распространять с собственными программами)

1. Программа NeuroShell Fire (NSFIRE.EXE)


2. Надстройка Excel — NeuroShell Fire (NSFIRE.XLA)

Есть два способа применить нейронную сеть, находясь в Excel. Это можно сделать с помощью Диалогового окна или с помощью функции FireNet.

Диалоговое окно


Вызов функции FireNet

Ниже приведен пример использования функции для получения результата предсказания сети, записанной в файле «c:NeuroShell PredictorExamplesburger.net». Четыре входа сети размещаются в ячейках A2:D2. Предсказание в ячейке F2 выполняется методом Enhanced Generalization (улучшенное обощение).

=NSFIRE.XLA!FireNet(A2:D2, «C:NeuroShell PredictorExamplesburger.net»,1)

3. Надстройка Excel NeuroShell Run (NSRUN.XLA)

Эту программу разрешается передавать людям, не имеющим программ Predictor или Classifier . В состав программного обеспечения, которое Вы передаете своим пользователям, следует включить файл NSRUN.XLA, который пользователь должен загрузить как надстройку Excel.

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

4. Динамическая библиотека NeuroShell OLE DLL Run (NSRUN.DLL)

Динамическая библиотека NeuroShell OLE DLL Run работает с такими языками программирования, как Microsoft® Visual Basic™, C++ и Borland™ Delphi™. Заметим, однако, что создание OLE-клиент-приложения при использовании Microsoft Visual Basic значительно проще, чем при использовании других языков.

5. Элемент управления NeuroShell Run ActiveX Control (NSRUN.OCX)

Для активизации Ваших сетей в своих программах Вы можете использовать элемент управления NeuroShell® ActiveX Control.

Для этих целей годятся любые языки программирования, которые позволяют вставлять элементы управления. Например, если Вы пользуетесь языком Visual Basic, то сначала Вам следует добавить контрольный элемент на панель инструментов. Выберите в меню Project пункт Components, найдите в списке компонентов NeuroShell Run-Time Server и включите флажок. После того, как Вы включите флажок и нажмете OK, к панели инструментов Вашего проекта VB будет добавлен значок . Теперь Вы сможете поместить в форму элемент управления, активизирующий Ваши нейронные сети, точно так же, как Вы сделали бы это для любого другого элемента управления.

6. Динамическая библиотека, реализующая класс-оболочку NeuroShell Run Wrapper DLL (NSWRAP.DLL)

Использование данной библиотеки представляет собой простейший способ вызова NeuroShell Run-Time Server из языков низкого уровня, таких как Cи и Паскаль.

Библиотека NSWRAP.DLL включает в себя 4 функции:

  1. OpenNetwork – Эта функции создает объект — нейросеть и считывает файл нейронной сети, которая была Вами создана с помощью программ NeuroShell Predictor или NeuroShell Classifier.
  2. FireNetwork – После того, как нейронная сеть создана, с помощю этой функции на входы нейронной сети можно подавать данные и получать ответы сети, используя массивы, определенные в Вашей программе.
  3. CloseNetwork – Данная функция очищает память и освобождает системные ресурсы компьютера, использовавшиеся для работы нейронной сети. Если в Вашей программе нужно еще раз использовать нейросеть, необходимо снова воспользоваться функцией OpenNetwork.
  4. GetMissingDataSpecifier – Возвращает значения специальных констант, которые использованы при подстановке пропущенных данных во входных переменных (если таковые имеются).

Первые три функции возвращают целое значение, причем код 0 означает отсутствие ошибки. Программирование вызова функций из DLL осуществляется в соответствии с правилами того языка, на котором Вы создаете программу. Например, при программировании на СИ следует включить в текст программы указание на файл NSWRAP.LIB, который поставляется вместе с библиотекой NSWRAP.DLL.

В состав NeuroShell Run-Time Server входят много примеров, которые при установке помещаются в каталог /NeuroShell Series/Run Time Server/examples/ :

  • Пример программы на языке Microsoft Visual C++ 4.0 с использованием динамической библиотеки NeuroShell OLE DLL Run
  • Два примера на языке Visual Basic 5.0 с использованием динамической библиотеки NeuroShell OLE DLL Run
  • Пример программы на языке Microsoft Visual C++ 4.0 с использованием динамической библиотеки NSWRAP.DLL, реализующей класс-оболочку
  • Пример программы на языке Delphi 3.0 c использованием NSWRAP.DLL
  • Три примера программ применения элементов управления ActiveX на языке Visual Basic 5.0

NeuroShell Run-Time Server состоит из шести программ :

  1. NeuroShell Fire (NSFIRE.EXE) — НЕ распространяемая программа
  2. Надстройка Excel NeuroShell Fire (NSFIRE.XLA) — НЕ распространяемая программа
  3. Надстройка Excel NeuroShell Run (NSRUN.XLA) — распространяемая программа
  4. Динамическая библиотека NeuroShell OLE DLL Run (NSRUN.DLL) — распространяемая программа
  5. Элемент управления — NeuroShell Run ActiveX Control — (NSRUN.OCX) — распространяемая программа
  6. Динамическая библиотека, реализующая класс-оболочку NeuroShell Run Wrapper DLL (NSWRAP.DLL) — распространяемая программа

Программы, указанные как распространяемые, можно продавать или передавать иными способами в качестве составных частей Ваших собственных программ или рабочих листов Excel. Вы освобождены от уплаты роялти при распространении NSRUN.XLA или NSRUN.DLL вместе с Вашими программами. Программы, помеченные как НЕ распространяемые, могут быть использованы ТОЛЬКО внутри компаний или организаций, купивших пакет NeuroShell Run-Time Server , и не могут быть переданы никому за пределы Вашей организации, ни вышестояшим организациям, ни родительским или дочерним фирмам. Распространяемые программы имеют в своем имени слово RUN. Программы, имеющие в своем имени слово FIRE, распространять нельзя.

Требования к компьютеру


Требования к программному обеспечению

Бесплатная техническая поддержка
Страницы.

Изучаем нейронные сети за четыре шага

    Переводы, 7 августа 2016 в 23:21

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

Шаг 1. Нейроны и метод прямого распространения

Так что же такое «нейронная сеть»? Давайте подождём с этим и сперва разберёмся с одним нейроном.

Нейрон похож на функцию: он принимает на вход несколько значений и возвращает одно.

Круг ниже обозначает искусственный нейрон. Он получает 5 и возвращает 1. Ввод — это сумма трёх соединённых с нейроном синапсов (три стрелки слева).

В левой части картинки мы видим 2 входных значения (зелёного цвета) и смещение (выделено коричневым цветом).

Входные данные могут быть численными представлениями двух разных свойств. Например, при создании спам-фильтра они могли бы означать наличие более чем одного слова, написанного ЗАГЛАВНЫМИ БУКВАМИ, и наличие слова «виагра».

Входные значения умножаются на свои так называемые «веса», 7 и 3 (выделено синим).

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

Потом нейрон производит какое-то вычисление и выдает выходное значение. Мы получили 1, т.к. округлённое значение сигмоиды в точке 5 равно 1 (более подробно об этой функции поговорим позже).

Если бы это был спам-фильтр, факт вывода 1 означал бы то, что текст был помечен нейроном как спам.

Иллюстрация нейронной сети с Википедии.

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

Я очень рекомендую посмотреть серию видео от Welch Labs для улучшения понимания процесса.

Шаг 2. Сигмоида

После того, как вы посмотрели уроки от Welch Labs, хорошей идеей было бы ознакомиться с четвертой неделей курса по машинному обучению от Coursera, посвящённой нейронным сетям — она поможет разобраться в принципах их работы. Курс сильно углубляется в математику и основан на Octave, а я предпочитаю Python. Из-за этого я пропустил упражнения и почерпнул все необходимые знания из видео.

Сигмоида просто-напросто отображает ваше значение (по горизонтальной оси) на отрезок от 0 до 1.

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

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

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

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

Шаг 3. Метод обратного распространения ошибки

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

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

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

Скриншот из руководства Мэтта Мазура по методу обратного распространения ошибки.

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

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

Шаг 4. Создание своей нейронной сети

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

Ещё одной полезной статьёй оказалась A Neural Network in 11 lines of Python от IAmTrask. В ней содержится удивительное количество знаний, сжатых до 11 строк кода.

Скриншот руководства от IAmTrask

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

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

После этого можно ознакомиться с руководством Wild ML от Denny Britz, в котором разбираются нейронные сети посложнее.

Скриншот из руководства WildML

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

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

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

Ссылка на основную публикацию
Adblock
detector