08-15-2025, 11:12 AM
Привет. Ты хочешь создать свою нейронную сеть, но не знаешь, с чего начать? Отлично, я тебе помогу. Создание нейронной сети с нуля – это прекрасный способ понять, как они работают “под капотом”. Не бойся, это не так сложно, как кажется на первый взгляд. Мы разберем все по шагам, и ты увидишь, что это вполне реально даже для новичка.
Первым делом, определимся с инструментом. Python – твой лучший друг в этом деле. У него простой синтаксис и огромное количество библиотек для машинного обучения. Я рекомендую использовать NumPy для математических операций и, возможно, в будущем, TensorFlow или PyTorch для более сложных проектов, но для начала мы сосредоточимся на реализации “с нуля”.
Начнем с самого простого: создадим персептрон – основу любой нейронной сети. Персептрон – это по сути один нейрон, который принимает несколько входов, умножает их на веса, суммирует и пропускает через функцию активации.
Шаг за шагом к собственной нейронной сети
- Инициализация параметров:
Нам понадобятся веса (weights) и смещение (bias). Веса определяют, насколько важен каждый вход, а смещение позволяет нейрону срабатывать, даже если все входы равны нулю. Инициализировать веса и смещение можно случайными числами. Почему случайными? Чтобы избежать симметрии в сети, когда все нейроны обучаются одинаково.
Python
import numpy as np
def initialize_parameters(n_features):
"""
Инициализирует веса и смещение для персептрона.
Args:
n_features: Количество входных признаков.
Returns:
Словарь, содержащий веса (W) и смещение (b).
"""
W = np.random.rand(n_features) # Веса - случайные числа от 0 до 1
b = np.random.rand() # Смещение - случайное число от 0 до 1
return {"W": W, "b": b}
Здесь n_features – это количество входных признаков. Например, если мы пытаемся предсказать, будет ли клиент покупать продукт на основе двух факторов: его возраста и дохода, то n_features будет равно 2. Функция np.random.rand(n_features) генерирует массив случайных чисел от 0 до 1, а np.random.rand() генерирует одно случайное число. Почему от 0 до 1? Это просто хороший диапазон для начала, но ты можешь экспериментировать с другими диапазонами, если хочешь.
- Функция активации:
Функция активации решает, должен ли нейрон “сработать” или нет. Существует множество функций активации, но для начала мы используем сигмоидную функцию. Сигмоид возвращает значение от 0 до 1, которое можно интерпретировать как вероятность.
Python
def sigmoid(x):
"""
Сигмоидная функция активации.
Args:
x: Входное значение.
Returns:
Сигмоид от x.
"""
return 1 / (1 + np.exp(-x))
Сигмоид – это S-образная кривая. Если x очень большое положительное число, сигмоид вернет значение близкое к 1. Если x очень большое отрицательное число, сигмоид вернет значение близкое к 0. Если x равно 0, сигмоид вернет 0.5.
- Прямое распространение (Forward Propagation):
Это процесс вычисления выхода нейрона на основе его входов, весов и смещения.
Python
def forward_propagation(X, parameters):
"""
Вычисляет выход персептрона.
Args:
X: Входные данные (массив).
parameters: Словарь с весами (W) и смещением (b).
Returns:
Значение выхода персептрона.
"""
W = parameters["W"]
b = parameters["b"]
Z = np.dot(X, W) + b # Линейная комбинация входов и весов
A = sigmoid(Z) # Применение функции активации
return A
Здесь X – это входные данные. np.dot(X, W) вычисляет скалярное произведение входных данных и весов. Z – это линейная комбинация входов и весов плюс смещение. A – это выход персептрона после применения функции активации.
- Функция потерь (Loss Function):
Функция потерь измеряет, насколько хорошо наша нейронная сеть предсказывает результаты. Для бинарной классификации (когда у нас два класса, например, 0 и 1) мы можем использовать бинарную кросс-энтропию.
Python
def binary_cross_entropy_loss(y_true, y_predicted):
"""
Вычисляет бинарную кросс-энтропию.
Args:
y_true: Истинные метки (0 или 1).
y_predicted: Предсказанные вероятности (от 0 до 1).
Returns:
Значение потерь.
"""
epsilon = 1e-15 # Небольшое число для предотвращения деления на ноль
y_predicted = np.clip(y_predicted, epsilon, 1 - epsilon) #ограничиваем значения, чтобы не было деления на ноль
loss = -np.mean(y_true * np.log(y_predicted) + (1 - y_true) * np.log(1 - y_predicted))
return loss
y_true – это истинные метки (0 или 1). y_predicted – это предсказанные вероятности (от 0 до 1). Функция np.mean() вычисляет среднее значение потерь по всем примерам.
- Обратное распространение (Backpropagation):
Это самый сложный, но и самый важный шаг. Здесь мы вычисляем градиенты (производные) функции потерь по весам и смещению. Градиенты показывают, в каком направлении нужно изменить веса и смещение, чтобы уменьшить потери.
Python
def backpropagation(X, y_true, y_predicted, parameters):
"""
Вычисляет градиенты весов и смещения.
Args:
X: Входные данные.
y_true: Истинные метки.
y_predicted: Предсказанные вероятности.
parameters: Словарь с весами (W) и смещением (b).
Returns:
Словарь с градиентами весов (dW) и смещения (db).
"""
W = parameters["W"]
m = X.shape[0] #количество примеров
dZ = y_predicted - y_true
dW = (1/m) * np.dot(X.T, dZ)
db = (1/m) * np.sum(dZ)
return {"dW": dW, "db": db}
dZ – это градиент функции потерь по выходу персептрона. dW – это градиент функции потерь по весам. db – это градиент функции потерь по смещению. m – это количество примеров в обучающем наборе.
- Обновление параметров:
Теперь мы используем градиенты, чтобы обновить веса и смещение. Мы вычитаем градиенты, умноженные на скорость обучения (learning rate), из текущих значений весов и смещения. Скорость обучения определяет, насколько сильно мы будем изменять веса и смещение на каждой итерации.
Python
def update_parameters(parameters, gradients, learning_rate):
"""
Обновляет веса и смещение.
Args:
parameters: Словарь с весами (W) и смещением (b).
gradients: Словарь с градиентами весов (dW) и смещения (db).
learning_rate: Скорость обучения.
Returns:
Словарь с обновленными весами (W) и смещением (b).
"""
W = parameters["W"]
b = parameters["b"]
dW = gradients["dW"]
db = gradients["db"]
W = W - learning_rate * dW
b = b - learning_rate * db
return {"W": W, "b": b}
Чем меньше скорость обучения, тем медленнее будет обучаться сеть, но тем меньше вероятность “проскочить” минимум функции потерь. Чем больше скорость обучения, тем быстрее будет обучаться сеть, но тем больше вероятность “проскочить” минимум функции потерь и никогда не сойтись.
- Обучение модели:
Теперь мы можем собрать все вместе и обучить нашу нейронную сеть.
Python
def train(X, y_true, n_epochs, learning_rate):
"""
Обучает персептрон.
Args:
X: Входные данные.
y_true: Истинные метки.
n_epochs: Количество эпох (итераций) обучения.
learning_rate: Скорость обучения.
Returns:
Словарь с обученными весами (W) и смещением (b).
"""
n_features = X.shape[1]
parameters = initialize_parameters(n_features)
for i in range(n_epochs):
y_predicted = forward_propagation(X, parameters)
loss = binary_cross_entropy_loss(y_true, y_predicted)
gradients = backpropagation(X, y_true, y_predicted, parameters)
parameters = update_parameters(parameters, gradients, learning_rate)
if i % 100 == 0:
print(f"Эпоха {i}, Потери: {loss}")
return parameters
n_epochs – это количество эпох обучения. Одна эпоха – это один проход по всему обучающему набору данных. Чем больше эпох, тем дольше будет обучаться сеть, но тем лучше она может научиться.
На каждой эпохе мы выполняем следующие шаги:
- Вычисляем предсказания с помощью прямого распространения.
- Вычисляем потери с помощью функции потерь.
- Вычисляем градиенты с помощью обратного распространения.
- Обновляем веса и смещение с помощью алгоритма градиентного спуска.
- Предсказание:
После того, как мы обучили нашу нейронную сеть, мы можем использовать ее для предсказания новых результатов.
Python
def predict(X, parameters):
"""
Делает предсказания.
Args:
X: Входные данные.
parameters: Словарь с обученными весами (W) и смещением (b).
Returns:
Массив предсказанных меток (0 или 1).
"""
y_predicted = forward_propagation(X, parameters)
y_predicted = np.round(y_predicted) # Округляем до 0 или 1
return y_predicted
Мы используем прямое распространение, чтобы вычислить вероятности для каждого класса. Затем мы округляем вероятности до 0 или 1, чтобы получить предсказанные метки.
Пример использования:
Python
# Пример данных
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) #входные данные.
y_true = np.array([0, 1, 1, 0]) #истинные ответы для входных данных
# Гиперпараметры
n_epochs = 1000
learning_rate = 0.1
# Обучение модели
parameters = train(X, y_true, n_epochs, learning_rate)
# Предсказание
y_predicted = predict(X, parameters)
print("Предсказанные метки:", y_predicted)
print("Точность:", np.mean(y_predicted == y_true))
В этом примере мы создали простейшую нейронную сеть, которая может решать задачу XOR (исключающее ИЛИ).
Что дальше?
Это только начало. Теперь ты можешь:
- Поэкспериментировать с различными функциями активации (ReLU, tanh и т.д.).
- Добавить больше слоев в нейронную сеть.
- Использовать другие функции потерь (например, категориальную кросс-энтропию для многоклассовой классификации).
- Реализовать более сложные алгоритмы оптимизации (например, Adam, RMSprop).
- Использовать фреймворки TensorFlow или PyTorch для создания более сложных нейронных сетей.
- Использовать готовые наборы данных, например из библиотеки scikit-learn, для тренировки модели.
Рекомендации и ресурсы
- Курсы: Есть множество онлайн-курсов по нейронным сетям и машинному обучению. Например, можно посмотреть курсы на Coursera, Stepik или Skillbox.
- Книги: Рекомендую книгу “Глубокое обучение” Яна Гудфеллоу, Иэна Бенджио и Аарона Курвиля. Это отличное введение в теорию и практику глубокого обучения.
- Форумы и сообщества: Общайся с другими учениками и экспертами на форумах и в сообществах. Например, Stack Overflow – отличное место для поиска ответов на конкретные вопросы по коду. Многие находят поддержку на площадке машинного обучения Kaggle. Также стоит поискать группы в социальных сетях.
- Практика: Самое главное – это практика. Бери простые задачи и пытайся их решить с помощью нейронных сетей. Не бойся экспериментировать и ошибаться.