Apprentissage automatique
L'apprentissage est en boucle
Un modèle ML est formé en bouclant les données plusieurs fois.
Pour chaque itération, les valeurs de poids sont ajustées.
La formation est terminée lorsque les itérations ne parviennent pas à réduire le coût .
Entraînez-moi à trouver la droite la mieux ajustée :
Descente graduelle
Gradient Descent est un algorithme populaire pour résoudre les problèmes d'IA.
Un simple modèle de régression linéaire peut être utilisé pour démontrer une descente de gradient.
Le but d'une régression linéaire est d'ajuster un graphique linéaire à un ensemble de points (x,y). Cela peut être résolu avec une formule mathématique. Mais un algorithme d'apprentissage automatique peut également résoudre ce problème.
C'est ce que fait l'exemple ci-dessus.
Il commence par un nuage de points et un modèle linéaire (y = wx + b).
Ensuite, il forme le modèle pour trouver une ligne qui correspond au tracé. Cela se fait en modifiant le poids (pente) et le biais (interception) de la ligne.
Vous trouverez ci-dessous le code d'un objet formateur qui peut résoudre ce problème (et bien d'autres problèmes).
Un objet formateur
Créez un objet Trainer qui peut prendre n'importe quel nombre de valeurs (x,y) dans deux tableaux (xArr,yArr).
Définissez à la fois le poids et le biais sur zéro.
Une constante d'apprentissage (learnnc) doit être définie et une variable de coût doit être définie :
Exemple
function Trainer(xArray, yArray) {
this.xArr = xArray;
this.yArr = yArray;
this.points = this.xArr.length;
this.learnc = 0.00001;
this.weight = 0;
this.bias = 1;
this.cost;
Fonction de coût
Un moyen standard de résoudre un problème de régression consiste à utiliser une "fonction de coût" qui mesure la qualité de la solution.
La fonction utilise le poids et le biais du modèle (y = wx + b) et renvoie une erreur, en fonction de l'ajustement de la ligne à un tracé.
La façon de calculer cette erreur consiste à parcourir tous les points (x, y) du tracé et à additionner les distances carrées entre la valeur y de chaque point et la ligne.
La manière la plus conventionnelle consiste à élever au carré les distances (pour garantir des valeurs positives) et à rendre la fonction d'erreur différentiable.
this.costError = function() {
total = 0;
for (let i = 0; i < this.points; i++) {
total += (this.yArr[i] - (this.weight * this.xArr[i] + this.bias)) **2;
}
return total / this.points;
}
Un autre nom pour la fonction de coût est la fonction d'erreur .
La formule utilisée dans la fonction est en fait celle-ci :
- E est l'erreur (coût)
- N est le nombre total d'observations (points)
- y est la valeur (étiquette) de chaque observation
- x est la valeur (caractéristique) de chaque observation
- m est la pente (poids)
- b est l'ordonnée à l'origine (biais)
- mx + b est la prédiction
- 1/N * N∑1 is the squared mean value
The Train Function
We will now run a gradient descent.
The gradient descent algorithm should walk the cost function towards the best line.
Each iteration should update both m and b towards a line with a lower cost (error).
To do that, we add a train function that loops over all the data many times:
this.train = function(iter) {
for (let i = 0; i < iter; i++) {
this.updateWeights();
}
this.cost = this.costError();
}
An Update Weights Function
The train function above should update the weights and biases in each iteration.
The direction to move is calculated using two partial derivatives:
this.updateWeights = function() {
let wx;
let w_deriv = 0;
let b_deriv = 0;
for (let i = 0; i < this.points; i++) {
wx = this.yArr[i] - (this.weight * this.xArr[i] + this.bias);
w_deriv += -2 * wx * this.xArr[i];
b_deriv += -2 * wx;
}
this.weight -= (w_deriv / this.points) * this.learnc;
this.bias -= (b_deriv / this.points) * this.learnc;
}
Create Your Own Library
Library Code
function Trainer(xArray, yArray) {
this.xArr = xArray;
this.yArr = yArray;
this.points = this.xArr.length;
this.learnc = 0.000001;
this.weight = 0;
this.bias = 1;
this.cost;
// Cost Function
this.costError = function() {
total = 0;
for (let i = 0; i < this.points; i++) {
total += (this.yArr[i] - (this.weight * this.xArr[i] + this.bias)) **2;
}
return total / this.points;
}
// Train Function
this.train = function(iter) {
for (let i = 0; i < iter; i++) {
this.updateWeights();
}
this.cost = this.costError();
}
// Update Weights Function
this.updateWeights = function() {
let wx;
let w_deriv = 0;
let b_deriv = 0;
for (let i = 0; i < this.points; i++) {
wx = this.yArr[i] - (this.weight * this.xArr[i] + this.bias);
w_deriv += -2 * wx * this.xArr[i];
b_deriv += -2 * wx;
}
this.weight -= (w_deriv / this.points) * this.learnc;
this.bias -= (b_deriv / this.points) * this.learnc;
}
} // End Trainer Object
Now you can include the library in HTML:
<script src="myailib.js"></script>