Training eines Perzeptrons
- Erstellen Sie ein Perceptron-Objekt
- Erstellen Sie eine Trainingsfunktion
- Trainieren Sie das Perzeptron gegen die gewünschten Antworten
Trainingsaufgabe
Stellen Sie sich eine gerade Linie in einem Raum mit verstreuten xy-Punkten vor.
Trainieren Sie ein Perzeptron, um die Punkte über und unter der Linie zu klassifizieren.
Erstellen Sie ein Perceptron-Objekt
Erstellen Sie ein Perceptron-Objekt. Nennen Sie es beliebig (wie Perceptron).
Lassen Sie das Perzeptron zwei Parameter akzeptieren:
- Die Anzahl der Eingänge (nein)
- Die Lernrate (learningRate).
Stellen Sie die Standard-Lernrate auf 0,00001 ein.
Erstellen Sie dann zufällige Gewichtungen zwischen -1 und 1 für jede Eingabe.
Beispiel
// 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
}
Die Zufallsgewichte
Das Perzeptron beginnt mit einer zufälligen Gewichtung für jede Eingabe.
Die Lernrate
Für jeden Fehler beim Training des Perzeptrons werden die Gewichte um einen kleinen Bruchteil angepasst.
Dieser kleine Bruchteil ist die „ Lernrate des Perzeptrons “.
Im Perceptron-Objekt nennen wir es learnc .
Die Voreingenommenheit
Wenn beide Eingaben Null sind, kann das Perzeptron manchmal eine falsche Ausgabe erzeugen.
Um dies zu vermeiden, geben wir dem Perzeptron einen zusätzlichen Eingang mit dem Wert 1.
Dies wird als Voreingenommenheit bezeichnet .
Fügen Sie eine Aktivierungsfunktion hinzu
Denken Sie an den Perceptron-Algorithmus:
- Multiplizieren Sie jede Eingabe mit den Gewichten des Perzeptrons
- Summieren Sie die Ergebnisse
- Berechne das Ergebnis
Beispiel
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}
}
Die Aktivierungsfunktion gibt aus:
- 1, wenn die Summe größer als 0 ist
- 0, wenn die Summe kleiner als 0 ist
Erstellen Sie eine Trainingsfunktion
Die Trainingsfunktion errät das Ergebnis basierend auf der Aktivierungsfunktion.
Jedes Mal, wenn die Vermutung falsch ist, sollte das Perzeptron die Gewichte anpassen.
Nach vielen Vermutungen und Anpassungen werden die Gewichte korrekt sein.
Beispiel
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];
}
}
}
Backpropagation
Nach jeder Vermutung berechnet das Perzeptron, wie falsch die Vermutung war.
Wenn die Vermutung falsch ist, passt das Perzeptron die Vorspannung und die Gewichte an, sodass die Vermutung beim nächsten Mal etwas genauer ist.
Diese Art des Lernens wird Backpropagation genannt .
Nach (ein paar tausend Versuchen) wird Ihr Perzeptron ziemlich gut im Raten sein.
Erstellen Sie Ihre eigene Bibliothek
Bibliothekscode
// 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
}
Jetzt können Sie die Bibliothek in HTML einbinden:
<script src="myperceptron.js"></script>
Verwenden Sie Ihre Bibliothek
Beispiel
// 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);
}