PyTorch'daki Adam optimizer ile öğrenme hızını düşürdüğümde kayıp aniden yükseliyor

Optimize edici (ile ) ve Tek kanallı Ses Kaynağı Ayırma görevi için bir auto-encoderağ eğitimi alıyorum . Öğrenme oranını bir faktörle azalttığımda, ağ kaybı aniden atlar ve daha sonra öğrenme hızındaki bir sonraki azalmaya kadar azalır.Adamamsgrad=TrueMSE loss

Ağ uygulaması ve eğitimi için Pytorch kullanıyorum.

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

# 2, # 3, # 4 kurulumları için çok şaşırtıcı sonuçlar alıyorum ve bunun için herhangi bir açıklama yapamıyorum. Sonuçlarım:

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.

Plot-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?

Plot-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.

Plot-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.

Aşağıdaki yorum @Dennis tarafından önerildiği gibi, ben her ikisiyle çalıştı ReLUve 1e-02 leakyReLUdoğrusal olmayan. Ancak, sonuçlar benzer davranıyor ve kayıp önce azalıyor, daha sonra artıyor ve daha sonra öğrenme hızı azalmadan elde edebileceğimden daha yüksek bir değerde doyuyor.

Çizelge-4 sonuçları göstermektedir.

Plot-4:

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)

DÜZENLEMELER:

• Aşağıdaki yorumlarda ve yanıtta önerildiği gibi, kodumda değişiklikler yaptım ve modeli eğittim. Ben aynı kod ve grafikleri ekledim.
• Çeşitli birlikte çalıştı lr_scheduleriçinde PyTorch (multiStepLR, ExponentialLR)ve aynı için araziler listelenen Setup-4aşağıdaki yorum @Dennis tarafından önerildiği gibi.
• Yorumlarda @Dennis tarafından önerilen leakyReLU ile deneniyor.

Herhangi bir yardım. Teşekkürler

Düşen öğrenme oranlarının, gözlemlediğiniz kayıplardaki sıçrama türlerini yaratması için hiçbir neden göremiyorum. Aksi halde, sürekli olarak daralan bir kayıp durumunda, en kötü ihtimalle, kayıplarınızda (bu sıçramalardan ziyade) bir platoya götürmesi gereken "ne kadar hızlı" hareket edeceğinizi "yavaşlatması" gerekir.

Kodunuzda gözlemlediğim ilk şey, her dönemi sıfırdan optimize ediciyi yeniden oluşturmanız. Henüz kesin olarak söylemek için PyTorch ile yeterince çalışmadım, ancak bu her zaman optimize edicinin dahili durumunu / hafızasını yok etmiyor mu? Bence, çığır açan döngüden önce, sadece bir kez optimizer oluşturmalısınız. Bu gerçekten kodunuzdaki bir hata ise, aslında öğrenme oranı bozulmasını kullanmadığınız durumda da bir hata olmalıdır ... ama belki de sadece şanslısınız ve aynı olumsuz etkileri yaşamazsınız. böcek.

Öğrenme oranı düşüşü için , bunun için manuel bir çözüm yerine resmi API'yi kullanmanızı öneririm . Özel durumunuzda , aşağıdakileri içeren bir StepLR zamanlayıcısını başlatmak istersiniz :

• optimizer = büyük olasılıkla yalnızca bir kez başlatmanız gereken ADAM iyileştirici.
• step_size = 25
• gamma = 0.25

Daha sonra scheduler.step()her çağın başlangıcında çağrı yapabilirsiniz (veya sonunda? API bağlantısındaki örnek her çağın başlangıcında onu çağırır).

Yukarıdaki değişikliklerden sonra hala sorun yaşıyorsanız, denemelerinizin her birini birden çok kez çalıştırmak ve ortalama sonuçları çizmek (veya tüm denemeler için satırları çizmek) de yararlı olacaktır. Deneyleriniz teorik olarak ilk 25 dönem boyunca aynı olmalıdır, ancak öğrenme oranı bozulmasının gerçekleşmediği ilk 25 dönemlerde bile iki şekil arasında büyük farklılıklar görüyoruz (örneğin, bir şekil ~ 28K kaybında başlar, diğeri ~ 40K kaybında başlar). Bu sadece farklı rastgele başlatmalardan kaynaklanıyor olabilir, bu nedenle arazilerinizden belirsizliği ortalamak iyi olur.