Mất đột ngột khi tôi giảm tốc độ học tập với trình tối ưu hóa Adam trong PyTorch


10

Tôi đang đào tạo một auto-encodermạng với trình Adamtối ưu hóa (với amsgrad=True) và MSE losscho nhiệm vụ Tách nguồn âm thanh một kênh. Bất cứ khi nào tôi phân rã tốc độ học tập theo một yếu tố, mất mạng đột ngột nhảy và sau đó giảm dần cho đến khi sự suy giảm tiếp theo trong tốc độ học tập.

Tôi đang sử dụng Pytorch để triển khai và đào tạo mạng.

Following are my experimental setups:

 Setup-1: NO learning rate decay, and 
          Using the same Adam optimizer for all epochs

 Setup-2: NO learning rate decay, and 
          Creating a new Adam optimizer with same initial values every epoch

 Setup-3: 0.25 decay in learning rate every 25 epochs, and
          Creating a new Adam optimizer every epoch

 Setup-4: 0.25 decay in learning rate every 25 epochs, and
          NOT creating a new Adam optimizer every time rather
          using PyTorch's "multiStepLR" and "ExponentialLR" decay scheduler 
          every 25 epochs

Tôi nhận được kết quả rất đáng ngạc nhiên cho các thiết lập # 2, # 3, # 4 và không thể đưa ra bất kỳ lời giải thích nào cho nó. Sau đây là kết quả của tôi:

Setup-1 Results:

Here I'm NOT decaying the learning rate and 
I'm using the same Adam optimizer. So my results are as expected.
My loss decreases with more epochs.
Below is the loss plot this setup.

Lô-1:

Kết quả cài đặt-1

optimizer = torch.optim.Adam(lr=m_lr,amsgrad=True, ...........)

for epoch in range(num_epochs):
    running_loss = 0.0
    for i in range(num_train):
        train_input_tensor = ..........                    
        train_label_tensor = ..........
        optimizer.zero_grad()
        pred_label_tensor = model(train_input_tensor)
        loss = criterion(pred_label_tensor, train_label_tensor)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    loss_history[m_lr].append(running_loss/num_train)

Setup-2 Results:  

Here I'm NOT decaying the learning rate but every epoch I'm creating a new
Adam optimizer with the same initial parameters.
Here also results show similar behavior as Setup-1.

Because at every epoch a new Adam optimizer is created, so the calculated gradients
for each parameter should be lost, but it seems that this doesnot affect the 
network learning. Can anyone please help on this?

Lô-2:

Kết quả cài đặt-2

for epoch in range(num_epochs):
    optimizer = torch.optim.Adam(lr=m_lr,amsgrad=True, ...........)

    running_loss = 0.0
    for i in range(num_train):
        train_input_tensor = ..........                    
        train_label_tensor = ..........
        optimizer.zero_grad()
        pred_label_tensor = model(train_input_tensor)
        loss = criterion(pred_label_tensor, train_label_tensor)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    loss_history[m_lr].append(running_loss/num_train)

Setup-3 Results: 

As can be seen from the results in below plot, 
my loss jumps every time I decay the learning rate. This is a weird behavior.

If it was happening due to the fact that I'm creating a new Adam 
optimizer every epoch then, it should have happened in Setup #1, #2 as well.
And if it is happening due to the creation of a new Adam optimizer with a new 
learning rate (alpha) every 25 epochs, then the results of Setup #4 below also 
denies such correlation.

Lô-3:

Kết quả cài đặt-3

decay_rate = 0.25
for epoch in range(num_epochs):
    optimizer = torch.optim.Adam(lr=m_lr,amsgrad=True, ...........)

    if epoch % 25 == 0  and epoch != 0:
        lr *= decay_rate   # decay the learning rate

    running_loss = 0.0
    for i in range(num_train):
        train_input_tensor = ..........                    
        train_label_tensor = ..........
        optimizer.zero_grad()
        pred_label_tensor = model(train_input_tensor)
        loss = criterion(pred_label_tensor, train_label_tensor)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    loss_history[m_lr].append(running_loss/num_train)

Setup-4 Results:  

In this setup, I'm using Pytorch's learning-rate-decay scheduler (multiStepLR)
which decays the learning rate every 25 epochs by 0.25.
Here also, the loss jumps everytime the learning rate is decayed.

Theo đề xuất của @Dennis trong các bình luận bên dưới, tôi đã thử với cả hai ReLU1e-02 leakyReLUphi tuyến. Nhưng, kết quả dường như hành xử tương tự và mất đầu tiên giảm, sau đó tăng và sau đó bão hòa ở giá trị cao hơn những gì tôi sẽ đạt được mà không cần giảm tốc độ học tập.

Lô-4 cho thấy kết quả.

Lô-4:

nhập mô tả hình ảnh ở đây

scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer=optimizer, milestones=[25,50,75], gamma=0.25)

scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.95)

scheduler = ......... # defined above
optimizer = torch.optim.Adam(lr=m_lr,amsgrad=True, ...........)

for epoch in range(num_epochs):

    scheduler.step()

    running_loss = 0.0
    for i in range(num_train):
        train_input_tensor = ..........                    
        train_label_tensor = ..........
        optimizer.zero_grad()
        pred_label_tensor = model(train_input_tensor)
        loss = criterion(pred_label_tensor, train_label_tensor)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    loss_history[m_lr].append(running_loss/num_train)

CHỈNH SỬA:

  • Như được đề xuất trong các nhận xét và trả lời bên dưới, tôi đã thay đổi mã của mình và đào tạo mô hình. Tôi đã thêm mã và các lô cho cùng.
  • Tôi đã thử với nhiều lr_schedulerPyTorch (multiStepLR, ExponentialLR)và âm mưu cho cùng được liệt kê trong Setup-4theo đề nghị của @Dennis trong ý kiến dưới đây.
  • Đang thử với rò rỉReLU theo đề xuất của @Dennis trong các bình luận.

Bất kỳ giúp đỡ. Cảm ơn


Bình luận không dành cho thảo luận mở rộng; cuộc trò chuyện này đã được chuyển sang trò chuyện .
Ben N

Câu trả lời:


8

Tôi thấy không có lý do tại sao phân rã tỷ lệ học tập sẽ tạo ra các loại nhảy trong mất mát mà bạn đang quan sát. Nó sẽ "làm chậm" tốc độ bạn "di chuyển" nhanh như thế nào, trong trường hợp mất mát, nếu không thì co lại một cách thực sự, tệ nhất, chỉ dẫn đến một cao nguyên trong tổn thất của bạn (chứ không phải là những cú nhảy đó).

Điều đầu tiên tôi quan sát thấy trong mã của bạn là bạn tạo lại trình tối ưu hóa từ đầu mỗi kỷ nguyên. Tôi vẫn chưa làm việc đủ với PyTorch để chắc chắn, nhưng điều này không chỉ phá hủy trạng thái / bộ nhớ trong của trình tối ưu hóa mỗi lần sao? Tôi nghĩ bạn chỉ nên tạo trình tối ưu hóa một lần, trước khi vòng lặp qua các kỷ nguyên. Nếu đây thực sự là một lỗi trong mã của bạn, thì nó thực sự vẫn là một lỗi trong trường hợp bạn không sử dụng phân rã tỷ lệ học tập ... nhưng có lẽ bạn chỉ đơn giản là gặp may mắn ở đó và không gặp phải những tác động tiêu cực tương tự bọ cánh cứng.

Để giảm tốc độ học tập, tôi khuyên bạn nên sử dụng API chính thức cho điều đó , thay vì giải pháp thủ công. Trong trường hợp cụ thể của bạn, bạn sẽ muốn khởi tạo một lịch trình StepLR , với:

  • optimizer = trình tối ưu hóa ADAM, có lẽ bạn chỉ nên khởi tạo một lần.
  • step_size = 25
  • gamma = 0.25

Sau đó, bạn có thể chỉ cần gọi scheduler.step()vào đầu mỗi kỷ nguyên (hoặc có thể ở cuối? Ví dụ trong liên kết API gọi nó ở đầu mỗi kỷ nguyên).


Nếu, sau những thay đổi ở trên, bạn vẫn gặp phải sự cố, thì cũng sẽ hữu ích khi chạy từng thử nghiệm của bạn nhiều lần và vẽ kết quả trung bình (hoặc đường biểu đồ cho tất cả các thử nghiệm). Các thí nghiệm của bạn về mặt lý thuyết phải giống hệt nhau trong 25 kỷ nguyên đầu tiên, nhưng chúng tôi vẫn thấy sự khác biệt rất lớn giữa hai con số ngay cả trong 25 kỷ nguyên đầu tiên trong đó không xảy ra sự phân rã tốc độ học tập (ví dụ, một con số bắt đầu mất ~ 28K, con số kia bắt đầu với mức lỗ ~ 40K). Điều này có thể đơn giản là do các khởi tạo ngẫu nhiên khác nhau, do đó, sẽ tốt khi lấy trung bình mà không cần thiết ra khỏi âm mưu của bạn.


1
Bình luận không dành cho thảo luận mở rộng; cuộc trò chuyện này đã được chuyển sang trò chuyện .
Ben N
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.