Addestrare un Perceptron
- Crea un oggetto Perceptron
- Crea una funzione di allenamento
- Allena il perceptron contro le risposte desiderate
Compito di formazione
Immagina una linea retta in uno spazio con punti xy sparsi.
Allena un perceptron per classificare i punti sopra e sotto la linea.
Crea un oggetto Perceptron
Crea un oggetto Perceptron. Dagli un nome qualsiasi (come Perceptron).
Lascia che il perceptron accetti due parametri:
- Il numero di ingressi (no)
- Il tasso di apprendimento (learningRate).
Imposta il tasso di apprendimento predefinito su 0,00001.
Quindi crea pesi casuali compresi tra -1 e 1 per ogni input.
Esempio
// 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
}
I pesi casuali
Il Perceptron inizierà con un peso casuale per ogni input.
Il tasso di apprendimento
Per ogni errore, durante l'allenamento del Perceptron, i pesi verranno aggiustati con una piccola frazione.
Questa piccola frazione è il " tasso di apprendimento del Perceptron ".
Nell'oggetto Perceptron lo chiamiamo learnc .
Il pregiudizio
A volte, se entrambi gli input sono zero, il perceptron potrebbe produrre un output corretto.
Per evitare ciò, diamo al perceptron un input aggiuntivo con il valore di 1.
Questo è chiamato pregiudizio .
Aggiungi una funzione di attivazione
Ricorda l'algoritmo del perceptron:
- Moltiplica ogni input per i pesi del perceptron
- Somma i risultati
- Calcola il risultato
Esempio
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}
}
La funzione di attivazione produrrà:
- 1 se la somma è maggiore di 0
- 0 se la somma è minore di 0
Crea una funzione di allenamento
La funzione di allenamento indovina il risultato in base alla funzione di attivazione.
Ogni volta che l'ipotesi è sbagliata, il perceptron dovrebbe regolare i pesi.
Dopo molte ipotesi e aggiustamenti, i pesi saranno corretti.
Esempio
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];
}
}
}
Backpropagazione
Dopo ogni ipotesi, il perceptron calcola quanto fosse sbagliata l'ipotesi.
Se l'ipotesi è sbagliata, il perceptron regola la distorsione e i pesi in modo che l'ipotesi sia un po' più corretta la prossima volta.
Questo tipo di apprendimento è chiamato backpropagation .
Dopo aver provato (qualche migliaio di volte) il tuo perceptron diventerà abbastanza bravo a indovinare.
Crea la tua libreria
Codice Biblioteca
// 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
}
Ora puoi includere la libreria in HTML:
<script src="myperceptron.js"></script>
Usa la tua libreria
Esempio
// 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);
}