反向传播输出趋向于相同的值

Question

我正试图创建一个多层前馈-反向传播神经网络来识别手写数字，我遇到了一个问题，我的输出层中的激活都趋向于相同的值。你知道吗

我使用的是Optical Recognition of Handwritten Digits Data Set，训练数据如下

0,1,6,15,12,1,0,0,0,7,16,6,6,10,0,0,0,8,16,2,0,11,2,0,0,5,16,3,0,5,7,0,0,7,13,3,0,8,7,0,0,4,12,0,1,13,5,0,0,0,14,9,15,9,0,0,0,0,6,14,7,1,0,0,0

它表示一个8x8矩阵，其中64个整数中的每一个都对应于子4x4矩阵中的暗像素数，最后一个整数是分类。你知道吗

我在输入层中使用64个节点对应64个整数，在一些隐藏层中使用一些隐藏节点，在输出层中使用10个节点对应0-9。你知道吗

我的权重在这里初始化，并且为输入层和隐藏层添加了偏差

self.weights = []
        for i in xrange(1, len(layers) - 1):
            self.weights.append(
                np.random.uniform(low=-0.2,
                                  high=0.2,
                                  size=(layers[i-1] + 1, layers[i] + 1)))
        # Output weights
        self.weights.append(
            np.random.uniform(low=-0.2,
                              high=0.2,
                              size=(layers[-2] + 1, layers[-1])))

其中list包含每层中的节点数，例如

layers=[64, 30, 10]

我用逻辑函数作为我的激活函数

def logistic(self, z):
        return sp.expit(z)

及其衍生物

def derivative(self, z):
        return sp.expit(z) * (1 - sp.expit(z))

我的反向传播算法大量借鉴了here；我以前的尝试失败了，所以我想尝试另一种路由。你知道吗

def back_prop_learning(self, X, y):
        # add biases to inputs with value of 1
        biases = np.atleast_2d(np.ones(X.shape[0]))
        X = np.concatenate((biases.T, X), axis=1)

        # Iterate over training set
        for epoch in xrange(self.epochs):
            # for each weight w[i][j] in network assign random tiny values
            # handled in __init__


            ''' PROPAGATE THE INPUTS FORWARD TO COMPUTE THE OUTPUTS '''
            for example in zip(X, y):
            # for each node i in the input layer
            # set input layer outputs equal to input vector outputs
            activations = [example[0]]

            # for layer = 1 (first hidden) to output layer
            for layer in xrange(len(self.weights)):
                # for each node j in layer
                weighted_sum = np.dot(activations[layer], self.weights[layer])
                # assert number of outputs == number of weights in each layer
                assert(len(activations[layer]) == len(self.weights[layer]))
                # compute activation of weighted sum of node j
                activation = self.logistic(weighted_sum)
                # append vector of activations
                activations.append(activation)

            ''' PROPAGATE DELTAS BACKWARDS FROM OUTPUT LAYER TO INPUT LAYER '''
            # for each node j in the output layer
            # compute error of target - output
            errors = example[1] - activations[-1]
            # multiply by derivative
            deltas = [errors * self.derivative(activations[-1])]

            # for layer = last hidden layer down to first hidden layer
            for layer in xrange(len(activations)-2, 0, -1):
                deltas.append(deltas[-1].dot(self.weights[layer].T) * self.derivative(activations[layer]))

            ''' UPDATE EVERY WEIGHT IN NETWORK USING DELTAS '''
            deltas.reverse()
            # for each weight w[i][j] in network
            for i in xrange(len(self.weights)):
                layer = np.atleast_2d(activations[i])
                delta = np.atleast_2d(deltas[i])
                self.weights[i] += self.alpha * layer.T.dot(delta)

我运行测试数据后的输出都类似于

[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.] 9.0
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.] 4.0
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.] 6.0
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.] 6.0
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.] 7.0

无论我选择什么样的学习率，隐藏节点的数量，或隐藏层的数量，一切似乎都倾向于1。这让我怀疑我是否正确地处理和设置了问题，64个输入到10个输出，或者我是否正确地选择/实现了我的sigmoid函数，或者我的反向传播算法的实现是否失败了。我已经用同样的结果重新创建了上述程序两到三次，这使我相信我从根本上误解了问题，没有正确地表示它。你知道吗

Answer 1

我想我已经回答了我的问题。你知道吗

我相信问题在于我是如何计算输出层中的错误的。我将其计算为errors = example[1] - activations[-1]，这创建了一个错误数组，其结果是从目标值中减去我的输出层激活。你知道吗

我改变了这个，使我的目标值是一个0-9的向量，所以我的目标值的索引是1.0。你知道吗

y = int(example[1])
errors_v = np.zeros(shape=(10,), dtype=float)
errors_v[y] = 1.0
errors = errors_v - activations[-1]

我还把我的激活函数改为tanh函数。你知道吗

这大大增加了我的输出层中激活的差异，到目前为止，在有限的测试中，我已经能够达到50%-75%的准确率。希望这能帮助其他人。你知道吗