समस्या
एक छोटे न्यूरल नेटवर्क में एक हिडन लेयर और एक आउटपुट लेयर होती है। डेटा इनसे होकर आगे बढ़ता है:
- हिडन लेयर: h_j = ReLU(inputs · hidden_weights[j] + hidden_biases[j]), जहाँ ReLU(z) = max(0, z)
- आउटपुट लेयर: y_k = sigmoid(h · output_weights[k] + output_biases[k]), जहाँ sigmoid(z) = 1 / (1 + e^(-z))
forward_pass(inputs, hidden_weights, hidden_biases, output_weights, output_biases) लागू करें।
इनपुट
inputs: n इनपुट मान।
hidden_weights, hidden_biases: हिडन लेयर, हर हिडन न्यूरॉन के लिए वेट की एक पंक्ति और एक बायस।
output_weights, output_biases: आउटपुट लेयर, हर आउटपुट के लिए एक पंक्ति और एक बायस; हर पंक्ति में हर हिडन न्यूरॉन के लिए एक वेट।
आउटपुट
नेटवर्क के आउटपुट y की सूची लौटाएँ।
सीमाएँ
1 ≤ इनपुट, हिडन न्यूरॉन, आउटपुट ≤ 50
-10 ≤ हर मान ≤ 10
उदाहरण
इनपुट:
inputs = [1.0, 0.5]
hidden_biases = [0.0, 0.5]
output_biases = [0.0]
hidden_weights = [
[1.0, -2.0],
[0.5, 1.0]
]
output_weights = [
[1.0, -1.0]
]
अपेक्षित आउटपुट:
expected = [0.182426]इनपुट:
std::vector<double> inputs = {1.0, 0.5};
std::vector<double> hidden_biases = {0.0, 0.5};
std::vector<double> output_biases = {0.0};
std::vector<std::vector<double>> hidden_weights = {
{1.0, -2.0},
{0.5, 1.0}
};
std::vector<std::vector<double>> output_weights = {
{1.0, -1.0}
};
अपेक्षित आउटपुट:
std::vector<double> expected = {0.182426};इनपुट:
double[] inputs = new double[] {1.0, 0.5};
double[] hidden_biases = new double[] {0.0, 0.5};
double[] output_biases = new double[] {0.0};
double[][] hidden_weights = new double[][] {
new double[] {1.0, -2.0},
new double[] {0.5, 1.0}
};
double[][] output_weights = new double[][] {
new double[] {1.0, -1.0}
};
अपेक्षित आउटपुट:
double[] expected = new double[] {0.182426};व्याख्या
हिडन: ReLU(1×1 + 0.5×(-2) + 0) = ReLU(0) = 0 और ReLU(1×0.5 + 0.5×1 + 0.5) = 1.5। आउटपुट: sigmoid(0×1 + 1.5×(-1) + 0) = sigmoid(-1.5) ≈ 0.182426।
इनपुट:
inputs = [2.0]
hidden_biases = [0.0, 0.0]
output_biases = [-1.0, 0.0]
hidden_weights = [
[1.0],
[-1.0]
]
output_weights = [
[0.5, 0.5],
[-0.5, 2.0]
]
अपेक्षित आउटपुट:
expected = [0.5, 0.268941]इनपुट:
std::vector<double> inputs = {2.0};
std::vector<double> hidden_biases = {0.0, 0.0};
std::vector<double> output_biases = {-1.0, 0.0};
std::vector<std::vector<double>> hidden_weights = {
{1.0},
{-1.0}
};
std::vector<std::vector<double>> output_weights = {
{0.5, 0.5},
{-0.5, 2.0}
};
अपेक्षित आउटपुट:
std::vector<double> expected = {0.5, 0.268941};इनपुट:
double[] inputs = new double[] {2.0};
double[] hidden_biases = new double[] {0.0, 0.0};
double[] output_biases = new double[] {-1.0, 0.0};
double[][] hidden_weights = new double[][] {
new double[] {1.0},
new double[] {-1.0}
};
double[][] output_weights = new double[][] {
new double[] {0.5, 0.5},
new double[] {-0.5, 2.0}
};
अपेक्षित आउटपुट:
double[] expected = new double[] {0.5, 0.268941};व्याख्या
हिडन: ReLU(2) = 2 और ReLU(-2) = 0। आउटपुट 1: sigmoid(2×0.5 + 0 - 1) = sigmoid(0) = 0.5। आउटपुट 2: sigmoid(2×(-0.5) + 0) = sigmoid(-1) ≈ 0.268941।
कैसे हल करें
पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।
संकेत 1
पहले inputs से सारे hidden activations निकालें, फिर उन्हीं hidden outputs को final layer में दें.
संकेत 2
हर layer dot products और biases का batch है, hidden layer में ReLU और output में sigmoid लगती है.
संकेत 3
दूसरी layer में original inputs को मत मिलाएँ; वह सिर्फ hidden layer outputs देखती है.
अपेक्षित जटिलता
समय O(hn + oh), अतिरिक्त स्थान O(h + o)
संदर्भ
यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।