Как создать свою нейросеть с нуля и обучить её

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

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

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

Содержание

• Что такое нейросеть и как она учится
• На каком языке программируют нейросети
• Обучаем собственную нейросеть
• Что дальше

Что такое нейросеть и как она учится

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

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

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

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

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

Читайте также:

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

На каком языке программирования создают нейросети

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

Кроме того, у Python есть развитая экосистема инструментов и библиотек для работы с данными и обучения нейросетей:

• NumPy — библиотека для работы с числами и многомерными массивами. Она позволяет быстро выполнять математические операции и преобразовывать данные в формат, подходящий для нейросети.
• Pandas — инструмент для загрузки и обработки данных в таблицах. С его помощью можно читать файлы CSV и Excel, удалять дубликаты, заполнять пропуски и выбирать нужные строки и столбцы.
• Matplotlib — библиотека для визуализации данных. Она помогает строить графики точности и ошибки, показывать изображения и наглядно оценивать результаты обучения.
• TensorFlow и PyTorch — фреймворки для создания и обучения нейросетей. В них можно добавлять слои, выбирать функцию потерь и оптимизатор, запускать обучение, проверять качество и сохранять готовую модель

Однако Python — не единственный язык, на котором разрабатывают нейросети. Выбор зависит от задачи и требований проекта:

• C++ используют, когда важна скорость работы и экономичное потребление памяти. Например, его применяют для нейросетей в беспилотных автомобилях и роботах. Кроме того, многие популярные библиотеки машинного обучения написаны на C++, хотя разработчики управляют ими через Python.
• JavaScript позволяет запускать готовые модели прямо в браузере. Например, сайт может распознавать изображение с веб-камеры или анализировать текст без отправки данных на сервер.
• Kotlin и Swift применяют в мобильной разработке. Kotlin используют для приложений на Android, а Swift — для программ на iPhone, iPad и других устройствах Apple. Обычно нейросеть сначала обучают на Python, а затем переносят готовую модель в мобильное приложение.

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

Как создать и обучить собственную нейросеть

Теперь перейдём к практике и обучим собственную нейросеть для распознавания рукописных цифр. Будем писать код на Python и использовать готовые инструменты TensorFlow. Для обучения возьмём уже готовый датасет.

Шаг 1: формулируем задачу и выбираем метрику качества

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

Например, задачу распознавания рукописных цифр можно сформулировать так: «Нейросеть получает чёрно-белое изображение размером 28×28 пикселей и должна определить, какая цифра от 0 до 9 на нём изображена».

В таком случае:

• входные данные — изображение;
• результат — одна из десяти цифр;
• ответы можно проверять по подписи к изображению или визуально.

Ещё надо выбрать метрику — числовой показатель качества модели. Для распознавания цифр подойдёт accuracy (с англ. «точность»). Она показывает долю правильных ответов: accuracy 97% означает, что нейросеть верно распознаёт 97 изображений из 100.

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

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

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

Шаг 2: устанавливаем Python и настраиваем окружение

На первом шаге надо убедиться, что у вас уже установлен Python. Для этого откройте терминал и выполните команду python3 --version. Если в терминале появится Python 3.10, 3.11 или 3.12, то можно продолжать работать.

Если Python отсутствует или установлена другая версия, скачайте последний установщик Python 3.12 с официального сайта. После установки откройте терминал и снова выполните команду python3 --version. В окне должно появиться что-то вроде Python 3.12.x.

Читайте также:

Как запустить Python офлайн и онлайн: руководство для новичка

Создайте папку проекта на рабочем столе с помощью интерфейса операционной системы или выполните команду mkdir -p ~/Desktop/neural-network-demo. После этого откройте папку в терминале с помощью команды cd ~/Desktop/neural-network-demo.

Чтобы библиотеки не конфликтовали с другими Python-проектами, создайте виртуальное окружение. Для этого в терминале выполните команду python3.12 -m venv .venv, а после активируйте окружение с помощью команды source .venv/bin/activate. Если вы всё сделали правильно, то в начале строки терминала должно появиться (.venv).

Теперь обновите установщик пакетов, чтобы получить из него свежие версии библиотек и фреймворков. Для этого выполните в терминале команду python -m pip install --upgrade pip и дождитесь сообщения Successfully installed pip-x.x.x.

В этом проекте мы будем обучать модель с помощью TensorFlow, поэтому установите библиотеку с помощью команды python -m pip install tensorflow. Проверьте установку, введя в терминале python -c «import tensorflow as tf; print ('TensorFlow: ', tf.__version__); print (tf.reduce_sum (tf.random.normal ([1000, 1000])))». Если всё прошло успешно, то в ответ появится строка следующего вида:

TensorFlow: 2.x.x
tf.Tensor(..., shape=(), dtype=float32)

Читайте также:

Библиотека TensorFlow: пишем нейросеть и изучаем принципы машинного обучения

Шаг 3: загружаем и подготавливаем данные

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

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

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

Например, все изображения цифр можно сделать чёрно-белыми, уменьшить до размера 28×28 пикселей и привести яркость пикселей к диапазону от 0 до 1. Тогда нейросеть сможет обрабатывать все данные по одному алгоритму.

После подготовки датасет разделяют на три части:

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

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

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

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

Шаг 4: выбираем архитектуру нейросети

Архитектура — это устройство нейросети: какие слои в неё входят, сколько в них нейронов и как они связаны друг с другом.

Тип архитектуры зависит от данных и задачи:

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

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

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

Шаг 5: создаём и обучаем модель

Создадим в папке проекта файл train.py и скопируйте в него следующий код:

import tensorflow as tf

# Загружаем изображения цифр и правильные ответы
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Переводим яркость пикселей из диапазона 0–255 в диапазон 0-1
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# Описываем архитектуру нейросети
model = tf.keras.Sequential([
    tf.keras.Input(shape=(28, 28)),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation="relu"),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10)
])

# Указываем способ обучения
model.compile(
    optimizer="adam",
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=["accuracy"]
)

# Обучаем модель
model.fit(
    x_train,
    y_train,
    epochs=5,
    validation_split=0.1
)

# Проверяем модель на тестовых данных
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"Точность на тесте: {test_accuracy:.3f}")

# Сохраняем модель
model.save("digit_model.keras")

Перед запуском обучения мы указываем модели функцию потерь и оптимизатор.

Функция потерь показывает, насколько предсказание нейросети отличается от правильного ответа. Чем меньше её значение, тем лучше модель справляется с задачей.

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

Само обучение проходит следующим образом:

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

В нашем примере модель проходит по данным пять раз — пять эпох.

Параметр validation_split=0.1 отделяет 10% обучающих данных для валидации. Эти изображения не используются для изменения весов, а помогают следить за тем, как модель работает на отложенных примерах.

Шаг 6: запускаем обучение и оцениваем результат

Чтобы начать обучение, запустите файл train.py с помощью команды python train.py. При первом запуске TensorFlow скачает датасет MNIST, а в терминале появится информация о пройденных эпохах обучения.

После каждой эпохи TensorFlow выводит метрики:

• accuracy — точность на обучающих данных;
• loss — ошибка модели;
• val_accuracy — точность на отложенных валидационных данных;
• val_loss — ошибка на отложенных валидационных данных.

После всех эпох обучения в терминале появится финальная точность на тестовых данных. Результат около 0,97-0,98 означает, что модель правильно распознаёт примерно 97-98% тестовых цифр.

Если обучение прошло успешно, то в папке нашего проекта появится файл digit_model.keras — это и есть обученная нейросеть.

Шаг 7: тестируем нейросеть

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

import numpy as np
import tensorflow as tf

# Загружаем сохранённую модель
model = tf.keras.models.load_model("digit_model.keras")

# Загружаем тестовые изображения
(_, _), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_test = x_test.astype("float32") / 255.0

# Случайно выбираем десять разных изображений
rng = np.random.default_rng()
indices = rng.choice(len(x_test), size=10, replace=False)

images = x_test[indices]
correct_answers = y_test[indices]

# Передаём все десять изображений нейросети
scores = model.predict(images, verbose=0)
predictions = tf.argmax(scores, axis=1).numpy()

# Выводим результаты
correct_count = 0

for number, (prediction, correct_answer) in enumerate(
    zip(predictions, correct_answers),
    start=1
):
    is_correct = prediction == correct_answer

    if is_correct:
        correct_count += 1

    result = "✅ верно" if is_correct else "❌ ошибка"

    print(
        f"{number}. Ответ нейросети: {prediction}; "
        f"правильный ответ: {correct_answer} -- {result}"
    )

print(f"\nПравильных ответов: {correct_count} из 10")

Сохраним файл и запустим его в терминале с помощью команды python predict.py. В ответ получим следующее.

Что дальше

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

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

Замените датасет. MNIST — это классический учебный набор, но принцип работы нейросети остаётся тем же и на других данных. Попробуйте датасет Fashion-MNIST с изображениями одежды или CIFAR-10 с цветными фотографиями животных и транспорта. Задача усложнится, и вы увидите, что для картинок, которые сложнее простых цифр, обычных полносвязных слоёв уже недостаточно.

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

Попробуйте свои данные. Самое интересное начинается, когда нейросеть решает вашу собственную задачу. Соберите небольшой датасет — например, фотографии для классификации или таблицу с данными для прогноза — и обучите на нём модель. Здесь пригодятся Pandas для подготовки данных и Matplotlib для визуализации результатов.

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

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