समस्या
XOR (एक्सक्लूसिव OR) वह क्लासिक समस्या है जिसे एक अकेला न्यूरॉन हल नहीं कर सकता, लेकिन एक हिडन लेयर वाला नेटवर्क कर सकता है। 2 इनपुट, 2 हिडन न्यूरॉन और 1 आउटपुट वाले नेटवर्क को ट्रेन करें, सभी sigmoid (σ(z) = 1 / (1 + e^(-z))), लॉस L = (y - target)² के साथ।
ट्रेनिंग डेटा, जो हर epoch में हमेशा इसी क्रम में इस्तेमाल होता है:
| इनपुट | target |
|---|---|
| [0, 0] | 0 |
| [0, 1] | 1 |
| [1, 0] | 1 |
| [1, 1] | 0 |
हर उदाहरण के लिए:
- फ़ॉरवर्ड: a_j = σ(x₁ × hidden_weights[j][0] + x₂ × hidden_weights[j][1] + hidden_biases[j]), y = σ(a₁ × output_weights[0] + a₂ × output_weights[1] + output_bias)
- delta_out = 2 × (y - target) × y × (1 - y), और delta_j = delta_out × output_weights[j] × a_j × (1 - a_j), इस उदाहरण के अपडेट से पहले वाले वेट का इस्तेमाल करते हुए
- लर्निंग रेट lr से हर पैरामीटर अपडेट करें: output_weights[j] -= lr × delta_out × a_j, output_bias -= lr × delta_out, hidden_weights[j][i] -= lr × delta_j × x_i, hidden_biases[j] -= lr × delta_j
train_xor(hidden_weights, hidden_biases, output_weights, output_bias, learning_rate, epochs) लागू करें।
आउटपुट
ट्रेनिंग के बाद, इनपुट [0, 0], [0, 1], [1, 0] और [1, 1] के लिए नेटवर्क की भविष्यवाणियाँ y इसी क्रम में लौटाएँ।
सीमाएँ
0 ≤ epochs ≤ 5,000
0 < learning_rate ≤ 5
-2 ≤ हर शुरुआती वेट और बायस ≤ 2
उदाहरण
इनपुट:
epochs = 0
output_bias = 0.0
hidden_biases = [0.0, 0.3]
learning_rate = 1.5
hidden_weights = [
[0.2, 0.8],
[0.9, -0.7]
]
output_weights = [-0.6, 0.4]
अपेक्षित आउटपुट:
expected = [0.482451, 0.436972, 0.494378, 0.452729]इनपुट:
long long epochs = 0;
double output_bias = 0.0;
std::vector<double> hidden_biases = {0.0, 0.3};
double learning_rate = 1.5;
std::vector<std::vector<double>> hidden_weights = {
{0.2, 0.8},
{0.9, -0.7}
};
std::vector<double> output_weights = {-0.6, 0.4};
अपेक्षित आउटपुट:
std::vector<double> expected = {0.482451, 0.436972, 0.494378, 0.452729};इनपुट:
long epochs = 0;
double output_bias = 0.0;
double[] hidden_biases = new double[] {0.0, 0.3};
double learning_rate = 1.5;
double[][] hidden_weights = new double[][] {
new double[] {0.2, 0.8},
new double[] {0.9, -0.7}
};
double[] output_weights = new double[] {-0.6, 0.4};
अपेक्षित आउटपुट:
double[] expected = new double[] {0.482451, 0.436972, 0.494378, 0.452729};व्याख्या
0 epoch में कुछ भी ट्रेन नहीं होता, इसलिए परिणाम बस शुरुआती वेट के साथ फ़ॉरवर्ड पास है: लगभग [0.482, 0.437, 0.494, 0.453]। बिना ट्रेनिंग वाला नेटवर्क हर इनपुट का लगभग एक जैसा जवाब देता है।
इनपुट:
epochs = 2000
output_bias = 0.0
hidden_biases = [0.0, 0.3]
learning_rate = 1.5
hidden_weights = [
[0.2, 0.8],
[0.9, -0.7]
]
output_weights = [-0.6, 0.4]
अपेक्षित आउटपुट:
expected = [0.015727, 0.982119, 0.985515, 0.013682]इनपुट:
long long epochs = 2000;
double output_bias = 0.0;
std::vector<double> hidden_biases = {0.0, 0.3};
double learning_rate = 1.5;
std::vector<std::vector<double>> hidden_weights = {
{0.2, 0.8},
{0.9, -0.7}
};
std::vector<double> output_weights = {-0.6, 0.4};
अपेक्षित आउटपुट:
std::vector<double> expected = {0.015727, 0.982119, 0.985515, 0.013682};इनपुट:
long epochs = 2000;
double output_bias = 0.0;
double[] hidden_biases = new double[] {0.0, 0.3};
double learning_rate = 1.5;
double[][] hidden_weights = new double[][] {
new double[] {0.2, 0.8},
new double[] {0.9, -0.7}
};
double[] output_weights = new double[] {-0.6, 0.4};
अपेक्षित आउटपुट:
double[] expected = new double[] {0.015727, 0.982119, 0.985515, 0.013682};व्याख्या
2,000 epoch के बाद भविष्यवाणियाँ लगभग [0.016, 0.982, 0.986, 0.014] हैं: [0, 0] और [1, 1] के लिए कम, [0, 1] और [1, 0] के लिए ज़्यादा। नेटवर्क ने XOR सीख लिया है।
कैसे हल करें
पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।
संकेत 1
चारों XOR samples को हर epoch में उसी fixed order में process करें, और हर एक के बाद तुरंत parameters update करें।
संकेत 2
Forward propagation करें, फिर current weights का उपयोग करके output error को दोनों hidden neurons तक backpropagate करें, और उसके बाद updates लागू करें।
संकेत 3
Sigmoid derivative और यह बात ध्यान में रखें कि hidden-layer updates input values पर depend करते हैं, इसलिए zero inputs कुछ weights को unchanged छोड़ते हैं।
अपेक्षित जटिलता
समय O(epochs), अतिरिक्त स्थान O(1)
संदर्भ
यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।