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到0的向量，因此我的目标值的索引是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％的准确率。希望这有助于其他人。

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

1 个答案: