Создание нейросети -фото: гайд для новичков, обучение с учителем и код без библиотек

Что такое нейросеть простыми словами

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

Немного необходимой теории.

Вероятно вы уже множество раз прочитали что‑нибудь подобное, так что постараюсь покороче. Говоря простым языком: нейронная сеть — несколько слоев, состоящих из искусственных нейронов и синапсов, которые их соединяют. Значение нейрона формируется из активированной суммы дочерних нейронов, умноженных на вес их синапсов. Первый (следующий после нулевого) слой формируется из активированных входных данных, тоже умноженных на веса синапсов. Обычно веса синапсов изначально генерируются случайно, а потом корректируются в зависимости от процесса обучения. «Активированное значение» — значение, которое преобразовано с помощью выбранной функции активации.

Почти переходим к практике

Дело в том, что когда я «твердо решил написать свою нейросеть», я совершенно не подумал о том, какую задачу эта нейросеть будет решать, так что это я решил на ходу:

Задумавшись над задачей для нейронной сети, я решил выбрать что‑нибудь подходящее под два критерия: наглядное, чтобы на выходом было какое‑то графическое действие и не очень тяжелое, ибо мой текущий компьютер не справится. После длительного отбора идей, я вспомнил статью про эксперименты над обучением одноклеточных организмов и пришел к выводу, что правильным решением будет создать примитивную нейросеть, которая будет выполнять роль клетки в чашке Петри. Предварительный анализ задачи показал, что логичней будет ограничить поле зрения: я выбрал поле 5 на 5 вокруг клетки. В итоге я решил сделать нейронную сеть, имеющую входной слой в 25 нейрона, скрытый в 16 и выходной слой в 14. Почему именно столько? В конструировании нейросетей нет четких правил, но для нашей задачи больше одного слоя не требуется (вообще эта задача может решаться без скрытых слоев вообще, но тогда у нейросети будут очень примитивные решения) количество нейронов в скрытом слою, принято делать между количеством во входном и выходном, а дальше корректировать, в зависимости от эмпирических данных, так что спустя несколько попыток, я выбрал именно 16. Ещё нужна функция активации, чтобы значение нейрона для удобства варьировалось между -1 и 1. Я выбираю стандартный гиперболический тангенс, который на самом деле является модифицированной экспонентой.

Шаг 1: Установите Python и библиотеки

Установите Python 3.10+ с. Затем в терминале: pip install tensorflow numpy matplotlib. TensorFlow — фреймворк от Google для создания нейросетей. NumPy — работа с массивами чисел. Matplotlib — визуализация результатов. Альтернатива: PyTorch от Meta (pip install torch) — более «питонический» синтаксис, популярен в исследованиях. Для первого проекта оба подходят одинаково.

Шаг 2: Подготовьте данные

Для первого проекта используйте MNIST — набор из 70 000 рукописных цифр (0-9). TensorFlow загружает его одной строкой: from import mnist; (x_train, y_train), (x_test, y_test) = mnist.load_data(). Нормализуйте данные: x_train = x_train / 255.0 (переводим значения пикселей из 0-255 в 0-1). Готово — у вас 60 000 изображений для обучения и 10 000 для тестирования.

Шаг 3: Создайте архитектуру

Простая нейросеть из 3 слоёв: model = ([(input_shape=(28, 28)), (128, activation=’relu’), (10, activation=’softmax’)]). Flatten превращает 28×28 картинку в массив из 784 чисел. Dense(128) — скрытый слой с 128 нейронами. Dense(10) — выходной слой с 10 нейронами (по одному на каждую цифру 0-9). Компиляция: (optimizer=’adam’, loss=’sparse_categorical_crossentropy’, metrics=[‘accuracy’]).

Шаг 4: Обучите и протестируйте

Обучение: (x_train, y_train, epochs=5). За 5 эпох (проходов по данным) модель достигнет 97-98% точности. Тест: (x_test, y_test) — проверяет на данных, которые модель никогда не видела. Результат: ~97% точности на тесте. Весь код — 15 строк. Время обучения — 1-2 минуты на обычном ноутбуке. Для помощи с кодом используйте ChatGPT или Claude в MashaGPT — они объяснят каждую строку и помогут отладить ошибки.

Пишем код

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

Мне понравилась эта картинка для объяснения, что такое нейрон смещения.

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

import math import random import time import datetime import json from copy import copy activation = deactivation = class NeuralNetwork: def __init__(self, neurons_size:list, weights:list=None): self.neuron_size = neurons_size for i in range(len(neurons_size)-1): self.neuron_size[i] += 1 if weights is None: = [] for i in range(len(neurons_size)-1): ([[(-1, 1) for x in range(neurons_size[i+1])] for y in range(neurons_size[i])]) else: = weights def out(self, inp): out=[inp +] for i in range(1, len()+1): a = [] for j in range(self.neuron_size[i]): s = sum([out[i-1][k] * [i-1][k][j] for k in range(self.neuron_size[i-1])]) (activation(s)) if i!= len(): a += (a) return out def correct(self, inp, answer, learning_rate=0.1): out = (inp) errors = [[answer[i] — out[-1][i] for i in range(len(out[-1]))]] for i in range(len() — 1, 0, -1): a = [] for j in range(self.neuron_size[i]): s = sum([errors[0][k] * [i][j][k] for k in range(self.neuron_size[i + 1])]) ((1 — out[i][j] ** 2) * s) (0, a) for i in range(len()): for j in range(self.neuron_size[i]): for k in range(self.neuron_size[i + 1]): [i][j][k] += learning_rate * errors[i][k] * out[i][j] error_count = sum([sum(abs(en) for en in el) for el in errors]) return out, error_count def save(self, name): with open(name, ‘w’) as f: neuron_size = copy(self.neuron_size) for i in range(len(neuron_size) — 1): neuron_size[i] -= 1 (({‘shape’: neuron_size, ‘weights’: })) def open(name): with open(name, ‘r’) as f: data = (()) return NeuralNetwork(data[‘shape’], data[‘weights’]) def show(self, name): import as plt import networkx as nx from.nx_agraph import graphviz_layout G = () for layer in range(len(self.neuron_size)): for neuron in range(self.neuron_size[layer]): G.add_node((layer, neuron)) for layer in range(len(self.neuron_size) — 1): for from_neuron in range(self.neuron_size[layer]): for to_neuron in range(self.neuron_size[layer + 1]): weight = [layer][from_neuron][to_neuron] G.add_edge((layer, from_neuron), (layer + 1, to_neuron), weight=weight) pos = graphviz_layout(G, prog=’dot’, args=»-Grankdir=LR») edge_widths = [2 + abs([edge][‘weight’]) for edge in] edge_alpha = [abs(activation([edge][‘weight’]))/2 for edge in] edge_colors = [‘green’ if [edge][‘weight’] >= 0 else ‘red’ for edge in] nx.draw_networkx_nodes(G, pos, node_size=300, node_color=’skyblue’, alpha=0.8) nx.draw_networkx_edges(G, pos, width=edge_widths, alpha=edge_alpha, edge_color=edge_colors, arrows=True) layer_labels = {} for layer in range(len(self.neuron_size)): for neuron in range(self.neuron_size[layer]): layer_labels[(layer, neuron)] = f»{neuron}» nx.draw_networkx_labels(G, pos, labels=layer_labels, font_size=12, font_color=’r’) (‘off’) (f»Neural Network Weights») (f'{name}.png’)

На этом сама нейросеть закончена, пора приступать к разработке среды обучения. Подробное описание процесса разработки среды не имеет ценности для темы, так что я просто опишу принцип работы:

Изначально создается массив, который является картой среды. Массив изначально состоит из 0.1, а потом каждый ход наполняется 1 и -1 случайным образом. Также создается клетка, которая управляется нейросетью, которой на вход подается массив из значений полей в квадрате 5*5, а на выходе число от 0 до 3, обозначающие ход (0 — шаг вверх, 1 — вниз, 2 — вправо, 3 — влево). Проверяется по одной клетке вокруг клетки и если находится 1 — то по этому направлению применяется положительное подкрепление, а если -1 — то отрицательное. Также я добавил к этому графический интерфейс на tkinter.

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

from neuro import NeuralNetwork from tkinter import * import as plt import as animation import random import asyncio mind = NeuralNetwork([25, 4]) canvas_size = 1280 realsize = 32 pix = canvas_size / realsize canvas = [[0.1 for x in range(realsize)] for y in range(realsize)] cellx, celly = 15, 5 def cellvision(vis): global cellx global celly global canvas inp = [] if vis!= -1: for j in range(vis): for i in range(vis): (canvas[int(cellx — vis // 2 + i) % realsize][int(celly — vis // 2 + j) % realsize]) return inp (canvas[int(cellx + 0) % realsize][int(celly — 1) % realsize]) (canvas[int(cellx + -1) % realsize][int(celly + 0) % realsize]) (canvas[int(cellx + 1) % realsize][int(celly + 0) % realsize]) (canvas[int(cellx + 0) % realsize][int(celly + 1) % realsize]) return inp def move(out): global cellx global celly if out == 0: celly -= 1 if out == 1: cellx -= 1 if out == 2: cellx += 1 if out == 3: celly += 1 if cellx == realsize: cellx = 0 if cellx == -1: cellx = realsize — 1 if celly == realsize: celly = 0 if celly == -1: celly = realsize — 1 cell(cellx, celly) return def goodpoint(x, y): color = «#476042» x, y = x * pix, y * pix x1, y1 = (x — pix / 2), (y — pix / 2) x2, y2 = (x + pix / 2), (y + pix / 2) w.create_oval(x1, y1, x2, y2, outline=color, fill=color) def badpoint(x, y): color = «#ff0000» x, y = x * pix, y * pix x1, y1 = (x — pix / 2), (y — pix / 2) x2, y2 = (x + pix / 2), (y + pix / 2) w.create_oval(x1, y1, x2, y2, outline=color, fill=color) def cell(x, y): color = «#ffffff» x, y = x * pix, y * pix x1, y1 = (x — pix / 2), (y — pix / 2) x2, y2 = (x + pix / 2), (y + pix / 2) w.create_oval(x1, y1, x2, y2, outline=color, fill=color) def canvas_print(): global canvas («all») ans = » for y in range(realsize): for x in range(realsize): ans += str(canvas[x][y]) + » » if canvas[x][y] == 1: goodpoint(x, y) if canvas[x][y] == -1: badpoint(x, y) if canvas[x][y] == 0: cell(x, y) ans += «\n» def usergoodpoint(event): x, y = int(event.x / pix), int(event.y / pix) canvas[x][y] = 1 def userbadpoint(event): x, y = int(event.x / pix), int(event.y / pix) canvas[x][y] = -1 master = Tk() («Среда обучения») w = Canvas(master, bg=»black», width=canvas_size, height=canvas_size) (expand=YES, fill=BOTH) («<B1-Motion>», usergoodpoint) («<B3-Motion>», userbadpoint) iterat = -1 allg = 0 graphic = [] while True: iterat += 1 if iterat % 200 == 0: (graphic) (0.0000001) good = 0 if iterat % 10000 == 0: () () canvas[(0, realsize — 1)][(0, realsize — 1)] = 1 canvas[(0, realsize — 1)][(0, realsize — 1)] = -1 canvas_print() visn = cellvision(5) visnn = cellvision(-1) out = (visn) move_ = out[-1].index(max(out[-1])) (visn, visnn, 0.1) answer = *4 answer[move_] = 1 move(move_) if canvas[cellx][celly] == 1: good += 50 canvas[cellx][celly] = 0.1 elif canvas[cellx][celly] == -1: good -= 50 canvas[cellx][celly] = 0.1 # print(input()) allg += good (allg) («Среда обучения: » + » i:» + str(iterat) + » good:» + str(good)) () () ()

Частые вопросы о создании нейросетей

Вопрос: Можно ли создать нейросеть без знания программирования?
Ответ: Да, существуют визуальные конструкторы и платформы с низким кодом, но для гибкости и глубокого понимания основ Python желателен.

Вопрос: Какой язык программирования лучше всего подходит для новичка?
Ответ: Python — самый популярный выбор благодаря простому синтаксису и богатым библиотекам (TensorFlow, PyTorch).

Вопрос: Какие библиотеки нужны для начала?
Ответ: Минимальный набор: NumPy для вычислений, TensorFlow или PyTorch для построения моделей, Matplotlib для визуализации.

Вопрос: Откуда брать данные для обучения?
Ответ: Используйте открытые датасеты (Kaggle, UCI Repository), генерируйте синтетические данные или собирайте свои.

Вопрос: Что такое архитектура нейросети?
Ответ: Это структура модели: количество слоёв, типы слоёв (полносвязные, свёрточные), количество нейронов и связи между ними.

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

Вопрос: Что такое переобучение и как его избежать?
Ответ: Переобучение — когда модель запоминает данные, а не учится общим закономерностям. Помогают методы регуляризации, Dropout-слои и validation set.

Вопрос: Как долго обучается нейросеть?
Ответ: Время зависит от сложности модели, объёма данных и мощности железа. Простые модели на CPU — минуты/часы, сложные на GPU — дни.

Вопрос: Где можно запускать код нейросети?
Ответ: На своём компьютере, на арендованных облачных GPU (Google Colab, Kaggle Kernels, облачные провайдеры) или на сервере.

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

Краткий чек-лист для вашего первого проекта

1. Убедитесь, что Python установлен и обновлён.
2. Установите необходимые библиотеки через pip (TensorFlow/PyTorch, NumPy, Pandas).
3. Определите чёткую задачу для нейросети (классификация, регрессия).
4. Найдите и загрузите подходящий датасет.
5. Проведите предобработку данных: нормализацию, разбиение на выборки.
6. Спроектируйте простую начальную архитектуру (например, несколько Dense-слоёв).
7. Выберите функцию потерь, оптимизатор и метрики качества.
8. Обучите модель на тренировочных данных, указав количество эпох.
9. В процессе обучения отслеживайте точность и потери на валидационной выборке.
10. Протестируйте итоговую модель на отдельном тестовом наборе данных.
11. Проанализируйте ошибки модели, попробуйте улучшить архитектуру или данные.
12. Сохраните обученную модель для последующего использования.
13. Напишите простой скрипт для запуска модели на новых данных.
14. Поделитесь кодом на GitHub или в профессиональном сообществе для обратной связи.