सभी चुनौतियाँ
मध्यम 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
इनपुट:
inputs = [1.0, 2.0]
weights = [0.5, -0.25]
bias = 0.0
target = 1.0

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

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

अपेक्षित आउटपुट:
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
इनपुट:
inputs = [3.0]
weights = [0.0]
bias = 0.0
target = 0.0

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

अपेक्षित आउटपुट:
std::vector<double> expected = {0.75, 0.25};
इनपुट:
double[] inputs = new double[] {3.0};
double[] weights = new double[] {0.0};
double bias = 0.0;
double target = 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] हैं। धनात्मक ग्रेडिएंट का अर्थ है कि वेट को घटाना चाहिए।

कैसे हल करें

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

संकेत 1

पहले neuron का sigmoid output निकालें और loss derivative को उसके pre-activation value के respect में लें.

संकेत 2

हर weight का gradient वही delta होता है, बस उसे उस input से scale करते हैं; bias के लिए सिर्फ delta चाहिए.

संकेत 3

Weight gradients को input order में रखें, फिर अंत में bias gradient जोड़ें.

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

समय O(n), अतिरिक्त स्थान O(n)

संदर्भ

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

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

अभी कोई पास हुआ समाधान नहीं है। इसे हल करें और पहला स्थान पाएँ।

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

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

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