Een Perceptron trainen
- Een Perceptron-object maken
- Een trainingsfunctie maken
- Train de perceptron tegen de gewenste antwoorden
Trainingstaak
Stel je een rechte lijn voor in een ruimte met verspreide xy-punten.
Train een perceptron om de punten boven en onder de lijn te classificeren.
Een Perceptron-object maken
Maak een Perceptron-object. Noem het maar wat (zoals Perceptron).
Laat de perceptron twee parameters accepteren:
- Het aantal ingangen (nee)
- De leersnelheid (learningRate).
Stel de standaard leersnelheid in op 0,00001.
Maak vervolgens willekeurige gewichten tussen -1 en 1 voor elke invoer.
Voorbeeld
// 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
}
De willekeurige gewichten
De Perceptron begint met een willekeurig gewicht voor elke invoer.
Het leertempo
Voor elke fout, tijdens het trainen van de Perceptron, worden de gewichten aangepast met een kleine fractie.
Deze kleine fractie is de " leersnelheid van Perceptron ".
In het Perceptron-object noemen we het learnc .
de vooringenomenheid
Soms, als beide invoer nul zijn, kan de perceptron een onjuiste uitvoer produceren.
Om dit te voorkomen geven we de perceptron een extra invoer met de waarde 1.
Dit wordt een vooroordeel genoemd .
Een activeringsfunctie toevoegen
Onthoud het perceptron-algoritme:
- Vermenigvuldig elke invoer met de gewichten van de perceptron
- Tel de resultaten op
- Bereken de uitkomst
Voorbeeld
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}
}
De activeringsfunctie geeft het volgende uit:
- 1 als de som groter is dan 0
- 0 als de som kleiner is dan 0
Een trainingsfunctie maken
De trainingsfunctie raadt de uitkomst op basis van de activeringsfunctie.
Elke keer dat de gok verkeerd is, moet de perceptron de gewichten aanpassen.
Na vele gissingen en aanpassingen zullen de gewichten correct zijn.
Voorbeeld
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];
}
}
}
terugpropagatie
Na elke gok berekent de perceptron hoe fout de gok was.
Als de gissing verkeerd is, past de perceptron de bias en de gewichten aan zodat de gissing de volgende keer een beetje correcter zal zijn.
Deze vorm van leren wordt backpropagation genoemd .
Na het proberen (een paar duizend keer) zal je perceptron behoorlijk goed worden in raden.
Maak je eigen bibliotheek
Bibliotheekcode
// 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
}
Nu kunt u de bibliotheek in HTML opnemen:
<script src="myperceptron.js"></script>
Gebruik je bibliotheek
Voorbeeld
// 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);
}