Python нейронные сети: обучение от простого к сложному

Как создать нейронную сеть с помощью PyTorch вместо Keras?

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

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Преобразование данных в тензоры
x_train_t = torch.tensor(x_train.reshape(-1, 784), dtype=torch.float32)
y_train_t = torch.tensor(y_train, dtype=torch.long)

# Определение сети
class SimpleNet(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 = SimpleNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

train_loader = DataLoader(TensorDataset(x_train_t, y_train_t), batch_size=32, shuffle=True)

for epoch in range(10):
    for xb, yb in train_loader:
        optimizer.zero_grad()
        outputs = model(xb)
        loss = criterion(outputs, yb)
        loss.backward()
        optimizer.step()

В PyTorch цикл обучения более явный, что дает контроль над каждым шагом. Проблемы: необходимо вручную управлять перемещением на GPU (используйте .to('cuda')).

Как реализовать нейронную сеть на чистом NumPy без фреймворков?

Это полезно для понимания математики обратного распространения. Реализуем двухслойный персептрон с сигмоидной активацией.

import numpy as np

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

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

# Инициализация весов
np.random.seed(42)
W1 = np.random.randn(784, 128)*0.01
b1 = np.zeros((1,128))
W2 = np.random.randn(128, 10)*0.01
b2 = np.zeros((1,10))

learning_rate = 0.1
epochs = 100

for epoch in range(epochs):
    # Прямое распространение
    z1 = np.dot(x_train_flat, W1) + b1
    a1 = sigmoid(z1)
    z2 = np.dot(a1, W2) + b2
    a2 = sigmoid(z2)

    # Обратное распространение
    loss = -np.mean(y_train_onehot * np.log(a2 + 1e-8))
    dZ2 = a2 - y_train_onehot
    dW2 = np.dot(a1.T, dZ2) / len(x_train_flat)
    db2 = np.mean(dZ2, axis=0, keepdims=True)
    dA1 = np.dot(dZ2, W2.T)
    dZ1 = dA1 * sigmoid_deriv(a1)
    dW1 = np.dot(x_train_flat.T, dZ1) / len(x_train_flat)
    db1 = np.mean(dZ1, axis=0, keepdims=True)

    # Обновление весов
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1

print(f'Loss after {epochs} epochs: {loss:.4f}')

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

Как быстро обучить многослойный персептрон с помощью scikit-learn?

Scikit-learn предоставляет класс MLPClassifier для быстрого прототипирования без написания циклов обучения.

from sklearn.neural_network import MLPClassifier

mlp = MLPClassifier(hidden_layer_sizes=(128,64), activation='relu', max_iter=20, random_state=42)
mlp.fit(x_train_flat, y_train)
print(f'Accuracy: {mlp.score(x_test_flat, y_test):.4f}')

Этот вариант подходит для небольших наборов данных и начального анализа, но ограничен в настройке (нет GPU, нет продвинутых регуляризаций).

Как создать модель с несколькими входами или выходами с помощью функционального API Keras?

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

input_text = keras.Input(shape=(100,), name='text')
input_num = keras.Input(shape=(5,), name='numeric')

x = layers.Dense(64, activation='relu')(input_text)
x = layers.concatenate([x, input_num])
x = layers.Dense(32, activation='relu')(x)
output = layers.Dense(1, activation='sigmoid')(x)

model = keras.Model(inputs=[input_text, input_num], outputs=output)
model.compile(optimizer='adam', loss='binary_crossentropy')

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