Maschinelles Lernen
Lernen ist Looping
Ein ML-Modell wird trainiert , indem Daten mehrfach durchlaufen werden.
Für jede Iteration werden die Gewichtungswerte angepasst.
Das Training ist abgeschlossen, wenn die Iterationen die Kosten nicht senken können .
Trainiere mich, um die Linie mit der besten Passform zu finden:
Gradientenabstieg
Gradient Descent ist ein beliebter Algorithmus zur Lösung von KI-Problemen.
Ein einfaches lineares Regressionsmodell kann verwendet werden, um einen Gradientenabstieg zu demonstrieren.
Das Ziel einer linearen Regression besteht darin, einen linearen Graphen an einen Satz von (x,y)-Punkten anzupassen. Dies kann mit einer mathematischen Formel gelöst werden. Aber auch hier kann ein Machine Learning Algorithmus Abhilfe schaffen.
Dies ist, was das obige Beispiel tut.
Es beginnt mit einem Streudiagramm und einem linearen Modell (y = wx + b).
Dann trainiert es das Modell, um eine Linie zu finden, die zum Diagramm passt. Dies geschieht durch Ändern der Gewichtung (Steigung) und der Neigung (Achsenabschnitt) der Linie.
Unten ist der Code für ein Trainer-Objekt , das dieses Problem (und viele andere Probleme) lösen kann.
Ein Trainer-Objekt
Erstellen Sie ein Trainer-Objekt, das eine beliebige Anzahl von (x,y)-Werten in zwei Arrays (xArr,yArr) annehmen kann.
Setzen Sie Gewicht und Bias auf Null.
Es muss eine Lernkonstante (learnc) gesetzt und eine Kostenvariable definiert werden:
Beispiel
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;
Kostenfunktion
Eine Standardmethode zur Lösung eines Regressionsproblems ist die Verwendung einer "Kostenfunktion", die misst, wie gut die Lösung ist.
Die Funktion verwendet die Gewichtung und Abweichung aus dem Modell (y = wx + b) und gibt einen Fehler zurück, basierend darauf, wie gut die Linie in ein Diagramm passt.
Die Methode zur Berechnung dieses Fehlers besteht darin, alle (x,y)-Punkte im Diagramm zu durchlaufen und die quadratischen Abstände zwischen dem y-Wert jedes Punkts und der Linie zu summieren.
Der gebräuchlichste Weg ist, die Abstände zu quadrieren (um positive Werte zu gewährleisten) und die Fehlerfunktion differenzierbar zu machen.
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;
}
Ein anderer Name für die Kostenfunktion ist Fehlerfunktion .
Die in der Funktion verwendete Formel lautet eigentlich wie folgt:
- E ist der Fehler (Kosten)
- N ist die Gesamtzahl der Beobachtungen (Punkte)
- y ist der Wert (Label) jeder Beobachtung
- x ist der Wert (Merkmal) jeder Beobachtung
- m ist die Steigung (Gewicht)
- b ist Schnittpunkt (Bias)
- mx + b ist die Vorhersage
- 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>