Обучаю ли я ANN для XOR, корректируя веса, определенные одним входом, затем следующим и так далее?

Question

Я пытаюсь обучить ANN в python для XOR без использования библиотек. Я не могу получить желаемый результат при тестировании. Я застрял в двух местах -

1. В настоящее время я использую 2 входа, 2 скрытых узла (1 скрытый слой) и один выход. Нужно ли использовать смещение для скрытых и выходных нейронов?

2. У меня есть 4 набора входов - [0,0], [0,1], [1,0] , [1,1]. Когда я начинаю обновлять веса, я делаю это для одного набора входных данных, скажем, [0,0]. Затем я использую второй набор [0,1] для обновления веса и так далее. Как только входной набор исчерпан, я повторяю весь процесс в течение нескольких итераций. Это правильный подход к обновлению веса, то есть делать это для одного ввода, а затем для следующего?

Ниже приведен мой код для справки. Пожалуйста, дайте мне знать, где я не прав?

import random

def activation_function(x):
    return 1/(1+pow(2.71828,-x))

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

#training data
training_inputs = [[0,0],[0,1],[1,0],[1,1]]
training_outputs = [[0],[1],[1],[0]]
LearningRate = 0.5
bias_h = 0.5
bias_o = 0.5

inodes = len(training_inputs[0])
hnodes = len(training_inputs[0])
onodes = int(len(training_inputs)/len(training_outputs))
lr = LearningRate

wih = []
for i in range(hnodes):
    x = []
    for j in range(inodes):
        x.append(random.random()-0.5)
    wih.append(x) 

who = []
for i in range(onodes):
    x= []
    for j in range(hnodes):
        x.append(random.random()-0.5)
    who.append(x)

inputs = training_inputs
targets = training_outputs


for iteration in range(10000):
    #Feed Forward

    for h in range(len(inputs)):
        hidden_inputs = []
        hidden_outputs = []
        final_inputs = []
        final_outputs = []
        output_errors = []
        localG_op = []
        localG_h = []
        for i in range(hnodes):
            sum = 0
            for j in range(inodes):
                sum += wih[i][j]*inputs[h][j]
            hidden_inputs.append(sum)
            hidden_outputs.append(activation_function(sum))

        for i in range(onodes):
            sum = 0
            for j in range(hnodes):
                sum += who[i][j]*hidden_outputs[j]
            final_inputs.append(sum)
            final_outputs.append(activation_function(sum))


        for j in range(onodes):
            output_errors.append(targets[h][j]-final_outputs[j])

        #Backpropagation
        #Local Gradient at output nodes
        for i in range(onodes):
            localG_op.append(output_errors[i]*der(final_outputs[i]))

        #Weight Adjustment for Hidden to Output synapses
        for i in range(onodes):
            for j in range(hnodes):
                who[i][j] += lr*localG_op[i]*hidden_outputs[j]

        #Local Gradient at output nodes
        for i in range(hnodes):
            sum = 0      
            for k in range(onodes):
                sum += who[k][i]*localG_op[k]
            localG_h.append(der(hidden_outputs[i]*sum))

        #Weight Adjustment for Input to Hidden synapses
        for i in range(hnodes):
            for j in range(inodes):
                wih[i][j] += lr*localG_h[i]*inputs[i][j]

#testing   
test_inputs = [1,0]
hidden_inputs = []
hidden_outputs = []
final_inputs = []
final_outputs = [] 
for i in range(hnodes):   
    sum = 0
    for j in range(inodes):
        sum += wih[i][j]*test_inputs[j]
    hidden_inputs.append(sum)
    hidden_outputs.append(activation_function(sum))

for i in range(onodes):
    sum = 0
    for j in range(hnodes):
        sum += who[i][j]*hidden_outputs[j]
    final_inputs.append(sum)
    final_outputs.append(activation_function(sum))    
print(final_outputs)