Python 奇异结果神经网络

我在这里看了一篇文章：

我写了关于网络的数学方程式，一切都有意义

然而，在编写代码之后，结果非常奇怪，就像它总是预测同一个类

我花了很多时间在这上面，改变了很多事情，但我仍然无法理解我做错了什么

代码如下：

# coding: utf-8

from mnist import MNIST
import numpy as np
import math
import os
import pdb


DATASETS_PREFIX    = '../Datasets/MNIST'
mndata             = MNIST(DATASETS_PREFIX)
TRAINING_IMAGES, TRAINING_LABELS  = mndata.load_training()
TESTING_IMAGES , TESTING_LABELS   = mndata.load_testing()

### UTILS

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

def d_sigmoid(x):
    return x.T * (1 - x)
    #return np.dot(x.T, 1.0 - x)

def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

def d_softmax(x):
    #This function has not yet been tested.
    return x.T * (1 - x)

def tanh(x):
    return np.tanh(x)

def d_tanh(x):
    return 1 - x.T * x

def normalize(image):
    return image / (255.0 * 0.99 + 0.01)

### !UTILS

class NeuralNetwork(object):
    """
    This is a 3-layer neural network (1 hidden layer).
    @_input   : input layer
    @_weights1: weights between input layer and hidden layer  (matrix shape (input.shape[1], 4))
    @_weights2: weights between hidden layer and output layer (matrix shape (4, 1))
    @_y       : output
    @_output  : computed output
    @_alpha   : learning rate
    """
    def __init__(self, xshape, yshape):
        self._neurones_nb = 20
        self._input       = None
        self._weights1    = np.random.randn(xshape, self._neurones_nb)
        self._weights2    = np.random.randn(self._neurones_nb, yshape)
        self._y           = np.mat(np.zeros(yshape))
        self._output      = np.mat(np.zeros(yshape))
        self._alpha1      = 0.1
        self._alpha2      = 0.1
        self._function    = sigmoid
        self._derivative  = d_sigmoid
        self._epoch       = 1

    def Train(self, xs, ys):
        for j in range(self._epoch):
            for i in range(len(xs)):
                self._input = normalize(np.mat(xs[i]))
                self._y[0, ys[i]] = 1
                self.feedforward()
                self.backpropagation()
                self._y[0, ys[i]] = 0

    def Predict(self, image):
        self._input = normalize(image)
        out = self.feedforward()
        return out

    def feedforward(self):
        self._layer1 = self._function(np.dot(self._input, self._weights1))
        self._output = self._function(np.dot(self._layer1, self._weights2))
        return self._output

    def backpropagation(self):
        d_weights2 = np.dot(
            self._layer1.T,
            2 * (self._y - self._output) * self._derivative(self._output)
        )
        d_weights1 = np.dot(
            self._input.T,
            np.dot(
                2 * (self._y - self._output) * self._derivative(self._output),
                self._weights2.T
            ) * self._derivative(self._layer1)
        )
        self._weights1 += self._alpha1 * d_weights1
        self._weights2 += self._alpha2 * d_weights2

if __name__ == '__main__':
    neural_network = NeuralNetwork(len(TRAINING_IMAGES[0]), 10)
    print('* training neural network')
    neural_network.Train(TRAINING_IMAGES, TRAINING_LABELS)
    print('* testing neural network')
    count = 0
    for i in range(len(TESTING_IMAGES)):
        image       = np.mat(TESTING_IMAGES[i])
        expected    = TESTING_LABELS[i]
        prediction  = neural_network.Predict(image)
        if i % 100 == 0: print(expected, prediction)
    #print(f'* results: {count} / {len(TESTING_IMAGES)}')

谢谢你的帮助，非常感谢

---

Julien

嗯，我看不出实施中有任何错误，因此考虑到您的网络，可以通过做两件事来改进：

• 一个时代是不够的。不是所有的！您需要多次传递数据（最基本的是10次，平均可能是100个纪元左右，这可能会达到5000个或更多）

• 您的网络是一个浅层网络，例如，非常简单。要检测困难的事物（如图像），您可以实现CNN（卷积神经网络），或者首先尝试深化网络并使其复杂化

---

=>尝试添加层（3、4、5等），然后根据输入的大小向每个层（50、60、…）添加神经元。您仍然可以增加到800900或更多。

我还尝试了不同的标准化函数（image/255），结果相同。有多少个纪元？隐藏层的数量是多少？按层划分的神经元数量？我想这都在代码中。1 epoch 1隐藏层20个神经元在隐藏层784个神经元在输入层（MNIST）10个神经元在输出层谢谢你的回答。我正在按照您的建议实现更多的层，我将看看它提供了什么。但我有一种感觉，即使是一个简单的感知器也应该提供一些有趣的东西，也许不是惊人的性能，但仍然是一些东西。我的意思是，即使一个贝叶斯可以正确地对MNIST进行分类，我也不必去深入学习技术来完成它。不，你明白我的意思吗？我明白你的意思。你如何监控你的结果？例如，你的衡量标准是什么？比如你的准确度得分，混淆矩阵等等？准确度得分是的。我还显示每个班级的分数。奇怪的是，它对每幅图像的评分都差不多。你的意思是0类为70%，1类为71%，等等？我没有看到任何奇怪的东西。你的总体准确度是多少？我刚才注意到的另一件奇怪的事情是，你应该使用softmax（用于多类）而不是sigmoid（仅用于两类）