Нейронные сети: заглядываем внутрь «черного ящика»

От биологического нейрона к математической модели

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

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

Как природа принимает решения

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

У биологического нейрона есть три главные части:

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

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

В 1957 году нейрофизиолог Фрэнк Розенблатт решил перенести этот биологический механизм в математику. Так появилась первая математическая модель нейрона — перцептрон.

Анатомия искусственного нейрона

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

В математической модели биологические термины заменили на числа:

Входы ( $x$ ) заменяют дендриты. Это данные, которые мы подаем в нейрон. Обычно это числа, например $1$ (да) или $0$ (нет).
Веса ( $w$ ) заменяют синапсы (силу связи между клетками). Это самое важное понятие в нейросетях. Вес показывает, насколько важен конкретный входной сигнал.
Сумматор заменяет тело клетки. Он умножает каждый вход на его вес и складывает их вместе.
Функция активации заменяет порог возбуждения. Она решает, достаточно ли накопленной суммы, чтобы выдать финальный ответ.

Пример: Нейрон решает, идти ли в кино

Давайте создадим один искусственный нейрон, задача которого — решить, стоит ли вам сегодня вечером пойти в кино. Наш нейрон будет учитывать три фактора (это наши входы $x$ ):

Вышел ли фильм с любимым актером? ( $x_1$ )
Идут ли с вами друзья? ( $x_2$ )
Нужно ли завтра рано вставать? ( $x_3$ )

Допустим, сегодня ситуация такая: любимый актер играет ( $x_1 = 1$ ), друзья не могут пойти ( $x_2 = 0$ ), а завтра нужно рано вставать ( $x_3 = 1$ ).

Теперь расставим веса ( $w$ ) — приоритеты. Для вас присутствие любимого актера — это очень важно, дадим этому фактору вес $w_1 = 3$ . Компания друзей — приятно, но не критично, вес $w_2 = 1$ . А вот ранний подъем — это сильный аргумент против похода в кино. Поэтому вес будет отрицательным: $w_3 = -4$ .

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

S = (x_1 \cdot w_1) + (x_2 \cdot w_2) + (x_3 \cdot w_3)

Подставляем наши числа: $S = (1 \cdot 3) + (0 \cdot 1) + (1 \cdot -4)$ $S = 3 + 0 - 4$ $S = -1$

Функция активации: принятие решения

Мы получили сумму $S = -1$ . Но нейрон должен дать четкий ответ: $1$ (идем в кино) или $0$ (остаемся дома).

Здесь в дело вступает функция активации. В самом простом случае (как в оригинальном перцептроне) это жесткий порог. Например, мы задаем правило: «Если итоговая сумма больше или равна нулю ( $S \geq 0$ ), то ответ 1. В противном случае ответ 0».

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

В нашем примере сумма равна $-1$ . Это меньше нуля. Значит, функция активации выдает $0$ . Нейрон принял решение: сегодня в кино мы не идем, потому что необходимость рано вставать (вес $-4$ ) перевесила желание посмотреть на любимого актера (вес $3$ ).

От одного нейрона к интеллекту

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

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

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

Как нейроны объединяются в сеть: слои и связи

Один нейрон способен принять решение на основе нескольких факторов. Но что, если задача сложнее? Представьте, что вам нужно отличить рукописную цифру «8» от «3». Одиночный математический нейрон с этим не справится: он может лишь провести прямую линию, разделив мир на «да» и «нет». Чтобы решать по-настоящему сложные задачи, нейронам нужно объединиться в систему, где результат работы одних становится отправной точкой для других.

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

Архитектура сети: разделение труда

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

Тип слоя	Роль в сети	Аналогия
Входной слой	Принимает сырые данные из внешнего мира. Нейроны здесь ничего не вычисляют, они просто передают числа дальше.	Рецепторы на сетчатке глаза, улавливающие свет.
Скрытые слои	Внутренняя часть сети. Именно здесь происходит вся магия вычислений. Слоев может быть от одного до нескольких сотен.	Зрительная кора мозга, анализирующая формы и контуры.
Выходной слой	Выдает финальный результат. Количество нейронов здесь зависит от задачи.	Принятие итогового решения: «Я вижу кота».

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

Если во входном слое 3 нейрона, а в первом скрытом — 4, между ними будет ровно 12 связей. И у каждой из этих 12 связей есть свой собственный вес ( $w$ ), который определяет, насколько сильно один нейрон влияет на другой. В современных сетях количество таких весов исчисляется миллиардами.

Как скрытые слои извлекают смысл

Скрытые слои называются «скрытыми», потому что мы, как пользователи, не видим их работу напрямую: мы подаем данные на вход и получаем ответ на выходе. Но именно внутри них сеть строит понимание мира.

Каждый следующий слой ищет в данных все более сложные закономерности. Рассмотрим это на примере распознавания черно-белой картинки размером 28×28 пикселей, на которой от руки написана цифра «8».

Входной слой состоит из 784 нейронов (28 умножить на 28). Каждый нейрон получает яркость одного конкретного пикселя.
Первый скрытый слой получает сигналы от пикселей. Его нейроны настроены так, чтобы реагировать на базовые детали: вертикальные линии, горизонтальные черточки, резкие перепады контраста.
Второй скрытый слой комбинирует информацию от первого. Его нейроны «загораются» (выдают высокий сигнал), когда видят более сложные фигуры. Один нейрон может научиться распознавать верхний круг, а другой — нижний круг.
Выходной слой состоит из 10 нейронов (цифры от 0 до 9). Нейрон, отвечающий за цифру «8», получит мощные сигналы от нейронов второго слоя, которые нашли «верхний круг» и «нижний круг». Взвешенная сумма превысит порог, и сеть выдаст уверенный ответ: это восьмерка.

Сеть не запоминает картинку целиком. Она разбирает ее на запчасти, а затем собирает из них смысловые концепции. Чем глубже слой, тем более абстрактные вещи он понимает.

Зачем нужна функция активации в сети

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

Представьте, что вы умножаете число на 2, а затем результат умножаете на 3. Это то же самое, что сразу умножить исходное число на 6. Если нейроны будут выполнять только сложение и умножение, то цепочка из ста скрытых слоев математически схлопнется — ее можно будет заменить одним-единственным слоем с другими весами. Сеть потеряет способность решать сложные задачи.

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

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

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

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

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

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

Прямой проход: от данных к догадке

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

Представим, что мы учим сеть отличать кошек от собак. Договоримся, что идеальный ответ для собаки — это $1$ , а для кошки — $0$ .

Мы подаем на вход картинку собаки. Сеть проводит вычисления и на выходном слое выдает число $0.2$ . Это значит, что сеть думает: «Я на 20% уверена, что это собака, и на 80% — что кошка». Сеть ошиблась. Но как объяснить математической модели, насколько сильно она неправа?

Функция потерь: измеряем глубину заблуждений

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

Самый простой и популярный способ измерить ошибку — использовать формулу среднеквадратичной ошибки:

E = (y - \hat{y})^2

Разберем её элементы:

$E$ — итоговая ошибка (Error).
$y$ — истинный ответ, который мы ожидаем (в нашем случае $1$ , так как на фото собака).
$\hat{y}$ — предсказание нашей сети (в нашем случае $0.2$ ).

Подставим наши значения: $E = (1 - 0.2)^2 = 0.8^2 = 0.64$ . Ошибка нашей сети для этой картинки равна $0.64$ .

Почему мы возводим разность в квадрат? Представьте, что мы показали сети кошку (истинный ответ $0$ ), а она выдала $0.3$ . Разность составит $0 - 0.3 = -0.3$ . Если мы начнем складывать ошибки для разных картинок без возведения в квадрат, положительные ошибки (для собак) и отрицательные (для кошек) просто компенсируют друг друга. Сеть будет думать, что в среднем она работает идеально, хотя на деле ошибается каждый раз. Квадрат делает все ошибки положительными и сильнее «штрафует» сеть за крупные промахи.

Как организовано обучение: датасеты, эпохи и батчи

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

Процесс прогона данных через сеть организован циклично. Здесь важно понимать два ключевых термина:

Эпоха (Epoch) — это один полный проход всего датасета через нейросеть. Если в вашей выборке 10 000 фотографий, и сеть посмотрела их все по одному разу, прошла ровно одна эпоха. Обычно для хорошего обучения требуются десятки или сотни эпох.
Батч (Batch) — это небольшая порция данных, после которой сеть обновляет свои веса.

Зачем нужны батчи? Если обновлять веса после каждой отдельной картинки, сеть будет «бросать» из стороны в сторону: собака потянет веса в одну сторону, следующая за ней кошка — в противоположную. Если же ждать конца эпохи и обновлять веса только после просмотра всех 10 000 картинок, обучение будет идти слишком медленно, а компьютеру не хватит оперативной памяти.

Батч — это золотая середина. Мы показываем сети, например, 32 картинки одновременно. Она считает среднюю ошибку для этой группы и делает один аккуратный шаг к исправлению весов.

Что дальше?

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

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

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

Обратное распространение ошибки и градиентный спуск простыми словами

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

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

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

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

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

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

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

Правило обновления каждого веса в сети можно описать простой логикой: Новый вес = Старый вес - (Шаг обучения × Уклон)

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

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

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

Здесь на сцену выходит алгоритм обратного распространения ошибки (backpropagation). Его суть — в справедливом распределении «вины» за итоговую ошибку между всеми нейронами сети.

Рассмотрим пример из жизни. Представьте кухню дорогого ресторана. Клиент возвращает блюдо и жалуется: «Слишком соленое и жесткое!» (это наша функция потерь). Шеф-повар (выходной слой) не готовил всё сам. Он вызывает су-шефов (последний скрытый слой) и говорит: «Мясо пересушено, а соус пересолен». Су-шеф, отвечающий за соус, идет к своему помощнику (предыдущий скрытый слой) и говорит: «Ты добавил слишком много соли в базу». Помощник понимает, что ему нужно изменить свою рецептуру (скорректировать вес связи).

Сигнал об ошибке распространяется строго в обратном направлении: от клиента к шеф-повару, затем к су-шефам, затем к рядовым поварам.

В нейросети происходит то же самое с помощью математического правила дифференцирования (цепного правила).

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

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

Полный цикл обучения: собираем всё вместе

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

Прямой проход (Forward pass): Сеть получает данные (например, картинку), пропускает их через все слои от начала к концу и делает предсказание.
Вычисление потерь (Loss): Сеть сравнивает предсказание с правильным ответом и вычисляет общую ошибку.
Обратное распространение (Backpropagation): Сигнал об ошибке идет от конца к началу. Сеть вычисляет градиент (уклон) для каждого веса — насколько каждый вес виноват в ошибке.
Градиентный спуск (Gradient descent): Сеть обновляет значения всех весов, делая шаг «вниз по склону», чтобы в следующий раз ошибка стала чуть меньше.

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

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

Ограничения «черного ящика» и почему нейросети иногда ошибаются

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

Дело в том, что математическая оптимизация не равнозначна человеческому пониманию.

Проблема интерпретируемости: почему ящик «черный»

В классическом программировании мы пишем четкие правила: if color == 'white' and shape == 'rectangle'. Если программа ошибается, мы можем открыть код, найти нужную строку и понять логику сбоя.

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

Нейросеть не учит суть объектов. Она находит статистические корреляции (совпадения) между пикселями на входе и правильными ответами на выходе.

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

Эффект Умного Ганса и смещение данных

В начале XX века в Германии жил конь по кличке Умный Ганс. Хозяин утверждал, что конь умеет считать: ему задавали математический пример, и он отстукивал копытом правильный ответ. Позже ученые выяснили, что конь не знал математики. Он просто внимательно следил за языком тела хозяина и зрителей: когда количество ударов копытом приближалось к правильному ответу, люди непроизвольно напрягались, а когда конь делал нужный удар — расслаблялись. Ганс реагировал на это расслабление и останавливался.

Нейросети постоянно повторяют трюк Умного Ганса. Это явление связано со смещением данных (bias) в датасетах.

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

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

Переобучение: зубрежка вместо понимания

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

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

Если дать ему задачу в точности из учебника, он решит ее мгновенно. Но стоит изменить в условии $x = 5$ на $x = 6$ , как студент впадает в ступор — такой строчки в его памяти нет.

Точно так же ведет себя переобученная нейросеть.

Признак	Хорошее обучение (Обобщение)	Переобучение (Зубрежка)
Ошибка на тренировочных данных	Низкая	Практически нулевая (идеальная)
Ошибка на новых данных	Низкая	Очень высокая
Что выучила сеть	Общие закономерности (формы, контуры)	Шум, фон, конкретные пиксели конкретных картинок

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

Иллюзия уверенности: отсутствие «Я не знаю»

У людей есть важное когнитивное свойство: столкнувшись с чем-то абсолютно неизвестным, мы осознаем свое незнание.

Базовые нейросети так не умеют. Их выходной слой устроен так, что сумма вероятностей всех возможных ответов всегда должна равняться $100\%$ .

Если вы обучили сеть распознавать только два класса — «кошка» и «собака», а затем покажете ей фотографию тостера, она не скажет «это тостер» или «я не знаю». Она прогонит пиксели тостера через свои веса и выдаст что-то вроде: с вероятностью $80\%$ это собака, а с вероятностью $20\%$ — кошка.

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

Итог

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

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

Архитектуры сверточных (CNN) и рекуррентных (RNN) нейросетей

Обычная фотография со смартфона в разрешении Full HD (1920 на 1080 пикселей) состоит примерно из 2 миллионов точек. Поскольку каждый пиксель цветного изображения содержит три канала (красный, зеленый, синий), на вход нейросети поступает более 6 миллионов чисел. Если мы попытаемся передать эту картинку в уже знакомую нам полносвязную сеть, где каждый нейрон первого скрытого слоя (допустим, их всего 1000) соединяется с каждым входом, нам потребуется 6 миллиардов весов только для первого шага.

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

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

Сверточные сети (CNN): зрение через фильтры

Когда вы смотрите на кота, вы не анализируете каждый волосок одновременно. Ваш мозг сначала замечает перепады света и тени, затем складывает их в контуры, контуры — в формы (уши, усы), а формы — в целостный образ. Сверточные нейронные сети (Convolutional Neural Networks) работают точно так же.

Вместо того чтобы смотреть на всю картинку целиком, CNN сканирует её небольшим «окном» — фильтром (или ядром).

Представьте себе квадрат $3 \times 3$ пикселя. Это и есть фильтр. Он накладывается на левый верхний угол изображения, умножает значения пикселей картинки на свои собственные веса, складывает их и выдает одно число. Затем фильтр сдвигается на шаг вправо и повторяет операцию, пока не «пройдется» по всей картинке.

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

Сжатие пространства: пулинг

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

Здесь вступает в игру операция пулинга (pooling), чаще всего — Max Pooling. Сеть снова берет небольшое окно, например $2 \times 2$ , накладывает его на карту признаков и оставляет только одно, самое большое значение, отбрасывая остальные три.

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

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

Рекуррентные сети (RNN): чтение с памятью

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

Прочитайте предложение: «Я вырос во Франции, поэтому сейчас я свободно говорю по-...». Чтобы подставить слово «французски», вам нужно помнить начало предложения. Стандартная сеть и CNN обрабатывают каждый вход изолированно. Для них первое слово и десятое никак не связаны. У них нет памяти.

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

Когда RNN читает текст, она читает его по одному слову за раз. На каждом шаге сеть обновляет свое скрытое состояние (hidden state) — своеобразную кратковременную память.

Математически этот шаг выглядит так: $h_t = f(W_x \cdot x_t + W_h \cdot h_{t-1})$

Разберем элементы формулы:

$x_t$ — текущее слово, которое сеть читает прямо сейчас (например, «Франции»).
$h_{t-1}$ — скрытое состояние (память), накопленное после прочтения всех предыдущих слов («Я», «вырос», «во»).
$W_x$ и $W_h$ — веса, которые определяют, насколько важно новое слово и насколько важен прошлый контекст.
$h_t$ — обновленная память, которая будет передана следующему слову.
$f$ — функция активации, сжимающая результат, чтобы числа не росли до бесконечности.

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

Общий секрет: разделение весов

На первый взгляд, CNN для картинок и RNN для текста не имеют ничего общего. Но под капотом они используют один и тот же гениальный математический трюк — разделение весов (weight sharing).

В полносвязной сети каждый пиксель или каждое слово умножается на свой уникальный вес. В CNN один и тот же фильтр (набор из 9 весов) скользит по всей картинке. Сеть использует одни и те же веса, чтобы найти кота и в левом, и в правом углу фото. В RNN одна и та же матрица весов $W_x$ и $W_h$ применяется к каждому слову в предложении, будь оно первым или сотым.

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

Предел человеческой памяти

RNN стали прорывом в машинном переводе и распознавании речи. Но вскоре разработчики столкнулись с суровой реальностью. Формула обновления памяти $h_t$ работает как испорченный телефон.

Если предложение состоит из 5 слов, сеть легко помнит первое. Но если на вход подать абзац из 100 слов, постоянное перезаписывание скрытого состояния приводит к тому, что информация из начала текста «размывается» и забывается. Сеть теряет нить повествования. Эта проблема получила название «затухание градиента».

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

Архитектура Transformer и механизмы внимания (Attention)

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

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

В 2017 году исследователи из Google предложили радикальную идею: давайте вообще откажемся от пошаговой обработки. Пусть нейросеть смотрит на все слова одновременно и сама решает, куда ей направить свое внимание. Так появилась архитектура Transformer и ее главное оружие — механизм Self-Attention (самовнимание).

Механизм Self-Attention: кто на кого смотрит

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

Возьмем слово с несколькими значениями: «Замок».

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

Механизм внимания позволяет слову «замок» посмотреть на своих соседей, математически оценить их важность и впитать их смысл.

Как это работает внутри: Query, Key, Value

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

Query (Q) — запрос. То, что слово «ищет» в других словах.
Key (K) — ключ. То, что слово «сообщает» о себе другим.
Value (V) — значение. Фактический смысл слова, который оно передаст, если на него обратят внимание.

Метафора: вы (Query) приходите в библиотеку и ищете книгу по истории. Вы идете вдоль полок и читаете корешки книг — это их теги (Key). Когда вы находите идеальное совпадение запроса и корешка, вы достаете книгу и читаете ее содержимое (Value).

Математически сила связи (внимание) между двумя словами вычисляется через умножение их векторов запроса и ключа:

$w = Q \cdot K$

Где:

$w$ — итоговый вес внимания (насколько сильно первое слово должно учитывать второе).
$Q$ — вектор-запрос текущего слова.
$K$ — вектор-ключ другого слова в предложении.
$\cdot$ — операция скалярного умножения (чем больше векторы похожи друг на друга, тем выше результат).

Если вектор запроса $Q$ слова «замок» (ищущего признаки строения) совпадает с вектором ключа $K$ слова «древний» (сообщающего о возрасте здания), вес внимания $w$ будет очень высоким. Слово «замок» впитает в себя смысл слова «древний» (его Value).

Архитектура Transformer: отказ от времени

Механизм Self-Attention оказался настолько мощным, что создатели архитектуры Transformer полностью удалили из сети рекуррентные слои (RNN).

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

Но здесь возникает парадокс. Если мы подаем все слова в сеть одновременно, как она поймет порядок слов? Для нейросети фразы «Собака кусает человека» и «Человек кусает собаку» будут состоять из абсолютно одинакового набора слов.

Positional Encoding: номера в очереди

Чтобы решить эту проблему, в архитектуру Transformer добавили механизм Positional Encoding (позиционное кодирование).

Перед тем как слова попадут в слои внимания, к каждому слову приклеивается математическая «бирка» с его порядковым номером в предложении.

$X_{final} = X_{word} + P_{pos}$

Где:

$X_{final}$ — итоговые данные, которые уходят в нейросеть.
$X_{word}$ — числовое представление смысла самого слова (например, векторы для слова «собака»).
$P_{pos}$ — специальный вектор, кодирующий позицию слова (например, «слово №1»).

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

Эволюция «черного ящика»: подводим итоги

Сравним два подхода к обработке текста, чтобы увидеть масштаб изменений:

Характеристика	Рекуррентные сети (RNN)	Transformer
Способ чтения	Шаг за шагом, слева направо	Все слова одновременно
Контекст	Сжимается в единый вектор памяти	Вычисляется напрямую между любыми словами
Обучение	Медленное (нельзя распараллелить)	Очень быстрое (идеально для GPU)
Длинные тексты	Забывают начало к концу абзаца	Удерживают связи на тысячи страниц

Именно архитектура Transformer стала фундаментом для революции больших языковых моделей (LLM). Аббревиатура GPT расшифровывается как Generative Pre-trained Transformer (Генеративный предварительно обученный трансформер).

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

Сеть состоит из слоев и нейронов, соединенных миллионами весов.
В процессе обучения через градиентный спуск эти веса были настроены так, чтобы минимизировать функцию потерь.
На вход поступает текст, к которому добавляется Positional Encoding.
Механизмы Self-Attention (миллиарды операций $Q \cdot K$ ) просчитывают контекстные связи между каждым словом вашего промпта.
Сеть предсказывает наиболее вероятное следующее слово, опираясь на извлеченные признаки.

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