为什么 MLP 的成本函数变平？

Question

我是机器学习的新手，正在尝试实施 MLP，但是成本函数似乎在达到全局最小值之前就已经达到了局部最小值。我将成本绘制为迭代的函数（包括 0 值，以免被 y 轴的起始位置所迷惑）。这是我尝试使用的代码：

import numpy as np

class NNet(object):
def __init__(self, n_in, n_hidden, n_out):
    self.n_in = n_in
    self.n_hidden = n_hidden
    self.n_out = n_out

    self.W1 = np.random.randn(n_in, n_hidden)
    self.W2 = np.random.randn(n_hidden, n_out)

    self.b1 = np.random.randn(n_hidden,)
    self.b2 = np.random.randn(n_out,)

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

def sig_prime(self, z):
    return (np.exp(-z))/((1+np.exp(-z))**2)

def propagate_forward(self, X):
    self.z1 = np.dot(self.W1.T, X) + self.b1
    self.a1 = self.sigmoid(self.z1)
    self.z2 = np.dot(self.W2.T, self.a1) + self.b2
    self.a2 = self.sigmoid(self.z2)
    return self.a2

def cost(self, y, y_hat):
    return np.mean([np.sum((y[i] - y_hat[i])**2) for i in range(y.shape[0])])/2

def cost_grad(self, X, y):
    y_hat = self.propagate_forward(X)

    d2 = np.multiply(self.sig_prime(self.z2), -(y - y_hat))
    gJ_W2 = np.matrix(np.multiply(self.a1.T, d2))

    d1 = np.dot(self.W2, d2)*self.sig_prime(self.z1)
    gJ_W1 = np.dot(np.matrix(X).T, np.matrix(d1))

    return [gJ_W1, d1, gJ_W2, d2]

m = 1000
n = 1

X = np.zeros((m, n))
y = np.zeros((m,1))

import random
import math

i = 0
for r, theta in zip(np.linspace(0, 5, num=m), np.linspace(0, 8 * math.pi, num=m)):
    r += random.random()
    X[i] = [r * math.cos(theta), r * math.sin(theta)]
    if i < 333:
        y[i] = 0
    elif i < 666:
        y[i] = 1
    else:
        y[i] = 2
    i += 1

nnet = NNet(n, 5, 1)
learning_rate = 0.2
improvement_threshold = 0.995
cost = np.inf

xs = []
ys = []

iter = 0
while cost > 0.2:
cost = nnet.cost(y, [nnet.propagate_forward(x_train) for x_train 

if iter % 100 == 0:
    xs.append(iter)
    ys.append(cost)
    print("Cost", cost)

if iter >= 1000:
    print("Gradient descent is taking too long, giving up.")
    break

cost_grads = [nnet.cost_grad(x_train, y_train) for x_train, y_train in zip(X, y)]
gW1 = [grad[0] for grad in cost_grads]
gb1 = [grad[1] for grad in cost_grads]
gW2 = [grad[2] for grad in cost_grads]
gb2 = [grad[3] for grad in cost_grads]

nnet.W1 -= np.mean(gW1, axis=0)/2 * learning_rate
nnet.b1 -= np.mean(gb1, axis=0)/2 * learning_rate
nnet.W2 -= np.mean(gW2, axis=0).T/2 * learning_rate
nnet.b2 -= np.mean(gb2, axis=0)/2 * learning_rate

iter += 1

为什么成本在某个点后没有改善？也非常感谢任何其他提示。

生成的玩具数据集如下所示

Answer 1

您的目标似乎是预测 class {0,1,2} 属于哪个数据。

你的网络的输出是一个 sigmoid（[0,1] 中的 sigm(x)），你是使用均方误差 (MSE) 进行训练时，模型不可能预测大于 1 的值。因此当 class 预测为 2 时，它总是错误的。

成本可能会变平，因为你的 sigmoid 单元饱和（当试图预测 2 时）并且饱和 sigmoid 的梯度为 0

对于 classification 神经网络通常以 softmax 层结束并且使用 cross-entropy.

训练

如果你想继续使用 MSE 和 sigmoids 单元进行 class化，你应该考虑以一种 One-vs-(One/All) 的方式一次只预测两个 classes。

无论如何，如果您只通过将输出四舍五入为 0 或 1 来进行双向 class class 化，它似乎可以工作。成本在下降，准确率在上升 (quickly modified code):

为什么 MLP 的成本函数变平？

Why does cost function for MLP flatten?

python

numpy

machine-learning

gradient-descent