Как создать нейросеть с нуля на python
Перейти к содержимому

Как создать нейросеть с нуля на python

  • автор:

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

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

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

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

Какие задачи решает нейросеть

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

  1. Классификация и распознавание образов: распознавание лиц, объектов, символов, образов и других графических данных. Например, системы автоматического распознавания рукописного текста, системы безопасности с распознаванием лиц, программы с автоматическим распознаванием изображений.
  2. С помощью нейросети происходит прогнозирование временных рядов, цен на акции, погоды, спроса на товары и другие величины. Например, финансовый анализ, прогнозирование спроса и анализ продаж за прошедший период.
  3. Обработка естественного языка. Эту функцию нейросети используют для анализа тональности, определения языка, машинного перевода, генерации контента и т.д. Например, их применяют для фильтрации сообщений электронной почты, в чат-ботах и для выполнения автоматического перевода.
  4. Генерация искусственного контента: изображений, музыки, текстов. Например, музыкальные искусственные инструменты и синтез фотореалистичных изображений.
  5. Управление и адаптивное управление. Нейросеть позволяет управлять процессами, оперативным прогнозированием, энергией. Например, системы автоматического управления трафиком, умный дом и взаимодействие с роботами.
  6. Распознавание голоса. Эта способность используется для распознавания голоса при управлении устройствами, для преобразования речи в текст, для систем синтеза речи.

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

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

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

Рассмотрим, из каких компонентов состоят нейросети:

Нейроны

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

Веса

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

Слои

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

Активационная функция

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

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

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

Оптимизатор

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

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

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

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

Применение нейросетей в реальной жизни

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

  1. Медицина. С помощью нейросетей производится диагностика и прогнозирование заболеваний. Они помогают анализировать медицинские изображения (например, рентгены или снимки МРТ), чтобы диагностировать наличие опухолей или обнаружить другие патологии. В медицинских исследованиях нейронные сети используют для выявления новых медицинских тенденций и разработки новых лекарств.
  2. Транспорт. Искусственный интеллект используют в системах автопилота для управления автомобилем. Его применяют для повышения безопасности на дорогах, например, для распознавания знаков, пешеходов и прогнозирования поведения другого автотранспорта.
  3. Финансы. Нейронные сети применяются для прогнозирования цен на финансовых рынках, анализа рисков и определения оптимальных стратегий инвестиций. Они внедряются для обнаружения мошенничества и анализа кредитного скоринга.
  4. Реклама и маркетинг. Нейросети используют для персонализации рекламы и формирования рекомендаций на основе интересов и предпочтений пользователей. Они анализируют данные о поведении клиентов и предлагают им подходящие товары или услуги.
  5. Интернет-поиск. Нейронные сети применяются для улучшения поисковых систем. Они анализируют контекст запроса посетителя сайта и предлагают более точные и релевантные результаты поиска. Сети учитывают привязанную к запросу локацию пользователя для предоставления результатов местных сайтов и веб-страниц.
  6. Робототехника. Для управления и обучения роботов прибегают к помощи искусственного разума. Он позволяет роботам обучаться выполнению конкретных действий и адаптироваться к изменяющимся условиям. Например, роботы-манипуляторы могут использовать нейронные сети для обучения точным движениям и схватыванию предметов.
  7. Компьютерные игры тоже активно используют нейросети для повышения привлекательности своего продукта. С помощью искусственного интеллекта создаются продвинутые герои с улучшенным поведением и реалистичными действиями.

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

Перейдем к инструкции как создать и обучить нейронные сети на Python .

Для создания собственной нейросети используйте надежное оборудование, с высоким уровнем аптайма и круглосуточной службой поддержки – заказывайте услугу Аренда VDS/VPS Linux.

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

Все описанные действия по написанию нейросети выполняются в терминале.

Для создания простой нейросети на Python, вам понадобится библиотека TensorFlow.

  1. Установите TensorFlow с помощью команды:

pip install tensorflow

  1. Импортируйте необходимые модули с помощью команд:

import tensorflow as tf

from tensorflow import keras

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

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

  1. Для подготовки данных используйте команду:

x_train = x_train / 255.0 # нормализация данных

x_test = x_test / 255.0

y_train = keras.utils.to_categorical(y_train) # преобразование меток в категориальное представление

  1. Создайте модель нейронной сети:

keras.layers.Flatten(input_shape=(28, 28)), # преобразование двумерного изображения в одномерный вектор

keras.layers.Dense(128, activation=’relu’), # плотный слой с 128 нейронами и функцией активации ReLU

keras.layers.Dense(10, activation=’softmax’) # плотный слой с 10 нейронами и функцией активации softmax (для классификации)

  1. Скомпилируйте модель, указав функцию потерь и оптимизатор:

model.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’])

  1. Обучите модель на тренировочных данных:

model.fit(x_train, y_train, epochs=10, batch_size=32)

  1. Оцените модель на тестовых данных:

test_loss, test_acc = model.evaluate(x_test, y_test)

print(‘Test accuracy:’, test_acc)

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

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

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

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

НЕЙРОСЕТЬ: просто о сложном! Создание нейронной сети на Python

НЕЙРОСЕТЬ: просто о сложном! Создание нейронной сети на Python

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

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

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

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

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

Искусственный интеллект

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

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

Следующий важный прорыв случился уже в 2016 году. Тогда программа AlphaGo компании Google DeepMind обыграла чемпиона мира по Го – Ли Седоля. Это стало важным событием, ведь в Го неограниченное или практически неограниченное количество возможных решений. Здесь в силу вступило машинное обучение, которое не оперировалось на всех возможных комбинациях игры, а оперировалось на основе своих собственных предположений, весов, которые подсказывали как стоит походить в разного рода ситуациях.

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

Машинное обучение и глубокое обучение

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

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

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

Задача классификации

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

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

После умножения все данные суммируют, добавляется число корреляции и далее результат сравнивают с неким числом. Если итог более числа 0, то можно предположить, что машина, к примеру, Mercedes, а если менее 0, то это будет, например, BMW.

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

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

Почем Python?

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

Мы тоже будем использовать Питон, но знайте, что такое можно написать и без использования библиотек, а соответственно можно писать хоть на PHP, хоть на C#. Нет смысла писать математические функции самому по типу Сигмоида, функция получения случайного числа и тому подобных. По этой причине мы будем использовать Python и библиотеку numpy .

Разработка нейронной сети

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

Код для реализации простой нейронной сети:

import numpy as np # Функция сигмоида # Необходима для опредления значения весов def sigmoid(x, der=False): if der: return x * (1 - x) return 1 / (1 + np.exp(-x)) # Набор входных данных x = np.array([[1, 0, 1], [1, 0, 1], [0, 1, 0], [0, 1, 0]]) # Выходные данные y = np.array([[0, 0, 1, 1]]).T # Сделаем случайные числа более определёнными np.random.seed(1) # Инициализируем веса случайным образом со средним 0 syn0 = 2 * np.random.random((3, 1)) - 1 l1 = [] for iter in range(10000): # Прямое распространение l0 = x l1 = sigmoid(np.dot(l0, syn0)) # Насколько мы ошиблись? l1_error = y - l1 # Перемножим это с наклоном сигмоиды # на основе значений в l1 l1_delta = l1_error * sigmoid(l1, True) # Обновим веса syn0 += np.dot(l0.T, l1_delta) print("Выходные данные после тренеровки:") print(l1)

Изучение программирования

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

Больше интересных новостей

Древнейшие сайты, которые работают до сих пор: ТОП-11

Древнейшие сайты, которые работают до сих пор: ТОП-11

Игровой движок Godot! Заменит ли он Unity и Unreal Engine?

Игровой движок Godot! Заменит ли он Unity и Unreal Engine?

Лучшие книги в 2023 году по DevOps

Лучшие книги в 2023 году по DevOps

Создание ПК программы на JavaScript. Библиотека Electron JS

Создание ПК программы на JavaScript. Библиотека Electron JS

Комментарии (1)

Сергей 25 марта 2023 в 20:57

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

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

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

from numpy import exp, array, random, dot training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]) training_set_outputs = array([[0, 1, 1, 0]]).T random.seed(1) synaptic_weights = 2 * random.random((3, 1)) — 1 for iteration in xrange(10000): output = 1 / (1 + exp(-(dot(training_set_inputs, synaptic_weights)))) synaptic_weights += dot(training_set_inputs.T, (training_set_outputs — output) * output * (1 — output)) print 1 / (1 + exp(-(dot(array([1, 0, 0]), synaptic_weights))))

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

Освойте профессию «Data Scientist»
Data Scientist

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

картинка - 2023-03-14T190938.211

Профессия / 24 месяца
Data Scientist
Решайте амбициозные задачи с помощью нейросетей
5 491 ₽/мес 9 983 ₽/мес

Group 1321314349 (2)

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

моделирование нейрона

Человеческий мозг состоит из ста миллиардов клеток, которые называются нейронами. Они соединены между собой синапсами. Если через синапсы к нейрону придет достаточное количество нервных импульсов, этот нейрон сработает и передаст нервный импульс дальше. Этот процесс лежит в основе нашего мышления. Мы можем смоделировать это явление, создав нейронную сеть с помощью компьютера. Нам не нужно воссоздавать все сложные биологические процессы, которые происходят в человеческом мозге на молекулярном уровне, нам достаточно знать, что происходит на более высоких уровнях. Для этого мы используем математический инструмент — матрицы, которые представляют собой таблицы чисел. Чтобы сделать все как можно проще, мы смоделируем только один нейрон, к которому поступает входная информация из трех источников и есть только один выход. Наша задача — научить нейронную сеть решать задачу, которая изображена в ниже. Первые четыре примера будут нашим тренировочным набором. Получилось ли у вас увидеть закономерность? Что должно быть на месте вопросительного знака — 0 или 1?

Входные данные Вывод
0 0 1 0
1 1 1 1
1 0 1 1
0 1 1 0
1 0 0 ?

Вы могли заметить, что вывод всегда равен значению левого столбца. Так что ответом будет 1. Пройдите наш тест и узнайте, какой контент подготовил искусственный интеллект, а какой — реальный человек. Ссылка в конце статьи.

Процесс тренировки

схема обучения нейронной сети

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

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

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

Станьте дата-сайентистом и решайте амбициозные задачи с помощью нейросетей

Формула для расчета выхода нейрона

Разберем специальную формулу для расчета выхода нейрона. Сначала возьмем взвешенную сумму входов нейрона:

взвешенная сумма входов нейрона

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

На графике функция Sigmoid нарисует S-образную кривую.

Sigmoid S-образная кривая

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

формула для выхода нейрона

Формула корректировки весов

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

формула для нейросети на python

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

  1. Мы использовали сигмоиду для того, чтобы посчитать выход нейрона.
  2. Если на выходе мы получаем большое положительное или отрицательное число, то это значит, что нейрон был весьма уверен в том или ином решении.
  3. На рисунке 4 мы можем увидеть, что при больших значениях переменной градиент принимает маленькие значения.
  4. Если нейрон уверен в том, что заданный вес верен, то мы не хотим сильно корректировать его. Умножение на градиент сигмоиды позволяет добиться такого эффекта.

Градиент сигмоиды может быть найден по следующей формуле:

Градиент сигмоиды для нейросети

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

конечная формула для корректировки весов

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

Как написать это на Python

Хотя мы не будем использовать специальные библиотеки для нейронных сетей, мы импортируем следующие 4 метода из математической библиотеки numpy:

  • exp — функция экспоненты
  • array — метод создания матриц
  • dot — метод перемножения матриц
  • random — метод, подающий на выход случайное число

Теперь мы можем, например, представить наш тренировочный набор с использованием array() :

training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]) training_set_outputs = array([[0, 1, 1, 0]]).T

Функция .T транспонирует матрицу из горизонтальной в вертикальную. В результате компьютер хранит эти числа таким образом:

вертикальная матрица

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

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

Итак, вот полноценно работающий пример нейронной сети, написанный на Python:

from numpy import exp, array, random, dot class NeuralNetwork(): def __init__(self):

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

random.seed(1)

Мы моделируем единственный нейрон с тремя входящими связями и одним выходом. Мы задаем случайные веса в матрице размера 3 x 1, где значения весов варьируются от -1 до 1, а среднее значение равно 0:

self.synaptic_weights = 2 * random.random((3, 1)) - 1

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

def __sigmoid(self, x): return 1 / (1 + exp(-x))

Производная от функции сигмоиды. Это градиент ее кривой. Его значение указывает насколько нейронная сеть уверена в правильности существующего веса:

def __sigmoid_derivative(self, x): return x * (1 - x)

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

def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations): for iteration in xrange(number_of_training_iterations):

Тренировочный набор передается нейронной сети (одному нейрону в нашем случае):

output = self.think(training_set_inputs)

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

error = training_set_outputs - output

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

adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))
self.synaptic_weights += adjustment

Заставляем наш нейрон подумать:

def think(self, inputs):

Пропускаем входящие данные через нейрон:

return self.__sigmoid(dot(inputs, self.synaptic_weights)) if __name__ == "__main__":

Инициализируем нейронную сеть, состоящую из одного нейрона:

neural_network = NeuralNetwork() print "Random starting synaptic weights:" print neural_network.synaptic_weights

Тренировочный набор для обучения. У нас это 4 примера, состоящих из 3 входящих значений и 1 выходящего значения:

training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])training_set_outputs = array([[0, 1, 1, 0]]).T

Обучаем нейронную сеть на тренировочном наборе, повторяя процесс 10000 раз, каждый раз корректируя веса:

neural_network.train(training_set_inputs, training_set_outputs, 10000) print "New synaptic weights after training:" print neural_network.synaptic_weights

Тестируем нейрон на новом примере:

print "Considering new situation [1, 0, 0] -> ?:" print neural_network.think(array([1, 0, 0]))

Этот код также можно найти на GitHub. Обратите внимание, что если вы используете Python 3, то вам будет нужно заменить команду “xrange” на “range”.

Несколько финальных замечаний

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

python main.py

Результат должен быть таким:

Random starting synaptic weights:
[[-0.16595599]
[ 0.44064899]
[-0.99977125]]

New synaptic weights after training:
[[ 9.67299303]
[-0.2078435 ]
[-4.62963669]]

Considering new situation
[1, 0, 0] -> ?: [ 0.99993704]

Ура, мы построили простую нейронную сеть с помощью Python!

Сначала нейронная сеть задала себе случайные веса, затем обучилась на тренировочном наборе. После этого она предсказала в качестве ответа 0.99993704 для нового примера [1, 0, 0]. Верный ответ был 1, так что это очень близко к правде!

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

Как можно улучшить нейронную сеть

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

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

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

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

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

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

Лучше обучение. Искусственные нейронные сети обучаются примерно по тому же принципу, что живые существа. Когда человек часто повторяет одни и те же действия, он учится: ездить на велосипеде, рисовать или набирать текст. Это происходит, потому что веса между нейронами в мозгу меняются: нервные клетки наращивают новые связи, по-новому начинают воспринимать сигналы и правильнее их передают. Нейронная сеть тоже изменяет веса при обучении — чем оно объемнее, тем сильнее она «запомнит» какую-то закономерность.

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

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

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

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

Больше мощностей. Нейронные сети работают с матрицами, так что если нейронов много, вычисления получаются очень ресурсоемкие. Известные нейросети вроде Midjourney или ChatGPT — это сложные и «тяжелые» системы, для их работы нужны сервера с мощным «железом». Так что написать собственный DALL-E на домашнем компьютере не получится. Но есть сервисы для аренды мощностей: ими как раз пользуются инженеры машинного обучения, чтобы создавать, обучать и тестировать модели.

Можно ли написать нейросеть еще короче

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

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

Нейросеть на Python

Искусственный интеллект (ИИ) – одна из наиболее обсуждаемых технологий в мире. Даже люди далекие от сферы IT горячо спорят про перспективы использования нейросетей. И несмотря на то, что нет окончательного мнения в вопросе “представляет ли искусственный интеллект угрозу для человечества или нет”, по итогам 2022 года вложения в развитие прикладного искусственного интеллекта достигли $104 млрд.[1]

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

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

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

Что такое нейросеть простым языком?

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

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

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

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

Устройство нейросети

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

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

Структура нейросети строго определена следующими элементами:

  • входной слой,
  • скрытые слои (все промежуточные слои),
  • выходной слой,
  • набор весов и смещений между каждым слоем,
  • функция активации для каждого скрытого слоя.

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

Архитектура однослойной (один скрытый слой) нейросети выглядит так:

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

Пишем первую нейросеть на Python

Кстати, почему именно Python?

  • Этот язык позволяет быстро создавать сложные алгоритмы.
  • Он прост в использовании, в том числе и для новичков, может быть интегрирован с кодом С и С++.
  • Python обладает высокой степенью модальности.
  • Возможно, в силу всех перечисленных факторов, он быстро «оброс» обширной экосистемой библиотек, где представлены готовые инструменты и модули для разработки нейросетей.
  • К тому же, Python имеет большое и активное сообщество разработчиков в области машинного обучения и глубокого обучения. Так что и начинающий, и опытный пользователь справится с трудностями в написании нейросети.

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

Этапы написания нейросети:

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

  1. Затем мы определяем наборы входных ( input_data) и ожидаемых выходных данных (expected_output). В нашем примере, это может быть таблица характеристик грибов и метки «съедобен/несъедобен».

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


  1. Чтобы «научить» нейросеть правильно работать со входными данными, ей необходимо «объяснить», что некоторые входные значения более важны для принятия решения. Для этого каждому нейрону в сети задается вес и смещение. Веса определяют важность входящего параметра, а смещение позволяет изменять нейрону выход в зависимости от получаемых данных. Значения случайных весов и биасов будет корректироваться нейросетью в процессе обучения.
  2. Определяем функцию активации и ее производную. Функция активации задаёт, как нейрон реагирует на полученное значение. Благодаря ей нейрон может вычислить активацию, которая будет передана следующим слоям нейронов.

Такой функцией может выступать ReLU (Rectified Linear Unit). Она имеет вид f(x) = max(0, x) и позволяет нейрону передавать значение без изменений, если оно положительно, и обнулять отрицательное. Другой вид активации — гиперболический тангенс, который переводит вход в диапазон между -1 и 1.

Но чаще всего вы будете встречать другую функцию.

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

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

В своем примере мы используем сигмоидную функцию активации и её производную, которые позволяют нейрону «активироваться» в зависимости от входных данных следующим образом:

  1. Метод обратного распространения ошибки как способ обучения нейросети.

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

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

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

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

_______________
[1] По данным исследования компании McKinsey, результаты которого обнародованы 20 июля 2023 года.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *