Dieser Artikel wurde maschinell übersetzt.

Testlauf

Gradientenverfahren trainieren mit C#

James McCaffrey

Laden Sie die Codebeispiele herunter

Meine informelle Definition des maschinellen Lernens (ML) ist ein System, das Daten verwendet, um Vorhersagen zu treffen. Wer startet Untersuchung ML schnell stößt die etwas geheimnisvolle Phrase "gradient Abstieg." In diesem Artikel werde ich erklären welche Steigung Abstieg ist und veranschaulichen zu verwenden, um ein Klassifizierungssystem für die logistische Regression zu trainieren.

Um eine Vorstellung davon, dieser Artikel wohin zu erhalten, schauen Sie sich das Demoprogramm in Abbildung 1. Die Demo beginnt durch die Generierung von 10.000 synthetische Datenelemente. Mit künstlichen Daten anstelle von realen Daten ist häufig sinnvoll, beim ML zu untersuchen, da Sie die Eigenschaften der Daten steuern können. Jedes Datenelement hat acht Predictor Variablenwerte (oft als Funktionen in der ML-Terminologie) gefolgt von eine einzelne abhängige Variable, der entweder 0 oder 1 sein. Die Daten wurde generiert mithilfe von acht zufällige Gewicht-Werte (-7.78,-0.65... -7.97) plus eine zusätzliche Konstante (-5.02).

Abbildung 1 Training eine logistische Regression-Klassifizierung mit Farbverlauf Abstieg

Sie können sich vorstellen, dass die synthetischen Daten ein Problem entspricht, wo willst du das Geschlecht Vorhersagen (männlich = 0, weiblich = 1) einer Person, die auf der Grundlage von acht Merkmale wie Alter, Jahreseinkommen, Kredit-Score und So weiter, wo die Funktion Werte haben alle wurde so skaliert sie zwischen-10.0 und + 10,0 fallen.

Nach dem Generieren von 10.000 Datenelemente, teilt die Demo zufällig, dass die Daten in ein 8.000-Element verwendet werden, um eine Klassifizierung zu trainieren, und ein 2.000-Element verwendet werden, um die Vorhersagegenauigkeit des resultierenden Modells zu schätzen. Als nächstes die Demo erstellt eine binäre logistische Regression-Klassifizierung und dann bereitet auf Farbverlauf Abstieg durch Festlegen der Werte für Variablen MaxEpochs (1.000) Ausbildung und lernen Rate (0,01). Gradient Abstieg ist ein iterativer Prozess und Variable MaxEpochs legt eine Grenze für die Anzahl der Iterationen. Ich erkläre das Lernen bewerten Parameter später, aber für jetzt Sie Lern-Kurs als Wert, die steuert vorstellen können, wie viel Änderung in das logistische Regressionsmodell Klassifizierung in jeder Iteration Ausbildung stattfindet.

Die Demo schult die Klassifizierung und zeigt den Fehler des Modells auf die Trainingsdaten, jede 100 Iterationen. Gradient Abstieg kann auf zwei verschiedene Arten zu trainieren eine logistische Regression-Klassifizierung verwendet werden. Der erste, häufige, Ansatz heißt "stochastische" oder "online" oder "inkrementelle." (ML-Vokabular ist chaotisch.) Der zweite Ansatz nennt man "Charge" oder "offline". Ich werde später beide Ansätze beschreiben, aber das Demoprogramm basiert auf dem stochastischen Farbverlauf Abstammung Training Ansatz.

Nach Abschluss der Ausbildung zeigt die Demo die besten Gewicht Werte gefunden (-9.84,-14.88... -15.09). Beachten Sie die Modell-Gewichte sind alle über doppelt so groß wie die Gewichte verwendet, um die zufälligen Daten zu generieren. Das Demoprogramm berechnet die Genauigkeit des resultierenden Modells auf den Trainingsdaten (99,88 Prozent oder 7.990 von 8.000 korrekt) und die Genauigkeit der Prüfdaten (99,80 % oder 1.996 von 2.000 korrekte).

Logistische Regression-Klassifizierung

Logistische Regression-Klassifikation ist am besten anhand eines konkreten Beispiels erklären. Angenommen, Sie möchten das Geschlecht einer Person vorherzusagen (männlich = 0, weiblich = 1) auf der Grundlage Alter (X 1), Stufe, Jahreseinkommen (X 2) und Bildung (X 3). Wenn Y der vorhergesagte Wert ist, würde ein logistisches Regressionsmodell für dieses Problem Form erfolgen:

Z = b0 + b1(x1) + b2(x2) + b3(x3)
Y = 1.0 / (1.0 + e^-Z)

B0, b1, b2 und b3 sind Gewichte, die nur numerische Werte sind, die bestimmt werden muss. In Worten Sie berechnen ein Zwischenwert Z, die die Summe der Eingangswerte mal b-Gewichte, hinzufügen eine Konstanten b0, dann übergeben Sie den Z-Wert der Gleichung, die mathematische Konstante e verwendet. Die Gleichung wird die logistische sigmoidale-Funktion aufgerufen. Beachten Sie, dass jeder Eingangsgröße (Xi) eine zugehörige Gewichtung (Bi hat) und, dass es ein zusätzliches Gewicht (b0) nicht Eingaben zugeordnete.

Es stellt sich heraus Y werden immer zwischen 0 und 1. Wenn Y kleiner als 0,5 ist (näher bei 0), Sie schließen der vorhergesagte Ausgang ist 0 und wenn Y größer als 0,5 ist, schließen Sie die Ausgabe ist 1. Wenn n Features vorhanden sind, gibt es n + 1 b-Gewichte. Nicht alle Daten mit logistische Regression modelliert werden können, sondern weil es eine der einfachsten Techniken, Klassifizierung, logistische Regression ist ein guter Ort zum starten.

Angenommen, eine Person hat eine skalierte Alter von x 1 = +0.80 (älter als der Durchschnitt), Jahreseinkommen von x 2 =-0.50 (etwas weniger als der Durchschnitt) und Bildungsniveau x 3 =-1.00 (weniger als der Durchschnitt). Und nehme an, dass b0 = 3.0, b1 =-2.0, b2 = 2.0 und b3 = 1.5. Dann Z = 3.0 + (-2.0)(0.80) + (2.0)(-0.50) + (1.5)(-1.00) =-1.10 und also Y = 1.0 / (1.0 + e^-(-1.10)) = 0,25. Da Y näher bei 0 (weniger als 0,5) als 1 ist, würde Sie Vorhersagen, die Person ist männlich.

Hier ist der Demo-Code, der implementiert computing logistische Regression Ausgabe:

public double ComputeOutput(double[] dataItem, double[] weights)
{
  double z = 0.0;
  z += weights[0]; // Add b0 constant
  for (int i = 0; i < weights.Length - 1; ++i)
    z += (weights[i + 1] * dataItem[i]); // Skip b0
  return 1.0 / (1.0 + Math.Exp(-z)); // Logistic sigmoid
}

Ist die Frage, wo die b-Gewichte aus kommen? Das Verfahren zur Bestimmung der Werte der b-Gewichte nennt man trainieren des Modells. Die Idee ist, eine Reihe von Trainingsdaten zu verwenden, die kennt Eingabe- und Ausgabewerte und dann versuchen unterschiedliche Werte für die b-Gewichte bis Sie eine Reihe von Werten, die den Fehler zwischen berechnete Ausgaben und die bekannten, korrekte Ausgabewerte finden (oft die Zielwerte oder die gewünschten Werte genannt) minimiert.

Die Gewicht-Werte, die Fehlerbekämpfung zu finden ist schwierig und es gibt viele Numerische Optimierungsverfahren-Algorithmen, die Sie verwenden können. Jeder Algorithmus hat andere stärken und Schwächen. Die häufigsten Optimierungsalgorithmen gehören simplex-Optimierung, L-BFGS-Optimierung, Particle Swarm Optimization, iterierten Newton-Raphson sowie etwa ein Dutzend andere. Der grundlegendste Optimierungsalgorithmus heißt Farbverlauf Abstieg.

Verständnis Farbverlauf Abstieg

Lassen Sie mich versuchen Farbverlauf Abstieg aus der Sicht eines Softwareentwicklers zu erklären. Ich nehme Freiheiten mit meiner Erklärung und Terminologie, um die Ideen so klar wie möglich zu machen. Schauen Sie sich das Diagramm in der Abbildung 2. Das Diagramm stellt Fehler als Funktion des Wertes der etwas an Gewicht. Als der Wert des ein Gewicht ändert ändert sich die resultierende logistische Regression-Klassifizierung-Fehler. Das Ziel ist, den Gewichtungswert zu finden, wo ist der Fehler auf ein Minimum. Für Abbildung 2, dies wäre w = 5.0. Hier verwende ich w eines b-Gewichte angegeben. Beachten Sie, dass es ein Diagramm wie in wäre Abbildung 2 für jedes Gewicht.

Abbildung 2 partielle Ableitungen und Gradient Abstieg

Wenn du wüsstest, dass die Form der Fehler-Diagramme, Bestimmung jedes Gewicht wäre einfach. Aber leider nicht die Form von jedem Fehler-Graph. Sie denken, Sie könnte nur versuchen, jeden möglichen Gewichtungswert und berechnen Sie den daraus resultierenden Fehler, aber es gibt eine unendliche Anzahl von möglichen Gewicht Werte.

Eine Kalkül Ableitung einer Funktion an einem gewissen Punkt ist die Steigung der Tangente an der Stelle. Hang hat ein Vorzeichen (+ oder -) darauf hinweist, dass die Richtung der Tangente und eine Größenordnung, die die Steigung der Tangente angibt. Z. B. in Abbildung 2, wenn w = 7.0, die Steigung der Tangente (das heißt, die Ableitung) ist +2.15 (von oben rechts nach links unten und steil). Wenn w =-5.0, die Ableitung ist-0.90 (von oben links nach unten rechts, und nicht zu steil).

Jede einzelne Ableitung wird eine partielle Ableitung (oder nur eine "teilweise" aus Platzgründen) bezeichnet, da gibt es Derivate für jedes Gewicht. Ein Farbverlauf ist die Auflistung von allen die partiellen Ableitungen. Im lässig Sprachgebrauch werden die Begriffe Farbverlauf und die partielle Ableitung häufig synonym, verwendet vor allem, weil ein Satz wie "die partielle Ableitung der Error-Funktion in Bezug auf Gewicht b2," ist viel schwerer zu sagen oder zu schreiben als, "der Neigung". Partielle Ableitungen werden häufig gekennzeichnet mit einem speziellen Math-Symbol, das eine rückwärts 6 ähnelt.

Also, was ist der Sinn? Wenn Sie genau hinsehen, an Abbildung 2, Sie werden sehen, dass eine partielle Ableitung verwendet werden kann, um aus einem gegebenen Gewichtungswert gegenüber der Gewichtungswert zu verschieben, wo die Fehler minimiert. Die Vorzeichen der partiellen zeigt die Richtung zu bewegen, und das Ausmaß der die teilweise verleiht einen Hauch von wie weit bewegen; eine größere Helligkeit bedeutet, dass Sie weiter als eine kleinere Größenordnung bewegen betrachten können. Diese Technik heißt Farbverlauf Abstieg, da du unten die Fehlerfunktion gegenüber einen Mindestwert wirst.

OK, so weit so gut, aber wie funktioniert diese Idee in nutzbare Code übersetzen? Oder, anders ausgedrückt, was ist der Pseudocode, eine logistische Regression-Gewicht zu aktualisieren? Es gibt viele Ressourcen im Internet, die zeigen, einige ziemlich anspruchsvoll Kalkül die Gewicht-Update-Regel ableiten. Das Endergebnis ist:

wj = wj + a * (target - computed) * xj

In Worten "für das Jth Gewicht, der neue Gewichtungswert ist das alte Gewicht plus das Produkt einer Konstanten 'a,' mal den Unterschied zwischen den Zielwert in den Trainingsdaten und die berechnete Ausgabewert, mal das Gewicht Jth zugeordneten Funktion (input) Wert." Die Update-Regel wird oft geschrieben mit griechischen Buchstaben mit Theta (θ) für Gewicht und Alpha (α) für die Konstante. Die Konstante "a" wird oft als der Lern-Kurs.

Angenommen, Sie arbeiten mit einem Gewicht wo j = 2, b2. Und nehme an, dass der aktuelle Wert von b2 0,50. Wenn für einige Training-Datenelement der bekannten Zielwert 1 und der berechnete Ausgabewert ist (unter Verwendung aller x-Werte) ist 0,80, und X 2 (die einzelnen Eingabewert, das Gewicht b2 entspricht) hat Wert 3.0 und der Lern-Kurs ist 0.10, dann ist das neue b2-Gewicht:

b2 = 0.50 + 0.10 * (1 - 0.80) * 3.0
b2 = 0.50 + 0.06
b2 = 0.56

Die Update-Regel wird iterativ angewendet, bis eine beenden-Bedingung erfüllt ist. Es ist fast zu einfach. Beachten Sie, dass die berechnete Ausgabe (0.80) zu klein im Vergleich zu den Zielausgabe (1.0), so die Regel zur Aktualisierung des Gewicht den Wert des Gewichts erhöht. Dies wird dadurch den berechnete Ausgabe-Wert bei der nächsten Iteration der Ausbildung haben. Wenn die berechnete Ausgabe im Vergleich zu den Zielausgabe zu groß gewesen wäre, würde die Regel zur Aktualisierung des Gewicht das Gewicht reduziert haben. Sehr nett!

Es gibt zwei Möglichkeiten, um die Regel zur Aktualisierung des Gewicht ableiten. Der am häufigsten verwendete Ansatz sehen Sie unter Referenzen im Internet beginnt durch die Wahrscheinlichkeit, dass immer eine Reihe von Trainingsdaten für einen bestimmten Satz von Gewicht Werte definieren und anschließend eine als maximum-Likelihood-Erwartung ziemlich kompliziert Kalkül-Technik verwendet, um die Werte der Parameter zu finden, die die Wahrscheinlichkeit der beobachteten Daten zu maximieren.

Eine alternative Methode beginnt mit der Definition, was mit Fehler, mit entweder zwei Definitionen für gemeinsame Fehler gemeint ist — die Summe der Abweichungen im Quadrat oder das Kreuz-Entropie-Fehler. Dieser Ansatz wird dann Kalkül um Gewicht Werte zu finden, die Fehler minimiert. Beim Starten mit Kreuz Entropie Fehler ist Regel zur Aktualisierung des resultierenden Gewicht identisch mit der Regel erzeugt durch die Maximierung der Wahrscheinlichkeit. Beim Start mit der Summe der quadrierten Abweichungen Fehler hat die resultierende Update-Regel zwei zusätzliche Bedingungen:

wj = wj + a * (target - computed) * xj * computed * (1 - computed)

In der Regel Alternative Update weil der berechnete Begriff immer zwischen 0 und 1, ist das Produkt der berechnet und (1 - berechnet) werden immer zwischen 0 und 0,25, was bedeutet, dass die Aktualisierung Gewichte verwenden der alternativen Update-Regel nur kleinere Schritte als die einfachere Form nimmt. In der Praxis geben beide Fortschreibungsregeln ähnliche Ergebnisse, so dass die einfachere Form fast immer verwendet wird. Zum Glück brauchen Sie nicht wissen, wie man die Regel zur Aktualisierung des Gewicht ableiten, um eine logistische Regression-Klassifizierung zu trainieren.

Der Wahrscheinlichkeit-Ableitung-Ansatz maximiert Wahrscheinlichkeit durch eine Steigung hinauf, daher Farbverlauf Aufstieg bezeichnet. Der Fehler-Ableitung-Ansatz minimiert Fehler durch einen Farbverlauf hinunter und heißt Farbverlauf Abstieg. Der Punkt ist, dass Sie sehen, dass training eine logistische Regression-Klassifizierung, die mit einem Farbverlauf als die Steigung Abstieg-Technik und der Farbverlauf Aufstieg-Technik bezeichnet. Beide Begriffe bezeichnen das gleiche Gewicht Update-Regel.

Demo-Programm-Struktur

Die Struktur des Programms Demo mit einigen geringfügigen Änderungen platzsparend, präsentiert sich in Abbildung 3. Um die Demo zu erstellen, ich startete Visual Studio und C#-Konsolenanwendung-Vorlage ausgewählt. Ich nannte das Projekt LogisticGradient. Die Demo hat keine bedeutenden .NET-Abhängigkeiten, damit jede Version von Visual Studio funktioniert. Die Demo ist zu lang, in seiner Gesamtheit zu präsentieren, aber der Quellcode ist verfügbar im Codedownload zu diesem Artikel. Ich entfernte alle normalen Fehlerprüfung um die wichtigsten Ideen, die so klar wie möglich zu halten.

Abbildung 3-Demo-Programm-Struktur

using System;
namespace LogisticGradient
{
  class LogisticGradientProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin classification demo");
      Console.WriteLine("Demonstrating gradient descent");
      ...
      Console.WriteLine("End demo");
      Console.ReadLine();
    }
    static double[][] MakeAllData(int numFeatures,
      int numRows, int seed) { . . }
    static void MakeTrainTest(double[][] allData, int seed,
      out double[][] trainData, out double[][] testData) { . . }
    static void ShowData(double[][] data, int numRows,
      int decimals, bool indices) { . . }
    static void ShowVector(double[] vector,
      int decimals, bool newLine) { . . }
  }
  public class LogisticClassifier
  {
    private int numFeatures;
    private double[] weights;
    private Random rnd;
    public LogisticClassifier(int numFeatures) { . . }
    public double[] Train(double[][] trainData,
      int maxEpochs, double alpha) { . . }
    private void Shuffle(int[] sequence) { . . }
    private double Error(double[][] trainData,
      double[] weights) { . . }
    private double ComputeOutput(double[] dataItem,
      double[] weights) { . . }
    private int ComputeDependent(double[] dataItem,
      double[] weights) { . . }
    public double Accuracy(double[][] trainData,
      double[] weights) { . . }
  }
}

Nachdem der Vorlagencode, im Fenster Projektmappen-Explorer geladen ich geklickt haben Datei Program.cs und benannte sie in aussagekräftigeren LogisticGradientProgram.cs und Visual Studio automatisch umbenannt Klasse Programm für mich. Im Editor-Fenster, an der Spitze des Quellcodes löschte ich alles nicht benötigte using-Anweisungen, verlassen nur die eine auf die oberste Ebene System-Namespace verweisen.

Die LogisticGradientProgram-Klasse enthält Hilfsmethoden, MakeAllData, MakeTrainTest, ShowData und ShowVector, die schaffen und die synthetischen Daten anzuzeigen. Die Klassifizierung-Logik ist im Programm definierten Klasse LogisticClassifier enthalten. Die Main-Methode erstellt die synthetischen Daten mit folgenden Anweisungen:

int numFeatures = 8;
int numRows = 10000;
int seed = 1; // Arbitrary
double[][] allData = MakeAllData(numFeatures, numRows, seed);

Methode MakeAllData ist im Wesentlichen die logistische Regression Klassifizierung in umgekehrter Richtung. Die Methode generiert zufällige Gewichte und dann iterativ generiert zufällige Eingabewerte, kombiniert die Gewichte und input-Werte mithilfe der logistischen sigmoid-Funktion und den entsprechenden Ausgabe-Wert berechnet. Die Methode hinzufügen keine Rauschen auf die Daten, was bedeutet, dass in der Theorie, hundertprozentige Vorhersage, dass Genauigkeit möglich ist. Die synthetischen Daten gliedert sich in Trainings- und Test-Sets, etwa so:

double[][] trainData;
double[][] testData;
MakeTrainTest(allData, 0, out trainData, out testData);
ShowData(trainData, 3, 2, true);
ShowData(testData, 3, 2, true);

Methode MakeTrainTest verwendet einen hartcodierten 80 bis 20 Prozent Zug-Test Split. Vielleicht möchten den Prozentsatz der Ausbildung als Parameter zu übergeben. Die logistische Regression-Klassifizierung ist erstellt und trainierte bei:

LogisticClassifier lc = new LogisticClassifier(numFeatures);
int maxEpochs = 1000;
double alpha = 0.01; // Learning rate
double[] weights = lc.Train(trainData, maxEpochs, alpha);
ShowVector(weights, 4, true);

Die Werte für Parameter MaxEpochs Training und Alpha (der Lern-Kurs) wurden durch Ausprobieren ermittelt. Tuning die meisten ML-Trainingsmethoden in der Regel muß man experimentieren einige gute Vorhersage-Genauigkeit zu erhalten. Die Qualität des ausgebildeten Modells wird ausgewertet, etwa so:

double trainAcc = lc.Accuracy(trainData, weights);
Console.WriteLine(trainAcc.ToString("F4"));
double testAcc = lc.Accuracy(testData, weights);
Console.WriteLine(testAcc.ToString("F4"));

Die Genauigkeit des Modells auf die Testdaten ist umso relevanter der beiden Genauigkeitswerte. Es bietet Ihnen eine grobe Schätzung, wie genau das Modell sein würde, wenn neue Daten mit unbekannten Ausgabewerten präsentiert.

Implementieren von Gradient Abstammung Training

Die Definition der Methode Zug beginnt mit:

public double[] Train(double[][] trainData, int 
  maxEpochs, double alpha)
{
  int epoch = 0;
  int[] sequence = new int[trainData.Length];
  for (int i = 0; i < sequence.Length; ++i)
    sequence[i] = i;
...

Variable Epoche ist die Zählervariable Training. Das Array mit dem Namen Sequenz wird mit den Indizes in den Trainingsdaten initialisiert. Die Idee dabei ist, dass die Trainingsdaten in einer anderen, zufälligen Reihenfolge bei jeder Iteration verarbeitet werden. Als nächstes beginnt die wichtigsten Gewicht-Update-Schleife:

while (epoch < maxEpochs)
{
  ++epoch;
  if (epoch % 100 == 0 && epoch != maxEpochs)
  {
    double mse = Error(trainData, weights);
    Console.Write("epoch = " + epoch);
    Console.WriteLine(" error = " + mse.ToString("F4"));
  }
  Shuffle(sequence); // Process data in random order
...

Ein gewisses Maß an Fehler berechnet und angezeigt, jede 100 Epochen. Methode Fehler zurückgibt den mittleren quadratischen Fehler, der dem Durchschnitt der Summe der quadrierten Differenzen ist zwischen berechnet und Ziel Werte ausgeben. Beachten Sie, dass dies etwas anders als die Definition der Fehler, der die Grundlage der Regel Farbverlauf Abstieg Gewicht aktualisieren. Bei der Verwendung von gradient Abstieg Ausbildung der Fehler wird implizit verwendet, aber nicht direkt verwendet. Andere Trainingsmethoden verwenden in bestimmten Partikel Schwarm Optimierung, den Fehler explizit. Shuffle-Methode verschlüsselt im Sequenz-Array mit dem Fisher-Yates-Algorithmus enthaltenen Indizes der Ausbildung.

Das Herz der gradient Abstieg Ausbildung ist kurz:

for (int ti = 0; ti < trainData.Length; ++ti)
{
  int i = sequence[ti];
  double computed = ComputeOutput(trainData[i], weights);
  int targetIndex = trainData[i].Length - 1;
  double target = trainData[i][targetIndex];
  weights[0] += alpha * (target - computed) * 1;
  for (int j = 1; j < weights.Length; ++j)
    weights[j] += alpha * (target - computed) * trainData[i][j - 1];
}

Zunächst wird zufälliger Reihenfolge Ausbildung der Tagesordnung identifiziert mit dem verschlüsselte Sequenz-Array. Methode ComputeOutput verwendet die aktuellen Gewichte, um die Ausgabe für den aktuellen Satz von Gewicht Werte, zu berechnen, die einen Wert zwischen 0,0 und 1,0. Der Zielwert 0 oder 1, ist das aktuelle Element der Ausbildung entnommen. Das b0-Gewicht wird zuerst aktualisiert. Daran erinnern Sie, dass die Regel des Gewicht-Update den Eingabewert, verbunden mit dem Gewicht geändert wird verwendet. Das b0-Gewicht ist jedoch keine tatsächliche Eingabe zugeordnet. Um dies zu bewältigen, logistische Regression b0 Gewichte sagt man einen Dummy-Eingabewert immer gleich 1,0. Der Demo-Code multipliziert mit den 1,0 Wert, der hat offensichtlich keine Wirkung, um die Ähnlichkeit zwischen aktualisieren b0 und aktualisieren alle anderen b-Gewicht zu illustrieren. Aktualisieren die reguläre b-Gewichte ist ziemlich einfach und erfordert nur einige Aufmerksamkeit auf die Indizierung Details. Methode Zug endet mit:

...
} // While loop
  return this.weights;
} // Train

Die Methode gibt einen Verweis auf die tatsächlichen Gewichte in der LogisticClassifier-Gewichte-Array. Zur Sicherheit sollten Sie Erstellen eines Ergebnis-Array, dann kopieren Sie die Gewichte in dieses Array und einen Verweis auf das Array.

Wie bereits erwähnt, verwendet die Demo stochastische Farbverlauf Abstieg. Wie jedes Training-Element gefunden wird, ist der Farbverlauf für dieses Element eine Ausbildung berechnet wird und alle Gewichte zu aktualisieren. In Batch-gradient-Abfahrt im Gegensatz dazu in jeder Iteration Farbverläufe werden kumuliert über alle Elemente der Ausbildung zuerst, und dann die Gewichte werden aktualisiert. Um Batch-Training zu verwenden, das Herzstück der Methode Zug würde der Code in Abbildung 4.

Abbildung 4 die Zug-Methode, bei der Verwendung von Batch-Training

double[] accumulatedGradients = new double[weights.Length];
for (int i = 0; i < trainData.Length; ++i)  // Accumulate
{
  double computed = ComputeOutput(trainData[i], weights);
  int targetIndex = trainData[i].Length - 1;
  double target = trainData[i][targetIndex];
  accumulatedGradients[0] += (target - computed) * 1; // For b0
  for (int j = 1; j < weights.Length; ++j)
    accumulatedGradients[j] += (target - computed) * trainData[i][j - 1];
}
for (int j = 0; j < weights.Length; ++j) // Update all wts
  weights[j] += alpha * accumulatedGradients[j];

Mit Batch-Training, da alle Training-Elemente verarbeitet werden, bevor alle Gewichte aktualisiert werden, es gibt keinen Vorteil für die Verarbeitung der Trainingsdaten in zufälliger Reihenfolge.

Als gradient Abstieg Ausbildung zunächst konzipiert wurde, galt der Batch-Ansatz theoretisch vorzuziehen, da diese Technik alle verfügbaren Informationen verwendet, um den Farbverlauf Gewicht zu finden. Jedoch erkannte ML Praktiker schnell, dass Training Geschwindigkeit erhöht werden könnte, mit dem Farbverlauf für nur ein einzelnes Training-Element als Schätzung für den gesamten Verlauf. Mit anderen Worten, stochastische (die Mittel nach dem Zufallsprinzip bestimmt) gradient Abstieg verwendet einen Farbverlauf, um der Gesamthöhenunterschied zu schätzen.

Zusammenfassung

Zwei ähnliche Varianten grundlegende Farbverlauf Abstammung, die oft mit logistische Regression Klassifizierungen verwendet werden werden BFGS und L-BFGS bezeichnet. Diese zwei Algorithmen sind ein Versuch, die grundlegenden Farbverlauf Abstammung, auf Kosten der deutlich gestiegenen Komplexität zu verbessern.

Neben der logistischen Regression Einstufung kann Farbverlauf Abstieg mit mehreren anderen ML-Techniken verwendet werden. Insbesondere kann Farbverlauf Abstieg verwendet werden, um ein neuronales Netz zu trainieren. Wenn Farbverlauf Abstieg mit neuronalen Netzen verwendet wird, wird die Technik zurück-Vermehrung bezeichnet.

Dr. James McCaffrey arbeitet für Microsoft Research in Redmond, Washington  Er arbeitete an verschiedenen Microsoft-Produkten, einschließlich Internet Explorer und Bing. Dr. McCaffrey kann erreicht werden unter jammc@microsoft.com.

Unser Dank gilt dem folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Richard Hughes