कठिन 1 हल किया गया 100.0% स्वीकृति

Train a Neural Network to Solve XOR

Combine everything: train a 2-2-1 sigmoid network with backpropagation until it learns XOR.

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

  • Train a small network end to end
  • See why XOR needs a hidden layer
  • Put forward and backward passes together

समस्या

अनुवाद दिखाएँ

XOR (exclusive or) is the classic problem a single neuron cannot solve, but a network with one hidden layer can. Train a network with 2 inputs, 2 hidden neurons and 1 output, all sigmoid (σ(z) = 1 / (1 + e^(-z))), using the loss L = (y - target)².

The training data, always used in this order in every epoch:

inputtarget
[0, 0]0
[0, 1]1
[1, 0]1
[1, 1]0

For each example:

  1. Forward: 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), and delta_j = delta_out × output_weights[j] × a_j × (1 - a_j), using the weights before this example's update
  3. Update every parameter with learning rate 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

Implement train_xor(hidden_weights, hidden_biases, output_weights, output_bias, learning_rate, epochs).

Output

After training, return the network's predictions y for the inputs [0, 0], [0, 1], [1, 0] and [1, 1], in that order.

सीमाएँ

0 ≤ epochs ≤ 5,000

0 < learning_rate ≤ 5

-2 ≤ each starting weight and bias ≤ 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};

व्याख्या

With 0 epochs nothing is trained, so the result is just the forward pass with the starting weights: about [0.482, 0.437, 0.494, 0.453]. The untrained network gives every input nearly the same answer.

उदाहरण 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};

व्याख्या

After 2,000 epochs the predictions are about [0.016, 0.982, 0.986, 0.014]: low for [0, 0] and [1, 1], high for [0, 1] and [1, 0]. The network has learned XOR.

कैसे हल करें

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

संकेत 1

Process the four XOR samples in the same fixed order for every epoch, and update parameters immediately after each one.

संकेत 2

Use forward propagation, then backpropagate the output error into both hidden neurons with the current weights before applying updates.

संकेत 3

Watch for the sigmoid derivative and the fact that hidden-layer updates depend on the input values, so zero inputs leave some weights unchanged.

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

O(epochs) time, O(1) extra space

संदर्भ

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

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

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

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

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

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