Почему нейросеть не обучается?

import numpy as np
from PIL import Image
import os
from random import randint
 
np.set_printoptions(precision=50)
 
inPath = "input/input2.jpg"
dir = "memorized/"
if not os.path.exists(dir):
    os.makedirs(dir)
outPath = dir + "output"
 
img = Image.open(inPath)
width, height = img.size
height = height // 2
width = width // 2
img = img.resize((width, height), Image.LANCZOS)
 
img = np.array(img)
img = img.flatten()
img_len = len(img)
 
extra = 0
#X = np.append(img[:-extra], np.empty((1, extra))).reshape(1, img_len) / 255.0
X = img.reshape(1, img_len) / 255.0
d = img.reshape(1, img_len) / 255.0  # Нормализация
 
# Увеличиваем размер скрытого слоя до 128
nS = np.array([len(X[0]) + 2] + [500] * 3 + [len(d[0])])  
 
print(nS, "@")
num_samples = len(X)
learning_rate = 0.0005 # Уменьшенная скорость обучения
min_error = 0.01 ** 2
length_nets = len(nS) - 1
alpha = 0.1
doBias = True
rand = 0
rot = 0
 
 
def main():
    MSE = 1
    while MSE > min_error:
        network = initialize_weights(doBias)
        network, MSE = train(network, X, doBias)
 
def train(network, X, doBias=False):
    global learning_rate, d, img_len, height, width, rand, rot
    
    epoch = 1
    step = 1
    save_picture(neurons_into_picture(directPass(X[0], network, doBias=doBias)), epoch)
    epoch+=1
    
    while True:
        for sample in range(num_samples):
            answer, sums = directPass(X[sample], network, True, doBias)
            
            if rand == 1:
                array = d[sample].reshape(height, width, 3)
                array = np.flip(d[sample], axis=0)
                d[sample] = array.flatten()
            else:
                array = d[sample].reshape(height, width, 3)
                array = np.rot90(array, k=rot)
                d[sample] = array.flatten()
            
            error = (d[sample] - answer) * df(answer)
            gradients = backPass(error, sums, network, doBias)
            
            for layer in range(length_nets):
                delta_w = learning_rate * sums[layer] * gradients[layer + 1][:, np.newaxis]
                if doBias:
                    network[layer][:-1 * doBias] += delta_w.T
                    network[layer][-1] += learning_rate * gradients[layer + 1][:, np.newaxis].reshape(network[layer][-1].shape)
                else:
                    network[layer] += delta_w.T                 
 
        error_sum = np.array([directPass(X[samples], network, doBias=doBias) for samples in range(num_samples)]).reshape(len(d), len(d[0]))
        
        MSE = np.sum((error_sum - d) ** 2) / img_len
        if MSE < min_error:
            print(f"\n[ОБУЧЕНИЕ ЗАВЕРШЕНО]\n[ЭПОХИ: {epoch}]\n[ОШИБКА: {MSE}")
            return network, MSE
        elif MSE > 100 or epoch > 2000:
            learning_rate = round(learning_rate * 0.9, 9)
            print("СКОРОСТЬ:", str(learning_rate))
            return None, MSE
 
        if epoch % step == 0:
            print(f"\n> эпох: {epoch}\n> ошибка: {MSE}")
            save_picture(neurons_into_picture(directPass(X[0], network, doBias=doBias)), epoch)
        if epoch % 10 == 0:
            step += 1
        epoch += 1
 
def directPass(X, network, save_list=None, doBias=False):
    global rand, rot
    rand = randint(0,2)
    rot = randint(1, 3)
    X = np.append(X, [rand, rot])
    #X[:-extra] += np.random.uniform(0, 0.05, len(X) - extra)
    #X[-extra:] = np.random.uniform(0, 5, extra)
    
    if save_list:
        sum_list = np.empty(length_nets + 1, dtype=object)
        sum_list[0] = X
 
    for layer in range(length_nets):
        if np.isscalar(X):
            X = X * (network[layer][:-1] if doBias else network[layer])
        else:
            X = X.dot(network[layer][:-1] if doBias else network[layer])
        
        if doBias:
            X += network[layer][-1]
        X = f(X)
 
        if save_list:
            sum_list[layer + 1] = X
 
    if save_list:
        return X, sum_list
    return X
 
def backPass(Y, sum_list, network, doBias=False):
    network = network[::-1]
    sum_list = np.flip(sum_list)
    gradient_list = np.empty(length_nets + 1, dtype=object)
    gradient_list[0] = Y
 
    for layer in range(length_nets):
        if np.isscalar(Y):
            Y = Y * (network[layer][:-1] if doBias else network[layer])
        else:
            Y = Y.dot(network[layer][:-1].T if doBias else network[layer].T)
        Y *= df(sum_list[layer + 1])
 
        gradient_list[layer + 1] = Y
    gradient_list = gradient_list[::-1]
    return gradient_list
 
"""def initialize_weights(doBias=False):
    return np.array([np.random.normal(0, 0.01, (nS[i] + doBias, nS[i + 1])) for i in range(length_nets)], dtype=object)"""
 
def initialize_weights(doBias=False):
    return np.array([np.random.randn(nS[i] + doBias, nS[i + 1]) * np.sqrt(2. / nS[i + 1]) for i in range(length_nets)], dtype=object)
 
"""def f(x):
    # Ограничение входных значений
    x = np.clip(x, -709, 709)
    return 1 / (1 + np.exp(-x))
 
def df(x):
    # Вычисляем сигмоиду для входа x
    sig = f(x)
    # Производная сигмоиды
    return sig * (1 - sig)"""
 
def f(x):
    return np.where(x > 0, x, alpha * x)
 
def df(x):
    return np.where(x > 0, 1, alpha)
 
def neurons_into_picture(Y):
    Y = Y.reshape(height, width, 3)
    Y = np.round((Y - np.min(Y)) / (max(1, np.max(Y) - np.min(Y))) * 255)
    return Image.fromarray(Y.astype(np.uint8))
 
def save_picture(Y, num):
    Y.save(outPath + f"_{num}.png")
 
main()