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

Что такое нейросеть и зачем её писать самому

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

Зачем писать нейросеть с нуля, если есть готовые библиотеки? Во-первых, это лучший способ понять, что происходит «под капотом». Во-вторых, вы сможете адаптировать архитектуру под нестандартные задачи. В-третьих, вы перестанете бояться ошибок и научитесь их исправлять. Даже простая сеть с одним скрытым слоем, написанная на чистом NumPy, даёт глубокое понимание градиентного спуска, обратного распространения и функций активации.

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

Подготовка среды: что установить перед стартом

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

Основные библиотеки:

• NumPy — работа с многомерными массивами и математическими операциями. Без неё не обойтись при реализации прямого распространения и обратного распространения ошибки.
• Matplotlib — визуализация данных и графиков обучения.
• Pandas — удобная загрузка и предобработка табличных данных.
• Scikit-learn — вспомогательные инструменты: разделение на train/test, метрики качества.
• TensorFlow / Keras или PyTorch — фреймворки для быстрого создания и обучения нейросетей (на выбор).

Установка через pip:

pip install numpy matplotlib pandas scikit-learn tensorflow

Если вы предпочитаете PyTorch, команда будет другой: pip install torch torchvision.

Альтернатива — Google Colab. Это бесплатная облачная среда, где уже предустановлены все библиотеки, а главное — есть доступ к видеокарте (GPU). Обучение на GPU происходит в разы быстрее, чем на обычном процессоре. Вам нужен только аккаунт Google. Перейдите на colab.research.google.com, создайте новый блокнот и сразу можете писать код.

Для тех, кто хочет работать локально, убедитесь, что версия Python не ниже 3.8. Если у вас есть дискретная видеокарта NVIDIA, можно установить CUDA и cuDNN, но для первой нейросети это не обязательно — CPU справится с небольшими моделями.

Математическая основа: нейрон, веса, функции активации

Чтобы уверенно писать нейросеть, нужно понимать три ключевые концепции: искусственный нейрон, веса и функции активации.

Искусственный нейрон — это простейший вычислительный элемент. Он получает на вход несколько чисел (x₁, x₂, …, xₙ), каждое из которых умножается на соответствующий вес (w₁, w₂, …, wₙ). Затем все произведения суммируются, и к сумме прибавляется смещение (bias). Результат проходит через нелинейную функцию активации, которая и даёт выход нейрона.

Формула: output = activation(Σ(wᵢ * xᵢ) + b)

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

• Sigmoid — выдаёт значение от 0 до 1. Хороша для бинарной классификации, но страдает от затухающих градиентов.
• ReLU — возвращает 0 для отрицательных аргументов и само значение для положительных. Проста и эффективна, часто используется в скрытых слоях.
• Softmax — превращает выходные значения в вероятности, сумма которых равна 1. Применяется в многоклассовой классификации.

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

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

Пишем нейросеть с нуля на NumPy: прямой проход и обратное распространение

Лучший способ разобраться в механике — реализовать нейросеть без готовых фреймворков. Мы создадим класс SimpleNeuralNetwork с одним скрытым слоем.

Структура сети:

• Входной слой: 2 нейрона (для задачи XOR).
• Скрытый слой: 4 нейрона с сигмоидной активацией.
• Выходной слой: 1 нейрон с сигмоидой.

Прямой проход (forward propagation):

1. Умножаем входные данные на матрицу весов первого слоя и прибавляем смещение.
2. Применяем функцию активации (sigmoid).
3. Повторяем для второго слоя.
4. Получаем предсказание.

Функция потерь: используем бинарную кросс-энтропию. Она показывает, насколько предсказание далеко от истины.

Обратное распространение (backpropagation):

1. Вычисляем градиент ошибки по выходу.
2. Через цепное правило находим градиенты для весов и смещений каждого слоя.
3. Обновляем веса: weight -= learning_rate * gradient.

Ключевые моменты в коде:

• Производная сигмоиды: sigmoid(x) * (1 - sigmoid(x)).
• Градиент для скрытого слоя учитывает вклад всех нейронов следующего слоя.
• Скорость обучения (learning rate) — гиперпараметр, который регулирует шаг обновления весов. Слишком большое значение приводит к расходимости, слишком маленькое — к медленному обучению.

После 10 000 эпох на задаче XOR сеть должна научиться выдавать правильные ответы: 0, 1, 1, 0. Если точность низкая, проверьте инициализацию весов или увеличьте число эпох.

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

Использование TensorFlow и Keras: быстрый старт

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

TensorFlow с Keras — самый популярный выбор для начинающих. Keras предоставляет высокоуровневый API: вы просто добавляете слои в модель.

Пример для задачи XOR:

import tensorflow as tf
from tensorflow import keras
import numpy as np

X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

model = keras.Sequential([
    keras.layers.Dense(4, input_dim=2, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, epochs=1000, verbose=0)

Что здесь важно:

• Dense — полносвязный слой. Первый слой имеет 4 нейрона и ReLU-активацию, второй — 1 нейрон с сигмоидой.
• compile задаёт функцию потерь и оптимизатор. Adam — адаптивный оптимизатор, который хорошо работает «из коробки».
• fit запускает обучение. Параметр verbose=0 скрывает вывод, но можно поставить 1 для отслеживания прогресса.

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

Какой фреймворк выбрать?

• Для быстрого прототипирования и промышленного развёртывания — TensorFlow/Keras.
• Для исследований и экспериментов — PyTorch.
• Для первой нейросети подойдёт любой, но Keras проще в освоении.

Работа с реальными данными: датасет MNIST

Теория — это хорошо, но настоящий опыт приходит при работе с реальными данными. Классический датасет MNIST содержит 70 000 изображений рукописных цифр от 0 до 9. Каждое изображение — 28×28 пикселей в оттенках серого.

Загрузка и подготовка:

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

Нормализация: значения пикселей (0–255) нужно привести к диапазону [0, 1]. Это ускоряет обучение и улучшает сходимость.

x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255

Архитектура сети для MNIST:

• Входной слой: 784 нейрона (28×28).
• Скрытый слой: 128 нейронов с ReLU.
• Выходной слой: 10 нейронов с softmax (вероятности для каждой цифры).

Компиляция и обучение:

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28,28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5, batch_size=32)

Оценка: после обучения проверьте точность на тестовых данных. Обычно простая сеть достигает 97–98%.

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

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

Как улучшить модель: регуляризация, dropout и подбор гиперпараметров

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

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

Dropout — во время обучения случайным образом «выключает» часть нейронов (например, 20–50%). Это заставляет сеть не полагаться на отдельные признаки и улучшает обобщение.

model.add(keras.layers.Dropout(0.5))

Регуляризация L1/L2 — добавляет штраф за большие веса в функцию потерь. L2 (Ridge) — самый распространённый вариант.

keras.layers.Dense(128, activation='relu', kernel_regularizer=keras.regularizers.l2(0.001))

Подбор гиперпараметров:

• Количество слоёв и нейронов. Для MNIST достаточно одного-двух скрытых слоёв. Слишком глубокая сеть на маленьком датасете приведёт к переобучению.
• Скорость обучения (learning rate). Обычно 0.001–0.01. Можно использовать планировщик, уменьшающий скорость со временем.
• Размер батча (batch size). 32–128 — стандартный диапазон. Маленький батч даёт более шумные градиенты, но может помочь выйти из локальных минимумов.
• Количество эпох. Следите за кривой обучения: как только ошибка на валидации перестаёт уменьшаться, останавливайтесь (early stopping).

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

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

Практический пример: фильтр токсичных комментариев

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

Превращаем текст в числа:

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

Архитектура сети:

• Embedding слой (размер словаря, размерность эмбеддинга, длина последовательности).
• Глобальный усредняющий слой (GlobalAveragePooling1D) или LSTM.
• Полносвязный слой с ReLU.
• Выходной слой с сигмоидой.

Пример на Keras:

model = keras.Sequential([
    keras.layers.Embedding(vocab_size, 100, input_length=max_len),
    keras.layers.GlobalAveragePooling1D(),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])

Данные: можно взять готовый датасет токсичных комментариев с Kaggle. Если данных мало, используйте предобученные эмбеддинги (Word2Vec, GloVe).

Обучение: компилируем с binary_crossentropy и adam. После обучения проверяем на тестовых комментариях: модель должна отличать «Ты молодец!» (0) от «Ты ужасен!» (1).

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

Типичные ошибки новичков и как их избежать

Даже опытные разработчики иногда допускают эти ошибки. Вот самые частые:

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

2. Забыли нормализовать данные. Если признаки имеют разный масштаб (один — от 0 до 1, другой — от 0 до 1000), градиентный спуск будет работать нестабильно. Нормализация обязательна.

3. Слишком высокая скорость обучения. Потери начинают расти или oscillate. Уменьшите learning rate или используйте адаптивные оптимизаторы (Adam).

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

5. Переобучение. Высокая точность на train, низкая на test. Добавьте dropout, регуляризацию или уменьшите число слоёв.

6. Игнорирование валидационной выборки. Не оценивайте модель только на train. Всегда выделяйте часть данных для валидации.

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

8. Отсутствие воспроизводимости. Фиксируйте random seed, чтобы результаты можно было повторить.

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

Вопросы и ответы