Masjienleer
Leer is lus
'n ML-model word opgelei deur meervoudige kere oor data te loop.
Vir elke iterasie word die gewigwaardes aangepas.
Opleiding is voltooi wanneer die herhalings nie die koste verminder nie .
Lei my op om die lyn van die beste passing te vind:
Gradiënt afkoms
Gradient Descent is 'n gewilde algoritme om KI-probleme op te los.
'n Eenvoudige lineêre regressiemodel kan gebruik word om 'n gradiëntdaling te demonstreer.
Die doel van 'n lineêre regressie is om 'n lineêre grafiek by 'n stel (x,y) punte te pas. Dit kan met 'n wiskundige formule opgelos word. Maar 'n Masjienleeralgoritme kan dit ook oplos.
Dit is wat die voorbeeld hierbo doen.
Dit begin met 'n spreidingsdiagram en 'n lineêre model (y = wx + b).
Dan lei dit die model op om 'n lyn te vind wat by die plot pas. Dit word gedoen deur die gewig (helling) en die vooroordeel (afsnit) van die lyn te verander.
Hieronder is die kode vir 'n Trainer Object wat hierdie probleem (en baie ander probleme) kan oplos.
'n Afrigtervoorwerp
Skep 'n Trainer-objek wat enige aantal (x,y) waardes in twee skikkings (xArr,yArr) kan neem.
Stel beide gewig en vooroordeel op nul.
'n Leerkonstante (learnc) moet gestel word, en 'n kosteveranderlike moet gedefinieer word:
Voorbeeld
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;
Koste funksie
'n Standaard manier om 'n regressieprobleem op te los, is met 'n "Kostefunksie" wat meet hoe goed die oplossing is.
Die funksie gebruik die gewig en vooroordeel van die model (y = wx + b) en gee 'n fout terug, gebaseer op hoe goed die lyn by 'n plot pas.
Die manier om hierdie fout te bereken, is om deur al (x,y) punte in die plot te lus, en die vierkantige afstande tussen die y-waarde van elke punt en die lyn op te som.
Die mees konvensionele manier is om die afstande te kwadraat (om positiewe waardes te verseker) en om die foutfunksie differensieerbaar te maak.
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;
}
'n Ander naam vir die kostefunksie is Foutfunksie .
Die formule wat in die funksie gebruik word, is eintlik dit:
- E is die fout (koste)
- N is die totale aantal waarnemings (punte)
- y is die waarde (etiket) van elke waarneming
- x is die waarde (kenmerk) van elke waarneming
- m is die helling (gewig)
- b is ondersny (vooroordeel)
- mx + b is die voorspelling
- 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>