Tất cả thử thách
Dễ 0 đã giải Tỷ lệ chấp nhận 0%

Hạ gradient với momentum

Áp dụng cập nhật momentum, giữ lại một phần bước trước để tăng tốc theo các hướng ổn định.

Bạn sẽ học được gì

  • Giữ một vận tốc cho mỗi trọng số
  • Tăng tốc huấn luyện theo hướng ổn định
  • So sánh momentum với hạ gradient thường

Đề bài

Xem bản gốc (English)

Momentum khiến hạ gradient giống một quả bóng lăn xuống dốc: mỗi bước giữ lại một phần của bước trước.

Bắt đầu với vận tốc bằng 0 cho mọi trọng số. Với mỗi bước t, có vector gradient g (mỗi trọng số một giá trị):

  1. v ← beta × v + g
  2. w ← w - learning_rate × v

Hãy cài đặt momentum_steps(gradients, weights, learning_rate, beta), áp dụng một lần cập nhật cho mỗi hàng của gradients, theo thứ tự.

Đầu vào

gradients: Mỗi bước một hàng; mỗi hàng có một gradient cho mỗi trọng số.

weights: Các trọng số ban đầu.

learning_rate: Bước nhảy.

beta: Hệ số momentum (0 nghĩa là hạ gradient thông thường).

Đầu ra

Trả về các trọng số sau tất cả các bước.

Ràng buộc

0 ≤ số bước ≤ 1.000, 1 ≤ số trọng số ≤ 100

0 < learning_rate ≤ 1, 0 ≤ beta < 1

-100 ≤ mỗi giá trị ≤ 100

Ví dụ

Ví dụ 1
Đầu vào:
gradients = [
    [1.0],
    [1.0],
    [1.0]
]
weights = [0.0]
learning_rate = 0.1
beta = 0.9

Kết quả mong đợi:
expected = [-0.561]
Đầu vào:
std::vector<std::vector<double>> gradients = {
    {1.0},
    {1.0},
    {1.0}
};
std::vector<double> weights = {0.0};
double learning_rate = 0.1;
double beta = 0.9;

Kết quả mong đợi:
std::vector<double> expected = {-0.561};
Đầu vào:
double[][] gradients = new double[][] {
    new double[] {1.0},
    new double[] {1.0},
    new double[] {1.0}
};
double[] weights = new double[] {0.0};
double learning_rate = 0.1;
double beta = 0.9;

Kết quả mong đợi:
double[] expected = new double[] {-0.561};

Giải thích

Vận tốc tăng 1 → 1.9 → 2.71 vì gradient luôn chỉ cùng một hướng, nên các bước là 0.1, 0.19 và 0.271: w = -0.561.

Ví dụ 2
Đầu vào:
gradients = [
    [2.0, -4.0]
]
weights = [1.0, 1.0]
learning_rate = 0.5
beta = 0.0

Kết quả mong đợi:
expected = [0.0, 3.0]
Đầu vào:
std::vector<std::vector<double>> gradients = {
    {2.0, -4.0}
};
std::vector<double> weights = {1.0, 1.0};
double learning_rate = 0.5;
double beta = 0.0;

Kết quả mong đợi:
std::vector<double> expected = {0.0, 3.0};
Đầu vào:
double[][] gradients = new double[][] {
    new double[] {2.0, -4.0}
};
double[] weights = new double[] {1.0, 1.0};
double learning_rate = 0.5;
double beta = 0.0;

Kết quả mong đợi:
double[] expected = new double[] {0.0, 3.0};

Giải thích

Với beta = 0, đây là hạ gradient thông thường: w = [1 - 0.5 × 2, 1 - 0.5 × (-4)] = [0, 3].

Hướng tiếp cận

Hãy tự thử trước, sau đó mở từng gợi ý một.

Gợi ý 1

Giữ một velocity vector tích lũy một phần của bước trước và gradient hiện tại.

Gợi ý 2

Cập nhật velocity trước khi chỉnh weights, và dùng lại cùng velocity cho mọi bước.

Gợi ý 3

Nếu beta bằng 0, method phải giảm về gradient descent thường, nên hãy kiểm tra hành vi đó kỹ.

Độ phức tạp mong đợi

thời gian O(s × w), bộ nhớ phụ O(w)

Tham khảo

Thử thách này đã được điều chỉnh cho CodeUtility. Hãy làm theo đề bài và các ràng buộc ở trên.

Lời giải đạt tốt nhất của mỗi người. Lời giải nhanh hơn, tốn ít bộ nhớ hơn và được đánh giá cao hơn sẽ đứng trên.

Chưa có lời giải nào đạt. Giải bài này để giành hạng nhất.

Học hỏi từ người khác

Giải pháp cộng đồng

Chưa có giải pháp nào được chia sẻ. Hãy giải thử thách này để đăng giải pháp đầu tiên.