समस्या
मिनी-बैच ग्रेडिएंट डिसेंट से लगभग हर न्यूरल नेटवर्क ट्रेन होता है: डेटा को छोटे बैच में बाँटें और हर बैच के बाद वज़न अपडेट करें।
माध्य वर्ग त्रुटि पर y = w × x + b को ट्रेन करें, w = 0 और b = 0 से शुरू करके। हर epoch में उदाहरणों को क्रम से batch_size के बैच में बाँटें (आख़िरी बैच छोटा हो सकता है)। आकार n के हर बैच के लिए:
- बैच के हर उदाहरण के लिए errorᵢ = w × xᵢ + b - yᵢ
- dw = (2 / n) × Σ errorᵢ × xᵢ और db = (2 / n) × Σ errorᵢ
- 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
उदाहरण
इनपुट:
xs = [1.0, 2.0, 3.0]
ys = [2.0, 4.0, 6.0]
epochs = 1
batch_size = 2
learning_rate = 0.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 epochs = 1;
long long batch_size = 2;
double learning_rate = 0.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 epochs = 1;
long batch_size = 2;
double learning_rate = 0.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]।
इनपुट:
xs = [1.0, 2.0, 3.0, 4.0]
ys = [3.0, 5.0, 7.0, 9.0]
epochs = 1
batch_size = 4
learning_rate = 0.05
अपेक्षित आउटपुट:
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 epochs = 1;
long long batch_size = 4;
double learning_rate = 0.05;
अपेक्षित आउटपुट:
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 epochs = 1;
long batch_size = 4;
double learning_rate = 0.05;
अपेक्षित आउटपुट:
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 के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।