Нейросети на языке Python: практическое руководство

Вариант 1: нейросеть с нуля на NumPy

Как реализовать полносвязную нейросеть без фреймворков, чтобы глубже понять механизмы обучения?

Этот вариант подходит для изучения обратного распространения ошибки и градиентного спуска. Пример для задачи XOR:

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# Данные XOR
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

# Инициализация весов
np.random.seed(42)
w1 = np.random.randn(2, 4)
w2 = np.random.randn(4, 1)
b1 = np.zeros((1,4))
b2 = np.zeros((1,1))

lr = 1.0
for epoch in range(10000):
    # Прямой проход
    z1 = X @ w1 + b1
    a1 = sigmoid(z1)
    z2 = a1 @ w2 + b2
    a2 = sigmoid(z2)
    # Обратный проход
    error = y - a2
    d2 = error * sigmoid_derivative(a2)
    d1 = (d2 @ w2.T) * sigmoid_derivative(a1)
    # Обновление
    w2 += a1.T @ d2 * lr
    b2 += np.sum(d2, axis=0, keepdims=True) * lr
    w1 += X.T @ d1 * lr
    b1 += np.sum(d1, axis=0, keepdims=True) * lr

print('Predictions after training:')
print(np.round(a2))

Feature names python (имена признаков в python)

Вариант 2: нейросеть на PyTorch для гибких архитектур

Как создать нейросеть с поддержкой динамического графа и автоматического дифференцирования?

PyTorch часто используют в исследованиях и для сложных моделей. Пример простого классификатора на MNIST:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Загрузка MNIST
X, y = fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False, parser='auto')
y = y.astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Преобразование в тензоры
X_train_t = torch.tensor(X_train, dtype=torch.float32)
y_train_t = torch.tensor(y_train, dtype=torch.long)
X_test_t = torch.tensor(X_test, dtype=torch.float32)
y_test_t = torch.tensor(y_test, dtype=torch.long)

train_dataset = TensorDataset(X_train_t, y_train_t)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# Определение модели
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Обучение
for epoch in range(5):
    for batch_x, batch_y in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_x)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()

# Оценка
with torch.no_grad():
    outputs = model(X_test_t)
    _, predicted = torch.max(outputs, 1)
    accuracy = (predicted == y_test_t).float().mean()
    print(f'Test accuracy: {accuracy:.3f}')