Perceptron လေ့ကျင့်ရေး
- Perceptron အရာဝတ္ထု တစ်ခုဖန်တီးပါ။
- လေ့ကျင့်ရေးလုပ်ဆောင်ချက်ကို ဖန်တီးပါ။
- လိုချင်သောအဖြေများနှင့်ဆန့်ကျင်ဘက် perceptron ကို လေ့ကျင့် ပါ။
လေ့ကျင့်ရေးတာဝန်
ပြန့်ကျဲနေသော xy အမှတ်များရှိသော အာကာသအတွင်း မျဉ်းဖြောင့်တစ်ခုကို စိတ်ကူးကြည့်ပါ။
မျဉ်းကြောင်းနှင့်အောက်ရှိ အမှတ်များကို ခွဲခြားရန် perceptron ကို လေ့ကျင့်ပါ။
Perceptron အရာဝတ္ထုတစ်ခုဖန်တီးပါ။
Perceptron အရာဝတ္ထုတစ်ခုဖန်တီးပါ။ ဘာကိုမဆို (Perceptron ကဲ့သို့) အမည်ပေးပါ။
perceptron သည် ကန့်သတ်ချက်နှစ်ခုကို လက်ခံခွင့်ပြုပါ-
- သွင်းအားစု အရေအတွက် (မရှိ)၊
- သင်ယူမှုနှုန်း (learningRate)။
မူရင်းသင်ယူမှုနှုန်းကို 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 သည် ထည့်သွင်းမှုတစ်ခုစီအတွက် ကျပန်းအလေးချိန်ဖြင့် စတင်မည် ဖြစ်သည်။
သင်ယူမှုနှုန်း
အမှားတစ်ခုစီအတွက် Perceptron ကို လေ့ကျင့်နေစဉ်တွင်၊ အလေးများကို အပိုင်းအနည်းငယ်ဖြင့် ချိန်ညှိပေးမည်ဖြစ်သည်။
ဤသေးငယ်သောအပိုင်းသည် " Perceptron ၏သင်ယူမှုနှုန်း " ဖြစ်သည်။
Perceptron object တွင် ၎င်းကို learnc ဟုခေါ်သည် ။
ဘက်လိုက်မှု
တစ်ခါတစ်ရံတွင်၊ သွင်းအားစုနှစ်ခုလုံးသည် သုညဖြစ်နေပါက၊ perceptron သည် မှန်ကန်သော output ကိုထုတ်ပေးနိုင်သည်။
ယင်းကိုရှောင်ရှားရန်၊ ကျွန်ုပ်တို့သည် perceptron အား 1 တန်ဖိုးဖြင့် အပိုထည့်သွင်းမှုတစ်ခုပေးသည်။
ဒါကို ဘက်လိုက်မှု လို့ ခေါ်ပါတယ် ။
Activate Function တစ်ခုထည့်ပါ။
perceptron algorithm ကိုသတိရပါ
- input တစ်ခုစီကို perceptron ၏အလေးများဖြင့် မြှောက်ပါ။
- ရလဒ်များကို ပေါင်းပါ။
- ရလဒ်ကိုတွက်ချက်
ဥပမာ
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}
}
activation function သည် output ထွက်လိမ့်မည်-
- ပေါင်းလဒ်သည် 0 ထက်ကြီးလျှင် 1
- 0 ပေါင်းလျှင် 0 ထက်နည်းသည်။
လေ့ကျင့်ရေးလုပ်ဆောင်ချက်ကို ဖန်တီးပါ။
လေ့ကျင့်ရေးလုပ်ဆောင်ချက်သည် activate function ကိုအခြေခံ၍ ရလဒ်ကို ခန့်မှန်းသည်။
မှန်းဆချက်မှားတိုင်း perceptron သည် အလေးချိန်များကို ချိန်ညှိသင့်သည်။
ခန့်မှန်းချက်များစွာနှင့် ချိန်ညှိပြီးနောက်၊ အလေးချိန်များသည် မှန်ကန်ပါလိမ့်မည်။
ဥပမာ
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 သည် ခန့်မှန်းချက်မည်မျှမှားကြောင်း တွက်ချက်သည်။
မှန်းဆချက်မှားပါက၊ perceptron သည် ဘက်လိုက်မှုနှင့် အလေးများကို ချိန်ညှိပေးသည်၊ သို့မှသာ နောက်တစ်ကြိမ် ခန့်မှန်းချက်အနည်းငယ် ပိုမှန်လာမည်ဖြစ်သည်။
ဤသင်ယူမှုမျိုးကို backpropagation ဟုခေါ်သည် ။
အကြိမ်ပေါင်း (ထောင်ပေါင်းများစွာ) ကြိုးစားပြီးနောက် သင်၏ perceptron သည် မှန်းဆနိုင်စွမ်း အလွန်ကောင်းလာလိမ့်မည်။
သင့်ကိုယ်ပိုင်စာကြည့်တိုက်ကို ဖန်တီးပါ။
စာကြည့်တိုက်ကုဒ်
// 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);
}