Создание нейросети с нуля: от теории к практике

Основы искусственного интеллекта: от перцептрона до глубокого обучения

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

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

Биологическое вдохновение

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

Давайте рассмотрим строение биологического нейрона упрощенно, чтобы понять, что именно мы пытаемся скопировать:

Дендриты — это «входные каналы». Они принимают сигналы от других нейронов.

Тело клетки (сома) — здесь происходит суммирование всех полученных сигналов. Если суммарный сигнал достаточно силен, клетка «возбуждается».

Аксон — это «выходной канал». Через него обработанный сигнал передается дальше.

Синапсы — места контакта между аксоном одного нейрона и дендритом другого. Именно здесь происходит «магия» обучения: эффективность передачи сигнала через синапс может меняться.

!Сравнение структуры биологического нейрона и его математической модели.

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

Рождение перцептрона

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

Как работает искусственный нейрон? Давайте разберем его анатомию. Он состоит из трех основных этапов обработки данных:

Входные данные (): Это информация, которую мы подаем в нейросеть (например, яркость пикселя картинки или числовые параметры квартиры).

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

Смещение ( — bias): Дополнительный параметр, который позволяет нейрону активироваться, даже если все входы равны нулю. Это своего рода «порог чувствительности».

Математика одного нейрона

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

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

Простыми словами: мы берем каждый входной параметр, умножаем его на его «важность» (вес), складываем всё вместе и добавляем поправку (смещение).

Пример из жизни: Покупка квартиры

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

* : Цена (низкая — 1, высокая — 0). * : Район (центр — 1, окраина — 0). * : Наличие ремонта (есть — 1, нет — 0).

У вас есть личные предпочтения — это веса ():

* : Для вас критически важна цена (вес большой, например, 5). * : Район важен, но не так сильно (вес средний, например, 2). * : Ремонт вам безразличен, вы любите делать его сами (вес маленький или даже отрицательный, например, 0.5).

Нейрон умножает факты на ваши предпочтения. Если итоговая сумма превысит определенный порог, нейрон скажет «Берем!».

Функция активации: решающий момент

Однако просто посчитать сумму недостаточно. Сумма может быть любым числом: 5, 100, -20. А нам часто нужен конкретный ответ, например, «Да» (1) или «Нет» (0). Для этого полученную сумму мы пропускаем через функцию активации.

В самом первом перцептроне использовалась пороговая функция (функция ступеньки):

Где: * — итоговый выход нейрона. * — взвешенная сумма, которую мы рассчитали ранее. * и — сигналы активации и покоя соответственно.

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

Проблема XOR и первая «Зима ИИ»

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

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

Классический пример — логическая операция XOR (Исключающее ИЛИ). Она выдает «истину» только тогда, когда входы различаются (один 0, другой 1). Если оба входа 0 или оба 1 — результат «ложь».

!Визуализация линейной разделимости и проблемы XOR, которую не может решить один нейрон.

Как видно из визуализации, одной прямой линией разделить точки в задаче XOR невозможно. Это открытие привело к разочарованию инвесторов и началу периода, известного как «Зима искусственного интеллекта». Финансирование прекратилось, и развитие замерло на десятилетие.

Многослойный перцептрон и Глубокое обучение

Решение проблемы оказалось элегантным: если один нейрон (одна прямая) не справляется, давайте объединим их в команду. Так появились Многослойные перцептроны (MLP).

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

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

Входной слой: Принимает данные.

Скрытые слои: Обрабатывают признаки, находят закономерности. Их может быть от одного до сотен.

Выходной слой: Выдает финальный результат.

Термин Глубокое обучение (Deep Learning) означает всего лишь использование нейронных сетей с большим количеством скрытых слоев. Чем глубже сеть, тем более сложные и абстрактные закономерности она может находить.

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

Как сеть учится?

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

Обучение состоит из трех шагов, повторяющихся тысячи раз:

Прямое распространение (Forward Propagation): Данные проходят через сеть, получается предсказание.

Вычисление ошибки (Loss Function): Мы сравниваем предсказание сети с правильным ответом. Разница между ними — это ошибка (Loss).

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

> «Обучение нейросети — это не магия, а итеративный процесс минимизации ошибки путем подкручивания миллионов ручек-весов.»

Почему революция происходит сейчас?

Математика нейросетей (включая метод обратного распространения ошибки) была известна еще в 80-х годах. Почему же ChatGPT, Midjourney и автопилоты появились только сейчас?

Для этого сложились три фактора:

Большие данные (Big Data): Интернетом накоплено колоссальное количество изображений и текстов для обучения.

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

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

Заключение

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

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

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

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

Многие новички совершают ошибку, сразу пытаясь «скормить» нейросети сырые данные. В мире Data Science существует жесткое правило: «Garbage In, Garbage Out» (Мусор на входе — мусор на выходе). Даже самая совершенная архитектура не сможет обучиться на плохих данных. Сегодня мы научимся превращать хаос информации в упорядоченные структуры, понятные машине.

Выбор оружия: Python и его экосистема

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

Для нашего курса нам понадобятся три «кита»:

NumPy (Numerical Python): Фундамент всего. Эта библиотека позволяет работать с многомерными массивами (матрицами) и выполнять сложные математические операции. Нейросети «думают» матрицами, поэтому NumPy будет нашим главным инструментом.

Pandas: Инструмент для работы с табличными данными. Представьте его как «Excel на стероидах», который можно программировать.

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

Установка окружения

Я рекомендую не устанавливать библиотеки по одной, а использовать дистрибутив Anaconda или Miniconda. Это пакетный менеджер, который создает изолированные виртуальные среды, чтобы ваши проекты не конфликтовали друг с другом.

После установки Anaconda, создание среды выглядит так:

Мы также установили Jupyter Notebook. Это интерактивная среда, где код, текст и графики живут в одном документе. Весь наш курс будет построен на работе в таких блокнотах.

Тензоры: Язык, на котором говорят нейросети

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

Тензор — это обобщение понятий скаляра, вектора и матрицы: * Скаляр (Ранг 0): Просто число (например, ). * Вектор (Ранг 1): Массив чисел (например, ). * Матрица (Ранг 2): Таблица чисел (например, черно-белое изображение). * 3D-Тензор (Ранг 3): Куб чисел (например, цветное изображение RGB).

!Визуализация различий между скаляром, вектором, матрицей и тензором.

В NumPy создание вектора выглядит элементарно:

Предварительная обработка данных (Preprocessing)

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

Проблема масштаба

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

Количество комнат: от 1 до 5.

Площадь в квадратных метрах: от 20 до 200.

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

Чтобы избежать этого, мы используем нормализацию или стандартизацию.

Нормализация (Min-Max Scaling)

Этот метод сжимает все данные в диапазон от 0 до 1. Формула выглядит так:

Где: * — новое нормализованное значение. * — исходное значение. * — минимальное значение в этом столбце данных. * — максимальное значение в этом столбце данных.

Стандартизация (Z-score normalization)

Этот метод делает так, чтобы среднее значение данных стало равно 0, а стандартное отклонение — 1. Это предпочтительный метод для большинства нейросетей, так как он лучше справляется с выбросами (аномально большими или маленькими значениями).

Где: * — стандартизированное значение. * — исходное значение. * (мю) — среднее арифметическое всех значений признака. * (сигма) — стандартное отклонение (показатель того, насколько сильно данные разбросаны от среднего).

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

Работа с категориальными данными

Нейросети понимают только числа. Но что делать, если наши данные — это слова? Например, цвет машины: «Красный», «Зеленый», «Синий».

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

Решение — One-Hot Encoding (Унитарное кодирование).

Мы превращаем каждый цвет в отдельный столбец, где 1 означает наличие признака, а 0 — отсутствие.

| Цвет (Исходный) | Is_Red | Is_Green | Is_Blue | | :--- | :---: | :---: | :---: | | Красный | 1 | 0 | 0 | | Зеленый | 0 | 1 | 0 | | Синий | 0 | 0 | 1 |

Теперь все признаки равноправны и выражены числами 0 и 1.

Разделение данных: Обучение и Экзамен

Представьте студента, который готовится к экзамену, просто заучивая ответы на билеты. Если на экзамене попадется тот же билет — он ответит. Но если вопрос немного изменить — он провалится. Это называется переобучение (overfitting).

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

Обучающая выборка (Training set): Обычно 70-80% данных. На этих примерах сеть настраивает свои веса.

Тестовая выборка (Test set): Оставшиеся 20-30%. Эти данные сеть никогда не видела во время обучения. Мы используем их только в самом конце, чтобы проверить реальное качество работы.

!Схематичное разделение набора данных на обучающую и тестовую выборки.

Векторизация: Ускорение в тысячи раз

В Python циклы работают медленно. Если мы будем умножать входы на веса в цикле for, обучение современной сети займет годы. NumPy использует векторизацию — способность процессора выполнять операцию сразу над целым массивом чисел за один такт (SIMD-инструкции).

Вместо:

Мы пишем:

Функция np.dot вычисляет скалярное произведение векторов. Это та самая операция взвешенной суммы, которую мы разбирали в формуле нейрона: . Векторизация позволяет убрать явные циклы из кода и ускорить вычисления в сотни раз.

Заключение

Мы подготовили почву. У нас есть инструменты (Python + NumPy), мы знаем, как привести данные к общему знаменателю (стандартизация), как переводить слова в цифры (One-Hot Encoding) и как честно проверять знания сети (Train/Test split).

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

Архитектура нейросети: слои, функции активации и инициализация весов

В предыдущих статьях мы разобрали историю искусственного интеллекта и подготовили рабочее окружение с Python и NumPy. Мы знаем, что нейросеть состоит из нейронов, которые взвешивают входные данные. Но как именно эти нейроны организованы? Почему простого умножения чисел недостаточно для создания «умной» машины? И с каких значений начинать обучение?

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

Анатомия нейросети: Слои

Представьте нейросеть как конвейер на заводе. Сырье (данные) поступает в начало, проходит через серию станков (слоев), каждый из которых как-то видоизменяет деталь, и в конце мы получаем готовый продукт (предсказание). В классической полносвязной нейронной сети (Feedforward Neural Network) выделяют три типа слоев.

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

1. Входной слой (Input Layer)

Это «глаза» и «уши» нейросети. Входной слой не производит никаких вычислений. Его единственная задача — принять вектор данных и передать его дальше. Количество нейронов здесь строго равно количеству признаков (features) в ваших данных.

* Если вы анализируете цену квартиры по 3 параметрам (площадь, комнаты, район), во входном слое будет 3 нейрона. * Если вы распознаете черно-белое изображение размером 28x28 пикселей, во входном слое будет нейрона.

2. Скрытые слои (Hidden Layers)

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

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

3. Выходной слой (Output Layer)

Этот слой выдает финальный вердикт. Его архитектура зависит от задачи: * Регрессия (предсказание числа): 1 нейрон (например, цена квартиры). * Бинарная классификация (Да/Нет): 1 нейрон (вероятность того, что это кошка). * Многоклассовая классификация: нейронов, где — количество классов (например, 10 цифр от 0 до 9).

Сердце нейросети: Функции активации

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

Почему линейность — это плохо?

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

Где: * — результат работы скрытого слоя. * — матрица весов первого слоя. * — входные данные. * — смещение.

Если второй слой тоже просто умножает вход на веса, то выход сети будет:

Раскроем скобки:

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

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

Сигмоида (Sigmoid)

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

Где: * — значение функции (выход нейрона). * — число Эйлера (основание натурального логарифма, ). * — взвешенная сумма входов.

Где используется: Сейчас в основном только в выходном слое для задач бинарной классификации (вероятность события).

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

ReLU (Rectified Linear Unit)

Король современного глубокого обучения. Несмотря на пугающее название, формула элементарна:

Где: * — выход функции. * — операция выбора максимального из двух чисел: нуля и .

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

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

Преимущества:

Вычислительная эффективность: Компьютеру очень легко сравнить число с нулем, не нужно считать сложные экспоненты.

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

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

Softmax

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

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

Суть проста: Softmax усиливает максимальное значение и подавляет остальные, при этом сумма всех выходов всегда равна 1 (100%).

Инициализация весов: С чего начать?

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

Проблема симметрии

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

> «Если все нейроны одинаковы, то зачем нам много нейронов? Достаточно было бы одного.»

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

Проблема масштаба (Взрыв и затухание)

Однако нельзя брать случайные числа «с потолка». * Если веса слишком маленькие, сигнал будет затухать, проходя через слои, и превратится в ноль. * Если веса слишком большие, сигнал будет лавинообразно расти, вызывая переполнение памяти («взрыв градиента»).

Правильная инициализация

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

Инициализация Ксавье (Xavier/Glorot Initialization): Идеально подходит для симметричных функций активации типа Sigmoid или Tanh. Веса берутся из нормального распределения с учетом количества входов и выходов слоя.

Инициализация Хе (He Initialization): Специально разработана для функции ReLU. Учитывает, что ReLU «убивает» половину нейронов (обнуляет отрицательные), поэтому веса должны быть чуть больше, чтобы сохранить мощность сигнала.

Итоговая архитектура для нашего курса

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

Входной слой: 784 нейрона (пиксели картинки).

Скрытый слой 1: 128 нейронов, функция активации ReLU, инициализация He.

Скрытый слой 2: 64 нейрона, функция активации ReLU, инициализация He.

Выходной слой: 10 нейронов (цифры 0-9), функция активации Softmax.

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

Процесс обучения: функции потерь, оптимизаторы и обратное распространение ошибки

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

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

Прямое распространение (Forward Propagation): Взгляд в будущее

Прежде чем учиться, сеть должна попробовать что-то сделать. Этот процесс называется прямым распространением.

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

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

Функция потерь (Loss Function): Измерение ошибки

Как объяснить машине, что она ошиблась? Сказать «плохо» нельзя — компьютер понимает только числа. Нам нужна формула, которая оценит, насколько сильно сеть ошиблась. Эта формула называется функцией потерь (или Loss Function, Cost Function).

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

Выбор функции потерь зависит от задачи, которую мы решаем.

1. Среднеквадратичная ошибка (MSE) — для регрессии

Если мы предсказываем конкретное число (например, цену квартиры или температуру завтра), мы используем Mean Squared Error (MSE).

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

2. Перекрестная энтропия (Cross-Entropy) — для классификации

Если мы решаем задачу классификации (кошка или собака, цифра 0-9), MSE работает плохо. Здесь используется Categorical Cross-Entropy.

Где: * — значение потери. * — количество классов. * — правильный ответ (1 для верного класса, 0 для остальных). * — натуральный логарифм. * — предсказанная вероятность того, что объект принадлежит классу .

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

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

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

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

В математике «наклон земли» называется градиентом. Градиент показывает направление самого крутого подъема функции. Чтобы уменьшить ошибку, нам нужно двигаться в сторону, противоположную градиенту (антиградиент).

!Визуализация процесса градиентного спуска: поиск минимума функции потерь.

Формула обновления весов

Это самая главная формула во всем глубоком обучении:

Где: * — новое, улучшенное значение веса. * — текущее значение веса. * — градиент (производная ошибки по весу). Это число говорит нам: «Если ты увеличишь вес , ошибка вырастет» (тогда градиент положительный) или «ошибка уменьшится» (градиент отрицательный). * (эта) — Learning Rate (скорость обучения). Это размер шага, который мы делаем.

Скорость обучения (Learning Rate)

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

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

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

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

Здесь на сцену выходит алгоритм Backpropagation (обратное распространение). Он использует цепное правило (Chain Rule) из математического анализа.

Где: * Мы разбиваем сложную производную на цепочку простых. * Мы вычисляем ошибку на выходе. * Затем мы «передаем» эту ошибку назад предыдущему слою, выясняя, какой вклад в ошибку внес каждый нейрон. * Затем идем еще на слой назад.

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

!Схематичное изображение прямого и обратного распространения сигнала в нейросети.

Оптимизаторы: Умный спуск

Классический градиентный спуск (SGD — Stochastic Gradient Descent) имеет недостатки. Он может застревать в локальных минимумах или слишком долго блуждать по равнинам. Чтобы исправить это, придумали более продвинутые алгоритмы обновления весов — оптимизаторы.

1. SGD с моментом (Momentum)

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

2. Adam (Adaptive Moment Estimation)

Это «золотой стандарт» сегодня. Adam объединяет идеи инерции и адаптивного шага. Он делает большие шаги по пологим склонам и маленькие, осторожные шаги по крутым, а также помнит направление движения.

В 95% случаев, когда вы начинаете новый проект, вы будете использовать оптимизатор Adam.

Эпохи и Батчи (Batches)

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

Батч (Batch): Небольшая порция данных (например, 32 или 64 картинки). Сеть смотрит батч, считает среднюю ошибку по нему и делает один шаг спуска (обновляет веса).

Эпоха (Epoch): Это когда сеть увидела весь набор данных (прошла через все батчи). Обычно обучение длится от 10 до 100 эпох.

Итоговый алгоритм обучения

Теперь мы можем собрать весь пазл воедино. Вот что происходит внутри цикла обучения model.fit():

Взять батч данных (например, 64 картинки).

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

Посчитать Loss: Сравнить предсказания с ответами.

Обратное распространение: Вычислить градиенты (кто виноват и насколько).

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

Повторить для следующего батча.

Заключение

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

В следующей статье мы наконец-то откроем Jupyter Notebook и реализуем этот процесс в коде, обучив нашу первую нейросеть распознавать рукописные цифры с точностью выше 95%.

Оценка качества модели, борьба с переобучением и практическое применение

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

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

Метрики качества: за пределами функции потерь

Функция потерь (например, MSE или Cross-Entropy), которую мы обсуждали в прошлой статье, нужна самой нейросети для оптимизации весов. Она дифференцируема и удобна для математики. Но для человека и бизнеса она часто бесполезна. Нам нужны понятные метрики, отвечающие на вопрос: «Насколько хорошо работает система?».

Матрица ошибок (Confusion Matrix)

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

Возможны четыре исхода:

True Positive (TP): Модель сказала «Болен», и пациент действительно болен. (Верное попадание).

True Negative (TN): Модель сказала «Здоров», и пациент здоров. (Верное отрицание).

False Positive (FP): Модель сказала «Болен», но пациент здоров. (Ложная тревога, ошибка I рода).

False Negative (FN): Модель сказала «Здоров», но пациент болен. (Пропуск цели, ошибка II рода).

!Визуальное представление четырех типов исходов классификации

Accuracy (Точность)

Самая интуитивная метрика — это доля правильных ответов.

Где: * — общая точность модели. * — количество верно предсказанных положительных примеров. * — количество верно предсказанных отрицательных примеров. * — общее количество всех примеров в выборке.

Проблема Accuracy: Представьте, что вы ищете редкое заболевание, которое встречается у 1 человека из 100. Если ваша модель будет всем подряд говорить «Здоров», ее Accuracy будет 99%. Звучит круто, но модель абсолютно бесполезна, так как она пропустила всех больных. В таких случаях (несбалансированные выборки) нужны другие метрики.

Precision (Точность срабатывания) и Recall (Полнота)

Эти две метрики всегда идут в паре и показывают разные стороны качества.

Precision отвечает на вопрос: «Из всех, кого модель назвала больными, сколько на самом деле больных?»

Где: * — верно предсказанные положительные. * — ложные срабатывания (здоровые, названные больными).

Высокий Precision важен, когда цена ложной тревоги высока (например, система блокировки спама — мы не хотим, чтобы важное письмо улетело в спам).

Recall отвечает на вопрос: «Какую долю реальных больных модель смогла найти?»

Где: * — верно предсказанные положительные. * — пропущенные положительные (больные, названные здоровыми).

Высокий Recall критичен в медицине или безопасности. Лучше проверить лишний раз здорового человека (низкий Precision), чем пропустить больного (низкий Recall).

F1-Score

Чтобы не выбирать между Precision и Recall, используют их гармоническое среднее:

Где: * — итоговая метрика, объединяющая точность и полноту. * — точность срабатывания. * — полнота охвата.

Эта метрика наказывает модель, если хотя бы один из показателей (Precision или Recall) слишком низкий.

Переобучение (Overfitting): Главный враг нейросетей

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

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

!График, демонстрирующий расхождение ошибок обучения и валидации при переобучении

Причины переобучения:

Слишком сложная модель: Слишком много слоев и нейронов для простой задачи.

Мало данных: Сети проще запомнить 100 картинок, чем найти в них общие черты.

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

Методы борьбы с переобучением (Регуляризация)

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

1. Dropout (Исключение нейронов)

Это удивительно простой и эффективный метод. Во время каждой итерации обучения мы случайным образом «выключаем» (обнуляем) часть нейронов (обычно 20-50%).

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

> Важно: Dropout используется только во время обучения. При реальном использовании (Inference) все нейроны работают на полную мощность.

2. Early Stopping (Ранняя остановка)

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

3. Data Augmentation (Аугментация данных)

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

Например, у нас есть фото кошки. Мы можем: * Повернуть его на 15 градусов. * Отразить зеркально. * Сдвинуть изображение. * Добавить шум.

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

Практическое применение (Inference)

Допустим, мы обучили модель, проверили метрики (F1-score высокий) и убедились в отсутствии переобучения. Что дальше? Как превратить набор весов в полезный продукт?

Этот этап называется Inference (вывод или предсказание).

Сохранение и загрузка

Обучение может занимать дни. Поэтому после обучения веса модели сохраняются в файл (обычно с расширением .h5, .pt или .onnx).

Отличия Inference от обучения

Нет Backpropagation: На этапе использования мы не считаем градиенты и не обновляем веса. Модель «заморожена».

Нет Dropout: Все нейроны включены.

Скорость: Inference проходит намного быстрее обучения, так как это просто один проход прямого распространения (матричные умножения).

Развертывание (Deployment)

Обученная модель может жить где угодно: * На сервере (Backend): Пользователь шлет фото, сервер обрабатывает мощной видеокартой и возвращает ответ. * В браузере (Frontend): С помощью библиотек вроде TensorFlow.js модель работает прямо в браузере клиента. * На мобильном устройстве (Edge AI): Оптимизированные модели работают внутри смартфонов без интернета (например, FaceID).

Заключение курса

В этом цикле статей мы прошли путь от теории перцептрона до стратегий развертывания. Мы узнали:

Как нейроны имитируют мозг.

Как готовить данные, чтобы не получить «мусор на выходе».

Как строить глубокие архитектуры.

Как обучать их с помощью градиентного спуска.

Как оценивать их качество и бороться с переобучением.

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