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

मिनी-बैच ग्रेडिएंट डिसेंट

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

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

  • डेटा को बैच में बाँटना
  • हर बैच के बाद वज़न अपडेट करना
  • बैच, मिनी-बैच और स्टोकेस्टिक ट्रेनिंग की तुलना करना

समस्या

मिनी-बैच ग्रेडिएंट डिसेंट से लगभग हर न्यूरल नेटवर्क ट्रेन होता है: डेटा को छोटे बैच में बाँटें और हर बैच के बाद वज़न अपडेट करें।

माध्य वर्ग त्रुटि पर y = w × x + b को ट्रेन करें, w = 0 और b = 0 से शुरू करके। हर epoch में उदाहरणों को क्रम से batch_size के बैच में बाँटें (आख़िरी बैच छोटा हो सकता है)। आकार n के हर बैच के लिए:

  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_mini_batch(xs, ys, batch_size, learning_rate, epochs) लागू करें।

इनपुट

xs, ys: डेटा बिंदु (समान लंबाई)।

batch_size: हर बैच में उदाहरणों की संख्या।

learning_rate, epochs: कदम का आकार और डेटा पर कितनी बार गुज़रना है।

आउटपुट

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

सीमाएँ

1 ≤ बिंदुओं की संख्या ≤ 1,000, 1 ≤ batch_size ≤ बिंदुओं की संख्या, 0 ≤ epochs ≤ 1,000

0 < learning_rate ≤ 1

-100 ≤ हर मान ≤ 100

उदाहरण

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

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

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

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

व्याख्या

बैच 1 है x = [1, 2]: त्रुटियाँ -2 और -4, dw = -10, db = -6, इसलिए w = 1 और b = 0.6। बैच 2 अकेला x = [3] है: त्रुटि 1×3 + 0.6 - 6 = -2.4, dw = 2 × (-2.4) × 3 = -14.4 और db = -4.8, इसलिए w = 2.44 और b = 1.08। परिणाम: [2.44, 1.08]।

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

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

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

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

व्याख्या

डेटासेट जितना बड़ा बैच साधारण बैच ग्रेडिएंट डिसेंट है: हर epoch में एक अपडेट। परिणाम: [1.75, 0.6]।

कैसे हल करें

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

संकेत 1

Samples को दिए गए order में process करें, और हर single point की बजाय हर batch के बाद parameters update करें.

संकेत 2

हर batch के लिए पहले prediction errors compute करें, फिर x values के साथ उनके averages से दो gradients निकालें.

संकेत 3

Last batch बाकी batches से छोटी हो सकती है, इसलिए उसकी gradient scaling में उसी batch का size use होना चाहिए.

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

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

संदर्भ

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

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

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

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

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

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