समस्या
परसेप्ट्रॉन (1958) कृत्रिम न्यूरॉन के लिए पहला लर्निंग एल्गोरिदम है। यह स्टेप फ़ंक्शन से अनुमान लगाता है और अपनी गलतियों से सीखता है।
सभी वेट और बायस को 0 से शुरू करें। हर epoch में सैंपलों को क्रम से लें, और लेबल y (0 या 1) वाले हर सैंपल x के लिए:
- अगर x · weights + bias > 0 तो अनुमान = 1, नहीं तो 0
- error = y - अनुमान (यानी -1, 0 या 1)
- अगर 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
उदाहरण
इनपुट:
epochs = 1
labels = [0, 0, 0, 1]
samples = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0]
]
learning_rate = 1.0
अपेक्षित आउटपुट:
expected = [1.0, 1.0, 1.0]इनपुट:
long long epochs = 1;
std::vector<long long> labels = {0, 0, 0, 1};
std::vector<std::vector<double>> samples = {
{0.0, 0.0},
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0}
};
double learning_rate = 1.0;
अपेक्षित आउटपुट:
std::vector<double> expected = {1.0, 1.0, 1.0};इनपुट:
long epochs = 1;
long[] labels = new long[] {0, 0, 0, 1};
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 learning_rate = 1.0;
अपेक्षित आउटपुट:
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]।
इनपुट:
epochs = 10
labels = [0, 0, 0, 1]
samples = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0]
]
learning_rate = 1.0
अपेक्षित आउटपुट:
expected = [2.0, 1.0, -2.0]इनपुट:
long long epochs = 10;
std::vector<long long> labels = {0, 0, 0, 1};
std::vector<std::vector<double>> samples = {
{0.0, 0.0},
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0}
};
double learning_rate = 1.0;
अपेक्षित आउटपुट:
std::vector<double> expected = {2.0, 1.0, -2.0};इनपुट:
long epochs = 10;
long[] labels = new long[] {0, 0, 0, 1};
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 learning_rate = 1.0;
अपेक्षित आउटपुट:
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 के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।