Como um acompanhamento de Minha rede neural não consegue nem aprender a distância euclidiana , simplifiquei ainda mais e tentei treinar uma única ReLU (com peso aleatório) em uma única ReLU. Essa é a rede mais simples que existe e, ainda assim, metade do tempo em que falha na convergência.
Se o palpite inicial estiver na mesma orientação que o destino, ele aprenderá rapidamente e convergirá para o peso correto de 1:
Se o palpite inicial for "para trás", ele fica preso a um peso zero e nunca passa por ele para a região de menor perda:
Eu não entendo o porquê. A descida do gradiente não deve seguir facilmente a curva de perda até os mínimos globais?
Código de exemplo:
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()
Coisas semelhantes acontecem se eu adicionar viés: a função de perda 2D é suave e simples, mas se o relu começar de cabeça para baixo, ele circula e fica preso (pontos de partida vermelhos) e não segue o gradiente até o mínimo (como ele faz para pontos de partida azuis):
Coisas semelhantes acontecem se eu adicionar peso e viés de saída também. (Virará da esquerda para a direita ou de cima para baixo, mas não ambos.)
Respostas:
Isso está relacionado ao fenômeno da morte relu; para alguma discussão, consulte Minha rede ReLU falha ao iniciar
Uma abordagem que poderia ser mais bem-sucedida seria usar uma não-linearidade diferente, como o relu com vazamento, que não possui a chamada questão do "gradiente de fuga". A função relu com vazamento é
LeakyReLU
ReLU
O código relevante está abaixo; use
opt_sgd
ouopt_adam
.fonte