सभी चुनौतियाँ
मध्यम 0 हल किए गए 0% स्वीकृति

ग्रेडिएंट डिसेंट से लीनियर रिग्रेशन

मीन स्क्वेयर्ड एरर पर बार-बार नीचे उतरकर रेखा का ढलान और इंटरसेप्ट सीखें।

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

  • माध्य वर्ग त्रुटि को कदम-दर-कदम घटाना
  • ढलान और अंतःखंड के ग्रेडिएंट निकालना
  • देखना कि लर्निंग रेट ट्रेनिंग को कैसे प्रभावित करता है

समस्या

सूत्र के बजाय, रेखा y = w × x + b को मीन स्क्वेयर्ड एरर MSE = Σ(w × x + b - y)² / n पर बैच ग्रेडिएंट डिसेंट से ट्रेन करें।

w = 0 और b = 0 से शुरू करें। हर epoch में सभी पॉइंट्स का इस्तेमाल करके:

  1. errorᵢ = w × xᵢ + b - yᵢ
  2. dw = (2 / n) × Σ errorᵢ × xᵢ और db = (2 / n) × Σ errorᵢ
  3. w ← w - learning_rate × dw और b ← b - learning_rate × db (दोनों एक ही एरर से निकाले गए)

train_linear_regression(xs, ys, learning_rate, epochs) लागू करें।

इनपुट

xs, ys: डेटा पॉइंट्स (समान लंबाई)।

learning_rate, epochs: स्टेप का आकार और अपडेट की संख्या।

आउटपुट

ट्रेनिंग के बाद [w, b] लौटाएँ।

सीमाएँ

1 ≤ पॉइंट्स की संख्या ≤ 1,000, 0 ≤ epochs ≤ 10,000

0 < learning_rate ≤ 1

-100 ≤ हर मान ≤ 100

उदाहरण

उदाहरण 1
इनपुट:
xs = [1.0, 2.0]
ys = [2.0, 4.0]
learning_rate = 0.1
epochs = 1

अपेक्षित आउटपुट:
expected = [1.0, 0.6]
इनपुट:
std::vector<double> xs = {1.0, 2.0};
std::vector<double> ys = {2.0, 4.0};
double learning_rate = 0.1;
long long epochs = 1;

अपेक्षित आउटपुट:
std::vector<double> expected = {1.0, 0.6};
इनपुट:
double[] xs = new double[] {1.0, 2.0};
double[] ys = new double[] {2.0, 4.0};
double learning_rate = 0.1;
long epochs = 1;

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

व्याख्या

w = b = 0 पर एरर -2 और -4 हैं। dw = (2 / 2) × (-2×1 - 4×2) = -10 और db = (2 / 2) × (-2 - 4) = -6, इसलिए w = 0 - 0.1 × (-10) = 1 और b = 0 - 0.1 × (-6) = 0.6। परिणाम: [1, 0.6]।

उदाहरण 2
इनपुट:
xs = [1.0, 2.0, 3.0]
ys = [3.0, 5.0, 7.0]
learning_rate = 0.05
epochs = 2000

अपेक्षित आउटपुट:
expected = [2.0, 1.0]
इनपुट:
std::vector<double> xs = {1.0, 2.0, 3.0};
std::vector<double> ys = {3.0, 5.0, 7.0};
double learning_rate = 0.05;
long long epochs = 2000;

अपेक्षित आउटपुट:
std::vector<double> expected = {2.0, 1.0};
इनपुट:
double[] xs = new double[] {1.0, 2.0, 3.0};
double[] ys = new double[] {3.0, 5.0, 7.0};
double learning_rate = 0.05;
long epochs = 2000;

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

व्याख्या

डेटा y = 2x + 1 पर है। 2,000 epoch के बाद ग्रेडिएंट डिसेंट w = 2 और b = 1 पर पहुँच जाता है, जो लीस्ट स्क्वेयर्स सूत्र जैसा ही जवाब है।

कैसे हल करें

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

संकेत 1

हर epoch में हर point का उपयोग करके मापा जाता है कि current line कितनी गलत है।

संकेत 2

दोनों parameters को साथ update करने से पहले सभी samples से gradient accumulate करें।

संकेत 3

एक parameter को पहले update न करें, क्योंकि दोनों updates को same epoch के errors का उपयोग करना चाहिए।

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

समय O(epochs × n), अतिरिक्त स्थान O(1)

संदर्भ

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

हर कोडर का सबसे अच्छा पास हुआ समाधान। तेज़, कम मेमोरी वाले और बेहतर रेटिंग वाले समाधान ऊपर रहते हैं।

अभी कोई पास हुआ समाधान नहीं है। इसे हल करें और पहला स्थान पाएँ।

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

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

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