Dieser Artikel wurde maschinell übersetzt.
Test Run
Codieren einer logistischen Regression mit der Newton-Raphson-Methode
.jpg)
Die logistische Regression (LR) ist ein maschinelles Lernen-Technik, die verwendet werden kann, um Vorhersagen auf Daten findet die abhängige Variable zu vorhergesagt werden, einen Wert von 0 oder 1.Beispiele sind Vorhersagen, ob ein Patient aufgrund von Herz-Kreislauferkrankungen innerhalb einer bestimmten Anzahl von Jahren sterben wird (0 = nicht sterben, 1 = sterben), basierend auf der behandelnde Alter, Geschlecht und Cholesterinspiegel und Vorhersagen, ob ein Baseball-Team ein Spiel zu gewinnen (0 = verlieren, 1 = Win) auf der Grundlage von Faktoren wie Team Durchschnitt zu zucken und Krug Earned Run Average ab.Die logistische Regression wird vorausgesetzt, dass Problem Daten passt eine Gleichung, die die Form p = 1.0 / (1.0 + e-Z) wo Z = b0 + (b1)(x1) + (b2)(x2) +...+ (bn)(xn).Die X-Variablen sind die Prädiktoren und die b-Werte sind Konstanten, die bestimmt werden müssen.Z. B. genommen Sie an, Sie Tod durch Herz-Kreislauferkrankungen vorhersagen möchten.Lassen Sie die Vorhersagedienst Variablen X 1 sein = Patientenalter, X 2 = Patient Geschlecht (0 = männlich, 1 = weiblich) und X 3 = Patienten Cholesterinspiegel.Und angenommen, Sie irgendwie festgestellt haben, dass b0 =-95.0, b1 = 0.4, b2 = 0,9 und b3 = 11.2.Wenn es ein 50 Jahre Alter männlicher Patienten deren Cholesterinspiegel 6.8, dann z ist =-95.0 + (0.4)(50) + (-0.9)(0) + (11.2)(6.8) = 1.16 und also p = 1.0 / (1.0 + exp(-1.16)) = 0.7613.Der p-Wert kann Lose als Wahrscheinlichkeit interpretiert werden, also in diesem Fall hatte Sie schlussfolgern, dass der Patient eine 0.7613 Wahrscheinlichkeit innerhalb der angegebenen Anzahl von Jahren zu sterben hat.
Die Funktion 1.0 / (1.0 + e-Z) nennt man die sigmoidale-Funktion.Die Domäne der möglichen Werte für z ist alle reellen Zahlen.Das Ergebnis der Funktion ist ein Wert zwischen 0,0 und 1,0, wie in Abbildung 1.Sie können nicht davon ausgehen, dass die Daten, die, denen Sie mit arbeiten, von der sigmoid Funktion modelliert werden können, aber viele reale Datensätze in der Tat genau von der Funktion modelliert werden können.
.png)
Abbildung 1 die sigmoidale-Funktion
Wenn die logistische Regression verwendet wird, ist das primäre Problem wie die b (oft als Beta) Werte für die LR-Gleichung bestimmt.In den meisten Situationen Sie haben einige historischen Daten mit bekannten Ergebnissen und verwenden Sie eine der mehrere Techniken, um die Werte von Beta zu finden, die die Daten am besten passen.Nachdem Sie die Werte der Beta ermittelt haben, können Sie sie auf neuen Daten Vorhersagen zu treffen.Eine der am häufigsten verwendeten Techniken für die Beta-Werte für eine logistische Regression-Gleichung zu finden wird iterativ reweighted Methode der kleinsten Quadrate (IRLS) genannt.IRLS beginnt mit einer Schätzung der Beta-Werte und iterativ berechnet dann eine neue, bessere Satz der Betaversionen bis einige stoppen-Bedingung erfüllt ist.Es gibt verschiedene Techniken, die verwendet werden können um zu bestimmen, eine neue, bessere Beta Werte festgelegt.Eine der häufigsten heißt Newton-Raphson (NR), die beinhaltet die Infinitesimalrechnung Ableitung einer Funktion zu finden – in diesem Fall die Ableitung der sigmoid-Funktion.Wegen der engen Verbindung zwischen IRLS und Newton-Raphson in die logistische Regression werden beide Begriffe häufig synonym verwendet.
Obwohl es viele Ressourcen zur Verfügung, die die komplexe Mathematik gibt hinter finden die logistische Regression Beta-Parameter mithilfe von Newton-Raphson beschreiben, gibt es sehr wenige, wenn überhaupt, Anleitungen zur Implementierung für Programmierer.Dieser Artikel erklärt genau, wie die logistische Regression mit Newton-Raphson-Werke und die Implementierung eine Lösung unter Verwendung der Programmiersprache c#.Werfen Sie einen Blick auf den Screenshot in Abbildung 2 zu sehen, wohin ich bin.
.png)
Abbildung 2 die logistische Regression mit Newton-Raphson
Das Demoprogramm beginnt mit der Erzeugung von zwei synthetische Datendateien.Die erste heißt die Trainingsdatei und besteht aus 80 Zeilen der Daten Alter, Geschlecht, Cholesterin und Tod.Die Ausbildung-Datei wird verwendet, um die LR-Beta-Werte zu berechnen.Die zweite heißt die Testdatei und hält 20 Zeilen mit Daten, die verwendet werden, um die Genauigkeit der LR-Gleichung mit den Beta-Werten berechnet aus den Trainingsdaten auswerten.Das Demoprogramm lädt die X-Predictor-Wert der Trainingsdaten in einer Matrix und lädt die abhängige Variable Y-Werte der Daten in einen Vektor.Beachten Sie, dass die X Ausbildung Matrix, oft als eine Entwurf-Matrix, eine zusätzliche erste Spalte hat, der alle 1,0 Werte besteht, und das die Vorhersagedienst-Werte haben alle in numerische Werte konvertiert.Als nächstes setzt das Demoprogramm drei stoppen Bedingungen des IRLS-Algorithmus, gekennzeichnet durch Variablen MaxIterations, Epsilon und JumpFactor.Das Demoprogramm verwendet den Newton-Raphson-Algorithmus zur Schätzung der b0, b1, b2 und b3 Beta-Werte, die am besten die Trainingsdaten entsprechen.Die Demo endet durch auswerten, wie genau die resultierende LR-Gleichung mit den berechneten Beta-Werten auf den Testdaten ist.In diesem Beispiel wurden 18 von 20 Y-Werte (90 Prozent) richtig getippt.
In diesem Artikel wird vorausgesetzt, Sie haben fortgeschrittene Programmierkenntnisse und mindestens fortgeschrittene Kenntnisse der Matrix-Operationen und Terminologie, aber nicht annehmen, dass Sie wissen nichts über die logistische Regression.Der Code, der den Screenshot in produziert Abbildung 2 ist viel zu groß, um in seiner Gesamtheit hier präsentieren, aber der vollständige Quellcode ist verfügbar unter archive.msdn.microsoft.com/mag201208TestRun.Aufgrund der Komplexität des Algorithmus IRLS/NR konzentriere ich mich hauptsächlich auf wesentliche Teile des Algorithmus anstatt auf den Code selbst, also Sie können ändern Sie den Code, um Ihre Bedürfnisse zu erfüllen oder es zu einer anderen Programmiersprache umgestalten, wenn Sie es wünschen.
Allgemeine Programmstruktur
Der Einfachheit halber alle Code generiert, die im Screenshot in Abbildung 2 befindet sich in einer einzigen c#-Konsolenanwendung.Die Programmstruktur und die Main-Methode, mit einigen WriteLine-Anweisungen entfernt, aufgeführt sind, Abbildung 3.
Abbildung 3-Programmstruktur
using System;
using System.IO;
namespace LogisticRegressionNewtonRaphson
{
class LogisticRegressionNRProgram
{
static void Main(string[] args)
{
try
{
string trainFile = "trainFile.txt";
string testFile = "testFile.txt";
MakeRawDataFile(80, 3, trainFile);
MakeRawDataFile(20, 4, testFile);
Console.WriteLine("First 5 lines of training data file are: \n");
DisplayRawData(trainFile, 5);
double[][] xTrainMatrix = LoadRawDataIntoDesignMatrix(trainFile);
double[] yTrainVector = LoadRawDataIntoYVector(trainFile);
double[][] xTestMatrix = LoadRawDataIntoDesignMatrix(testFile);
double[] yTestVector = LoadRawDataIntoYVector(testFile);
int maxIterations = 25;
double epsilon = 0.01;
double jumpFactor = 1000.0;
double[] beta = ComputeBestBeta(xTrainMatrix, yTrainVector,
maxIterations, epsilon, jumpFactor);
Console.WriteLine("Newton-Raphson complete");
Console.WriteLine("The beta vector is: ");
Console.WriteLine(VectorAsString(beta, int.MaxValue, 4, 10));
double acc = PredictiveAccuracy(xTestMatrix, yTestVector, beta);
Console.WriteLine("The predictive accuracy of the model on the test
data is " + acc.ToString("F2") + "%\n");
}
catch (Exception ex)
{
Console.WriteLine("Fatal: " + ex.Message);
Console.ReadLine();
}
} // Main
static void MakeRawDataFile(int numLines, int seed, string fileName)
static void DisplayRawData(string fileName, int numLines)
static double[][] LoadRawDataIntoDesignMatrix(string rawDataFile)
static double[] LoadRawDataIntoYVector(string rawDataFile)
static double PredictiveAccuracy(double[][] xMatrix,
double[] yVector, double[] bVector)
static double[] ComputeBestBeta(double[][] xMatrix, double[] yVector,
int maxNewtonIterations, double epsilon, double jumpFactor)
static double[] ConstructNewBetaVector(double[] oldBetaVector,
double[][] xMatrix,
double[] yVector, double[] oldProbVector)
static double[][] ComputeXtilde(double[] pVector, double[][] xMatrix)
static bool NoChange(double[] oldBvector, double[] newBvector, double epsilon)
static bool OutOfControl(double[] oldBvector, double[] newBvector,
double jumpFactor)
static double[] ConstructProbVector(double[][] xMatrix, double[] bVector)
// Matrix and vector routines:
static double MeanSquaredError(double[] pVector, double[] yVector)
static double[][] MatrixCreate(int rows, int cols)
static double[] VectorCreate(int rows)
static string MatrixAsString(double[][] matrix, int numRows,
int digits, int width)
static double[][] MatrixDuplicate(double[][] matrix)
static double[] VectorAddition(double[] vectorA, double[] vectorB)
static double[] VectorSubtraction(double[] vectorA, double[] vectorB)
static string VectorAsString(double[] vector, int count, int digits, int width)
static double[] VectorDuplicate(double[] vector)
static double[][] MatrixTranspose(double[][] matrix) // assumes
matrix is not null
static double[][] MatrixProduct(double[][] matrixA, double[][] matrixB)
static double[] MatrixVectorProduct(double[][] matrix, double[] vector)
static double[][] MatrixInverse(double[][] matrix)
static double[] HelperSolve(double[][] luMatrix, double[] b) // helper
static double[][] MatrixDecompose(double[][] matrix, out int[] perm,
out int tog)
} // Program
} // ns
Obwohl die logistische Regression ein komplexes Thema, den Code in ist Abbildung 3 ist nicht ganz so kompliziert, wie es zunächst erscheinen mag, weil die meisten der gezeigten Methoden relativ kurzen Hilfsroutinen. Die beiden wichtigsten Methoden sind ComputeBestBeta und ConstructNewBetaVector.
Die MakeRawData-Methode generiert eine Datei von einer Alter-Geschlecht-Cholesterin-Death-Daten. Alter ist ein zufälliger Integerwert zwischen 35 und 80, Sex ist entweder m oder f mit gleicher Wahrscheinlichkeit und Cholesterin ist ein zufälliger reeller Wert zwischen 0,1 und 9,9, der auf das aktuelle Alterswert basiert. Der Tod abhängigen Variablen erfolgt unter Verwendung einer logistischen Regressionsgleichung mit festen Beta Werte b0 =-95.0, b1 = 0.4, b2 = 0,9 und b3 = 11.2. MakeRawData erzeugt also Daten, die Verwendung von LR, im Gegensatz zu generieren von rein zufällige Daten, die wahrscheinlich kein LR-Modell folgen würde definitiv modelliert werden können.
Datenverarbeitung einen neue Beta-Vektor
Das Herz der logistischen Regression mit Newton-Raphson ist eine Routine, die eine neue berechnet, vermutlich besser, der Beta-Werte vom den aktuellen Satz von Werten. Die Mathematik ist sehr tief, aber zum Glück ist das Ergebnis nicht zu komplex. In Pseudo-equation Form ist der Updateprozess gegeben durch:
b [t] = b [t-1] + Inv (X'W [t 1] X) X'(Y-p[t-1])
B [t] ist hier die neue ("zur Zeit t," nicht array indizieren) Beta-Vektor. B [t-1] ist auf der rechten Seite der alte ("bei Zeit t-1") Beta-Vektor. Die Inv-Funktion ist Matrix-Inversion. Großbuchstaben x ist der Entwurf-Matrix – das heißt, die Werte der Vorhersagedienst Variablen mit einer führenden Spalte 1.0s erweitert. Großbuchstaben X' ist die Transponierte der Matrix X Entwurf. Großbuchstabe y ist der Vektor der abhängigen Variablenwerte (erinnern, jeder Wert ist, 0 oder 1). Die Menge p [t-1] stellt der Vektor der alten vorhergesagt Wahrscheinlichkeitswerte für Y (die Werte zwischen 0,0 und 1,0 bestehen wird). Die Großbuchstabe W Menge ist eine so genannte Gewichte-Matrix, wonach erläutert.
Die Beta-Update-Gleichung und die W-Matrix werden am besten mit einem konkreten Beispiel erläutert. Nehmen Sie an der Einfachheit, die nur die ersten fünf Zeilen der Daten in dem Trainingssatz besteht Abbildung 1. So wäre die Gestaltung Matrix X:
1.00 48.00 1.00 4.40
1.00 60.00 0.00 7.89
1.00 51.00 0.00 3.48
1.00 66.00 0.00 8.41
1.00 40.00 1.00 3.05
Der abhängige Variable Vektor Y wäre:
0
1
0
1
0
Nehmen wir an, dass die alten Werte aktualisiert werden Beta-Vektor, b [t-1], ist:
1.00
0.01
0.01
0.01
Mit diesen Werten für x und Beta, die alte p-Vektor, p [t-1], ist:
0.8226
0.8428
0.8242
0.8512
0.8085
Beachten Sie, dass, wenn wir davon, p-Werte ausgehen < 0,5 als y interpretiert werden = 0 und p-Werte > = 0,5 werden interpretiert, wie y = 1, die alten Beta-Werte würden nur zwei von fünf Fällen in den Trainingsdaten vorherzusagen.
Die Gewichte Matrix W ist ein m x m-Matrix, wobei m die Anzahl der Zeilen von x ist. Alle Werte in der W-Matrix sind 0.0 bis auf jene m-Werte, die auf der Hauptdiagonale sind. Jeder dieser Werte gleich dem entsprechenden p-Wert multipliziert mit 1-p. Also in diesem Beispiel W Größe 5 x 5 wäre. Die obere linke Zelle am [0,0] wäre (0.8226)(1-0.8226) = 0.1459. Die Zelle am [1,1] wäre (0.8428)(1-0.8428) = 0.1325, und so weiter. Die Menge (p)(1-p) stellt die Kalkül-Ableitung der sigmoid-Funktion.
In der Praxis wird die W-Matrix nicht explizit berechnet, weil seine Größe enorm sein könnte. Wenn Sie 1.000 Datenzeilen Ausbildung hatte, hätte Matrix W 1.000.000 Zellen. Ankündigung der Beta Update Gleichung hat eine Laufzeit B [t-1] X, die d. das Produkt W [t-1] und x h.. Da die meisten Werte in W [t-1] NULL sind, sind die meisten Matrix Multiplikation Begriffe auch NULL. Dies ermöglicht W [t-1] mal x direkt von p [t-1] und X, berechnet werden, ohne explizit konstruieren W. Einige der Math-Verweise, die IRLS mit dem NR-Algorithmus für LR beschreiben Verwenden des Symbols X ~ (X Tilde) für das Produkt W [t-1] und X. Finden Sie unter ComputeXtilde im Codedownload Implementierungsdetails.
ConstructNewBetaVector-Methode akzeptiert als Eingabeparameter den alte Beta-Vektor, Matrix X Entwurf, der abhängigen Variablen Y-Vektor und der alten Wahrscheinlichkeit Vektor. Die Methode berechnet und gibt den aktualisierte Beta-Vektor.
Die Methode implementiert wie folgt:
double[][] Xt = MatrixTranspose(xMatrix); // X'
double[][] A = ComputeXtilde(oldProbVector, xMatrix); // WX
double[][] B = MatrixProduct(Xt, A); // X'WX
double[][] C = MatrixInverse(B); // inv(X'WX)
if (C == null) // inverse failed!
return null;
double[][] D = MatrixProduct(C, Xt); // inv(X'WX)X'
double[] YP = VectorSubtraction(yVector, oldProbVector); // Y-p
double[] E = MatrixVectorProduct(D, YP); // inv(X'WX)X'(y-p)
double[] result = VectorAddition(oldBetaVector, E);
return result;
Mit der Sammlung von Matrix und Vektor Hilfsmethoden gezeigt Abbildung 3, computing einen neue Beta-Vektor ist relativ unkompliziert. Beachten Sie, dass die Methode Matrix Umkehrung ausführt. Dies ist ein Prozess, der in vielerlei Hinsicht schief gehen kann und ist eine bedeutende Schwäche des Newton-Raphson.
Fortsetzung des Beispiels, wäre Matrix Xt (die transponierte X):
1.00 1.00 1.00 1.00 1.00
48.00 60.00 51.00 66.00 40.00
1.00 0.00 0.00 0.00 1.00
4.40 7.89 3.48 8.41 3.05
Matrix A (X ~) würde von Vektor p und Matrix X von Hilfsmethode ComputeXtilde als berechnet werden:
0.15 7.00 0.15 0.64
0.13 7.95 0.00 1.05
0.14 7.39 0.00 0.50
0.13 8.36 0.00 1.07
0.15 6.19 0.15 0.47
Fortgeschrittene Matrix B, darstellt das Produkt der Xt und X ~ (die wiederum XtW[t-1]X) ist wäre:
0.70 36.90 0.30 3.73
36.90 1989.62 13.20 208.46
0.30 13.20 0.30 1.11
3.73 208.46 1.11 23.23
Fortgeschrittene Matrix C ist die Inverse der Matrix B und wäre:
602.81 -14.43 -110.41 38.05
-14.43 0.36 2.48 -1.02
-110.41 2.48 26.43 -5.77
38.05 -1.02 -5.77 3.36
Fortgeschrittene Matrix D ist das Produkt der Matrix C und X-Transponierte Matrix und würde wie folgt berechnet werden:
-33.00 37.01 -0.90 -29.80 31.10
0.77 -0.96 0.30 0.66 -0.72
9.52 -7.32 -4.17 4.54 -2.51
-1.86 3.39 -2.24 -0.98 1.76
Fortgeschrittene Vektor YP ist der Unterschied zwischen Vektoren Y und p [t-1] und wäre:
-0.8
0.2
-0.8
0.1
-0.8
Fortgeschrittene Vektor E ist das Produkt der Matrix D und Vektor YP und hält die Inkremente der alten Beta-Vektor hinzugefügt werden. Vektor e wäre:
4.1
-0.4
-2.8
2.3
Der neue, endgültige Beta-Vektor wird erhalten, indem Sie hinzufügen, dass die Werte im mittlere Vektor E auf die alten Werte der Beta, und in diesem Beispiel wäre:
5.1
-0.3
-2.8
2.4
Mit den neuen Werten von Beta wäre die neuen Werte für die p-Vektor:
0.0240
0.9627
0.0168
0.9192
0.0154
Wenn diese p-Werte, als y interpretiert werden = 0 wenn p < 0,5, dann, nach nur einer Iteration der Newton-Raphson, die Beta-Werte korrekt Vorhersagen alle fünf Fälle in der Testdaten.
Wissen, wann man aufhören
Das Newton-Raphson-Verfahren für die logistische Regression wird iterativ die Werte des Vektors Beta verbessert, bis einige stoppen-Bedingung erfüllt ist. Es ist überraschend schwierig zu wissen, wann die Iteration zu stoppen. Methode ComputeBestBeta übernimmt diese Aufgabe. Der Code wird in Abbildung 4 gezeigt.
Abbildung 4 Datenverarbeitung des besten Beta-Vektors
static double[] ComputeBestBeta(double[][] xMatrix, double[] yVector,
int maxIterations, double epsilon, double jumpFactor)
{
int xRows = xMatrix.Length;
int xCols = xMatrix[0].Length;
if (xRows != yVector.Length)
throw new Exception("xxx (error)");
// Initialize beta values
double[] bVector = new double[xCols];
for (int i = 0; i < xCols; ++i) { bVector[i] = 0.0; }
double[] bestBvector = VectorDuplicate(bVector);
double[] pVector = ConstructProbVector(xMatrix, bVector);
double mse = MeanSquaredError(pVector, yVector);
int timesWorse = 0;
for (int i = 0; i < maxIterations; ++i)
{
double[] newBvector = ConstructNewBetaVector(bVector, xMatrix,
yVector, pVector);
if (newBvector == null)
return bestBvector;
if (NoChange(bVector, newBvector, epsilon) == true)
return bestBvector;
if (OutOfControl(bVector, newBvector, jumpFactor) == true)
return bestBvector;
pVector = ConstructProbVector(xMatrix, newBvector);
double newMSE = MeanSquaredError(pVector, yVector); // Smaller is better
if (newMSE > mse) // new MSE is worse
{
++timesWorse; // Update got-worse counter
if (timesWorse >= 4)
return bestBvector;
bVector = VectorDuplicate(newBvector); // Attempt escape
for (int k = 0; k < bVector.Length; ++k)
bVector[k] = (bVector[k] + newBvector[k]) / 2.0;
mse = newMSE;
}
else // Improved
{
bVector = VectorDuplicate(newBvector);
bestBvector = VectorDuplicate(bVector);
mse = newMSE;
timesWorse = 0;
}
} // End main iteration loop
return bestBvector;
}
Eine der größten Gefahren der logistischen Regression ist zu oft durchlaufen, was zu einer Reihe von Beta-Werten, die die Trainingsdaten perfekt passen, aber auch jede andere Datensätze passen nicht. Dies nennt man over-fitting. Zu wissen, wann die Ausbildung Abbrechen in die logistische Regression ist Teil Kunst und Wissenschaft Teil. Methode ComputeBestBeta beginnt mit den Beta-Vektor, alle 0,0 Werte initialisieren, computing die zugehörigen p-Werte und dann den Fehler zwischen den p-Werten und den Y-Werten Datenverarbeitung. Der Code in diesem Artikel verwendet die mittleren quadratischen Fehler — dem Durchschnitt der Summen der quadrierten Unterschiede zwischen p und Y. Weitere Möglichkeiten der EDV Fehler beinhalten durchschnittliche absolute Abweichung und Kreuz-Entropie-Fehler.
Die Hauptverarbeitungsschleife in ComputeBestBeta berechnet immer wieder eine neue Beta-Vektor und entsprechende Fehler-Begriff. Die primäre stoppen-Bedingung in der Algorithmus ist ein MaxIterations-Parameter. Erinnern Sie, dass der Newton-Raphson-Algorithmus eine Inverse Matrix berechnet, die anfällig für Fehler ist. In dieser Rechtssache ComputeBestBeta liefert der besten Beta-Vektor gefunden (die jedoch leider den ersten All-Null-Vektor). Vielleicht möchten hier stattdessen Ausnahme. Eine weitere Alternative ist, eine Flucht zu versuchen, durch Ändern der neuen Beta-Werte durch sie dem Durchschnitt der vorherigen Werte anpassen und die neuen Werte.
Die nächste Stoppbedingung überprüft, ob die Änderung in der neuen Beta-Werte kleiner als einige kleine Wert des Parameters Epsilon, mit Hilfsmethode NoChange ist. Dies zeigt an, dass Newton-Raphson angenähert hat, und in der Tat, es gibt eine gute Chance, dass, die Ihr Modell jetzt over-fitted ist. Statt Rückgabe des besten Beta-Vektors an dieser Stelle gefunden, sollten Sie den besten Beta-Vektor aus einer früheren Iteration zurückzugeben. Die nächste Stoppbedingung überprüft, ob die neue Beta-Werte durch einen Betrag größer als einige große Wert von Parameter JumpFactor gegeben sprang. Dies bedeutet, dass Newton-Raphson möglicherweise außer Kontrolle gesponnen hat und zu einem Ausnahmefehler anstelle Neueinstellung des besten Beta-Vektors gefunden werden soll.
Ein weiterer Stoppbedingung in ComputeBestBeta überprüft, um festzustellen, ob die neuen Beta-Werte tatsächlich einen größeren Fehler als die früheren Beta-Werte produzieren haben. In diesem Beispiel wenn neue Betaversionen einen größeren Fehler vier Mal in Folge produzieren, der Algorithmus beendet und gibt der besten Beta-Vektor gefunden. Vielleicht möchten den Wert für die maximale Anzahl von aufeinander folgenden Anstieg der Fehler zu parametrisieren. Wenn eine Zunahme der Fehler erkannt wird, versucht die Methode, die Situation zu entkommen, durch Ändern der Werte in der aktuellen Beta-Vektor der Durchschnitt der Werte in der aktuellen Beta und die Werte in der neu berechnete Beta.
Es gibt keine beste einheitlicher Bedingungen zu beenden. Jedes logistische Regression Problem erfordert etwas experimentieren, den Newton-Raphson-Algorithmus zu optimieren.
Vorteile vs.. Nachteile
Es gibt mehrere Alternativen zu Newton-Raphson zur Abschätzung von des besten Satz von Beta-Werte in die logistische Regression. Newton-Raphson ist eine deterministische Numerische Optimierungsverfahren-Technik. Sie können auch nicht-deterministische (d. h. probabilistische) Techniken wie Partikel Schwarm Optimierung, evolutionäre Algorithmen und bakterielle Futtersuche Optimierung beschäftigen.
Der Hauptvorteil der Newton-Raphson im Vergleich zu probabilistischen Alternativen ist, dass in den meisten Situationen NR viel schneller. Aber Newton-Raphson hat mehrere Nachteile. Da NR Matrix Umkehrung verwendet, wird der Algorithmus fehlschlagen, wenn Begegnung mit eine singuläre Matrix während der Berechnung. Einfache Implementierungen von Newton-Raphson erfordern alle Daten im Arbeitsspeicher, die bedeutet, dass es eine Grenze für die Größe des Trainings und Testen von Datensätzen, die Sie verwenden können. Obwohl es selten ist, möglicherweise einige Datensätze nicht zu besten Beta Werte überhaupt mit NR konvergieren.
Wenn ich die logistische Regression verwenden, setzen ich häufig einen zwei-Säulen-Angriff. Ich experimentiere zuerst mit einem Newton-Raphson-Ansatz. Unterlässt, die Technik, Falle ich zurück mit Partikel Schwarm Optimierung finden den besten Satz von Beta-Werte. Es ist wichtig zu beachten, dass die logistische Regression ist nicht magisch, und nicht alle Daten passt ein logistisches Regressionsmodell. Andere Maschinelles Lernen Techniken an Modell-Daten mit einer binären abhängigen Variablen sind neuronale Netze, support-Vector-Machines und lineare Diskriminanzanalyse.
Die Erklärung für die Beta-Vektor-Update-Prozess des Newton-Raphson-Algorithmus präsentiert in diesem Artikel und den zugehörigen Codedownload sollten Sie unternehmungslustig mit logistische Regression mit NR erhalten. Die logistische Regression kann ist eine faszinierende, komplexe Thema und eine wertvolle Ergänzung zu Ihrem persönlichen Fertigkeiten.
Dr. James McCaffrey arbeitet für Volt Information Sciences Inc., wo er technische Schulungen für Softwareentwickler auf der Microsoft in Redmond, Washington, Campus. Er hat an verschiedenen Microsoft-Produkten mitgearbeitet, unter anderem an Internet Explorer und MSN Search. McCaffrey ist der Autor von „.NET Test Automation Recipes“ (Apress, 2006). Er kann erreicht werden unter jammc@microsoft.com.
Unser Dank gilt den folgenden technischen Experten für die Durchsicht dieses Artikels: Dan Liebling und Anne Loomis Thompson