Практическая разработка нейронной сети на Python без использования библиотек

Как улучшить сходимость нейросети с помощью функции ReLU и оптимизатора Adam?

Первый вариант заменяет сигмоид на ReLU в скрытых слоях и использует Adam вместо простого SGD. Это ускоряет сходимость и уменьшает затухание градиента.

class ImprovedNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # Инициализация He для ReLU
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2.0 / input_size)
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2.0 / hidden_size)
        self.b2 = np.zeros((1, output_size))
        # Параметры Adam
        self.m = {}
        self.v = {}
        self.beta1 = 0.9
        self.beta2 = 0.999
        self.epsilon = 1e-8

    def relu(self, z):
        return np.maximum(0, z)

    def relu_derivative(self, z):
        return (z > 0).astype(float)

    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.relu(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = 1 / (1 + np.exp(-self.z2))  # Sigmoid для бинарной классификации
        return self.a2

    def backward(self, X, y, output):
        m = X.shape[0]
        dZ2 = output - y
        dW2 = np.dot(self.a1.T, dZ2) / m
        db2 = np.sum(dZ2, axis=0, keepdims=True) / m
        dA1 = np.dot(dZ2, self.W2.T)
        dZ1 = dA1 * self.relu_derivative(self.a1)
        dW1 = np.dot(X.T, dZ1) / m
        db1 = np.sum(dZ1, axis=0, keepdims=True) / m
        return {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2}

    def adam_update(self, grads, t):
        for param in ['W1', 'b1', 'W2', 'b2']:
            g = grads['d' + param]
            if param not in self.m:
                self.m[param] = np.zeros_like(g)
                self.v[param] = np.zeros_like(g)
            self.m[param] = self.beta1 * self.m[param] + (1 - self.beta1) * g
            self.v[param] = self.beta2 * self.v[param] + (1 - self.beta2) * (g ** 2)
            m_hat = self.m[param] / (1 - self.beta1 ** t)
            v_hat = self.v[param] / (1 - self.beta2 ** t)
            delta = self.learning_rate * m_hat / (np.sqrt(v_hat) + self.epsilon)
            setattr(self, param, getattr(self, param) - delta)

    def train(self, X, y, epochs=1000, learning_rate=0.001):
        self.learning_rate = learning_rate
        t = 0
        for epoch in range(epochs):
            output = self.forward(X)
            loss = np.mean((output - y) ** 2)
            grads = self.backward(X, y, output)
            t += 1
            self.adam_update(grads, t)
            if epoch % 100 == 0:
                print(f"Epoch {epoch}, loss: {loss:.4f}")
    

нейросеть для генерации кода python (нейросеть для генерации кода на python)

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

Как предотвратить переобучение нейросети с нуля?

Добавление регуляризации L2 (weight decay) и Dropout в полносвязную сеть помогает бороться с переобучением.

class RegularizedNetwork:
    def __init__(self, input_size, hidden_size, output_size, lambd=0.01, keep_prob=0.8):
        # ... (инициализация как в ImprovedNetwork) ...
        self.lambd = lambd  # коэффициент регуляризации L2
        self.keep_prob = keep_prob  # вероятность сохранения нейрона при Dropout

    def forward(self, X, training=True):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.relu(self.z1)
        if training and self.keep_prob < 1.0:
            # Dropout: случайное обнуление нейронов
            self.dropout_mask1 = np.random.binomial(1, self.keep_prob, size=self.a1.shape) / self.keep_prob
            self.a1 *= self.dropout_mask1
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

    def compute_loss(self, output, y):
        base_loss = np.mean((output - y) ** 2)
        # L2 регуляризация: добавляем сумму квадратов весов
        reg_loss = (self.lambd / (2 * y.shape[0])) * (np.sum(self.W1 ** 2) + np.sum(self.W2 ** 2))
        return base_loss + reg_loss

    def backward(self, X, y, output):
        m = X.shape[0]
        dZ2 = output - y
        dW2 = np.dot(self.a1.T, dZ2) / m + (self.lambd / m) * self.W2  # + regularization term
        db2 = np.sum(dZ2, axis=0, keepdims=True) / m
        dA1 = np.dot(dZ2, self.W2.T)
        # При обратном распространении через Dropout используем маску
        if hasattr(self, 'dropout_mask1'):
            dA1 *= self.dropout_mask1
        dZ1 = dA1 * self.relu_derivative(self.a1)
        dW1 = np.dot(X.T, dZ1) / m + (self.lambd / m) * self.W1
        db1 = np.sum(dZ1, axis=0, keepdims=True) / m
        return {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2}
    

Python нейросеть тексты (нейросеть для работы с текстом на python)

Во время обучения используется Dropout, а во время предсказания маска не применяется (выходы масштабируются автоматически за счет деления на keep_prob).

Как стабилизировать обучение глубокой сети с помощью Batch Normalization?

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

class BatchNormNetwork:
    def __init__(self, layers, momentum=0.9):
        # layers: список числа нейронов, например [input, hidden, output]
        self.params = {}
        self.gamma = {}  # масштаб
        self.beta = {}   # сдвиг
        self.running_mean = {}
        self.running_var = {}
        self.momentum = momentum
        # инициализация весов, гаммы и беты для каждого слоя, кроме входного
        for i in range(1, len(layers)):
            self.params[f'W{i}'] = np.random.randn(layers[i-1], layers[i]) * np.sqrt(2.0 / layers[i-1])
            self.params[f'b{i}'] = np.zeros((1, layers[i]))
            self.gamma[f'gamma{i}'] = np.ones((1, layers[i]))
            self.beta[f'beta{i}'] = np.zeros((1, layers[i]))
            self.running_mean[f'mean{i}'] = np.zeros((1, layers[i]))
            self.running_var[f'var{i}'] = np.ones((1, layers[i]))

    def batchnorm_forward(self, Z, gamma, beta, training, running_mean, running_var, epsilon=1e-8):
        if training:
            mu = np.mean(Z, axis=0, keepdims=True)
            var = np.var(Z, axis=0, keepdims=True)
            running_mean = self.momentum * running_mean + (1 - self.momentum) * mu
            running_var = self.momentum * running_var + (1 - self.momentum) * var
            Z_norm = (Z - mu) / np.sqrt(var + epsilon)
        else:
            Z_norm = (Z - running_mean) / np.sqrt(running_var + epsilon)
        out = gamma * Z_norm + beta
        # кэшируем для обратного прохода
        cache = (Z, mu, var, Z_norm, gamma, beta, epsilon)
        return out, cache, running_mean, running_var

    def forward(self, X, training=True):
        caches = []
        A = X
        for i in range(1, len(self.params)//2 + 1):
            W = self.params[f'W{i}']
            b = self.params[f'b{i}']
            gamma = self.gamma[f'gamma{i}']
            beta = self.beta[f'beta{i}']
            Z = np.dot(A, W) + b
            # Применяем BN перед активацией
            Z_norm, cache, self.running_mean[f'mean{i}'], self.running_var[f'var{i}'] = \
                self.batchnorm_forward(Z, gamma, beta, training, self.running_mean[f'mean{i}'], self.running_var[f'var{i}'])
            A = self.relu(Z_norm)
            caches.append(cache)
        # последний слой без BN и активации (для бинарной классификации сигмоид на выходе)
        # ... (опустим для краткости) ...
    

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