为什么单个ReLU无法学习ReLU？

作为我神经网络甚至无法学习欧几里德距离的后续操作，我进一步简化了方法，并尝试将单个ReLU（具有随机权重）训练为单个ReLU。这是目前最简单的网络，但有一半时间未能融合。

如果初始猜测与目标的方位相同，则它会快速学习并收敛到正确的权重1：

如果最初的猜测是“向后”，则它的权重为零，并且永远不会经过它到达较低损失的区域：

我不明白为什么。梯度下降不应该轻易遵循损耗曲线达到全局最小值吗？

示例代码：

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, ReLU
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

batch = 1000


def tests():
    while True:
        test = np.random.randn(batch)

        # Generate ReLU test case
        X = test
        Y = test.copy()
        Y[Y < 0] = 0

        yield X, Y


model = Sequential([Dense(1, input_dim=1, activation=None, use_bias=False)])
model.add(ReLU())
model.set_weights([[[-10]]])

model.compile(loss='mean_squared_error', optimizer='sgd')


class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = []
        self.weights = []
        self.n = 0
        self.n += 1

    def on_epoch_end(self, batch, logs={}):
        self.losses.append(logs.get('loss'))
        w = model.get_weights()
        self.weights.append([x.flatten()[0] for x in w])
        self.n += 1


history = LossHistory()

model.fit_generator(tests(), steps_per_epoch=100, epochs=20,
                    callbacks=[history])

fig, (ax1, ax2) = plt.subplots(2, 1, True, num='Learning')

ax1.set_title('ReLU learning ReLU')
ax1.semilogy(history.losses)
ax1.set_ylabel('Loss')
ax1.grid(True, which="both")
ax1.margins(0, 0.05)

ax2.plot(history.weights)
ax2.set_ylabel('Weight')
ax2.set_xlabel('Epoch')
ax2.grid(True, which="both")
ax2.margins(0, 0.05)

plt.tight_layout()
plt.show()

如果我添加偏差，也会发生类似的事情：2D损失函数既平滑又简单，但是如果relu上下颠倒，它就会绕圈并卡住（红色起始点），并且不会遵循梯度下降到最小值（就像它一样）对于蓝色起点）：

如果我也增加输出权重和偏差，也会发生类似的情况。（它会左右翻转，或上下翻转，但不能同时翻转）。

在您的图中有一个暗示，表明损耗是的函数。这些图在附近有一个“扭结” ：这是因为在0的左侧，损耗的梯度逐渐消失为0（但是，是次优的解决方案，因为那里的损耗比）。此外，此图还显示了损失函数是非凸的（您可以在3个或更多位置绘制一条与损失曲线交叉的线），因此在使用局部优化器（例如SGD）时，我们应该谨慎行事。确实，以下分析表明，当初始化为负数时，有可能收敛到次优解。$w$$w=0$w = 0 w = 1 w$w=0$$w=1$$w$

优化问题是

$$\begin{align} \min_{w,b} &\|f(x)-y\|_2^2 \\ f(x) &= \max(0, wx+b) \end{align}$$

并且您正在使用一阶优化来做到这一点。这种方法的问题是具有梯度$f$

$$f^\prime(x)= \begin{cases} w, & \text{if $x>0$} \\ 0, & \text{if $x<0$} \end{cases}$$

当您从开始时，您将必须移至的另一侧才能接近正确的答案，即。这很困难，因为非常非常小，梯度也会逐渐变小。而且，您从左侧越接近0，则进度会越慢！$w<0$$0$$w=1$$|w|$

这就是为什么在您的图中，对于为负的初始化，您的轨迹都停在。这也是第二个动画显示的内容。$w^{(0)} <0$$w^{(i)}=0$

这与垂死的鲁鲁现象有关；有关某些讨论，请参阅My ReLU网络无法启动

可能更成功的方法是使用不同的非线性，例如泄漏的磁阻效应，它没有所谓的“消失梯度”问题。泄漏的relu函数是

$$g(x)= \begin{cases} x, & \text{if $x>0$} \\ cx, & \text{otherwise} \end{cases}$$ 其中是一个常数，因此小而积极。起作用的原因是导数不是“左侧”为0。$c$$|c|$

$$g^\prime(x)= \begin{cases} 1, & \text{if $x>0$} \\ c, & \text{if $x < 0$} \end{cases}$$

设置是普通的relu。大多数人选择为或。我还没有看到使用，但是我有兴趣研究一下它对这样的网络有什么影响。（请注意，对于这简化为恒等函数；对于，许多这样的层的组成可能会导致爆炸梯度，因为梯度在连续的层中会变大。）$c=0$$c$$0.1$$0.3$$c<0$$c=1,$$|c|>1$

稍微修改OP的代码可以证明问题在于激活功能的选择。此代码将初始化为负数，并使用in代替normal 。损耗迅速减小到一个很小的值，权重正确地移动到，这是最佳的。$w$LeakyReLUReLU$w=1$

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, ReLU
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

batch = 1000


def tests():
    while True:
        test = np.random.randn(batch)

        # Generate ReLU test case
        X = test
        Y = test.copy()
        Y[Y < 0] = 0

        yield X, Y


model = Sequential(
    [Dense(1, 
           input_dim=1, 
           activation=None, 
           use_bias=False)
    ])
model.add(keras.layers.LeakyReLU(alpha=0.3))
model.set_weights([[[-10]]])

model.compile(loss='mean_squared_error', optimizer='sgd')


class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = []
        self.weights = []
        self.n = 0
        self.n += 1

    def on_epoch_end(self, batch, logs={}):
        self.losses.append(logs.get('loss'))
        w = model.get_weights()
        self.weights.append([x.flatten()[0] for x in w])
        self.n += 1


history = LossHistory()

model.fit_generator(tests(), steps_per_epoch=100, epochs=20,
                    callbacks=[history])

fig, (ax1, ax2) = plt.subplots(2, 1, True, num='Learning')

ax1.set_title('LeakyReLU learning ReLU')
ax1.semilogy(history.losses)
ax1.set_ylabel('Loss')
ax1.grid(True, which="both")
ax1.margins(0, 0.05)

ax2.plot(history.weights)
ax2.set_ylabel('Weight')
ax2.set_xlabel('Epoch')
ax2.grid(True, which="both")
ax2.margins(0, 0.05)

plt.tight_layout()
plt.show()

另一层复杂性来自以下事实：我们不是无限地运动，而是有限地多次“跳跃”，这些跳跃将我们从一次迭代转移到了另一次迭代。这意味着在某些情况下负初始值不会卡住；这些情况是由于和梯度下降步长的特定组合而产生的，该步长足够大以“消失”在消失的梯度上。$w$ $w^{(0)}$

我已经使用了一些代码，发现将初始化保留在，并将优化器从SGD更改为Adam，Adam + AMSGrad或SGD +动量没有任何帮助。此外，从SGD更改为Adam不仅减缓了在此问题上消失的梯度，而且实际上减缓了进度。$w^{(0)}=-10$

另一方面，如果将初始化更改为并将优化器更改为Adam（步长为0.01），则实际上可以克服消失的梯度。如果您使用和SGD带动量（步长为0.01），它也可以使用。如果您使用香草SGD（步长为0.01）并且它甚至可以工作。$w^{(0)}=-1$ $w^{(0)}=-1$$w^{(0)}=-1$

相关代码如下；使用opt_sgd或opt_adam。

opt_sgd = keras.optimizers.SGD(lr=1e-2, momentum=0.9)
opt_adam = keras.optimizers.Adam(lr=1e-2, amsgrad=True)
model.compile(loss='mean_squared_error', optimizer=opt_sgd)