एक परसेप्ट्रोन प्रशिक्षण
- एक परसेप्ट्रॉन ऑब्जेक्ट बनाएं
- एक प्रशिक्षण समारोह बनाएँ
- वांछित उत्तरों के विरुद्ध परसेप्ट्रोन को प्रशिक्षित करें
प्रशिक्षण कार्य
बिखरे हुए xy बिंदुओं वाले स्थान में एक सीधी रेखा की कल्पना करें।
लाइन के ऊपर और नीचे के बिंदुओं को वर्गीकृत करने के लिए एक परसेप्ट्रॉन को प्रशिक्षित करें।
एक परसेप्ट्रॉन ऑब्जेक्ट बनाएं
एक परसेप्ट्रॉन ऑब्जेक्ट बनाएं। इसे कुछ भी नाम दें (जैसे Perceptron)।
परसेप्ट्रोन को दो मापदंडों को स्वीकार करने दें:
- इनपुट की संख्या (नहीं)
- सीखने की दर (सीखने की दर)।
डिफ़ॉल्ट सीखने की दर को 0.00001 पर सेट करें।
फिर प्रत्येक इनपुट के लिए -1 और 1 के बीच यादृच्छिक भार बनाएं।
उदाहरण
// Perceptron Object
function Perceptron(no, learningRate = 0.00001) {
// Set Initial Values
this.learnc = learningRate;
this.bias = 1;
// Compute Random Weights
this.weights = [];
for (let i = 0; i <= no; i++) {
this.weights[i] = Math.random() * 2 - 1;
}
// End Perceptron Object
}
यादृच्छिक भार
Perceptron प्रत्येक इनपुट के लिए एक यादृच्छिक वजन के साथ शुरू होगा।
सीखने की दर
प्रत्येक गलती के लिए, परसेप्ट्रोन को प्रशिक्षित करते समय, वजन को एक छोटे से अंश के साथ समायोजित किया जाएगा।
यह छोटा अंश " परसेप्ट्रॉन की सीखने की दर " है।
परसेप्ट्रॉन ऑब्जेक्ट में हम इसे लर्नसी कहते हैं ।
पूर्वाग्रह
कभी-कभी, यदि दोनों इनपुट शून्य हैं, तो परसेप्ट्रोन सही आउटपुट में उत्पादन कर सकता है।
इससे बचने के लिए, हम परसेप्ट्रोन को 1 के मान के साथ एक अतिरिक्त इनपुट देते हैं।
इसे पूर्वाग्रह कहा जाता है ।
एक सक्रिय फ़ंक्शन जोड़ें
परसेप्ट्रोन एल्गोरिथम याद रखें:
- प्रत्येक इनपुट को परसेप्ट्रोन के भार से गुणा करें
- परिणामों का योग करें
- परिणाम की गणना करें
उदाहरण
this.activate = function(inputs) {
let sum = 0;
for (let i = 0; i < inputs.length; i++) {
sum += inputs[i] * this.weights[i];
}
if (sum > 0) {return 1} else {return 0}
}
सक्रियण फ़ंक्शन आउटपुट करेगा:
- 1 यदि योग 0 . से अधिक है
- 0 यदि योग 0 . से कम है
एक प्रशिक्षण समारोह बनाएँ
प्रशिक्षण फ़ंक्शन सक्रिय फ़ंक्शन के आधार पर परिणाम का अनुमान लगाता है।
हर बार अनुमान गलत होने पर, परसेप्ट्रोन को वज़न समायोजित करना चाहिए।
कई अनुमानों और समायोजनों के बाद, वज़न सही होगा।
उदाहरण
this.train = function(inputs, desired) {
inputs.push(this.bias);
let guess = this.activate(inputs);
let error = desired - guess;
if (error != 0) {
for (let i = 0; i < inputs.length; i++) {
this.weights[i] += this.learnc * error * inputs[i];
}
}
}
बैकप्रोपेगेशन
प्रत्येक अनुमान के बाद, परसेप्ट्रोन गणना करता है कि अनुमान कितना गलत था।
यदि अनुमान गलत है, तो परसेप्ट्रॉन पूर्वाग्रह और भार को समायोजित करता है ताकि अगली बार अनुमान थोड़ा और सही हो।
इस प्रकार की शिक्षा को बैकप्रोपेगेशन कहा जाता है ।
कोशिश करने के बाद (कुछ हज़ार बार) आपका परसेप्ट्रोन अनुमान लगाने में काफी अच्छा हो जाएगा।
अपनी खुद की लाइब्रेरी बनाएं
पुस्तकालय कोड
// Perceptron Object
function Perceptron(no, learningRate = 0.00001) {
// Set Initial Values
this.learnc = learningRate;
this.bias = 1;
// Compute Random Weights
this.weights = [];
for (let i = 0; i <= no; i++) {
this.weights[i] = Math.random() * 2 - 1;
}
// Activate Function
this.activate = function(inputs) {
let sum = 0;
for (let i = 0; i < inputs.length; i++) {
sum += inputs[i] * this.weights[i];
}
if (sum > 0) {return 1} else {return 0}
}
// Train Function
this.train = function(inputs, desired) {
inputs.push(this.bias);
let guess = this.activate(inputs);
let error = desired - guess;
if (error != 0) {
for (let i = 0; i < inputs.length; i++) {
this.weights[i] += this.learnc * error * inputs[i];
}
}
}
// End Perceptron Object
}
अब आप लाइब्रेरी को HTML में शामिल कर सकते हैं:
<script src="myperceptron.js"></script>
अपनी लाइब्रेरी का उपयोग करें
उदाहरण
// Initiate Values
const numPoints = 500;
const learningRate = 0.00001;
// Create a Plotter
const plotter = new XYPlotter("myCanvas");
plotter.transformXY();
const xMax = plotter.xMax;
const yMax = plotter.yMax;
const xMin = plotter.xMin;
const yMin = plotter.yMin;
// Create Random XY Points
const xPoints = [];
const yPoints = [];
for (let i = 0; i < numPoints; i++) {
xPoints[i] = Math.random() * xMax;
yPoints[i] = Math.random() * yMax;
}
// Line Function
function f(x) {
return x * 1.2 + 50;
}
//Plot the Line
plotter.plotLine(xMin, f(xMin), xMax, f(xMax), "black");
// Compute Desired Answers
const desired = [];
for (let i = 0; i < numPoints; i++) {
desired[i] = 0;
if (yPoints[i] > f(xPoints[i])) {desired[i] = 1}
}
// Create a Perceptron
const ptron = new Perceptron(2, learningRate);
// Train the Perceptron
for (let j = 0; j <= 10000; j++) {
for (let i = 0; i < numPoints; i++) {
ptron.train([xPoints[i], yPoints[i]], desired[i]);
}
}
// Display the Result
for (let i = 0; i < numPoints; i++) {
const x = xPoints[i];
const y = yPoints[i];
let guess = ptron.activate([x, y, ptron.bias]);
let color = "black";
if (guess == 0) color = "blue";
plotter.plotPoint(x, y, color);
}