python - 简单的神经网络调试

Question

我正在尝试基于编码训练课程创建一个 python 神经网络实现，但我一直在调试，无法找出我搞砸了什么。目前在计算隐藏层的增量时出现问题，我认为矩阵操作存在一些影响后续步骤的问题。有人可以帮忙调试吗？

import numpy as np


class NeuralNetwork:

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

    def sigmoid_d(self, x):
        return x * (1 - x)

    def __init__(self, input_nodes, hidden_nodes, output_nodes):
        # Save size properties
        self.input_nodes_count = input_nodes
        self.hidden_nodes_count = hidden_nodes
        self.output_nodes_count = output_nodes

        # Generate random weights
        self.weights_ih = np.random.random((self.hidden_nodes_count, self.input_nodes_count))
        self.weights_ho = np.random.random((self.output_nodes_count, self.hidden_nodes_count))

        # Generate weights for biases
        self.bias_h = np.random.randn()
        self.bias_o = np.random.randn()

        # Set learning rate
        self.learningRate = 0.1

    def calc_hidden(self, inputs):
        # Prepare hidden values
        hidden_without_bias = np.dot(self.weights_ih, inputs)

        # Add bias for hidden values
        hidden_not_activated = np.add(hidden_without_bias, self.bias_h)

        # Execute hidden activation
        hidden = list(map(lambda x: self.sigmoid(x), hidden_not_activated))

        return hidden

    def calc_output(self, inputs):
        # Prepare output values
        output_without_bias = np.dot(self.weights_ho, inputs)

        # Add bias for output values
        output_not_activated = np.add(output_without_bias, self.bias_o)

        # Execute output activation
        outputs = list(map(lambda x: self.sigmoid(x), output_not_activated))

        return outputs

    def predict(self, inputs):
        # Calc hidden values
        hidden = self.calc_hidden(inputs)

        # Calc output values
        outputs = self.calc_output(hidden)

        return outputs

    def train(self, inputs, targets):
        # Calc hidden values
        hidden = self.calc_hidden(inputs)

        # Calc output values
        outputs = self.calc_output(hidden)

        # Calc output errors
        output_errors = np.subtract(outputs, targets)

        # Calc the output gradient
        gradients = list(map(lambda x: self.sigmoid_d(x), outputs))
        gradients = np.multiply(gradients, output_errors)
        gradients = np.multiply(gradients, self.learningRate)

        # Calc deltas
        hidden_t = np.transpose(hidden)
        weights_ho_deltas = np.dot(gradients, hidden_t)

        # Adjust output weights by deltas
        for i in range(len(self.weights_ho)):
            for j in range(len(self.weights_ho[i])):
                self.weights_ho[i][j] += weights_ho_deltas[i][j]
        self.bias_o += gradients

        # Calc the hidden layer errors
        weights_ho_t = np.transpose(self.weights_ho)
        hidden_errors = np.dot(weights_ho_t, output_errors)
        # Calc the hidden gradient
        hidden_gradients = list(map(lambda x: self.sigmoid_d(x), hidden))
        hidden_gradients = np.multiply(hidden_gradients, hidden_errors)
        hidden_gradients = np.multiply(hidden_gradients, self.learningRate)

        # Calc hidden deltas
        inputs_t = np.transpose(inputs)
        weights_ih_deltas = np.dot(hidden_gradients, inputs_t)

        # Adjust hidden weights by deltas
        for i in range(len(self.weights_ih)):
            for j in range(len(self.weights_ih)):
                self.weights_ih[i][j] += weights_ih_deltas[i][j]
        self.bias_h += hidden_gradients


if __name__ == '__main__':
    neuralNetwork = NeuralNetwork(2, 2, 1)

    training_data = [[0, 0], [0, 1], [1, 0], [1, 1]]
    training_output = [[0], [1], [1], [0]]

    for i in range(1):
        index = np.random.randint(0, len(training_output))
        neuralNetwork.train(training_data[index], training_output[index])

    print(neuralNetwork.predict([1, 1]))

标签： pythonneural-network