चुनौतियों पर वापस जाएँ
आसान 0 हल किए गए 0% स्वीकृति

मोमेंटम के साथ ग्रेडिएंट डिसेंट

मोमेंटम अपडेट लागू करें जो पिछले कदम का कुछ हिस्सा बनाए रखते हैं, ताकि एक ही दिशा में ट्रेनिंग तेज़ हो।

आप क्या सीखेंगे

  • हर वज़न के लिए वेग रखना
  • एक ही दिशा में ट्रेनिंग तेज़ करना
  • मोमेंटम की साधारण ग्रेडिएंट डिसेंट से तुलना करना

समस्या

मोमेंटम ग्रेडिएंट डिसेंट को ढलान से लुढ़कती गेंद जैसा बनाता है: हर कदम पिछले कदम का कुछ हिस्सा रखता है।

हर वज़न के लिए वेग 0 से शुरू करें। ग्रेडिएंट वेक्टर g (हर वज़न के लिए एक मान) वाले हर कदम t के लिए:

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

momentum_steps(gradients, weights, learning_rate, beta) लागू करें, gradients की हर पंक्ति के लिए क्रम से एक अपडेट करते हुए।

इनपुट

gradients: हर कदम के लिए एक पंक्ति; हर पंक्ति में हर वज़न के लिए एक ग्रेडिएंट।

weights: शुरुआती वज़न।

learning_rate: कदम का आकार।

beta: मोमेंटम गुणांक (0 देने पर साधारण ग्रेडिएंट डिसेंट)।

आउटपुट

सभी कदमों के बाद वज़न लौटाएँ।

सीमाएँ

0 ≤ कदम ≤ 1,000, 1 ≤ वज़न ≤ 100

0 < learning_rate ≤ 1, 0 ≤ beta < 1

-100 ≤ हर मान ≤ 100

उदाहरण

उदाहरण 1
इनपुट:
beta = 0.9
weights = [0.0]
gradients = [
    [1.0],
    [1.0],
    [1.0]
]
learning_rate = 0.1

अपेक्षित आउटपुट:
expected = [-0.561]
इनपुट:
double beta = 0.9;
std::vector<double> weights = {0.0};
std::vector<std::vector<double>> gradients = {
    {1.0},
    {1.0},
    {1.0}
};
double learning_rate = 0.1;

अपेक्षित आउटपुट:
std::vector<double> expected = {-0.561};
इनपुट:
double beta = 0.9;
double[] weights = new double[] {0.0};
double[][] gradients = new double[][] {
    new double[] {1.0},
    new double[] {1.0},
    new double[] {1.0}
};
double learning_rate = 0.1;

अपेक्षित आउटपुट:
double[] expected = new double[] {-0.561};

व्याख्या

वेग 1 → 1.9 → 2.71 बढ़ता है क्योंकि ग्रेडिएंट लगातार एक ही दिशा में है, इसलिए कदम 0.1, 0.19 और 0.271 हैं: w = -0.561।

उदाहरण 2
इनपुट:
beta = 0.0
weights = [1.0, 1.0]
gradients = [
    [2.0, -4.0]
]
learning_rate = 0.5

अपेक्षित आउटपुट:
expected = [0.0, 3.0]
इनपुट:
double beta = 0.0;
std::vector<double> weights = {1.0, 1.0};
std::vector<std::vector<double>> gradients = {
    {2.0, -4.0}
};
double learning_rate = 0.5;

अपेक्षित आउटपुट:
std::vector<double> expected = {0.0, 3.0};
इनपुट:
double beta = 0.0;
double[] weights = new double[] {1.0, 1.0};
double[][] gradients = new double[][] {
    new double[] {2.0, -4.0}
};
double learning_rate = 0.5;

अपेक्षित आउटपुट:
double[] expected = new double[] {0.0, 3.0};

व्याख्या

beta = 0 पर यह साधारण ग्रेडिएंट डिसेंट है: w = [1 - 0.5 × 2, 1 - 0.5 × (-4)] = [0, 3]।

कैसे हल करें

पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।

संकेत 1

एक velocity vector रखें जो पिछले step के हिस्से और current gradient को accumulate करे.

संकेत 2

Weights adjust करने से पहले velocity update करें, और सभी steps में उसी velocity को reuse करें.

संकेत 3

अगर beta zero है, तो method को ordinary gradient descent में reduce होना चाहिए, इसलिए उस behavior को ध्यान से check करें.

अपेक्षित जटिलता

समय O(s × w), अतिरिक्त स्थान O(w)

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।