• Artikel

Dieser Artikel wurde maschinell übersetzt.

Testlauf

L1- und L2-Regularisierung für Machine Learning

James McCaffrey

Laden Sie die Codebeispiele herunter

James McCaffreyRegularisierung von L1 und L2 Regularisierung sind zwei eng verwandte Techniken, die durch Maschinelles Lernen (ML)-Ausbildung-Algorithmen verwendet werden können, Modell Überanpassung zu reduzieren. Die Beseitigung von Überanpassung führt zu einem Modell, das macht bessere Vorhersagen. In diesem Artikel werde ich erläutern, welche Regularisierung aus Sicht eines Softwareentwicklers ist. Die Ideen hinter Regularisierung sind ein bisschen schwierig zu erklären, nicht weil sie schwierig sind, sondern weil es gibt mehrere zusammenhängende Ideen,

In diesem Artikel veranschaulichen ich Regularisierung mit logistische Regression (LR)-Klassifikation, aber Regularisierung kann mit vielen Arten von maschinellen Lernens, insbesondere neuronales Netz Klassifikation verwendet werden. Das Ziel der LR-Klassifikation ist ein Modell zu erstellen, die eine Variable vorhersagt, die einen von zwei möglichen Werten annehmen können. Beispielsweise möchten Sie Vorhersagen, das Ergebnis für ein Fußball-Team (verlieren = 0, gewinnen = 1) in einem kommenden Spiel basierend auf des Teams aktuellen gewinnenden Prozentsatz (X 1), Feld Speicherort (X 2) und Anzahl der Spieler abwesend wegen Verletzung (X 3).

Wenn Y der vorhergesagte Wert ist, würde eine LR-Modell für dieses Problem Form erfolgen:

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

Hier sind b0, b1, b2 und b3 Gewichte, die nur numerische Werte sind, die bestimmt werden muss. In Worten Sie berechnen einen Wert Z, der 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. Es stellt sich heraus, dass Y immer zwischen 0 und 1. Wenn Y kleiner als 0,5 ist, schließen Sie die vorhergesagte Ausgabe 0 ist und wenn Y größer als 0,5 ist man schließen, dass der Ausgang 1 ist. Beachten Sie, dass wenn n Features vorhanden sind, gibt es n + 1 b-Gewichte.

Genommen Sie ein Team derzeit hat einen gewinnenden Prozentsatz von 0,75, spielen ihre Gegner Field (-1) und besteht aus 3 Spielern, aufgrund einer Verletzung an. Und nehme an b0 = 5.0, b1 = 8.0, b2 = 3.0 und b3 =-2.0. Dann Z = 5.0 + (8.0)(0.75) + (3.0)(-1) + (-2.0)(3) = 2,0 und damit Y = 1.0 / (1.0 + e ^-2.0) = 0.88. Da Y größer als 0,5 ist, würde Sie Vorhersagen, dass die Mannschaft ihre bevorstehende Spiel gewinnen werden.

Ich denke der beste Weg, Regularisierung wird anhand eines konkreten Beispiels zu erklären. Werfen Sie einen Blick auf den Screenshot von einem Demoprogramm in Abbildung 1. Anstatt reale Daten zu verwenden, beginnt das Demoprogramm durch die Generierung von 1.000 synthetische Datenelemente. Jedes Element verfügt über 12 Vorhersagedienst Variablen (häufig genannt "Funktionen" in der ML-Terminologie). Der abhängige Variable-Wert ist in der letzten Spalte. Nach dem Erstellen der 1.000 Datenelemente, wurde der Datensatz zufällig in eine 800-Element Trainingssatz verwendet werden, um feststellen, dass das Modell b-Gewichte und ein 200-Produkt-test-Set verwendet werden, um die Qualität des resultierenden Modells bewerten aufgeteilt.

Regularisierung logistische Regression-Klassifizierung
Abbildung 1-Regularisierung logistische Regression-Klassifizierung

Das Demoprogramm ausgebildet als nächstes die LR-Klassifizierung, ohne Verwendung von Regularisierung. Das resultierende Modell hatte 85.00 % Genauigkeit auf den Trainingsdaten und 80,50 % Genauigkeit auf den Testdaten. Die 80,50 % Genauigkeit ist umso relevanter der beiden Werte, und eine grobe Schätzung, wie genau man das Modell erwarten würde zu sein, wenn mit neuen Daten dargestellt. Wie ich kurz erläutern werde, war das Modell über ausgestattet, was zu mittelmäßig Vorhersagegenauigkeit.

Als nächstes hat die Demo Verarbeitungsaufgaben um eine gute L1 Regularisierung und eine gute L2 Regularisierung Gewicht zu finden. Regularisierung Gewichte sind einzelne numerische Werte, die durch die Regularisierung-Prozess verwendet werden. In der Demo eine gute L1-Gewicht war entschlossen, 0,005 und eine gute L2-Gewicht war 0,001.

Die Demo uraufgeführt training mit L1 Regularisierung und dann wieder mit L2 Regularisierung. Mit L1 Regularisierung das resultierende LR-Modell hatte 95.00 % Genauigkeit auf die Testdaten und mit L2 Regularisierung, das LR-Modell hatte 94.50 % Genauigkeit auf den Testdaten. Beide Formen der Regularisierung deutlich verbessert Vorhersagegenauigkeit.

Dieser Artikel setzt voraus, Sie haben zumindest fortgeschrittene Programmierkenntnisse, aber nicht annehmen, dass Sie wissen nichts über L1 oder L2 Regularisierung. Das Demoprogramm ist codiert mit c# sollte nicht, aber Sie allzu große Schwierigkeiten, die Umgestaltung des Codes in eine andere Sprache wie JavaScript oder Python.

Der Demo-Code ist zu lang hier vorstellen, aber vollständigen Quellcode ist verfügbar in den Codedownload zu diesem Artikel. Der Demo-Code enthält alle normalen Fehlerüberprüfung entfernt, die wichtigsten Ideen, die so klar wie möglich und die Größe des Codes klein zu halten.

Allgemeine Programmstruktur

Die gesamte Programmstruktur mit einigen geringfügigen Änderungen platzsparend, präsentiert sich in Abbildung 2. Um die Demo zu erstellen, ich Visual Studio gestartet und erstellt eine neue C#-Konsolenanwendung mit dem Namen Regularisierung. Die Demo hat keine signifikante Microsoft .NET Framework Abhängigkeiten, damit aktuelle Version des Visual Studio funktioniert.

Abbildung 2 Allgemeine Programmstruktur

using System;
namespace Regularization
{
  class RegularizationProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin L1 and L2 Regularization demo");
      int numFeatures = 12;
      int numRows = 1000;
      int seed = 42;
      Console.WriteLine("Generating " + numRows +
        " artificial data items with " + numFeatures + " features");
      double[][] allData = MakeAllData(numFeatures, numRows, seed);
      Console.WriteLine("Creating train and test matrices");
      double[][] trainData;
      double[][] testData;
      MakeTrainTest(allData, 0, out trainData, out testData);
      Console.WriteLine("Training data: ");
      ShowData(trainData, 4, 2, true);
      Console.WriteLine("Test data: ");
      ShowData(testData, 3, 2, true);
      Console.WriteLine("Creating LR binary classifier");
      LogisticClassifier lc = new LogisticClassifier(numFeatures);
      int maxEpochs = 1000;
      Console.WriteLine("Starting training using no regularization");
      double[] weights = lc.Train(trainData, maxEpochs,
        seed, 0.0, 0.0);
      Console.WriteLine("Best weights found:");
      ShowVector(weights, 3, weights.Length, true);
      double trainAccuracy = lc.Accuracy(trainData, weights);
      Console.WriteLine("Prediction accuracy on training data = " +
        trainAccuracy.ToString("F4"));
      double testAccuracy = lc.Accuracy(testData, weights);
      Console.WriteLine("Prediction accuracy on test data = " +
        testAccuracy.ToString("F4"));
      Console.WriteLine("Seeking good L1 weight");
      double alpha1 = lc.FindGoodL1Weight(trainData, seed);
      Console.WriteLine("L1 weight = " + alpha1.ToString("F3"));
      Console.WriteLine("Seeking good L2 weight");
      double alpha2 = lc.FindGoodL2Weight(trainData, seed);
      Console.WriteLine("L2 weight = " + alpha2.ToString("F3"));
      Console.WriteLine("Training with L1 regularization, " +
        "alpha1 = " + alpha1.ToString("F3"));
      weights = lc.Train(trainData, maxEpochs, seed, alpha1, 0.0);
      Console.WriteLine("Best weights found:");
      ShowVector(weights, 3, weights.Length, true);
      trainAccuracy = lc.Accuracy(trainData, weights);
      Console.WriteLine("Prediction accuracy on training data = " +
        trainAccuracy.ToString("F4"));
      testAccuracy = lc.Accuracy(testData, weights);
      Console.WriteLine("Prediction accuracy on test data = " +
        testAccuracy.ToString("F4"));
      Console.WriteLine("Training with L2 regularization, " +
        "alpha2 = " + alpha2.ToString("F3"));
      weights = lc.Train(trainData, maxEpochs, seed, 0.0, alpha2);
      Console.WriteLine("Best weights found:");
      ShowVector(weights, 3, weights.Length, true);
      trainAccuracy = lc.Accuracy(trainData, weights);
      Console.WriteLine("Prediction accuracy on training data = " +
        trainAccuracy.ToString("F4"));
      testAccuracy = lc.Accuracy(testData, weights);
      Console.WriteLine("Prediction accuracy on test data = " +
        testAccuracy.ToString("F4"));
      Console.WriteLine("End Regularization 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) { . . }
    public static void ShowData(double[][] data, int numRows,
      int decimals, bool indices) { . . }
    public static void ShowVector(double[] vector, int decimals,
      int lineLen, bool newLine) { . . }
  }
  public class LogisticClassifier
  {
    private int numFeatures;
    private double[] weights;
    private Random rnd;
    public LogisticClassifier(int numFeatures) { . . }
    public double FindGoodL1Weight(double[][] trainData,
      int seed) { . . }
    public double FindGoodL2Weight(double[][] trainData,
      int seed) { . . }
    public double[] Train(double[][] trainData, int maxEpochs,
      int seed, double alpha1, double alpha2) { . . }
    private void Shuffle(int[] sequence) { . . }
    public double Error(double[][] trainData, double[] weights,
      double alpha1, double alpha2) { . . }
    public double ComputeOutput(double[] dataItem,
      double[] weights) { . . }
    public int ComputeDependent(double[] dataItem,
      double[] weights) { . . }
    public double Accuracy(double[][] trainData,
      double[] weights) { . . }
    public class Particle { . . }
  }
} // ns

Nachdem der Template-Code in den Visual Studio -Editor geladen, im Fenster Projektmappen-Explorer ich benannte Datei Program.cs, die aussagekräftigeren RegularizationProgram.cs und Visual Studio -Auto­matisch umbenannt Klasse Programm für mich. An der Spitze des Quellcodes löschte ich alle using-Anweisungen, die auf nicht benötigte Namespaces verwiesen, so dass nur den Verweis auf die Top-Level-System-Namespace.

Die gesamte logistische Regression Logik ist in einer einzigen LogisticClassifier-Klasse enthalten. Die Logistik­Classifier-Klasse enthält einen geschachtelten Helfer Partikel-Klasse um Partikel Schwarm Optimierung (PSO), der Optimierungsalgorithmus für das Training zu kapseln. Beachten Sie, dass die LogisticClassifier-Klasse eine Methode Fehler enthält die Parameter, die mit dem Namen alpha1 und alpha2 akzeptiert. Diese Parameter sind die Regularisierung Gewichte für L1 und L2 Regularisierung.

In der Main-Methode werden die synthetischen Daten mit diesen Anweisungen erstellt:

int numFeatures = 12;
int numRows = 1000;
int seed = 42;
double[][] allData = MakeAllData(numFeatures, numRows, seed);

Der Startwert von 42 wurde verwendet, nur, weil dieser Wert schöne, repräsentative Demo-Ausgabe gab. Methode MakeAllData erzeugt 13 zufällige Gewichte zwischen-10.0 und + 10,0 (ein Gewicht für jedes Feature, plus das b0-Gewicht). Die Methode durchläuft dann tausendmal. Bei jeder Iteration wird eine zufällige Gruppe von 12 input-Werte generiert, dann ein intermediate logistische Regression-Ausgabewert wird berechnet mit der zufälligen Gewichten. Eine zusätzliche Zufallswert wird die Ausgabe der Daten laut und anfälliger für Überanpassung zu hinzugefügt.

Die Daten ist aufgeteilt in ein 800-Item-Set für Training und ein 200-Item-Set für Modell Bewertung mit folgenden Anweisungen:

double[][] trainData;
double[][] testData;
MakeTrainTest(allData, 0, out trainData, out testData);

Ein logistisches Regressionsmodell Vorhersage wird mit folgenden Anweisungen erstellt:

LogisticClassifier lc = new LogisticClassifier(numFeatures);
int maxEpochs = 1000;
double[] weights = lc.Train(trainData, maxEpochs, seed, 0.0, 0.0);
ShowVector(weights, 4, weights.Length, true);

Variable MaxEpochs ist ein Grenzwert für den PSO-Training-Algorithmus Schleifenzähler. Die beiden 0,0-Zug Methode übergebenen Argumente sind die L1 und L2 Regularisierung Gewichte. Diese Gewichte auf 0,0 festlegen, wird keine Regularisierung verwendet. Die Modellqualität wird mit diesen beiden Anweisungen ausgewertet:

double trainAccuracy = lc.Accuracy(trainData, weights);
double testAccuracy = lc.Accuracy(testData, weights);

Einer der Nachteile mit Regularisierung ist, dass die Regularisierung Gewichte ermittelt werden müssen. Ein Ansatz für die Suche nach guten Regularisierung Gewichte ist die Verwendung der manuellen Versuch und Irrtum, sondern eine programmgesteuerte Technik ist in der Regel besser. Eine gute L1 Regularisierung Gewicht ist gefunden und dann mit diesen Anweisungen verwendet werden:

double alpha1 = lc.FindGoodL1Weight(trainData, seed);
weights = lc.Train(trainData, maxEpochs, seed, alpha1, 0.0);
trainAccuracy = lc.Accuracy(trainData, weights);
testAccuracy = lc.Accuracy(testData, weights);

Die Anweisungen für das training mit L2 Regularisierung LR-Klassifizierung sind ebenso wie die für die Verwendung von L1 Regularisierung:

double alpha2 = lc.FindGoodL2Weight(trainData, seed);
weights = lc.Train(trainData, maxEpochs, seed, 0.0, alpha2);
trainAccuracy = lc.Accuracy(trainData, weights);
testAccuracy = lc.Accuracy(testData, weights);

In der Demo die alpha1 und alpha2-Werte waren entschlossen, mit den LR-Objekt Public-Bereich Methoden FindGoodL1Weight und FindGoodL2Weight und dann an Methode Zug übergeben. Neuartiger Bauweise wird vorgeschlagen, durch den Aufruf dieser Code:

bool useL1 = true;
bool useL2 = false:
lc.Train(traiData, maxEpochs, useL1, useL2);

Diese Design-Ansatz ermöglicht die Trainingsmethode, um zu bestimmen, die Regularisierung Gewichte und führt zu ein wenig saubere Oberfläche.

Verständnis Regularisierung

Da L1 und L2 Regularisierung sind Techniken zur Verringerung Modell Überanpassung, um zu verstehen, Regularisierung, müssen Sie verstehen, Überanpassung. Lose gesprochen, wenn Sie ein Modell zu viel trainieren, schließlich erhalten Sie Gewichte, die die Trainingsdaten sehr gut passen, aber wenn Sie das resultierende Modell auf neue Daten anwenden, die Vorhersagegenauigkeit sehr schlecht ist.

Überanpassung zeigt sich durch die zwei Grafiken in Abbildung 3. Das erste Diagramm zeigt einer hypothetischen Situation, wo das Ziel ist es, zwei Arten von Elementen, gekennzeichnet durch rote und grüne Punkte zu klassifizieren. Die glatte blaue Kurve repräsentiert die wahre Trennung der beiden Klassen, mit roten Punkten gehören oberhalb der Kurve und grüne Punkte unterhalb der Kurve gehören. Beachten Sie, dass aufgrund von zufälligen Fehlern in den Daten, die roten Punkte sind unterhalb der Kurve und zwei grüne Punkte sind oberhalb der Kurve. Gute Ausbildung, wo Überanpassung nicht auftritt, führt zu gewichten, die die reibungslose blaue Kurve entsprechen. Angenommen, ein neuer Datenpunkt kam (3, 7). Das Datenelement wäre oberhalb der Kurve und Klasse rot korrekt vorhergesagt werden.

Modell Überanpassung
Abbildung 3 Modell Überanpassung

Das zweite Diagramm in Abbildung 3 hat die gleichen Punkte, aber eine andere blaue Kurve, die ein Resultat von Überanpassung. Dieses Mal sind die roten Punkte oberhalb der Kurve und alles, was die grünen Punkte unterhalb der Kurve zu stellen. Aber die Kurve ist zu komplex. Ein neues Datenelement an (3, 7) unterhalb der Kurve wäre und als Klasse grün falsch vorhergesagt werden.

Überanpassung generiert Vorhersage nicht-glatte Kurven, mit anderen Worten, diejenigen, die nicht "normal." Solche Armen, komplexe Vorhersage-Kurven zeichnen sich meist durch Gewichte, die sehr große oder sehr kleine Werte aufweisen. Daher ist eine Möglichkeit, Überanpassung reduzieren zu verhindern, dass Modell Gewichte zu sehr klein oder groß. Dies ist die Motivation für die Regularisierung.

Wenn eine ML-Modell ausgebildet ist, müssen Sie eine gewisse Fehler verwenden, um gute Gewichte zu bestimmen. Es gibt verschiedene Möglichkeiten, Fehler zu messen. Eines der gängigsten Verfahren ist der mittlere quadratische Fehler, wo Sie die Summe der quadrierten Differenzen zwischen den berechneten Ausgabewerte für einen Satz von Werten für Gewicht und die bekannten, korrekte Ausgabewerte in den Trainingsdaten zu finden, und dann teilen Sie diese Summe durch die Anzahl der Ausbildung Gegenstände. Nehmen wir beispielsweise an, für einen Kandidaten-Satz der logistischen Regression Gewichte, mit nur drei Ausbildung Gegenstände, die berechnete Ausgaben und korrekte Ausgabe (manchmal genannt die gewünschte oder Zielwerte) sind:

computed  desired
  0.60      1.0
  0.30      0.0
  0.80      1.0

Hier wäre der mittlere quadratische Fehler:

((0.6 - 1.0)^2 + (0.3 - 0.0)^2 + (0.8 - 1.0)^2) / 3 =
(0.16 + 0.09 + 0.04) / 3 =
0.097

Symbolisch ausgedrückt, bedeutet, dass die quadrierten Fehler geschrieben werden kann:

E = Sum(o - t)^2 / n

wobei Summe ist die kumulierte Summe über alle Elemente der Ausbildung, o stellt berechnete Ausgabe dar, t Zielausgabe und n ist die Anzahl der Datenelemente Training. Der Fehler ist, welche Ausbildung minimiert die Verwendung eines etwa ein Dutzend numerischen Methoden mit Namen wie Farbverlauf Abstammung, iterative Newton-Raphson, L-BFGS, Back-Propagation und Schwarm Optimierung.

Um zu verhindern, dass das Ausmaß der Modellwerte Gewicht groß, ist die Idee der Regularisierung Gewicht Werte zu ahnden, indem diese Gewicht-Werte für die Berechnung des Begriffs Fehler. Wenn Gewicht Werte langfristig Gesamt Fehler enthalten sind, die minimiert werden wird, dann kleinere Gewicht Werte kleiner Fehlerwerte generiert. L1 Gewicht Regularisierung bestraft Gewicht Werte, indem Sie die Summe der absoluten Werte der Fehler-Begriff hinzufügen. Symbolisch:

E = Sum(o - t)^2 / n + Sum(Abs(w))

L2 Gewicht Regularisierung bestraft Gewicht Werte, indem Sie den Begriff Fehler die Summe der quadrierten Werte hinzufügen. Symbolisch:

E = Sum(o - t)^2 / n + Sum(w^2)

Angenommen, gibt es für dieses Beispiel sind vier Schnitte bestimmt werden und ihre aktuellen Werte (2.0,-3.0, 1.0,-4.0). Die L1 Gewicht Strafe hinzugefügt, um den 0,097 mittleren quadratischen Fehler wäre (2.0 + 3.0 + 1.0 + 4.0) = 10.0. Die L2 Gewicht Strafe wäre 2.0 ^ 2 + -3.0 ^ 2 + 1.0 ^ 2 + -4.0 ^ 2 = 4.0 + 9.0 + 1.0 + 16,0 = 30,0.

Zusammenfassend können großes Modell Gewichte zu Überanpassung, führen, führt zu schlechten Vorhersagegenauigkeit. Regularisierung begrenzt die Größe des Modells Gewichte indem eine Strafe für Gewichte zu den Modell-Error-Funktion. L1-Regularisierung wird die Summe der absoluten Werte der Gewichte verwendet. L2 Regularisierung wird die Summe der quadrierten Werte der Gewichte verwendet.

Warum zwei verschiedene Arten von Regularisierung?

L1 und L2 Regularisierung ähneln. Welche ist besser? Die Quintessenz ist, dass obwohl es einige Theorie-Richtlinien gibt über die Form der Regularisierung besser in bestimmten Problemszenarien meiner Meinung nach in der Praxis, die Sie experimentieren müssen, um welche Art von Regularisierung finden besser ist, oder ob mit Regularisierung überhaupt besser ist.

Wie sich herausstellt, kann mit L1 Regularisierung manchmal haben eine positive Seite Wirkung der Fahrt mindestens Gewicht Wert auf 0.0, was effektiv bedeutet, dass das zugeordnete Feature benötigt ist nicht. Dies ist eine Form der sogenannten Featureauswahl hat. Zum Beispiel in der Demo führen in Abbildung 1, mit L1 Regularisierung ist das letzte Modell Gewicht 0,0. Dies bedeutet, dass der letzte Predictor-Wert mit dem LR-Modell tragen nicht. L2 Regularisierung Modellwerte Gewicht beschränkt, aber in der Regel nicht beschneiden, Gewichte vollständig, indem sie auf 0,0.

Also, scheint es, dass die Regularisierung L1 L2 Regularisierung besser ist. Ein Nachteil der Verwendung von L1 Regularisierung ist jedoch, dass die Technik leicht verwendet werden kann, mit einigen ML Ausbildung Algorithmen, vor allem diese Algorithmen, mit denen Kalkül berechnen, was einen Farbverlauf genannt hat. L2 Regularisierung kann mit jeder Art von Trainingsalgorithmus verwendet werden.

Zusammenfassend hat L1 Regularisierung manchmal angenehmer Nebeneffekt der Beschneidung nicht benötigte Funktionen indem ihre zugehörigen Gewichte auf 0,0 aber L1 Regularisierung funktioniert nicht leicht mit allen Formen des Trainings. L2 Regularisierung arbeitet mit allen Formen der Ausbildung, aber nicht Ihnen implizite Featureauswahl. In der Praxis verwenden Sie ausprobieren, um zu bestimmen, welche Form der Regularisierung (oder auch nicht) für ein bestimmtes Problem besser ist.

Umsetzung Regularisierung

Implementieren von L1 und L2 Regularisierung ist relativ einfach. Das Demoprogramm verwendet PSO-Training mit eine explizite Fehler-Funktion, so dass alles, was notwendig ist das Hinzufügen die L1 und L2 Gewicht Strafen. Die Definition der Methode Fehler beginnt mit:

public double Error(double[][] trainData, double[] weights,
  double alpha1, double alpha2)
{
  int yIndex = trainData[0].Length - 1;
  double sumSquaredError = 0.0;
  for (int i = 0; i < trainData.Length; ++i)
  {
    double computed = ComputeOutput(trainData[i], weights);
    double desired = trainData[i][yIndex];
    sumSquaredError += (computed - desired) * (computed - desired);
  }
...

Der erste Schritt ist den mittleren quadratischen Fehler berechnen durch Aufsummieren der quadrierten Differenzen zwischen berechnete Ausgaben und Zielausgaben. (Eine andere übliche Form des Fehlers ist Kreuz-Entropie Fehler genannt.) Als nächstes wird die L1-Strafe berechnet:

double sumAbsVals = 0.0; // L1 penalty
for (int i = 0; i < weights.Length; ++i)
  sumAbsVals += Math.Abs(weights[i]);

Dann wird die L2 Strafe berechnet:

double sumSquaredVals = 0.0; // L2 penalty
for (int i = 0; i < weights.Length; ++i)
  sumSquaredVals += (weights[i] * weights[i]);

Fehler-Methode gibt den MSE plus Sanktionen:

...
  return (sumSquaredError / trainData.Length) +
    (alpha1 * sumAbsVals) +
    (alpha2 * sumSquaredVals);
}

Die Demo benutzt eine explizite Fehler-Funktion. Einige Training-Algorithmen, z. B. Farbverlauf Abstammung und Back-Propagation, verwenden die Fehlerfunktion implizit durch die Berechnung der Infinitesimalrechnung partielle Ableitung (die Steigung genannt) der Error-Funktion. Für diese Ausbildung-Algorithmen, L2 Regularisierung verwenden (da die Ableitung von w ^ 2 ist 2w), Sie fügen Sie einfach ein Ausdruck 2w auf den Farbverlauf (obwohl die Details ein bisschen schwierig sein können).

Suche nach guten Regularisierung Gewichte

Es gibt mehrere Möglichkeiten, eine gute (aber nicht unbedingt optimal) Regularisierung Gewicht zu finden. Das Demoprogramm richtet eine Reihe von Kandidaten Werte, berechnet den Fehler, die jeder Kandidat zugeordnet und gibt der beste Kandidat gefunden. Die Methode, um eine gute L1 Gewicht finden beginnt:

public double FindGoodL1Weight(double[][] trainData, int seed)
{
  double result = 0.0;
  double bestErr = double.MaxValue;
  double currErr = double.MaxValue;
  double[] candidates = new double[] { 0.000, 0.001, 0.005,
    0.010, 0.020, 0.050, 0.100, 0.150 };
  int maxEpochs = 1000;
  LogisticClassifier c =
    new LogisticClassifier(this.numFeatures);

Hinzufügen von zusätzlichen Kandidaten würden Ihnen eine bessere Chance auf eine optimale Regularisierung Gewicht auf Kosten der Zeit zu finden. Als nächstes jeder Kandidat wird ausgewertet, und der beste Kandidat gefunden wird zurückgegeben:

for (int trial = 0; trial < candidates.Length; ++trial) {
    double alpha1 = candidates[trial];
    double[] wts = c.Train(trainData, maxEpochs, seed, alpha1, 0.0);
    currErr = Error(trainData, wts, 0.0, 0.0);
    if (currErr < bestErr) {
      bestErr = currErr; result = candidates[trial];
    }
  }
  return result;
}

Beachten Sie das Kandidaten Regularisierung Gewicht wird verwendet, um die Auswertung-Klassifizierung zu trainieren, aber der Fehler wird ohne die Regularisierung Gewicht berechnet.

Zusammenfassung

Regularisierung kann mit beliebigen ML-Klassifizierung-Verfahren verwendet werden, die auf eine mathematische Gleichung basiert. Beispiele sind die logistische Regression, probit Klassifizierung und neuronale Netze. Da die Größenordnungen der Gewicht-Werte in einem Modell verringert wird, ist Regularisierung Gewicht Zerfall bezeichnet. Der große Vorteil der Verwendung von Regularisierung ist, dass es oft zu ein genaueres Modell führt. Der Hauptnachteil ist, dass es einen zusätzliche Parameterwert, der ermittelt werden muss, die Regularisierung Gewicht führt. Bei logistische Regression das ist nicht zu ernst, da es in der Regel nur das Erlernen rate Parameter, doch wenn Sie komplexere Klassifizierung-Techniken verwenden, neuronale Netze insbesondere Hinzufügen einer anderen sogenannten Hyperparameter können eine Menge zusätzliche Arbeit, die kombinierten Werte der Parameter zu optimieren.

Dr. James McCaffreyarbeitet 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.

Dank den folgenden technischen Experten bei Microsoft Research für die Überprüfung dieses Artikels: Richard Hughes