Tại sao một ReLU không thể học ReLU?

Khi theo dõi mạng lưới thần kinh của tôi, tôi thậm chí không thể học được khoảng cách Euclide, tôi đã đơn giản hóa hơn nữa và cố gắng huấn luyện một ReLU duy nhất (với trọng lượng ngẫu nhiên) thành một ReLU duy nhất. Đây là mạng đơn giản nhất có, và một nửa thời gian nó không hội tụ.

Nếu dự đoán ban đầu có cùng hướng với mục tiêu, nó sẽ học nhanh và hội tụ đúng trọng số 1:

Nếu dự đoán ban đầu là "ngược", nó sẽ bị kẹt ở mức 0 và không bao giờ đi qua vùng bị mất:

Tôi không hiểu tại sao. Không nên giảm độ dốc dễ dàng theo đường cong mất đến cực tiểu toàn cầu?

Mã ví dụ:

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

Điều tương tự cũng xảy ra nếu tôi thêm sai lệch: Hàm mất 2D rất đơn giản và đơn giản, nhưng nếu Relu bắt đầu lộn ngược, nó sẽ quay vòng và bị kẹt (điểm bắt đầu màu đỏ) và không theo độ dốc xuống mức tối thiểu (như nó không cho điểm bắt đầu màu xanh):

Điều tương tự cũng xảy ra nếu tôi thêm trọng lượng đầu ra và thiên vị, quá. (Nó sẽ lật từ trái sang phải hoặc từ trên xuống, nhưng không lật cả hai.)

$w$$w=0$$w=0$$w=1$$w$ được khởi tạo là âm tính, có thể hội tụ thành một giải pháp tối ưu.

và bạn đang sử dụng tối ưu hóa đơn hàng đầu tiên để làm như vậy. Một vấn đề với cách tiếp cận này là có độ dốc$f$

Khi bạn bắt đầu với , bạn sẽ phải di chuyển sang phía bên kia của để đến gần hơn với câu trả lời đúng, đó là . Điều này thật khó để làm, bởi vì khi bạn córất, rất nhỏ, độ dốc cũng sẽ trở nên nhỏ bé. Hơn nữa, bạn càng tiến gần đến 0 từ bên trái, tiến độ của bạn sẽ càng chậm!$w<0$$0$$w=1$$|w|$

Đây là lý do tại sao trong âm mưu của bạn cho các khởi tạo âm , tất cả các quỹ đạo của bạn bị đình trệ gần . Đây cũng là những gì hoạt hình thứ hai của bạn đang hiển thị.$w^{(0)} <0$$w^{(i)}=0$

Điều này có liên quan đến hiện tượng Relu sắp chết; để thảo luận, hãy xem mạng ReLU của tôi không khởi chạy được

Một cách tiếp cận có thể thành công hơn là sử dụng một phi tuyến khác như relu bị rò rỉ, không có vấn đề gọi là "độ dốc biến mất". Hàm Relu bị rò rỉ là

Đặt là relu thông thường. Hầu hết mọi người chọn là một cái gì đó như hoặc . Tôi chưa thấy được sử dụng, mặc dù tôi rất muốn xem một nghiên cứu về tác dụng gì, nếu có, nó có trên các mạng như vậy. (Lưu ý rằng với điều này làm giảm chức năng nhận dạng; đối với , các tác phẩm của nhiều lớp như vậy có thể gây ra độ dốc nổ vì độ dốc trở nên lớn hơn trong các lớp liên tiếp.)$c=0$$c$$0.1$$0.3$$c<0$$c=1,$$|c|>1$

Sửa đổi một chút mã của OP cung cấp một minh chứng rằng vấn đề nằm ở sự lựa chọn chức năng kích hoạt. Mã này khởi tạo là âm và sử dụng thay cho thông thường . Mất mát nhanh chóng giảm xuống một giá trị nhỏ và trọng lượng chính xác di chuyển đến , đó là tối ưu.$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()

Một lớp phức tạp khác phát sinh từ thực tế là chúng ta không di chuyển vô cùng, mà thay vào đó là rất nhiều "bước nhảy", và những bước nhảy này đưa chúng ta từ lần lặp này sang lần lặp tiếp theo. Điều này có nghĩa là có một số trường hợp các giá trị âm ban đầu của sẽ không bị kẹt; những trường hợp này phát sinh đối với các kết hợp cụ thể của và kích thước bước xuống dốc đủ lớn để "nhảy" qua gradient biến mất.$w$ $w^{(0)}$

Tôi đã chơi xung quanh với mã này một số và tôi thấy rằng việc để khởi tạo ở và thay đổi trình tối ưu hóa từ SGD sang Adam, Adam + AMSGrad hoặc SGD + không giúp được gì. Hơn nữa, việc thay đổi từ SGD sang Adam thực sự làm chậm tiến độ ngoài việc không giúp khắc phục độ dốc biến mất trong vấn đề này.$w^{(0)}=-10$

Mặt khác, nếu bạn thay đổi khởi tạo thành và thay đổi trình tối ưu hóa thành Adam (kích thước bước 0,01), thì bạn thực sự có thể khắc phục độ dốc biến mất. Nó cũng hoạt động nếu bạn sử dụng và SGD với động lượng (kích thước bước 0,01). Nó thậm chí hoạt động nếu bạn sử dụng vanilla SGD (kích thước bước 0,01) và .$w^{(0)}=-1$ $w^{(0)}=-1$$w^{(0)}=-1$

Các mã có liên quan là dưới đây; sử dụng opt_sgdhoặc 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)