มีพฤติกรรมแปลก ๆ กับ Adam optimizer เมื่อฝึกอบรมนานเกินไป

ฉันพยายามฝึก perceptron เดี่ยว (1,000 หน่วยอินพุต, 1 เอาต์พุต, ไม่มีเลเยอร์ที่ซ่อนอยู่) ใน 64 จุดข้อมูลที่สร้างแบบสุ่ม ฉันใช้ Pytorch ใช้เพิ่มประสิทธิภาพอดัม:

import torch
from torch.autograd import Variable

torch.manual_seed(545345)
N, D_in, D_out = 64, 1000, 1

x = Variable(torch.randn(N, D_in))
y = Variable(torch.randn(N, D_out))

model = torch.nn.Linear(D_in, D_out)
loss_fn = torch.nn.MSELoss(size_average=False)

optimizer = torch.optim.Adam(model.parameters())
for t in xrange(5000):
  y_pred = model(x)
  loss = loss_fn(y_pred, y)

  print(t, loss.data[0])

  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

ในขั้นต้นการสูญเสียได้อย่างรวดเร็วลดลงตามที่คาด:

(0, 91.74887084960938)
(1, 76.85824584960938)
(2, 63.434078216552734)
(3, 51.46927261352539)
(4, 40.942893981933594)
(5, 31.819372177124023)

ประมาณ 300 ทำซ้ำถึงข้อผิดพลาดที่อยู่ใกล้กับศูนย์:

(300, 2.1734419819452455e-12)
(301, 1.90354676465887e-12)
(302, 2.3347573874232808e-12)

สิ่งนี้ดำเนินต่อไปอีกสองสามพันครั้ง อย่างไรก็ตามหลังจากการฝึกอบรมมานานเกินไปข้อผิดพลาดจะเริ่มเพิ่มขึ้นอีกครั้ง:

(4997, 0.002102422062307596)
(4998, 0.0020302983466535807)
(4999, 0.0017039275262504816)

ทำไมสิ่งนี้จึงเกิดขึ้น

ความไม่แน่นอนเล็ก ๆ นี้ในตอนท้ายของการบรรจบกันเป็นคุณลักษณะของอดัม (และ RMSProp) เนื่องจากวิธีการประมาณขนาดการไล่ระดับสีหมายถึงการไล่ระดับสีในขั้นตอนที่ผ่านมาและหารด้วย

สิ่งหนึ่งที่อดัมทำคือรักษาค่าเฉลี่ยของรูปทรงเรขาคณิตของการไล่ระดับสีและสี่เหลี่ยมของการไล่ระดับสี กำลังสองของการไล่ระดับสีจะใช้ในการแบ่ง (ค่าเฉลี่ยการหมุนของ) การไล่ระดับสีในปัจจุบันเพื่อตัดสินใจขั้นตอนปัจจุบัน อย่างไรก็ตามเมื่อการไล่ระดับสีของคุณกลายเป็นและอยู่ใกล้กับศูนย์มากที่สุดสิ่งนี้จะทำให้สี่เหลี่ยมของการไล่ระดับสีมีค่าต่ำจนพวกเขามีข้อผิดพลาดในการปัดเศษขนาดใหญ่หรือมีค่าเป็นศูนย์อย่างมีประสิทธิภาพ มิติเดียวทำให้ขั้นตอนค่อนข้างเล็ก$10^{-10}$ ถึง $10^{-5}$เนื่องจากการเปลี่ยนแปลงในparams อื่น ๆ ) และขนาดขั้นตอนจะเริ่มกระโดดไปรอบ ๆ ก่อนที่จะตัดสินอีกครั้ง

สิ่งนี้ทำให้อาดัมมีเสถียรภาพน้อยลงและแย่ลงสำหรับปัญหาของคุณมากกว่าการไล่ระดับสีพื้นฐานมากขึ้นโดยสมมติว่าคุณต้องการได้ตัวเลขที่ใกล้เคียงกับการสูญเสียศูนย์มากที่สุดเนื่องจากการคำนวณอนุญาตสำหรับปัญหาของคุณ

ในทางปฏิบัติเกี่ยวกับปัญหาการเรียนรู้อย่างลึกซึ้งคุณจะไม่เข้าใกล้การบรรจบกัน (และสำหรับเทคนิคการทำให้เป็นมาตรฐานเช่นการหยุด แต่เนิ่น ๆ คุณไม่ต้องการอยู่ดี) ดังนั้นจึงมักไม่กังวลเกี่ยวกับประเภทของปัญหาที่ปฏิบัติ อดัมถูกออกแบบมาเพื่อ

คุณสามารถเห็นสิ่งนี้เกิดขึ้นจริงสำหรับ RMSProp ในการเปรียบเทียบตัวเพิ่มประสิทธิภาพที่แตกต่างกัน (RMSProp เป็นเส้นสีดำ - ดูขั้นตอนสุดท้ายที่ใกล้ถึงเป้าหมาย):

คุณสามารถทำให้อาดัมมีเสถียรภาพมากขึ้นและสามารถใกล้เคียงกับการบรรจบจริงโดยลดอัตราการเรียนรู้ เช่น

optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)

จะใช้เวลานานขึ้นในการเพิ่มประสิทธิภาพ การใช้งานlr=1e-5คุณต้องฝึกซ้ำมากกว่า 20,000 ครั้งก่อนที่คุณจะเห็นความไม่แน่นอนและความไม่เสถียรนั้นมีค่าน้อยกว่าอย่างมาก$10^{-7}$.

เหตุผลตรงตามที่กล่าวไว้ในคำตอบอื่น ๆ พร้อมข้อเสนอแนะที่ดีในการใช้อัตราการเรียนรู้ขนาดเล็กเพื่อหลีกเลี่ยงปัญหานี้กับการไล่ระดับสีเล็กน้อย

ฉันจะคิดว่าคู่ของวิธีการนี้:

1. คุณสามารถคลิปการไล่ระดับสีที่มีขอบเขตบน / ล่าง แต่นี่ไม่ได้รับประกันการบรรจบกันและอาจส่งผลในการฝึกอบรมการตรึงโดยการติดกับดักใน minima ท้องถิ่นบางและไม่เคยออกไป

2. ฝึกด้วยขนาดชุดที่สูงขึ้นยุคที่มากขึ้นและด้วยอัตราการเรียนรู้ที่ลดลง ตอนนี้ฉันไม่มีข้อพิสูจน์ในทางปฏิบัติใด ๆ ที่การเพิ่มขนาดแบทช์ส่งผลให้เกิดการไล่ระดับสีที่ดีขึ้น แต่จากสิ่งที่ฉันสังเกตเห็นจากการเผชิญหน้ากับปัญหาที่คล้ายกับของคุณการทำเช่นนั้นช่วยได้เกือบตลอดเวลา

ฉันแน่ใจว่ามีวิธีอื่น ๆ (เช่นอัตราการเรียนรู้วัฏจักรและอื่น ๆ ) ที่พยายามค้นหาอัตราการเรียนรู้ที่ดีที่สุดตามสถิติ