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

परसेप्ट्रॉन लर्निंग एल्गोरिदम

मूल परसेप्ट्रॉन को ट्रेन करें, जो गलती होने पर ही अपने वेट बदलता है।

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

  • केवल ग़लती पर वज़न अपडेट करना
  • कई एपॉक तक ट्रेन करना
  • जानना कि पहला न्यूरल मॉडल कैसे काम करता था

समस्या

परसेप्ट्रॉन (1958) कृत्रिम न्यूरॉन के लिए पहला लर्निंग एल्गोरिदम है। यह स्टेप फ़ंक्शन से अनुमान लगाता है और अपनी गलतियों से सीखता है।

सभी वेट और बायस को 0 से शुरू करें। हर epoch में सैंपलों को क्रम से लें, और लेबल y (0 या 1) वाले हर सैंपल x के लिए:

  1. अगर x · weights + bias > 0 तो अनुमान = 1, नहीं तो 0
  2. error = y - अनुमान (यानी -1, 0 या 1)
  3. अगर error ≠ 0: हर i के लिए weights[i] ← weights[i] + learning_rate × error × x[i], और bias ← bias + learning_rate × error

train_perceptron(samples, labels, learning_rate, epochs) लागू करें।

इनपुट

samples: m सैंपल, हर एक में n फ़ीचर।

labels: m लेबल, हर एक 0 या 1।

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

आउटपुट

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

सीमाएँ

1 ≤ m ≤ 100, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 100

0 < learning_rate ≤ 1

-10 ≤ हर फ़ीचर ≤ 10

उदाहरण

उदाहरण 1
इनपुट:
samples = [
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0]
]
labels = [0, 0, 0, 1]
learning_rate = 1.0
epochs = 1

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

अपेक्षित आउटपुट:
std::vector<double> expected = {1.0, 1.0, 1.0};
इनपुट:
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}
};
long[] labels = new long[] {0, 0, 0, 1};
double learning_rate = 1.0;
long epochs = 1;

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

व्याख्या

[0, 0]: z = 0, अनुमान 0, सही। [0, 1] और [1, 0]: भी अनुमान 0, सही। [1, 1]: अनुमान 0 लेकिन लेबल 1 है, इसलिए error = 1: वेट [1, 1] और बायस 1 हो जाता है। परिणाम: [1, 1, 1]।

उदाहरण 2
इनपुट:
samples = [
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0]
]
labels = [0, 0, 0, 1]
learning_rate = 1.0
epochs = 10

अपेक्षित आउटपुट:
expected = [2.0, 1.0, -2.0]
इनपुट:
std::vector<std::vector<double>> samples = {
    {0.0, 0.0},
    {0.0, 1.0},
    {1.0, 0.0},
    {1.0, 1.0}
};
std::vector<long long> labels = {0, 0, 0, 1};
double learning_rate = 1.0;
long long epochs = 10;

अपेक्षित आउटपुट:
std::vector<double> expected = {2.0, 1.0, -2.0};
इनपुट:
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}
};
long[] labels = new long[] {0, 0, 0, 1};
double learning_rate = 1.0;
long epochs = 10;

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

व्याख्या

10 epoch के बाद परसेप्ट्रॉन ने AND गेट सीख लिया है: वेट [2, 1] और बायस -2 के साथ केवल [1, 1] पर z > 0 होता है।

कैसे हल करें

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

संकेत 1

हर epoch में samples को order में process करें, क्योंकि earlier updates बाद की predictions को affect करते हैं।

संकेत 2

सिर्फ तब update करें जब predicted class label से अलग हो, और weights तथा bias दोनों को साथ adjust करें।

संकेत 3

Prediction rule strict sign test का उपयोग करता है, इसलिए score zero होने पर class 0 माना जाता है।

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

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

संदर्भ

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

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

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

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

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

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