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

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

उदाहरणों से sigmoid न्यूरॉन को सिखाने के लिए फ़ॉरवर्ड पास, ग्रेडिएंट और वेट अपडेट बार-बार दोहराएँ।

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

  • फ़ॉरवर्ड पास, ग्रेडिएंट और अपडेट दोहराना
  • लर्निंग रेट समायोजित करना
  • देखना कि न्यूरॉन उदाहरणों से कैसे सीखता है

समस्या

ग्रेडिएंट डिसेंट ग्रेडिएंट की उल्टी दिशा में चलकर वेट को थोड़ा-थोड़ा बेहतर बनाता है:

w ← w - learning_rate × dL/dw

स्टोकेस्टिक ग्रेडिएंट डिसेंट से एक sigmoid न्यूरॉन को ट्रेन करें। हर epoch में सैंपलों को दिए गए क्रम में लें, और हर सैंपल के लिए:

  1. z = sample · weights + bias, y = 1 / (1 + e^(-z))
  2. delta = 2 × (y - target) × y × (1 - y)
  3. weights[i] ← weights[i] - learning_rate × delta × sample[i] (हर i के लिए), फिर bias ← bias - learning_rate × delta

train_neuron(samples, targets, weights, bias, learning_rate, epochs) लागू करें।

इनपुट

samples: m ट्रेनिंग उदाहरण, हर एक में n मान।

targets: m सही आउटपुट (0 और 1 के बीच)।

weights, bias: शुरुआती वेट (n मान) और बायस।

learning_rate, epochs: स्टेप का आकार और डेटा पर कितनी बार चलना है।

आउटपुट

ट्रेन किए गए वेट और उनके बाद ट्रेन किया गया बायस लौटाएँ (n + 1 संख्याएँ)।

सीमाएँ

1 ≤ m ≤ 50, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 1,000

0 < learning_rate ≤ 5

-5 ≤ हर मान ≤ 5

उदाहरण

उदाहरण 1
इनपुट:
samples = [
    [1.0]
]
targets = [1.0]
weights = [0.0]
bias = 0.0
learning_rate = 1.0
epochs = 1

अपेक्षित आउटपुट:
expected = [0.25, 0.25]
इनपुट:
std::vector<std::vector<double>> samples = {
    {1.0}
};
std::vector<double> targets = {1.0};
std::vector<double> weights = {0.0};
double bias = 0.0;
double learning_rate = 1.0;
long long epochs = 1;

अपेक्षित आउटपुट:
std::vector<double> expected = {0.25, 0.25};
इनपुट:
double[][] samples = new double[][] {
    new double[] {1.0}
};
double[] targets = new double[] {1.0};
double[] weights = new double[] {0.0};
double bias = 0.0;
double learning_rate = 1.0;
long epochs = 1;

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

व्याख्या

y = σ(0) = 0.5, delta = 2 × (0.5 - 1) × 0.25 = -0.25। वेट: 0 - 1 × (-0.25) × 1 = 0.25। बायस: 0 - 1 × (-0.25) = 0.25। परिणाम: [0.25, 0.25]।

उदाहरण 2
इनपुट:
samples = [
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0]
]
targets = [0.0, 0.0, 0.0, 1.0]
weights = [0.0, 0.0]
bias = 0.0
learning_rate = 2.0
epochs = 500

अपेक्षित आउटपुट:
expected = [6.346558, 6.339863, -9.592092]
इनपुट:
std::vector<std::vector<double>> samples = {
    {0.0, 0.0},
    {0.0, 1.0},
    {1.0, 0.0},
    {1.0, 1.0}
};
std::vector<double> targets = {0.0, 0.0, 0.0, 1.0};
std::vector<double> weights = {0.0, 0.0};
double bias = 0.0;
double learning_rate = 2.0;
long long epochs = 500;

अपेक्षित आउटपुट:
std::vector<double> expected = {6.346558, 6.339863, -9.592092};
इनपुट:
double[][] samples = new double[][] {
    new double[] {0.0, 0.0},
    new double[] {0.0, 1.0},
    new double[] {1.0, 0.0},
    new double[] {1.0, 1.0}
};
double[] targets = new double[] {0.0, 0.0, 0.0, 1.0};
double[] weights = new double[] {0.0, 0.0};
double bias = 0.0;
double learning_rate = 2.0;
long epochs = 500;

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

व्याख्या

यह लॉजिकल AND गेट है। 500 epoch के बाद दोनों वेट बड़े और धनात्मक हो जाते हैं और बायस काफ़ी ऋणात्मक, इसलिए केवल इनपुट [1, 1] का आउटपुट 0.5 से ज़्यादा होता है।

कैसे हल करें

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

संकेत 1

हर epoch में training samples को क्रम से process करें, और हर example के बाद weights तुरंत update करें.

संकेत 2

हर sample के लिए sigmoid output निकालें, फिर उसके gradient से weights और bias को downhill move करें.

संकेत 3

क्योंकि updates online हैं, एक ही epoch में बाद वाले samples पहले हुए updates देखेंगे.

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

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

संदर्भ

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

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

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

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

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

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