Основы нейронных сетей на python zhitsoboy.ru

Основы нейронных сетей на python

Распознавание рукописного текста. Нейронные сети.Python

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

  • Немного теории.
  • Пишем сеть.
  • Обучение сети, обратное распространение ошибки, машинное обучение.
  • Итог.

Совсем без теории конечно не обойтись и начнем мы с нейрона.

Все нейронные сети состоят из нейронов. А если конкретней из математической модели работы настоящего нейрона. Суть этой модели в том что есть много входов ( X ) по которым поступают какие то данные ( на примет 1 или ). У каждого сигналавхода есть вес (сила сигнала W) . Все эти данные обрабатываются внутри нейрона, так называемая функция активации нейрона f(x) . И нейрон падает обработанные данные на выход.

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

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

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

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

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

numpy.random.rand() — создает массив заданной формы и заполняет его случайными значениями от 0 до 1.

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

Сигмооида — это гладкая монотонная возрастающая нелинейная функция, имеющая форму буквы «S», которая часто применяется для «сглаживания» значений некоторой величины. Формула : f(x) = 1 / (1+e ** -x )

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

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

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

А теперь представим эти данные в виде матрицы :

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

Машинное обучение.

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

Мы возьмем готовую базу MNIST (сокращение от «Modified National Institute of Standards and Technology») — объёмная база данных образцов рукописного написания цифр. База данных является стандартом, предложенным Национальным институтом стандартов и технологий США с целью калибрации и сопоставления методов распознавания изображений с помощью машинного обучения в первую очередь на основе нейронных сетей. Качаем с нашего сайта.

Смысл обучения нейронной сети сводиться к коррекции W весов связей( силы сигнала) между нейронами. Первым делом мы вычисляем ошибку выходных данных : e1 = t1 — o1 где t1 проверочное значение для нейрона выходного слоя, o1 — фактическое значение. Что бы посчитать ошибку для нейронов скрытого слоя мы воспользуемся методом обратного распространения ошибки . Суть проста : Ошибка1 (первого нейрона скрытого слоя) = e1 (выходной) * w1.1 + e2(второй выходной нейрона) * w1.2(вес связи от него)

Формула для матриц

Ошибки нейронов мы посчитали, а на сколько же и как нам менять веса связей ? Не вдаваясь в подробности, будем использовать метод Градиентного спуска. То есть коррекция = lern_nodes * e выходного слой * сигмоида выходного слоя * (1 — сигмоида выходного слоя) * сигмоида скрытого слоя

Обучающие данные.

Нас с вами интересует два файл :

  • mnist_train.csv
  • mnist_test.csv

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

  • Первое значение это маркер от 0-9 , какая цифра изображена.
  • Далее следует пиксельный массив 28х28 . Всего 784 значения от 0 до 255.

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

Наша нейросеть будет классифицировать изображения по 10 признакам , цифра от 0 до 9 . Выходные значения опять же будут в рамках нашей функции активации, фактически сигмоида не может достичь 1 , по этому мы записываем 0.99 .

Немного все сумбурно получилось. Используя эту базу данных мы будем подавать на каждый входной нейрон одно значение пикселя картинки. То есть входной слой будет у нас матрица 28х28 (784 нейрона) . А выходной слой будет содержать 10 нейронов- классификаторов. Самый интерес вопрос : сколько нейронов должно быть в скрытом слое ? Если их будет мало, сеть будет не способна распознать цифры. Если очень много сеть просто запомнит обучающие данные(зазубрит) что скажется на точности распознания. Попробуем остановиться на 100 скрытых нейронах.

Читать еще:  Проверка оперативной памяти Windows xp

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

Как построить трехслойную нейронную сеть с нуля на Python

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

Проблема, которую нужно решить

У итальянского фермера были проблемы с его этикетировочной машиной: она перепутала этикетки трех сортов вина. Теперь у него осталось 178 бутылок, и никто не знает, какого они сорта! Чтобы помочь этому бедному человеку, мы создадим классификатор, который распознает вино на основе 13 атрибутов.

Тот факт, что наши данные помечены (одной из трех меток сорта), делает эту проблему Supervised learning. По сути, мы хотим использовать наши входные данные (178 не секретных винных бутылок) для обучения нейронной сети, а затем получим правильную метку для каждого сорта вина в качестве результата.

Нейронная сеть будет тренироваться, чтобы лучше предсказать (y-hat), какая бутылка принадлежит какой этикетке.

Теперь пришло время начать строить нейронную сеть!

Нейронная сеть: метод построения

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

Overview of the 3 Layer neural network, a wine classifier

Входной слой (х) состоит из 178 нейронов.
А1, первый слой, состоит из 8 нейронов.
А2, второй слой, состоит из 5 нейронов.
А3, третий и выходной слой, состоит из 3 нейронов.

Шаг 1: обычная подготовка

Импортируйте все необходимые библиотеки (NumPy, skicit-learn, pandas) и набор данных и определите x и y.

Шаг 2: инициализация

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

В Python функция random.seed генерирует «случайные числа». Однако случайные числа не являются действительно случайными. Сгенерированные числа являются псевдослучайными, то есть числа генерируются сложной формулой, которая делает их случайными. Для генерации чисел формула принимает предыдущее значение, сгенерированное в качестве входных данных. Если предыдущее значение не генерируется, часто в качестве первого значения используется время.

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

Шаг 3: прямое распространение (forward propagation)

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

После того, как мы инициализировали веса псевдослучайным числом, мы делаем линейный шаг вперед. Мы рассчитываем это, взяв наше входное значение A0, умноженное на произведение случайных инициализированных весов плюс смещение. Мы начали с смещения 0. Оно представляется как:

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

Существуют различные виды функций активации. Для этой модели мы решили использовать функцию активации tanh для наших двух скрытых слоев — A1 и A2. Функция дает нам выходное значение от -1 до 1.

Так как это проблема классификации нескольких классов (у нас есть 3 метки), мы будем использовать функцию softmax для выходного слоя — A3 — потому что она вычислит вероятности для классов, на выходе будет значение между 0 и 1.

tanh function

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

В Python этот процесс выглядит так:

В итоге все наши значения хранятся в кеше.

Шаг 4: обратное распространение (back propagation)

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

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

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

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

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

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

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

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

На самом деле градиентный спуск выглядит примерно так:

Мы всегда начинаем с вычисления наклона функции потерь относительно z, наклона линейного шага, который мы делаем.

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

Затем мы вычисляем наклон функции потерь относительно наших весов и смещений. Поскольку это слой 3 уровня, мы повторим этот процесс для z3,2,1 + W3,2,1 и b3,2,1. Распространение в обратном направлении от выхода к входному слою.

Читать еще:  Операционная система на флешке без установки

Вот как этот процесс выглядит в Python:

Шаг 5: этап обучения

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

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

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

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

  • : = означает, что это определение, а не уравнение или проверенное утверждение.
  • скорость обучения называется альфа
  • dL (w) — это производная от общей потери по отношению к нашему весу w
  • da является производной альфа

Мы выбрали скорость обучения 0,07 после некоторых экспериментов.

Наконец, это наш график. Вы можете построить график со своей точностью и / или потерями. После 4500 эпох наш алгоритм имеет точность 99,4382022472%.

Короткое повторение

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

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

Затем мы вычисляем разницу между нашим прогнозом (y-hat) и ожидаемым выходным значением (y) и используем это значение ошибки во время обратного распространения.

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

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

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

Overview of Forward and Backwards propagation

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

Переведено по материалам Daphne Cornelisse. How to build a three-layer neural network from scratch

Машинное зрение на Python. Обучаем нейросеть распознавать цифры

Содержание статьи

Для каждого примера я приведу код на Python 3.7. Ты можешь запустить его и посмотреть, как все это работает. Для запуска примеров потребуется библиотека Tensorflow. Установить ее можно командой pip install tensorflow-gpu , если видеокарта поддерживает CUDA, в противном случае используй команду pip install tensorflow . Вычисления с CUDA в несколько раз быстрее, так что, если твоя видеокарта их поддерживает, это сэкономит немало времени. И не забудь установить наборы данных для обучения сети командой pip install tensorflow-datasets .

Все приведенные в этой статье примеры работают полностью автономно. Это важно, потому что существуют различные онлайн-сервисы AI, например компании Amazon, которые берут оплату за каждый запрос. Создав и обучив собственную нейронную сеть с помощью Python и Tensorflow, ты сможешь использовать ее неограниченно и независимо от какого-либо провайдера.

Как работает нейронная сеть

Как работает один нейрон? Сигналы со входов (1) суммируются (2), причем каждый вход имеет свой «коэффициент передачи» — w . Затем к получившемуся результату применяется «функция активации» (3).

Модель нейрона

Типы этой функции различны, она может быть:

  • прямоугольной (на выходе 0 или 1);
  • линейной;
  • в виде сигмоиды.

Еще в 1943 году Мак-Каллок и Питтс доказали, что сеть из нейронов может выполнять различные операции. Но сначала эту сеть нужно обучить — настроить коэффициенты w каждого нейрона так, чтобы сигнал передавался нужным нам способом. Запрограммировать нейронную сеть и обучить ее с нуля сложно, но, к счастью для нас, все необходимые библиотеки уже написаны. Благодаря компактности языка Python все действия можно запрограммировать в несколько строк кода.

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

Простейшая нейронная сеть

Сначала нужно подключить необходимые библиотеки, в нашем случае это tensorflow . Я также отключаю вывод отладочных сообщений и работу с GPU, они нам не пригодятся. Для работы с массивами нам понадобится библиотека numpy .

Теперь мы готовы создать нейросеть. Благодаря Tensorflow на это понадобится всего лишь четыре строчки кода.

Мы создали модель нейронной сети — класс Sequential — и добавили в нее два слоя: входной и выходной. Такая сеть называется «многослойный перцептрон» (multilayer perceptron), в общем виде она выглядит так.

Сеть multilayer perceptron

В нашем случае сеть имеет два входа (внешний слой), два нейрона во внутреннем слое и один выход.

Можно посмотреть, что у нас получилось:

Параметры сети

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

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

Читать еще:  Установка Windows xp по сети

Результат соответствует тому, чему сеть обучалась.

Network test:
XOR(0,0): [[0.00741202]]
XOR(0,1): [[0.99845064]]
XOR(1,0): [[0.9984376]]
XOR(1,1): [[0.00741202]]

Мы можем вывести все значения найденных коэффициентов на экран.

W1: [[ 2.8668058 -2.904025 ] [-2.871452 2.9036295]]
b1: [-0.00128211 -0.00191825]
W2: [[3.9633768] [3.9168582]]
b2: [-4.897212]

Внутренняя реализация функции model.predict_proba выглядит примерно так:

Рассмотрим ситуацию, когда на вход сети подали значения [0,1]:

L1 = X1W1 + b1 = [02.8668058 + 1-2.871452 + -0.0012821, 0-2.904025 + 1*2.9036295 + -0.00191825] = [-2.8727343 2.9017112]

Функция активации ReLu (rectified linear unit) — это просто замена отрицательных элементов нулем.

Теперь найденные значения попадают на второй слой.

L2 = X2W2 + b2 = 03.9633768 +2.9017112*3.9633768 + -4.897212 = 6.468379

Наконец, в качестве выхода используется функция Sigmoid , которая приводит значения к диапазону 0. 1:

Мы совершили обычные операции умножения и сложения матриц и получили ответ: XOR(0,1) = 1 .

С этим примером на Python советую поэкспериментировать самостоятельно. Например, ты можешь менять число нейронов во внутреннем слое. Два нейрона, как в нашем случае, — это самый минимум, чтобы сеть работала.

Но алгоритм обучения, который используется в Keras, не идеален: нейросети не всегда удается обучиться за 1000 итераций, и результаты не всегда верны. Так, Keras инициализирует начальные значения случайными величинами, и при каждом запуске результат может отличаться. Моя сеть с двумя нейронами успешно обучалась лишь в 20% случаев. Неправильная работа сети выглядит примерно так:

XOR(0,0): [[0.66549516]]
XOR(0,1): [[0.66549516]]
XOR(1,0): [[0.66549516]]
XOR(1,1): [[0.00174837]]

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

Можно сделать сеть поумнее: использовать четыре нейрона вместо двух, для этого достаточно заменить строчку кода model.add(Dense(2, input_dim=2, activation=’relu’)) на model.add(Dense(4, input_dim=2, activation=’relu’)) . Такая сеть обучается уже в 60% случаев, а сеть из шести нейронов обучается с первого раза с вероятностью 90%.

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

Продолжение доступно только участникам

Вариант 1. Присоединись к сообществу «Xakep.ru», чтобы читать все материалы на сайте

Членство в сообществе в течение указанного срока откроет тебе доступ ко ВСЕМ материалам «Хакера», увеличит личную накопительную скидку и позволит накапливать профессиональный рейтинг Xakep Score! Подробнее

Простейшие нейронные сети на Python в Visual Studio (Python neural networks in Visual Studio)

Из статьи вы узнаете, как написать простую нейросеть на Python в среде Visual Studio (VS). Для более глубокого понимания проблематики приводятся примеры различных версий кода — от простого из 7 строк до более профессионального.

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

Во входном слое расположены нейроны, которые принимают сигнал, но не обрабатывают его.

Стрелочки, передающие сигналы — синапсы. Они умножают входной сигнал xi на синаптический вес wi. В каждом из нейронов определяется сумма значений входящих сигналов

Результат d приводится к диапазону [0 … 1] при помощи функции активации y=S(d) (нелинейной сигмоидальной функции).

alpha – параметр наклона сигмоидальной функции S(d). Чем больше этот параметр, тем круче функция (угол касательной в точке перегиба функции будет больше).

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

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

  1. Инициализировать синаптические веса маленькими случайными значениями.
  2. Выбрать очередную обучающую пару из обучающего множества; подать входной вектор на вход сети.
  3. Вычислить выход сети.
  4. Вычислить разность между выходом сети и требуемым выходом (целевым вектором обучающей пары).
  5. Подкорректировать веса сети для минимизации ошибки.
  6. Повторять шаги с 2 по 5 для каждой пары обучающего множества до тех пор, пока ошибка на всем множестве не достигнет приемлемого уровня.

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

Создание нейронной сети в Visual Studio (версия кода 1)

Запускаем редактор VS и создаем проект (File>New>Project>Python>Python Application)

Вставляем в исходный файл (.py) код:

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

Обучающая выборка для обучения из 3-х примеров:

  • На входе сигналы: [3,5],[5,1],[10,2];
  • На выходе сигналы: 75,82,93;

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

Если отладчик подчеркивает 1-й рядок кода, значит, у Вас еще не инсталлирован пакет (package) numpy. Его можно инсталлировать не выходя из проекта (Шаг 5. Установка пакетов в окружении Python). Для этого открываете контекстное меню в Solution Explore и выбираете в нем «Install Python Package»:

Откроется окно «Python Environments». В поисковом окошке набираете «numpy» и, затем, запускаете «Install numpy».

Откроется окно, в котором выбираете права администратора:

Инсталляция длится не более 5 минут.

Математическая разминка:

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

Простая нейронная сеть (версия кода 2)

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

Подробное описание приложения см. в первоисточнике Простая нейронная сеть в 9 строчек кода на Python

Вставляем в исходный файл следующий код:

Запускаем приложение, получаем следующий результат:

Усложняем приложение. Вставляем в исходный файл следующий код:

Запускаем приложение, получаем следующий результат:

Простая нейронная сеть (версия кода 3)

Ниже рассмотрены коды приложений для 2-х и 3-х уровневых нейронных сетей. Подробное описание обоих приложений и алгоритма к ним см. в первоисточнике Нейронная сеть в 11 строках Python (часть 1).

Код к 2-х уровневой нейронной сети:

Запускаем приложение, получаем следующий результат:

Код к 3-х уровневой нейронной сети:

Запускаем приложение, получаем следующий результат:

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