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

Gradient Descent with Momentum

Apply momentum updates, which keep part of the previous step so training speeds up along consistent directions.

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

  • Keep a velocity for each weight
  • Speed up training along steady directions
  • Compare momentum with plain gradient descent

Đề bài

Xem bản dịch

Momentum makes gradient descent behave like a ball rolling downhill: each step keeps part of the previous one.

Start with a velocity of 0 for every weight. For each step t, with gradient vector g (one value per weight):

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

Implement momentum_steps(gradients, weights, learning_rate, beta), applying one update per row of gradients, in order.

Input

gradients: One row per step; each row has one gradient per weight.

weights: The starting weights.

learning_rate: The step size.

beta: The momentum coefficient (0 means plain gradient descent).

Output

Return the weights after all steps.

Ràng buộc

0 ≤ steps ≤ 1,000, 1 ≤ weights ≤ 100

0 < learning_rate ≤ 1, 0 ≤ beta < 1

-100 ≤ each value ≤ 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

The velocity grows 1 → 1.9 → 2.71 because the gradient keeps pointing the same way, so the steps are 0.1, 0.19 and 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

With beta = 0 this is plain gradient descent: 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

Keep a velocity vector that accumulates part of the previous step and the current gradient.

Gợi ý 2

Update the velocity before adjusting the weights, and reuse the same velocity across all steps.

Gợi ý 3

If beta is zero, the method should reduce to ordinary gradient descent, so check that behavior carefully.

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

O(s × w) time, O(w) extra space

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.