Machinaal leren
Leren is loopen
Een ML-model wordt getraind door gegevens meerdere keren te herhalen .
Voor elke iteratie worden de Gewichtswaarden aangepast.
De training is voltooid wanneer de iteraties er niet in slagen om de kosten te verlagen .
Train me om de lijn te vinden die het beste past:
Gradiëntafdaling
Gradient Descent is een populair algoritme voor het oplossen van AI-problemen.
Een eenvoudig lineair regressiemodel kan worden gebruikt om een gradiëntdaling aan te tonen.
Het doel van een lineaire regressie is om een lineaire grafiek te passen op een reeks (x,y) punten. Dit kan worden opgelost met een wiskundige formule. Maar een Machine Learning Algorithm kan dit ook oplossen.
Dit is wat het bovenstaande voorbeeld doet.
Het begint met een spreidingsdiagram en een lineair model (y = wx + b).
Vervolgens traint het het model om een lijn te vinden die bij de plot past. Dit wordt gedaan door het gewicht (helling) en de bias (intercept) van de lijn te wijzigen.
Hieronder staat de code voor een Trainer Object dat dit probleem (en vele andere problemen) kan oplossen.
Een trainer-object
Maak een Trainer-object dat een willekeurig aantal (x,y) waarden in twee arrays (xArr,yArr) kan aannemen.
Stel zowel het gewicht als de bias in op nul.
Er moet een leerconstante (learnc) worden ingesteld en er moet een kostenvariabele worden gedefinieerd:
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;
Kostenfunctie
Een standaard manier om een regressieprobleem op te lossen, is met een "Kostenfunctie" die meet hoe goed de oplossing is.
De functie gebruikt het gewicht en de bias van het model (y = wx + b) en retourneert een fout, gebaseerd op hoe goed de lijn in een plot past.
De manier om deze fout te berekenen, is door alle (x,y) punten in de plot te doorlopen en de vierkante afstanden tussen de y-waarde van elk punt en de lijn op te tellen.
De meest conventionele manier is om de afstanden te kwadrateren (om positieve waarden te verzekeren) en om de foutfunctie differentieerbaar te maken.
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;
}
Een andere naam voor de kostenfunctie is de foutfunctie .
De formule die in de functie wordt gebruikt, is eigenlijk deze:
- E is de fout (kosten)
- N is het totale aantal waarnemingen (punten)
- y is de waarde (label) van elke waarneming
- x is de waarde (kenmerk) van elke waarneming
- m is de helling (gewicht)
- b is onderscheppen (bias)
- mx + b is de 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>