Нейросеть стремится к значению 0.5 а не е 1

Я только начинаю изучать нейросети и значение выходного нейрона стремится к 0.5. Тут 2 нейрона в входном, 2 в скрытом и 1 в выходном.

Нейросеть делал по этой статье https://habr.com/ru/post/313216

import math
from random import uniform
from time import sleep

ideal = 1

neurons = [[1, 1], 
           [0, 0], 
           [0]]

weights = [ #layer neuron weight
       [[1, 1],
        [1, 1]],

       [[1],
        [1]]
    ]

biases = [ #layer weight
        [0, 0],
        [0]
    ]
    

deltas = [[0, 0],
          [0, 0],
          [0]]


DELTAS = [   #слой    нейрон    Δ

    [[0, 0],  #Δ 1 слоя 1 нейрона
     [0, 0]], #Δ 1 слоя 2 нейрона

    [[0], 
    [0]]]      #Δ 2 слоя 1 нейрона




def train():


    print("Error:", get_loss(), "Output:", neurons[-1][0], "Weights:", weights)
    print()
    print()
   
    for layer in range(len(deltas)-1, -1, -1):
        for neuron in range(len(neurons[layer])):
            if (layer == len(weights)):
                delta_output(neuron)
            elif (layer != 0): 
                delta_hidden(layer, neuron)

            if (layer != len(weights)):
                for weight_neuron in range(len(weights[layer][0])):
                    set_neurons()
                    DELTA = get_Δ(layer, neuron, weight_neuron)
                
                    weights[layer][neuron][weight_neuron] += DELTA






def get_loss():
    return (ideal - neurons[-1][0] ) ** 2


def set_neurons():
    for layer in range(1, len(neurons)):
        for neuron in range(len(neurons[layer])):
            for weight_neuron in range(len(weights[layer-1][0])):

                neurons[layer][neuron] = sigmoid(  weights[layer-1][weight_neuron][neuron] * neurons[layer-1][weight_neuron] + biases[layer-1][weight_neuron]  )


def delta_output(neuron_id):
    global ideal
    

    
    neuron_activate = neurons[-1][neuron_id]

    delta = (ideal - neuron_activate)  *  ((1 - neuron_activate) * neuron_activate)

    
    #сейвим дельту
    deltas[-1][neuron_id] = delta

    return delta


def delta_hidden(layer_of_neuron, neuron_id):
    sigma = 0
    
    for i in range(len(weights[layer_of_neuron][neuron_id])):
        sigma += weights[layer_of_neuron][neuron_id][i] * deltas[layer_of_neuron+1][i]
            
    neuron_activate = neurons[layer_of_neuron][neuron_id]
    delta = ((ideal - neuron_activate) * neuron_activate) * sigma
    
    #сейвим дельту
    deltas[layer_of_neuron][neuron_id] = delta


    return delta


def get_Δ(layer, neuron_id, weight_id):
    GRAD = deltas[layer+1][weight_id] * neurons[layer][neuron_id]
    
    
    E = 0.7
    a = 0.3 + 1
    
    Δ = E * GRAD + a * DELTAS[layer][neuron_id][weight_id]
    
    #сейвим Δ
    DELTAS[layer][neuron_id][weight_id] = Δ

    return Δ


def sigmoid(x):
    return 1/(1 + math.e ** x)



while True:
    train()