Il presente articolo è stato tradotto automaticamente.

Test Run

Multi Klasse logistische Regression-Klassifizierung

James McCaffrey

Laden Sie die Codebeispiele herunter

Ich halte die logistische Regression (LR)-Klassifikation werden die "Hello, World!" des maschinellen Lernens (ML). In Standardklassifikation LR ist das Ziel, den Wert einer Variablen vorherzusagen, die nur einen oder zwei kategorische Werte annehmen kann. Beispielsweise möchten Sie Vorhersagen, eine Person, die Geschlecht (männlich oder weiblich), basierend auf ihrer Höhe und Jahreseinkommen.

Multi Klasse LR Klassifikation erweitert standard LR indem die Variable vorherzusagen, um drei oder mehr Werte aufweisen. Beispielsweise möchten Sie Vorhersagen, eine Person, die politische Neigung (konservative, moderat oder liberale), basierend auf Vorhersagedienst Variablen wie Alter, jährliche Einkommen und so weiter. In diesem Artikel wird erläutert, wie Multi-Klasse LR funktioniert und zeigen Ihnen, wie sie mit c# realisiert.

Der beste Weg zu verstehen, wohin dieses Artikels ist es, einen Blick auf das Demoprogramm in Abbildung 1. Die Demo beginnt durch die Generierung von 1.000 Zeilen mit synthetischen Daten mit vier Vorhersagedienst Variablen (auch aufgerufene Funktionen), wo die Variable vorherzusagen auf einen der drei Werte annehmen kann. Beispielsweise kann eine Zeile generierten Daten aussehen:

5.33  -4.89  0.15  -6.67  0.00  1.00  0.00

Abbildung 1 Multi Klasse logistische Regression in Aktion

Die ersten vier Werte sind Predictor-Werten, die realen Daten darstellen, die damit ein Wert von 0.0 genau durchschnittlich für die Funktion ist normalisiert wurde, größer als 0.0 größer als im Durchschnitt Funktion sind und Werte kleiner als 0.0 sind kleiner als im Durchschnitt Funktion. Die letzten drei Werte sind ein 1-von-N-codierte Version der Variablen vorherzusagen. Beispielsweise, wenn Sie versuchen, politische Neigung, dann zu vorherzusagen (1 0 0) stellt konservativer (0 1 0) stellt Moderate und (0-0-1) liberale darstellt.

Nachdem die synthetischen Daten generiert wurde, wurde es nach dem Zufallsprinzip in eine Trainingsmenge (80 Prozent der Daten oder 800 Zeilen) und eine Test-Reihe (die restlichen 200 Zeilen) aufgeteilt. Die Trainingsdaten werden verwendet, um die Vorhersagemodell zu erstellen, und die Testdaten werden verwendet, um die Vorhersagegenauigkeit des Modells auf neue Daten zu schätzen wo ist nicht der Wert vorhersagen bekannt.

Ein Multi-Klasse-LR-Modell mit f-Features und C Klassen haben (f * c) Gewichte und C Voreingenommenheit. Dies sind die numerische Konstanten, die ermittelt werden muss. Für die Demo gibt es 4 * 3 = 12 Gewichte und 3 Voreingenommenheit. Training ist der Prozess zur Schätzung der Werte der Gewichte und Voreingenommenheit. Ausbildung ist ein iterativer Prozess, und die Demo legt die maximale Anzahl der Ausbildung Iterationen (häufig genannt Epochen in ML Literatur) bis 100. Die Technik verwendet, um die Multi-Klasse-LR-Klassifizierung zu trainieren heißt Batch Farbverlauf Abstieg. Diese Technik erfordert Werte für zwei Parameter der Lern-Kurs und die Gewicht Decay Rate. Diese beiden Werte sind in der Regel durch Versuch und Irrtum gefunden und die Demo weist Werte von 0,01 und 0,10, beziehungsweise.

Während der Ausbildung zeigt die Demo eine Statusnachricht an jeden 10 Epochen. Schaut man sich die Nachrichten in Abbildung 1, kann man das training sehr schnell konvergente und es gab keine Besserung nach den ersten 20 Epochen.

Nach dem Training abgeschlossen angezeigt die Demo die besten Werte für die 12 Gewichte und 3 Vorurteile gefunden. Diese 15 Werte definieren das Multi Klassenmodell LR. Verwenden diese Werte, berechnet die Demo die Vorhersagegenauigkeit des Modells auf den Trainingsdaten (92.63 Prozent korrekt oder 741 von 800) und auf die Testdaten (90.00 % korrekte oder 180 von 200).

Dieser Artikel setzt voraus, Sie haben intermediate oder advanced Programmierkenntnisse, aber nicht annehmen, dass Sie wissen nichts über Multi-Klasse die logistische Regression. Das Demoprogramm ist codiert mit c#, aber sollte man in der Lage, die Demo zu anderen Programmiersprachen ohne allzu viel Mühe umzugestalten.

Verständnis Multi Klasse logistische Regression

Angenommen, Sie möchten die politische Neigung (konservativ, mäßig, liberale) einer Person, die aufgrund des Alters (X 0) vorherzusagen, level Jahreseinkommen (X 1), Höhe (X 3) und Bildung (X 4). Sie codieren politische Neigung mit drei Variablen (y0, y1, y2), wo konservative ist (1, 0, 0), mittelgradig ist (0, 1, 0) und liberal ist (0, 0, 1). Ein Multi-Klasse-LR-Modell für dieses Problem wäre die Form annehmen:

z0 = (w00)(x0) + (w01)(x1) + (w02)(x2) + b0
y0 = 1.0 / (1.0 + e^-z0)
z1 = (w10)(x0) + (w11)(x1) + (w12)(x2) + b1
y1 = 1.0 / (1.0 + e^-z1)
z2 = (w20)(x0) + (w21)(x1) + (w22)(x2) + b2
y2 = 1.0 / (1.0 + e^-z2)

Hier ist Wij der Gewichtung mit dem Wert zugeordnete Funktion Variable ich und Klasse Variable j und Bj ist der Bias-Wert zugeordnete Klasse Variable j.

Ein Beispiel für Multi-Klasse LR sich in zeigt Abbildung 2. Eine Ausbildung-Datenelement hat vier Predictor Werte (5,10,-5.20, 5.30,-5.40), gefolgt von drei Ausgabewerte (1, 0, 0). Die Vorhersagedienst-Werte sind willkürlich, aber Sie können sich vorstellen, sie repräsentieren eine Person, deren Alter größer als der Durchschnitt ist, ist das Einkommen weniger als der Durchschnitt, Höhe ist größer als der Durchschnitt und Bildungsniveau ist weniger als der Durchschnitt, und die Person hat eine politische Tendenz der Konservativen.

Abbildung 2 Multi Klasse logistische Regression Datenstrukturen

Jede der drei Spalten der Matrix Gewichte entspricht einer der drei-Klassen-Werte. Die vier Werte in jeder Spalte entsprechen den vier Tippspiel X-Werten. Das Vorurteile-Array enthält eine zusätzliche, besondere Gewicht — eine für jede Klasse — die ein Indikator für zugeordnet ist.

Beachten Sie, dass das Vorurteile-Array als eine zusätzliche Zeile in der Gewichte-Matrix eingelagert haben konnte. Dies geschieht häufig in Forschungsarbeiten, da dadurch die Mathegleichungen vereinfacht wird. Aber zwecks Umsetzung Demo pflegen, eine separate Gewichte-Matrix und eine Voreingenommenheit ist Array etwas leichter zu verstehen, meiner Meinung nach.

In Multi-Klasse LR werden die Ausgabewerte für jede Klasse berechnet. In Abbildung 2, die berechneten Ausgabewerte sind (0.32, 0,33, 0.35). Die Ausgabewerte sum auf 1.0 und können als Wahrscheinlichkeiten interpretiert werden. Da die letzte Wert ausgegeben wird (gerade noch) der größte der drei, Sie schließen die Ausgaben entsprechen (0, 0, 1). In diesem Beispiel entsprechen die berechneten Ausgaben der drei Eingänge in das Datenelement Training, so dass das Modell eine korrekte Vorhersage gemacht hat.

Die Ausgabewerte werden berechnet, indem zuerst die Produkte der einzelnen Eingabewert mal den entsprechenden Gewichtungswert summieren und dann den entsprechenden Bias-Wert hinzufügen. Diese Beträge Produkte werden oft Z-Werte genannt. Die Z-Werte werden gefüttert, was die logistische sigmoidale-Funktion aufgerufen wird: 1.0 / (1.0 + e ^-Z) wo e ist die mathematische Konstante und ' ^' bedeutet Potenzierung. Es ist zwar nicht aus Abbildung 2, das Ergebnis der logistischen sigmoid-Funktion werden immer zwischen 0,0 und 1,0.

Jeder logistischen sigmoid Wert wird verwendet, um die endgültige Ausgabe-Werte zu berechnen. Die logistische sigmoid Werte werden summiert und als Divisor verwendet. Dabei wird die Softmax-Funktion aufgerufen. Wenn Sie alle diese LR-Konzepte haben, können sie sehr verwirrend sein am Anfang. Aber wenn Sie das Beispiel in durchgehen Abbildung 2 ein paar Mal, schließlich sehen Sie, dass LR nicht so kompliziert ist, wie es zuerst erscheint.

Woher kommen die Gewichte und Voreingenommenheit Werte? Das Verfahren zur Bestimmung dieser Werte nennt man trainieren des Modells. Die Idee ist, eine Reihe von Trainingsdaten, die Eingabe- und Ausgabewerte und dann versuchen unterschiedliche Werte für die Gewichte und Voreingenommenheit gekannt hat, bis Sie eine Reihe von Werten, die den Fehler zwischen berechnete Ausgaben und die korrekte Ausgabewerte finden (oft als die Zielwerte) minimiert in den Trainingsdaten zu verwenden.

Es ist nicht möglich, die genauen Werte für die Gewichte berechnen und Vorurteile, also Gewichte und Voreingenommenheit müssen geschätzt werden. Es gibt mehrere so genannte numerische Optimierungsmethoden, die dazu verwendet werden können. Allgemeine Techniken sind der L-BFGS-Algorithmus, die iterativ reweighted Methode der kleinsten Quadrate-Methode und Particle Swarm Optimization. Das Demoprogramm verwendet eine Technik, die etwas verwirrend beide Farbverlauf Abstieg (minimale Abweichung zwischen den berechneten und bekannte Ausgabewerte) aufgerufen hat und gradient Aufstieg (Maximierung der Wahrscheinlichkeit, dass Gewichte und Voreingenommenheit optimal sind).

Demo-Programm-Struktur

Die Struktur des Programms Demo mit einigen geringfügigen Änderungen platzsparend, präsentiert sich in Abbildung 3. Um das Demoprogramm zu erstellen, ich startete Visual Studio und C#-Konsolenanwendung-Vorlage ausgewählt. Ich nannte das Projekt LogisticMultiClassGradient. 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 LogisticMultiClassGradient
{
  class LogisticMultiProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin classification demo");
      ...
      Console.WriteLine("End demo");
      Console.ReadLine();
    }
    public static void ShowData(double[][] data,
      int numRows, int decimals, bool indices) { . . }
    public static void ShowVector(double[] vector,
      int decimals, bool newLine) { . . }
    static double[][] MakeDummyData(int numFeatures,
      int numClasses, int numRows, int seed) { . . }
    static void SplitTrainTest(double[][] allData,
      double trainPct, int seed, out double[][] trainData,
      out double[][] testData) { . . }
  }
  public class LogisticMulti
  {
    private int numFeatures;
    private int numClasses;
    private double[][] weights; // [feature][class]
    private double[] biases;    // [class]
    public LogisticMulti(int numFeatures,
      int numClasses) { . . }
    private double[][] MakeMatrix(int rows,
      int cols) { . . }
    public void SetWeights(double[][] wts,
      double[] b) { . . }
    public double[][] GetWeights() { . . }
    public double[] GetBiases() { . . }
    private double[] ComputeOutputs(double[] dataItem) { . . }
    public void Train(double[][] trainData, int maxEpochs,
      double learnRate, double decay) { . . }
    public double Error(double[][] trainData) { . . }
    public double Accuracy(double[][] trainData) { . . }
    private static int MaxIndex(double[] vector) { . . }
    private static int MaxIndex(int[] vector) { . . }
    private int[] ComputeDependents(double[] dataItem) { . . }
  }
}

Nachdem der Template-Code geladen, im Fenster Projektmappen-Explorer ich geklickt haben Datei Program.cs und benannte sie in aussagekräftigeren LogisticMultiProgram.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 ein Verweis auf die Top-Level-System-Namespace.

Die LogisticMultiProgram-Klasse enthält Hilfsmethoden, MakeDummyData, SplitTrainTest, ShowData und ShowVector. Diese Methoden erstellen und die synthetischen Daten anzuzeigen. Die Klassifizierung-Logik ist in einem Programm definierten Klasse mit dem Namen LogisticMulti enthalten.

Die Main-Methode erstellt die synthetischen Daten mit folgenden Anweisungen:

int numFeatures = 4;
int numClasses = 3;
int numRows = 1000;
double[][] data = MakeDummyData(numFeatures, 
  numClasses, numRows, 0);

Methode MakeDummyData generiert eine Reihe von zufälligen Gewichte und Voreingenommenheit, dann für jede Datenzeile, generiert zufällige Eingabewerte, kombiniert die Gewichte und die Vorurteile und die Eingabewerte und einige entsprechende 1-von-N-codierten Ausgabewerte berechnet. Die synthetischen Daten gliedert sich in 80 Prozent Training und 20 Prozent-Prüfgeräte, etwa so:

double[][] trainData;
double[][] testData;
SplitTrainTest(data, 0.80, 7, out trainData, out testData);
ShowData(trainData, 3, 2, true);
ShowData(testData, 3, 2, true);

Das Argument mit der Wert 7 ist eine Zufallsverteilung verwendet, nur weil sie eine gut aussehende Demo bereitgestellt. Die LR-Klassifizierung von Multi-Klasse erstellt und trainiert mit folgenden Anweisungen:

LogisticMulti lc = new LogisticMulti(numFeatures, numClasses);
int maxEpochs = 100;
double learnRate = 0.01;
double decay = 0.10;
lc.Train(trainData, maxEpochs, learnRate, decay);

Die Werte für Ausbildung Parameter MaxEpochs (100), der Lern-Kurs (0,01) und die Gewicht Decay Rate (0.10) wurden durch Versuch und Irrtum bestimmt. Tuning die meisten ML-Trainingsmethoden in der Regel muß man experimentieren einige gute Vorhersage-Genauigkeit zu erhalten.

Nach dem Training werden die besten Gewichte und Voreingenommenheit Werte in das LogisticMulti-Objekt gespeichert. Sie sind abgerufen und angezeigt wie folgt:

double[][] bestWts = lc.GetWeights();
double[] bestBiases = lc.GetBiases();
ShowData(bestWts, bestWts.Length, 3, true);
ShowVector(bestBiases, 3, true);

Neuartiger Bauweise mit void Zug-Methode kombiniert mit Get-Methoden ist es, die Methode Zug umgestalten, damit sie die Best-Gewichte-Matrix und Best-Vorurteile-Array als Out-Parameter oder in einem kombinierten Array zurückgibt. 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.

Implementierende Klasse Multi-LR-Training

Der Konstruktor der LogisticMulti-Klasse ist definiert als:

public LogisticMulti(int numFeatures, int numClasses)
{
  this.numFeatures = numFeatures;
  this.numClasses = numClasses;
  this.weights = MakeMatrix(numFeatures, numClasses);
  this.biases = new double[numClasses];
}

MakeMatrix-Methode ist eine Hilfsmethode, die Speicher für ein Array von Arrays Stil-Matrix reserviert. Die Gewichte-Matrix und Vorurteile-Array werden implizit alle 0,0 Werten initialisiert. Eine Alternative, die einige Forscher bevorzugen ist explizit Gewichte und Voreingenommenheit zu klein (in der Regel zwischen 0,001 und 0,01) Zufallswerten initialisieren.

Die Definition der Methode ComputeOutputs wird dargestellt in Abbildung 4. Die Methode gibt einen Array von Werten, eine für jede Klasse, wobei jeder Wert zwischen 0.0 und 1.0 und die Summe der Werte 1.0 ist.

Abbildung 4-Methode ComputeOutputs

private double[] ComputeOutputs(double[] dataItem)
{
  double[] result = new double[numClasses];
  for (int j = 0; j < numClasses; ++j) // compute z
  {
    for (int i = 0; i < numFeatures; ++i)
      result[j] += dataItem[i] * weights[i][j];
    result[j] += biases[j];
  }
  for (int j = 0; j < numClasses; ++j) // 1 / 1 + e^-z
    result[j] = 1.0 / (1.0 + Math.Exp(-result[j]));
  double sum = 0.0; // softmax scaling
  for (int j = 0; j < numClasses; ++j)
    sum += result[j];
  for (int j = 0; j < numClasses; ++j)
    result[j] = result[j] / sum;
  return result;
}

Die Klassendefinition enthält eine ähnliche Methode, ComputeDependents:

private int[] ComputeDependents(double[] dataItem)
{
  double[] outputs = ComputeOutputs(dataItem); // 0.0 to 1.0
  int maxIndex = MaxIndex(outputs);
  int[] result = new int[numClasses];
  result[maxIndex] = 1;
  return result;
}

ComputeDependents-Methode gibt ein Integer-Array, wobei ein Wert 1 und die anderen Werte sind 0, zurück. Diese berechneten Ausgabewerte können verglichen werden, um die bekannte Ausgabe Zielwerte in den Trainingsdaten zu bestimmen, ob das Modell eine korrekte Vorhersage gemacht hat, die wiederum zur Berechnung der Vorhersagegenauigkeit.

Ausgedrückt in sehr hochrangigen Pseudocode, Methode, die Bahn ist:

loop maxEpochs times
  compute all weight gradients
  compute all bias gradients
  use weight gradients to update all weights
  use bias gradients to update all biases
end-loop

Einzelwerte Gewicht und Voreingenommenheit ist ein Farbverlauf Wert zugeordnet. Lose sprechend, ist ein Farbverlauf einen Wert, der angibt, wie weit und in welche Richtung (positiv oder negativ) eine berechnete Ausgabewert mit der Ziel-Ausgabe-Wert verglichen wird. Genommen Sie ein Gewicht an, wenn die Werte der anderen alle Gewichte und Voreingenommenheit werden konstant gehalten, eine berechnete Ausgabewert 0.7 ist und der Ausgabe-Zielwert 1.0 ist. Der berechnete Wert ist zu klein, damit der Farbverlauf wird ein Wert von etwa 0.3, die auf das Gewicht hinzugefügt werden. Wenn der Wert des Gewichts erhöht, erhöht der berechnete Ausgabewert. Einige Details weggelassen, aber die Grundidee ist relativ einfach.

Die Mathematik hinter Farbverlauf Training Infinitesimalrechnung verwendet und ist sehr komplex, aber zum Glück, du musst nicht die Mathematik zum Implementieren des Codes vollständig zu verstehen. Die Definition der Methode Zug beginnt mit:

public void Train(double[][] trainData, int maxEpochs,
  double learnRate, double decay)
{
  double[] targets = new double[numClasses];
  int msgInterval = maxEpochs / 10;
  int epoch = 0;
  while (epoch < maxEpochs)
  {
    ++epoch;
...

Das Ziele-Array wird die korrekte Ausgabewerte in einem Datenelement Training gespeichert halten. Variable MsgInterval steuert die Häufigkeit Statusmeldungen angezeigt. Dann werden Statusmeldungen angezeigt:

if (epoch % msgInterval == 0 && epoch != maxEpochs)
{
  double mse = Error(trainData);
  Console.Write("epoch = " + epoch);
  Console.Write(" error = " + mse.ToString("F4"));
  double acc = Accuracy(trainData);
  Console.WriteLine(" accuracy = " + acc.ToString("F4"));
}

Da ML Dressur in der Regel sollen einige Testversion und Fehler anzeigen von Statusmeldungen ist sehr nützlich. Als nächstes wird Speicher für die Gewichte und Voreingenommenheit Farbverläufe zugeordnet:

double[][] weightGrads = MakeMatrix(numFeatures, numClasses);
double[] biasGrads = new double[numClasses];

Beachten Sie diese Zuordnungen innerhalb der wichtigsten While-Schleife auftreten. Da c# Arrays auf 0,0 initialisiert wird, werden alle Verläufe initialisiert. Eine Alternative ist Speicherplatz außerhalb der While-Schleife und rufen anschließend Hilfsmethoden mit Namen wie ZeroMatrix und ZeroArray. Weiter, alle Gewichte, die Farbverläufe berechnet werden:

for (int j = 0; j < numClasses; ++j) {
  for (int i = 0; i < numFeatures; ++i) {
    for (int r = 0; r < trainData.Length; ++r) {
      double[] outputs = ComputeOutputs(trainData[r]);
        for (int k = 0; k < numClasses; ++k)
          targets[k] = trainData[r][numFeatures + k];
        double input = trainData[r][i];
        weightGrads[i][j] += (targets[j] - outputs[j]) * input;
    }
  }
}

Dieser Code ist das Herz des Multi-Klasse LR. Jedes Gewicht-Verlauf ist im Wesentlichen der Unterschied zwischen einen Zielwert für die Ausgabe und einem berechneten Ausgabewert. Die Differenz, von den zugehörigen Eingabewert multipliziert wird um der Tatsache Rechnung tragen, dass die Eingabe ein negativer Wert sein kann, wodurch das Gewicht sollte in die entgegengesetzte Richtung angepasst werden.

Eine interessante Alternative, die ich häufig benutze ist das Ausmaß des Eingabewertes ignorieren und nur die Zeichen zu verwenden:

double input = trainData[r][i];
int sign = (input > 0.0) ? 1 : -1;
weightGrads[i][j] += (targets[j] - outputs[j]) * sign;

Nach meiner Erfahrung führt diese Technik häufig zu ein besseres Modell. Weiter, alle Vorurteile, die Farbverläufe berechnet werden:

for (int j = 0; j < numClasses; ++j) {
  for (int i = 0; i < numFeatures; ++i) {
    for (int r = 0; r < trainData.Length; ++r) {
      double[] outputs = ComputeOutputs(trainData[r]);
      for (int k = 0; k < numClasses; ++k)
        targets[k] = trainData[r][numFeatures + k];
      double input = 1; // 1 is a dummy input
      biasGrads[j] += (targets[j] - outputs[j]) * input;
    }
  }
}

Wenn Sie den Code untersuchen, sehen Sie, dass computing die Vorurteile-Farbverläufe innerhalb der for-Schleifen ausgeführt werden konnte, die die Gewichte Farbverläufe zu berechnen. Ich getrennt die zwei Farbverlauf Berechnungen aus Gründen der Übersichtlichkeit auf Kosten der Leistung. Darüber hinaus kann die Multiplikation mit der stillschweigenden Eingabewert 1 gelöscht werden. Es wurde auch zur Verdeutlichung hinzugefügt. Als nächstes werden die Gewichte aktualisiert:

for (int i = 0; i < numFeatures; ++i) {
  for (int j = 0; j < numClasses; ++j) {
    weights[i][j] += learnRate * weightGrads[i][j];
    weights[i][j] *= (1 - decay);  // wt decay
  }
}

Nach erhöhen oder eine Gewicht auf der Grundlage einer Bewertung Bruchteil Farbverlauf, der Gewichtungswert des wird verringert, mit dem Gewicht-Verfall-Kurs. Beispielsweise verwendet die Demo Gewicht Zerfall der Wert 0,10, also Multiplikation mit (1 - 0.10) ist, das ist ein Rückgang von 10 Prozent, mit 0,90, multipliziert. Gewicht Verfall wird auch Regularisierung genannt. Die Technik verhindert Spinnen außer Kontrolle Gewicht Werte. Methode Zug schließt mit der Aktualisierung der Vorurteile-Werte:

...
    for (int j = 0; j < numClasses; ++j) {
      biases[j] += learnRate * biasGrads[j];
      biases[j] *= (1 - decay);
    }
  } // While
} // Train

Die Ausbildung-Technik aktualisiert die Klasse Mitglied Gewichte Matrix und Vorurteile-Array vorhanden. Diese Werte definieren das Multi Klassenmodell LR und mit Get-Methoden abgerufen werden können.

Zusammenfassung

Es gibt zwei Varianten der gradient aus-und aufgerufenen Batch und Stochastik. In diesem Artikel dargestellt die Batch-Version, wo sind die Farbverläufe durch Aufsummieren berechnet, die Unterschiede zwischen berechnet und Ausgänge über alle Elemente der Ausbildung als Ziel. Stochastische Verlauf Ausbildung sind Verläufe mit nur Einzelschulungen Datenelemente geschätzt. Basierend auf einige Experimente, bei Anwendung auf Multi-Klasse LR, Batch-Training, ein genaueres Modell zu geben scheint, aber dauert länger als stochastische Training. Das ist ziemlich überraschend, weil stochastische Training Batch-Training für neuronale Netze in der Regel vorzuziehen.

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

Unser Dank gilt den folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Todd Bello und Alisson Sol