Former un Perceptron
- Créer un objet Perceptron
- Créer une fonction d'entraînement
- Entraînez le perceptron par rapport aux réponses souhaitées
Tâche de formation
Imaginez une ligne droite dans un espace avec des points xy dispersés.
Entraînez un perceptron pour classer les points au-dessus et au-dessous de la ligne.
Créer un objet Perceptron
Créez un objet Perceptron. Nommez-le n'importe quoi (comme Perceptron).
Soit le perceptron accepter deux paramètres :
- Le nombre d'entrées (non)
- Le taux d'apprentissage (learningRate).
Définissez le taux d'apprentissage par défaut sur 0,00001.
Créez ensuite des poids aléatoires entre -1 et 1 pour chaque entrée.
Exemple
// 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
}
Les poids aléatoires
Le Perceptron commencera avec un poids aléatoire pour chaque entrée.
Le taux d'apprentissage
Pour chaque erreur, lors de l'entraînement du Perceptron, les poids seront ajustés avec une petite fraction.
Cette petite fraction est le « taux d'apprentissage de Perceptron ».
Dans l'objet Perceptron, nous l'appelons learnc .
Le biais
Parfois, si les deux entrées sont nulles, le perceptron peut produire une sortie incorrecte.
Pour éviter cela, nous donnons au perceptron une entrée supplémentaire avec la valeur 1.
C'est ce qu'on appelle un biais .
Ajouter une fonction d'activation
Rappelez-vous l'algorithme du perceptron :
- Multipliez chaque entrée avec les poids du perceptron
- Faire la somme des résultats
- Calculer le résultat
Exemple
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 fonction d'activation affichera :
- 1 si la somme est supérieure à 0
- 0 si la somme est inférieure à 0
Créer une fonction d'entraînement
La fonction d'entraînement devine le résultat en fonction de la fonction d'activation.
Chaque fois que la conjecture est fausse, le perceptron doit ajuster les poids.
Après de nombreuses suppositions et ajustements, les poids seront corrects.
Exemple
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];
}
}
}
Rétropropagation
Après chaque supposition, le perceptron calcule à quel point la supposition était erronée.
Si l'estimation est erronée, le perceptron ajuste le biais et les poids afin que l'estimation soit un peu plus correcte la prochaine fois.
Ce type d'apprentissage est appelé rétropropagation .
Après avoir essayé (quelques milliers de fois), votre perceptron deviendra assez bon pour deviner.
Créez votre propre bibliothèque
Code de la bibliothèque
// 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
}
Vous pouvez maintenant inclure la bibliothèque dans HTML :
<script src="myperceptron.js"></script>
Utilisez votre bibliothèque
Exemple
// 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);
}