Сразу к делу. Ниже - полный код нейросети на Python, который решает задачу XOR. Он копируется целиком, запускается и работает. Потом разберем каждую строчку.
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])
np.random.seed(1)
W1 = np.random.uniform(-1, 1, (2, 2))
b1 = np.random.uniform(-1, 1, (2, 1))
W2 = np.random.uniform(-1, 1, (2, 1))
b2 = np.random.uniform(-1, 1, (1, 1))
for epoch in range(10000):
# forward
h = sigmoid(X @ W1 + b1.T)
out = sigmoid(h @ W2 + b2.T)
# loss
loss = np.mean((y - out) ** 2)
# backprop
d_out = (out - y) * sigmoid_derivative(out)
d_W2 = h.T @ d_out
d_b2 = np.sum(d_out, axis=0)
d_h = d_out @ W2.T * sigmoid_derivative(h)
d_W1 = X.T @ d_h
d_b1 = np.sum(d_h, axis=0)
# update
W2 -= 0.1 * d_W2
b2 -= 0.1 * d_b2
W1 -= 0.1 * d_W1
b1 -= 0.1 * d_b1
if epoch % 1000 == 0:
print(f'Epoch {epoch}, Loss: {loss:.6f}')
print('Prediction after training:')
print(out)Писать нейросеть вручную полезно, даже когда есть готовые библиотеки
TensorFlow и PyTorch делают все за тебя. Но когда впервые видишь, как 30 строк numpy превращают случайные числа в предсказания, появляется чутье. Перестаешь воспринимать нейросеть как черный ящик. Внутри - просто умножение матриц, сложение со смещением и функция активации.
Аналогия с механикой: можно всю жизнь ездить на автомобиле и не знать, где поршень. Но если однажды заглохнешь в поле, знание устройства двигателя спасает.
Что решает наша нейросеть на Python
Задача - классическая логическая операция XOR. Ответ 1, если входы разные. Ответ 0, если одинаковые. Звучит просто, но один нейрон с линейной функцией не справляется. Нужен скрытый слой. Поэтому берем архитектуру 2-2-1: два входа, два нейрона в скрытом слое, один выход.
В обучении есть четыре шага, которые повторяются тысячи раз:
- Прямой проход (forward): считаем ответ сети.
- Ошибка (loss): измеряем, насколько ответ далек от правильного.
- Обратное распространение (backprop): распределяем ошибку по слоям.
- Обновление весов: делаем шаг градиентного спуска.
Ниже - каждый из этих шагов в деталях.
Шаг 1. Инициализация: почему np.random.seed(1) - это важно
Перед обучением сети нужны начальные веса. Без случайности они были бы одинаковыми, и сеть не смогла бы различать входы. Но если просто задать случайные числа, каждый запуск даст разный результат. Поэтому в коде стоит строка np.random.seed(1). Она фиксирует генератор случайных чисел. Теперь при каждом запуске программы веса будут одинаковыми. Это нужно для воспроизводимости экспериментов. Меняй архитектуру и скорость обучения. Результат всегда будет объясним: изменения в поведении сети связаны именно с ними, а не с шумом случайности.
Веса и смещения мы берем из равномерного распределения от -1 до 1. Это стандартный трюк, чтобы избежать слишком больших или слишком маленьких значений на старте.
Шаг 2. Прямой проход: как нейросеть считает ответ
Мы передаем входные данные через два слоя. Первый слой: sigmoid(X @ W1 + b1). Матричное умножение X @ W1 - это взвешенная сумма входов. Каждый нейрон скрытого слоя получает сумму своих входов, умноженных на соответствующие веса. Затем прибавляем смещение (bias) и пропускаем через сигмоиду.
Сигмоида - это S-образная функция, которая превращает любое число в диапазон от 0 до 1. Это нелинейность. Именно она позволяет сети разделять сложные нелинейные зависимости вроде XOR. После скрытого слоя получаем матрицу h. Повторяем тот же трюк для второго слоя: sigmoid(h @ W2 + b2). Выход out - предсказание сети, число от 0 до 1. Например, 0.02 или 0.98.
Обратите внимание: мы обрабатываем сразу весь тренировочный набор. Все четыре примера проходят через сеть одновременно, как одна матрица. Это называется пакетная обработка. Она эффективнее, чем по одному примеру, потому что матричные операции в numpy оптимизированы.
Шаг 3. Функция потерь: как измерить ошибку
Сеть дала ответы, но они пока что далеки от правильных. Ошибку считаем как среднеквадратичную разницу между предсказанием и истиной: np.mean((y - out) ** 2). Например, если для примера [0,1] сеть выдала 0.4, а нужно 1, то квадрат разности равен (0.6)^2 = 0.36. Среднее по всем примерам даст число, которое мы будем уменьшать.
Число loss показывает, насколько сеть ошибается. Чем меньше, тем лучше. На старте, при случайных весах, loss будет около 0.27. После обучения он должен упасть до 0.0001 или еще ниже. В консоли увидишь, как это происходит.
Шаг 4. Обратное распространение: как сеть учится
Самая сложная часть, но на самом деле здесь просто применяется цепное правило из матанализа. Сначала вычисляем, как изменился бы ответ out, если бы сеть ошибалась. Это производная функции потерь по выходу, умноженная на производную сигмоиды. Получаем матрицу d_out.
Затем распределяем эту ошибку обратно через второй слой к скрытому: d_h = d_out @ W2.T * sigmoid_derivative(h). Здесь W2.T - транспонированная матрица весов. Так мы понимаем, вклад каждого нейрона скрытого слоя в итоговую ошибку. Дальше - то же самое для первого слоя: d_W1 = X.T @ d_h.
На выходе получаем градиенты для каждой матрицы весов и каждого смещения. Градиент показывает направление, в котором нужно изменить веса, чтобы ошибка уменьшилась.
Шаг 5. Обновление весов: градиентный спуск
У нас есть градиент - вектор, указывающий в сторону наибольшего возрастания ошибки. Мы хотим уменьшить ошибку, значит, двигаемся в противоположном направлении. Формула проста: W2 -= 0.1 * d_W2. Число 0.1 - это скорость обучения. Больше шаг - быстрее сходится, но есть риск перескочить минимум. Меньше шаг - медленнее, но точнее. В примере 0.1 работает хорошо.
Мы повторяем цикл обучения 10000 раз. Это эпохи. На каждой эпохе сеть видит весь тренировочный набор, считает ошибку, распространяет ее обратно и обновляет веса. Постепенно веса подстраиваются так, чтобы предсказания все больше походили на правильные ответы.
В коде стоит вывод ошибки каждые 1000 эпох. Так ты видишь динамику: как loss уменьшается от 0.2761 до 0.0001 и даже ниже.
Что дальше: как перейти от игрушечного примера к реальным задачам
XOR - это классика для понимания, но в жизни никому не нужна нейросеть для решения XOR. Тебе нужно писать продающие тексты, генерировать изображения, делать прогнозы для бизнеса. И вот тут начинается развилка.
Вариант первый - использовать специализированные библиотеки вроде PyTorch. Они абстрагируют все детали, дают готовые слои, оптимизаторы и автоматическое дифференцирование. Пример выше можно переписать на PyTorch за 10 минут, и он будет работать быстрее.
Вариант второй - не изобретать велосипед, а взять готовую мощную нейросеть, которая уже обучена на огромном количестве данных. Например, ChatGPT 6 или Claude Fable 5. Их не нужно обучать. Они уже умеют писать код, анализировать тексты, отвечать на вопросы и даже генерировать изображения.
Разницу чувствуешь сразу. Своя нейросеть на Python - это как велосипед, который ты собрал из запчастей. А современные LLM - это гоночный болид, заправленный и готовый к рекорду.
Вопрос в том, доступен ли тебе такой болид. Если ты в России, то сталкиваешься с блокировками: нужно платить иностранной картой, а ее нет. Напрягает, да. Могу порекомендовать решение, которым сам пользуюсь. ИИ-роутер 3GPT от 3SELLER дает прямой доступ к последним флагманским моделям: ChatGPT 6 Astra, Claude Fable 5, Claude Opus 5.5, а также Nano Banana для изображений и генерации видео. Платить можно российской картой, через СБП или криптой - никаких иностранных карт не нужно. Цена стартует от 149 рублей.
Меняется главное: ты перестаешь думать о том, как оплатить и как подключиться. Просто открываешь сайт, выбираешь модель, и работаешь. Причем за эти деньги получаешь доступ ко всем топовым моделям сразу - это как швейцарский нож, только для нейросетей.
Если хочешь не просто чатиться, а автоматизировать рутину, у 3GPT есть готовые ИИ-агенты. Ты выбираешь агента под свою задачу - например, написание постов или анализ данных - и общаешься с ним. Модель внутри чата можно менять на лету. Заходит в тупик - переключил на другую, и дело пошло.
Лично я такой подход применяю в работе. Когда нужно быстро набросать структуру статьи или сгенерировать идеи для контента, открываю 3GPT и просто спрашиваю. Не приходится возиться с настройкой среды, покупкой API-ключей и прочими прелестями. Все уже готово.
Как сделать свою первую нейросеть лучше: финальные штрихи
Если хочешь закрепить результат на практике, вот несколько шагов, которые реально работают:
- Поменяй скорость обучения. Поставь 0.5 и 0.01. Посмотри, как изменится скорость сходимости. Ощути разницу.
- Измени количество нейронов в скрытом слое. Вместо двух поставь три или четыре. Ошибка может упасть быстрее.
- Попробуй другую функцию активации. Например, tanh вместо сигмоиды. Производная другая, динамика обучения изменится.
- Возьми другой датасет. Например, предсказание цены квартиры по площади и количеству комнат. Нормализуй данные - и увидишь, как сеть обучается на реальных числах.
Эти эксперименты дадут больше, чем чтение теории. Потому что ты уже не просто знаешь - ты видишь, как влияют параметры на поведение сети.
Когда разберешься с базой, не останавливайся. Переходи к готовым большим моделям через 3GPT. Там решишь задачи, которые обычной самописной сети не под силу. Прямой доступ к ChatGPT 6 и Claude Fable 5 открывает возможности, о которых раньше приходилось только мечтать. Заходи на сайт 3GPT, выбирай модель - и вперед.
Помни: нейросеть - это инструмент. Вопрос не в том, чтобы уметь ее написать, а в том, чтобы уметь ее применять. Поэтому следующий шаг простой: запусти код, поиграй с параметрами, а затем попробуй те же задачи на ChatGPT 6 через 3GPT. Разница между самописной сетью и флагманской моделью почувствуется сразу.