सभी चुनौतियाँ
मध्यम 0 हल किए गए 0% स्वीकृति

एक न्यूरॉन के ग्रेडिएंट

चेन रूल से पता करें कि sigmoid न्यूरॉन के हर वेट और बायस के साथ लॉस कैसे बदलता है।

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

  • न्यूरॉन पर चेन नियम लागू करना
  • हर वज़न और बायस के ग्रेडिएंट निकालना
  • समझना कि सीखने के संकेत कैसे बहते हैं

समस्या

न्यूरॉन को ट्रेन करने के लिए हमें जानना होगा कि हर वेट एरर पर कैसे असर डालता है। एक ट्रेनिंग उदाहरण के लिए:

  • z = inputs · weights + bias
  • y = sigmoid(z) = 1 / (1 + e^(-z))
  • लॉस L = (y - target)²

चेन रूल के अनुसार, delta = dL/dz = 2 × (y - target) × y × (1 - y) लेने पर:

  • dL/dw_i = delta × x_i
  • dL/dbias = delta

neuron_gradients(inputs, weights, bias, target) लागू करें।

इनपुट

inputs, weights: समान लंबाई n की सूचियाँ।

bias: न्यूरॉन का बायस।

target: इस उदाहरण का सही आउटपुट (0 और 1 के बीच)।

आउटपुट

n + 1 संख्याओं की सूची लौटाएँ: क्रम से हर वेट का ग्रेडिएंट, फिर बायस का ग्रेडिएंट।

सीमाएँ

1 ≤ n ≤ 100

-10 ≤ हर इनपुट, वेट और बायस ≤ 10

0 ≤ target ≤ 1

उदाहरण

उदाहरण 1
इनपुट:
bias = 0.0
inputs = [1.0, 2.0]
target = 1.0
weights = [0.5, -0.25]

अपेक्षित आउटपुट:
expected = [-0.25, -0.5, -0.25]
इनपुट:
double bias = 0.0;
std::vector<double> inputs = {1.0, 2.0};
double target = 1.0;
std::vector<double> weights = {0.5, -0.25};

अपेक्षित आउटपुट:
std::vector<double> expected = {-0.25, -0.5, -0.25};
इनपुट:
double bias = 0.0;
double[] inputs = new double[] {1.0, 2.0};
double target = 1.0;
double[] weights = new double[] {0.5, -0.25};

अपेक्षित आउटपुट:
double[] expected = new double[] {-0.25, -0.5, -0.25};

व्याख्या

z = 1×0.5 + 2×(-0.25) = 0, इसलिए y = 0.5। delta = 2 × (0.5 - 1) × 0.5 × 0.5 = -0.25। ग्रेडिएंट: [-0.25×1, -0.25×2, -0.25] = [-0.25, -0.5, -0.25]।

उदाहरण 2
इनपुट:
bias = 0.0
inputs = [3.0]
target = 0.0
weights = [0.0]

अपेक्षित आउटपुट:
expected = [0.75, 0.25]
इनपुट:
double bias = 0.0;
std::vector<double> inputs = {3.0};
double target = 0.0;
std::vector<double> weights = {0.0};

अपेक्षित आउटपुट:
std::vector<double> expected = {0.75, 0.25};
इनपुट:
double bias = 0.0;
double[] inputs = new double[] {3.0};
double target = 0.0;
double[] weights = new double[] {0.0};

अपेक्षित आउटपुट:
double[] expected = new double[] {0.75, 0.25};

व्याख्या

z = 0 और y = 0.5। delta = 2 × (0.5 - 0) × 0.5 × 0.5 = 0.25, इसलिए ग्रेडिएंट [0.25×3, 0.25] = [0.75, 0.25] हैं। धनात्मक ग्रेडिएंट का अर्थ है कि वेट को घटाना चाहिए।

संदर्भ

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

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

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

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।