सभी चुनौतियाँ
कठिन 1 हल किया गया 100.0% स्वीकृति

XOR हल करने के लिए न्यूरल नेटवर्क ट्रेन करें

सब कुछ एक साथ: 2-2-1 sigmoid नेटवर्क को बैकप्रोपेगेशन से तब तक ट्रेन करें जब तक वह XOR न सीख ले।

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

  • छोटा नेटवर्क शुरू से अंत तक ट्रेन करना
  • समझना कि XOR को हिडन लेयर क्यों चाहिए
  • फ़ॉरवर्ड और बैकवर्ड पास को साथ लाना

समस्या

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

हर उदाहरण के लिए:

  1. फ़ॉरवर्ड: 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)
  2. delta_out = 2 × (y - target) × y × (1 - y), और delta_j = delta_out × output_weights[j] × a_j × (1 - a_j), इस उदाहरण के अपडेट से पहले वाले वेट का इस्तेमाल करते हुए
  3. लर्निंग रेट 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

उदाहरण

उदाहरण 1
इनपुट:
hidden_weights = [
    [0.2, 0.8],
    [0.9, -0.7]
]
hidden_biases = [0.0, 0.3]
output_weights = [-0.6, 0.4]
output_bias = 0.0
learning_rate = 1.5
epochs = 0

अपेक्षित आउटपुट:
expected = [0.482451, 0.436972, 0.494378, 0.452729]
इनपुट:
std::vector<std::vector<double>> hidden_weights = {
    {0.2, 0.8},
    {0.9, -0.7}
};
std::vector<double> hidden_biases = {0.0, 0.3};
std::vector<double> output_weights = {-0.6, 0.4};
double output_bias = 0.0;
double learning_rate = 1.5;
long long epochs = 0;

अपेक्षित आउटपुट:
std::vector<double> expected = {0.482451, 0.436972, 0.494378, 0.452729};
इनपुट:
double[][] hidden_weights = new double[][] {
    new double[] {0.2, 0.8},
    new double[] {0.9, -0.7}
};
double[] hidden_biases = new double[] {0.0, 0.3};
double[] output_weights = new double[] {-0.6, 0.4};
double output_bias = 0.0;
double learning_rate = 1.5;
long epochs = 0;

अपेक्षित आउटपुट:
double[] expected = new double[] {0.482451, 0.436972, 0.494378, 0.452729};

व्याख्या

0 epoch में कुछ भी ट्रेन नहीं होता, इसलिए परिणाम बस शुरुआती वेट के साथ फ़ॉरवर्ड पास है: लगभग [0.482, 0.437, 0.494, 0.453]। बिना ट्रेनिंग वाला नेटवर्क हर इनपुट का लगभग एक जैसा जवाब देता है।

उदाहरण 2
इनपुट:
hidden_weights = [
    [0.2, 0.8],
    [0.9, -0.7]
]
hidden_biases = [0.0, 0.3]
output_weights = [-0.6, 0.4]
output_bias = 0.0
learning_rate = 1.5
epochs = 2000

अपेक्षित आउटपुट:
expected = [0.015727, 0.982119, 0.985515, 0.013682]
इनपुट:
std::vector<std::vector<double>> hidden_weights = {
    {0.2, 0.8},
    {0.9, -0.7}
};
std::vector<double> hidden_biases = {0.0, 0.3};
std::vector<double> output_weights = {-0.6, 0.4};
double output_bias = 0.0;
double learning_rate = 1.5;
long long epochs = 2000;

अपेक्षित आउटपुट:
std::vector<double> expected = {0.015727, 0.982119, 0.985515, 0.013682};
इनपुट:
double[][] hidden_weights = new double[][] {
    new double[] {0.2, 0.8},
    new double[] {0.9, -0.7}
};
double[] hidden_biases = new double[] {0.0, 0.3};
double[] output_weights = new double[] {-0.6, 0.4};
double output_bias = 0.0;
double learning_rate = 1.5;
long epochs = 2000;

अपेक्षित आउटपुट:
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 के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

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

# कोडर भाषा समय मेमोरी AI रिव्यू समाधान
1 ННикита Python 870 ms - 5/5 कोड देखें

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

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

स्पॉइलर अलर्ट: नीचे 1 पूरा समाधान पहले खुद हल करने की कोशिश करें। आप फिर भी अन्य डेवलपर्स का कोड और AI समीक्षा देख सकते हैं। चर्चा में शामिल होने के लिए साइन इन करें और चुनौती हल करें।