सभी चुनौतियाँ
मध्यम 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]
epochs = 1
learning_rate = 0.1

अपेक्षित आउटपुट:
expected = [1.0, 0.6]
इनपुट:
std::vector<double> xs = {1.0, 2.0};
std::vector<double> ys = {2.0, 4.0};
long long epochs = 1;
double learning_rate = 0.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};
long epochs = 1;
double learning_rate = 0.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]
epochs = 2000
learning_rate = 0.05

अपेक्षित आउटपुट:
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};
long long epochs = 2000;
double learning_rate = 0.05;

अपेक्षित आउटपुट:
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};
long epochs = 2000;
double learning_rate = 0.05;

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

व्याख्या

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

संदर्भ

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

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

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

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