ValueError: формы (2,) и (5,) не выровнены: 2 (dim 0)! = 5 (dim 0)

Question

После просмотра YouTube-видео с нейронными сетями я попытался создать одно с нуля, но это дает мне ошибку, что размеры неправильные. Я не знаю много о матрицах или numpy, и именно поэтому я не могу получить ответ. Я был бы очень рад, если бы кто-то мог помочь мне с моей сетью.

import numpy as np

class NeuralNetwork:

    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.w1 = np.random.randn(self.input_size, self.hidden_size)
        self.w2 = np.random.randn(self.hidden_size, self.output_size)

    def sigmoid(self, n):
        return 1 / (1 + np.exp(-n))

    def sigmoid_prime(self, n):
        return self.sigmoid(n) * (1 - self.sigmoid(n))

    def propagation(self, x, y):
        # forward 
        hidden1 = np.dot(x, self.w1)
        hidden = self.sigmoid(hidden1)
        output1 = np.dot(hidden, self.w2)
        output = self.sigmoid(output1)
        # backward
        output_error = y - output
        output_delta = output_error * self.sigmoid_prime(output)
        hidden_error = output_delta.dot(self.w2.T)
        hidden_delta = hidden_error*self.sigmoid_prime(hidden)
        self.w1 += x.T.dot(hidden_delta)
        self.w2 += hidden.T.dot(output_delta)

    def predict(self, x):
        hidden1 = np.dot(x, self.w1)
        hidden = self.sigmoid(hidden1)
        output1 = np.dot(hidden, self.w2)
        output = self.sigmoid(output1)
        return(output)


MyNet = NeuralNetwork(2, 5, 1)

for _ in range(500):
    MyNet.propagation(
        np.array([0, 1]),
        np.array([1])
    )

print(MyNet.predict( np.array([0, 1])))

Answer 1

Для облегчения помощи, пожалуйста, укажите, где произошла ошибка и какая в сообщении.

Как я вижу, вы пытаетесь сделать следующее (верно в математической формулировке):

Ваша проблема в том, что вы пытаетесь выполнить матричное умножение, когда ваши векторы имеют только одно измерение. Чтобы решить эту проблему, вы должны просто использовать reshape:

self.w1 + = x.T.reshape(-1, 1).dot(hidden_delta.reshape(1, -1))
self.w2 + = hidden.T.reshape(-1, 1).dot(output_delta.reshape(1, -1))

Я предлагаю, чтобы при использовании сигмоида не использовалась ошибка MSE (|| y - y_pred||^2), а использовалась кросс-энтропия . Это лучший показатель, когда вы имеете дело с вероятностями.

Перекрестная энтропия определяется следующим образом:

# cross_entropy = - y log(x) + (1 - y) log(1 - x)
# dcross_entropy/dx = - y / x + (1 - y) / (1 - x)
output_error = (-y / (output + 1e-10)) + ((1 - y) / ( (1 - output) + 1e-10))

EDIT

import numpy as np

class NeuralNetwork:

    def __init__(self, input_size, hidden_size, output_size, lr=0.1):
        self.lr = lr
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.w1 = np.random.randn(self.input_size, self.hidden_size)
        self.w2 = np.random.randn(self.hidden_size, self.output_size)

    def sigmoid(self, n):
        return 1 / (1 + np.exp(-n))

    """def sigmoid_prime(self, n):
        return self.sigmoid(n) * (1 - self.sigmoid(n))"""

    def propagation(self, x, y):
        # forward 
        hidden1 = np.dot(x, self.w1)
        hidden = self.sigmoid(hidden1)
        output1 = np.dot(hidden, self.w2)
        output = self.sigmoid(output1)

        loss = -np.sum(y*np.log(output) + (1 - y)*np.log(1 - output), axis=-1)
        print('Loss:', np.mean(loss))

        # backward
        #output_error = (-y / (output + 1e-10)) + ((1 - y) / ( (1 - output) + 1e-10))
        #output_delta = output_error * output * (1 - output)
        # simplified
        output_delta = - y*(1 - output) + (1 - y)*output
        self.w2 += - self.lr*hidden.T.dot(output_delta) / x.shape[0]

        hidden_error = output_delta.dot(self.w2.T)
        hidden_delta = hidden_error* hidden * (1 - hidden)
        self.w1 += - self.lr*x.T.dot(hidden_delta) / x.shape[0]

    def predict(self, x):
        hidden1 = np.dot(x, self.w1)
        hidden = self.sigmoid(hidden1)
        output1 = np.dot(hidden, self.w2)
        output = self.sigmoid(output1)
        return(output)


MyNet = NeuralNetwork(2, 10, 1)

for _ in range(50000):
    MyNet.propagation(
        np.array([[0, 1], [1, 0], [1, 1], [0, 0]]),
        np.array([[1], [1], [0], [0]])
    )

print(MyNet.predict( np.array([0, 0]).reshape(1, -1)))
print(MyNet.predict( np.array([0, 1]).reshape(1, -1)))
print(MyNet.predict( np.array([1, 0]).reshape(1, -1)))
print(MyNet.predict( np.array([1, 1]).reshape(1, -1)))