Perché una sola ReLU non può imparare una ReLU?

Come follow-up della mia rete neurale non riesco nemmeno a imparare la distanza euclidea, ho semplificato ancora di più e ho cercato di addestrare una singola ReLU (con peso casuale) su una singola ReLU. Questa è la rete più semplice che ci sia, eppure la metà delle volte non riesce a convergere.

Se l'ipotesi iniziale ha lo stesso orientamento del bersaglio, impara rapidamente e converge al peso corretto di 1:

Se l'ipotesi iniziale è "all'indietro", si blocca con un peso pari a zero e non passa mai attraverso la regione di perdita inferiore:

Non capisco perché. La discesa del gradiente non dovrebbe seguire facilmente la curva di perdita ai minimi globali?

Codice di esempio:

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()

Cose simili accadono se aggiungo distorsione: la funzione di perdita 2D è fluida e semplice, ma se la relù si avvia sottosopra, gira e si blocca (punti di partenza rossi) e non segue il gradiente fino al minimo (piace fa per i punti di partenza blu):

Cose simili accadono se aggiungo anche peso e distorsione dell'output. (Capovolge da sinistra a destra o dall'alto verso il basso, ma non entrambi.)

$w$$w=0$$w=0$$w=1$$w$ è inizializzato per essere negativo, è possibile convergere in una soluzione non ottimale.

$f$

$w<0$$0$$w=1$$|w|$

$w^{(0)} <0$$w^{(i)}=0$

Ciò è legato al fenomeno dei morenti relu; per alcune discussioni, vedere Impossibile avviare la mia rete ReLU

Un approccio che potrebbe avere più successo sarebbe quello di utilizzare una diversa non linearità come la reli perde, che non ha il cosiddetto problema del "gradiente di sparizione". La funzione relu che perde è

$c=0$$c$$0.1$$0.3$$c<0$$c=1,$$|c|>1$

$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)}$

$w^{(0)}=-10$

$w^{(0)}=-1$ $w^{(0)}=-1$$w^{(0)}=-1$

Il codice pertinente è di seguito; usare opt_sgdo 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)