在 for 循环期间错误地收缩为向量的矩阵 - 神经网络，Python

Question

我正在尝试用 Python 编写简单的 2 输出 XOR 神经网络，没有隐藏层。我有大小为 (3,2) 的权重矩阵。因为我在学习时有两个输出，所以我计算两个单独的错误：第一个错误假设更新权重矩阵的第一列，第二个错误 - 第二列权重矩阵。因此，在用于训练过程的 for 循环的中间，我插入了一个根据错误数量（本例中为 2）迭代的 for 循环。在这个内部 for 循环中，它尝试更新权重矩阵，但在第一次迭代中，在权重矩阵更新后，由于某种我不知道的原因，它被缩短为仅由更新后的第一列组成的向量权重矩阵。

有人可以帮我解决这个问题吗？代码：

import numpy as np

data = np.array([[0, 0],
                [0, 1],
                [1, 0],
                [1, 1]])
data = np.transpose(data)
print("Data:")
print(data)

#target = np.array([[0], [0], [0], [1]])     #AND
target = np.array([[0, 1],
                   [1, 0],
                   [1, 0],
                   [0, 1]])     #XOR
print("Targets:")
print(target)

# get the number of columns
numberOfColumns = data.shape[1]
print('Number of columns', numberOfColumns)

inputSize = data.shape[0]
print('Number of rows', inputSize)

# add the vector of ones to the data matrix - polarization
data = np.r_[data, np.ones((1, numberOfColumns), int)]


# sigmoid activation function
def sigmoid(x, derivative=False):
    v = 1 / (1 + np.exp(-x))

    if derivative:
        v = v * (1 - 1 / (1 + np.exp(-x)))

    return v


# linear activation function
def linear(x, derivative=False):
    v = x

    if derivative:
        v = np.ones(x.shape)

    return v


eta = 0.1  # learning rate
epochs = 1000   #number of epochs
afun = sigmoid  #activation function
#afun = linear
w = np.array([[0.01, 0.2],   #net weights
              [0.1, 0.1],
              [0.2, 0.01]])



y = np.zeros(numberOfColumns)
e = 0
for j in range(numberOfColumns):
    y= afun(np.dot(w.transpose(),data))
    y= np.transpose(y)
    #print("Y:")
    #print(y)
    e = e + 0.5 * np.power((y[j, ] - target[j]), 2)
    #print("Error:")
    #print(e)

e=np.mean(e)

print("\nBefore training")
print("Weights:")
print(w)
print("Y:")
print(y)
print("Error:")
print(e)

#####################################
print("\nData after polarization:")
print(data)

#####################################
print("\nLearning")

for epoch in range(epochs):
    for j in range(numberOfColumns):
        y = afun(np.dot(data[:, j], w))
        #print("Y:")
        #print(y)
        error = y - target[j]
        print("Error:")
        print(error)
        print("Error shape:")
        print(error.shape[0])
        print("w shape:")
        print(w.shape)
        for i in range(error.shape[0]):
            dw = eta * error[i] * np.multiply(afun(data[:, j], True), data[:, j])
            print("dw:")
            print(dw)
            print("w before:")
            print(w)
            w = w[:, i]-np.transpose(dw)
            print("w after:")
            print(w)

# Checking the learning
y = np.zeros(numberOfColumns)
e = 0
for j in range(numberOfColumns):
    y = afun(np.dot(w.transpose(), data))
    y = np.transpose(y)
    #print("Y:")
    #print(y)
    e = e + 0.5*np.power((y[j, ] - target[j]), 2)

e=np.mean(e)

print("\nAfter training")
print("Weights:")
print(w)
print("Net output:")
print(y)
print("Error:")
print(e)

老实说我不明白这个问题。我不知道为什么权重矩阵被缩短为仅由更新的权重矩阵第一列组成的向量。我期望在第一次迭代中更新权重矩阵的第一列，然后在第二次迭代中更新第二列。

Answer 1

您正在代码第 106 行重新定义

w

：

w = w[:, i] - np.transpose(dw)

我想应该是：

w[:, i] = w[:, i] - np.transpose(dw)