Cet article a fait l'objet d'une traduction automatique.
Série de tests
Codage de la régression logistique avec Newton-Raphson
Télécharger l'exemple de code
.jpg)
Régression logistique (LR) est une technique d'apprentissage-machine qui peut être utilisée pour faire des prédictions sur les données où la variable dépendante à prévoir prend la valeur 0 ou 1.Exemples prédire si un patient vont mourir à cause d'une maladie cardiaque dans un certain nombre d'années (0 ne = pas die, 1 = die), en se fondant sur le patient âge, sexe et niveau de cholestérol et prévoir ou non une équipe de baseball gagneront un jeu (0 = perdre, 1 = victoire) fondée sur des facteurs tels que l'équipe au bâton à moyenne et à partir de moyenne de points mérités de baseball.Régression logistique suppose que les données du problème correspond une équation qui a la forme p = 1,0 / (1.0 + e-z) où z = b0 + (b1)(x1) + (b2)(x2) +...+ (bn)(xn).Les variables x sont les variables explicatives et les valeurs de b sont des constantes qui doivent être déterminées.Par exemple, supposons que vous souhaitez prédire la mort d'une maladie cardiaque.Soit les variables prédictives x 1 = âge des patients, x 2 = patient sexe (0 = mâle, 1 = femelle) et x 3 = niveau de cholestérol de patients.Et supposons que vous avez déterminé d'une certaine façon que b0 =-95.0, b1 = 0,4, b2 = -0,9 et b3 = 11,2.S'il y a un patient âgé de 50 an dont le niveau de cholestérol est de 6,8, alors z =-95.0 + (0.4)(50) + (-0.9)(0) + (11.2)(6.8) = 1.16 et si p = 1,0 / (1.0 + exp(-1.16)) = 0.7613.La valeur de p peut être librement interprété comme une probabilité, donc dans ce cas vous avez eu conclure que le patient a une probabilité 0.7613 de mourir dans le nombre spécifié d'années.
La fonction 1.0 / (1.0 + e-z) est appelée la fonction sigmoïde.Le domaine des valeurs possibles pour z est tous les nombres réels.Le résultat de la fonction est une valeur comprise entre 0,0 et 1,0, comme le montre Figure 1.Vous ne pouvez pas supposer que les données que vous manipulez peuvent être modélisées par la fonction sigmoïde, mais plusieurs ensembles de données de vie réelle peut en fait être fidèlement modélisées par la fonction.
.png)
La figure 1, la fonction sigmoïde
Lors de la régression logistique, le problème principal est comment déterminer les valeurs de b (souvent appelé bêta) de l'équation de LR.Dans la plupart des situations, vous avez certaines données historiques avec les résultats connus et utilisez l'une de plusieurs techniques pour trouver les valeurs de la bêta qui répondent le mieux à des données.Après que vous avez déterminé les valeurs de la bêta, vous pouvez les utiliser pour faire des prédictions sur de nouvelles données.Une des techniques plus courantes pour trouver les valeurs bêta pour une équation de régression logistique est appelée des moindres carrés itérativement repondérés (IRLS).IRLS démarre avec une estimation des valeurs bêta et puis itérativement calcule un nouveau, mieux définir des versions bêta jusqu'à ce qu'une condition d'arrêt est rencontrée.Il existe plusieurs techniques qui peuvent servir à déterminer une nouvelle mieux définir des valeurs de la bêta.Un du plus commun est appelé Newton-Raphson (NR), qui consiste à trouver la dérivée de calcul d'une fonction — dans ce cas, la dérivée de la fonction sigmoïde.En raison du lien étroit entre les IRLS et de Newton-Raphson en régression logistique, les deux termes sont souvent utilisés de façon interchangeable.
Bien qu'il y a beaucoup de ressources disponibles qui décrivent les mathématiques complexes derrière trouver une régression logistique paramètres bêta à l'aide de Newton-Raphson, il existe des guides de mise en œuvre très peu, le cas échéant, pour les programmeurs.Cet article explique une régression logistique exactement comment avec les travaux de Newton-Raphson et comment implémenter une solution utilisant le langage c#.Regardez la capture d'écran dans Figure 2 de voir vers où je suis.
.png)
La figure 2 une régression logistique avec Newton-Raphson
Le programme de la démo commence par générer deux fichiers de données synthétiques.Le premier est appelé le fichier formation et se compose de 80 lignes de données d'âge, de sexe, de cholestérol et de mort.Le fichier de formation est utilisé pour calculer les valeurs de bêta de LR.Le second est appelé le fichier de test et détient 20 lignes de données qui sont utilisées pour évaluer l'exactitude de l'équation de LR avec les valeurs de bêta calculés à partir des données d'apprentissage.Le programme de démonstration charge les valeurs prédictives x les données d'apprentissage dans une matrice et charge les valeurs de variable dépendante y des données dans un vecteur.Notez que la matrice de formation X, souvent appelée une matrice de conception, une première colonne supplémentaire qui se compose de toutes les valeurs 1.0, et que les valeurs prédictives ont tous été convertis en valeurs numériques.Ensuite, le programme de démonstration définit les trois conditions de l'arrêt de l'algorithme IRLS, indiquée par jumpFactor, epsilon et maxIterations variables.Le programme de démonstration utilise l'algorithme de Newton-Raphson pour estimer la b0, b1, b2 et b3 valeurs bêta qui répondent le mieux à des données d'apprentissage.La démo conclut en évaluant de façon exacte l'équation résultante de LR avec les valeurs calculées de bêta est sur les données de test.Dans cet exemple, 18 des 20 valeurs de Y (90 %) ont été correctement prédit.
Cet article suppose que vous avez avancé des compétences en programmes et au moins une connaissance intermédiaire de la terminologie et les opérations de matrice, mais n'est pas que vous savez rien de la régression logistique.Le code qui a produit la capture d'écran dans Figure 2 est beaucoup trop grand pour présenter dans son intégralité ici, mais le code source complet est disponible à archive.msdn.microsoft.com/mag201208TestRun.En raison de la complexité de l'algorithme IRLS/NR, je concentrerai principalement sur des éléments clés de l'algorithme plutôt que sur le code lui-même, ainsi vous serez capable de modifier le code afin de répondre à vos propres besoins ou à refactoriser dans un autre langage de programmation, si vous le souhaitez.
Structure générale du programme
Pour plus de simplicité, tout le code qui produit la capture d'écran dans Figure 2 est contenue dans une seule application de console c#.La structure du programme et la méthode Main, avec quelques déclarations de WriteLine enlevés, sont énumérés dans Figure 3.
La figure 3 Structure du programme
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
Bien que la régression logistique est un sujet complexe, le code de Figure 3 n'est pas très compliqué car il peut apparaître tout d'abord parce que la plupart des méthodes indiquées sont les routines d'assistance relativement courte. Les deux principales méthodes sont ComputeBestBeta et ConstructNewBetaVector.
La méthode MakeRawData génère un fichier de données d'âge-sexe-cholestérol-mort quasi-randomisées. L'âge est une valeur entière aléatoire entre 35 et 80, sexe est m ou f avec une probabilité égale et cholestérol est une valeur réelle semi-random entre 0,1 et 9,9 qui est basée sur la valeur actuelle. La variable dépendante de décès est calculée à l'aide d'une équation de régression logistique avec des valeurs fixes bêta de b0 =-95.0, b1 = 0,4, b2 = -0,9 et b3 = 11,2. Si MakeRawData génère des données qui certainement peuvent être modélisées à l'aide de LR, par opposition à la génération des données purement aléatoires qui suivraient probablement pas un modèle de LR.
Calcul d'un nouveau vecteur de Beta
Au coeur d'une régression logistique avec Newton-Raphson est une routine qui calcule un nouveau, probablement mieux, définir des valeurs de la version bêta de l'ensemble des valeurs. Le calcul est très profond, mais heureusement le résultat net n'est pas trop complexe. Sous forme de pseudo-equation, le processus de mise à jour est donné par :
b [t] = b [t-1] + inv (X'W [t-1] X) X'(Y-p[t-1])
B [t] Voici le nouveau (« au temps t, » pas tableau d'indexation) vecteur bêta. Sur le côté droit, b [t-1] est le vecteur de version bêta vieux (« au temps t-1 »). La fonction inv est inversion de matrice. Majuscules x est la matrice de conception — c'est-à-dire, les valeurs des variables prédictives augmentée avec une colonne principale de 1.0s. Majuscules X' est la transposée de la matrice de conception de X. MAJUSCULE y est le vecteur des valeurs de la variable dépendante (rappel chaque valeur sera de 0 ou 1). La représente [t-1] de quantité p le vecteur prédit de vieilles valeurs de probabilité de Y (qui se composera des valeurs entre 0,0 et 1,0). La quantité w majuscule est une matrice de poids qu'on appelle, qui nécessite un peu d'explication.
L'équation de la mise à jour bêta et la matrice w sont mieux expliquées par un exemple concret. Supposons pour simplifier que l'ensemble de la formation comprend seulement les cinq premières lignes de données indiquées dans Figure 1. La matrice de conception x serait donc :
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
Le vecteur de la variable dépendante y serait :
0
1
0
1
0
Supposons que le vecteur des valeurs de mise à jour bêta vieux b [t-1], est :
1.00
0.01
0.01
0.01
Avec ces valeurs pour x et beta, le vieux vecteur p, p [t-1], est :
0.8226
0.8428
0.8242
0.8512
0.8085
Notez que, si on suppose que les valeurs de p < 0,5 sont interprétées comme y = 0 et p valeurs > = 0,5 sont interprétées comme y = 1, les anciennes valeurs de bêta pourraient prédire correctement seulement deux des cinq cas dans les données d'apprentissage.
La matrice de poids w est un m x la matrice m, où m est le nombre de lignes de X. Toutes les valeurs dans la matrice w sont 0,0 à l'exception de ces valeurs de m sur la diagonale principale. Chacune de ces valeurs estégale à la valeur de p correspondantes multipliée par 1-p. Pour cet exemple, W serait donc taille 5 x 5. La cellule supérieure gauche à [0,0] serait (0.8226)(1-0.8226) = 0.1459. La cellule en [1,1] serait (0.8428)(1-0.8428)= 0.1325 et ainsi de suite. La quantité (p)(1-p) représente la dérivée de calcul de la fonction sigmoïde.
Dans la pratique, la matrice w n'est pas calculée explicitement parce que sa taille pourrait être énorme. Si vous aviez 1 000 lignes de données sur la formation, la matrice w aurait 1 000 000 cellules. Avis de quel'équation de la mise à jour bêta est un terme W X [t-1], qui signifie que le produit de matrice de x et de W [t-1]. Parce que la plupart des valeurs de W [t-1] est à zéro, la plupart des termes de multiplication de matriceest également zéro. Cela permet à W [t-1] fois x pour être calculée directement à partir de p [t-1] et X, sans construire explicitement W. Plusieurs des références mathématiques qui décrivent les IRLS avec l'algorithmeNR pour LR utilisent le symbole X ~ (X tilde) pour le produit de x et de W [t-1]. Voir la méthode ComputeXtilde dans le téléchargement de code pour les détails d'implémentation.
Méthode ConstructNewBetaVector accepte comme paramètres d'entrée le vecteur vieux de bêta, la matrice de conception de X, le vecteur de la variable dépendante y et le vecteur de probabilités vieux. La méthodecalcule et retourne le vecteur de mise à jour bêta.
La méthode est implémentée comme suit :
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;
Avec la collection de la matrice et le vecteur des méthodes d'assistance dans Figure 3, un nouveau vecteur de bêta de calcul est assez simple. Notez que la méthode effectue inversion de matrice. Il s'agit d'un processus qui peuvent mal tourner à bien des égards et qui est une faiblesse importante de Newton-Raphson.
Continuer avec l'exemple, matrice Xt (la transposée de X) serait :
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
Matrice A (X ~) devrait être calculé à partir de vecteur p et de matrice de x par la méthode d'assistance ComputeXtilde comme :
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
Matrice intermédiaire B, représentant le produit de Xt et X ~ (qui est à son tour XtW[t-1]X) serait :
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
Matrice intermédiaire c est l'inverse de la matrice b et serait :
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
Matrice intermédiaire d est le produit de la matrice c et X-transposition de matrice et pourrait être calculé comme :
-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
Vecteur intermédiaire YP est la différence entre les vecteurs y et p [t-1] et serait :
-0.8
0.2
-0.8
0.1
-0.8
Vecteur intermédiaire e est le produit de la matrice d et le vecteur YP et détient les incréments à ajouter à la vieille vecteur de bêta.Vecteur e serait :
4.1
-0.4
-2.8
2.3
Le vecteur de la bêta de nouveau, final est obtenu en ajoutant que les valeurs intermédiaire vecteur e pour les anciennes valeurs de beta et dans cet exemple serait :
5.1
-0.3
-2.8
2.4
Avec les nouvelles valeurs de la bêta, les nouvelles valeurs pour le vecteur p serait :
0.0240
0.9627
0.0168
0.9192
0.0154
Si ces valeurs de p sont interprétées comme Y = 0 alors p < 0,5, puis, après qu'une itération de Newton-Raphson, les valeurs bêta prédisent correctement tous les cinq cas dans les données de test.
Savoir quand arrêter
La technique de Newton-Raphson pour la régression logistique a itérativement améliore les valeurs du vecteur bêta jusqu'à ce qu'une condition d'arrêt est rencontrée. Il est étonnamment difficile de savoir quand s'arrêter l'itération. Méthode ComputeBestBeta gère cette tâche. Le code est présenté à la Figure 4.
La figure 4, le meilleur vecteur de bêta de calcul
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;
}
L'un des plus grands pièges de la régression logistique est une itération trop de fois, résultant en un ensemble de valeurs bêta qui correspondre parfaitement à des données d'apprentissage, mais qui ne correspondent pas bien les autres ensembles de données. Ceci est appelé over-fitting. Savoir quand arrêter le processus de formation dans la régression logistique est partie art et la science de la partie. ComputeBestBeta de la méthode commence par lors de l'initialisation du vecteur bêta pour toutes les valeurs de 0,0, calculer les valeurs de p associé et ensuite calculer l'erreur entre les valeurs de p et les valeurs de Y. Le code dans cet article utilise l'erreur quadratique moyenne — la moyenne de la somme des différences au carré entre p et Y. D'autres possibilités d'erreur de calcul incluent la déviation absolue moyenne et l'erreur de l'entropie croisée.
La boucle de traitement principale de ComputeBestBeta calcule à plusieurs reprises un nouveau vecteur de bêta et le terme d'erreur correspondante. La condition principale de s'arrêter dans l'algorithme est un paramètre de maxIterations. Rappelons que l'algorithme de Newton-Raphson calcule un inverse de la matrice, qui est sensible à l'échec. Dans cette affaire ComputeBestBeta renvoie le meilleur vecteur de bêta trouvé (qui, malheureusement, pourrait être le vecteur initial de zéro pour tous). Vous pouvez lever une exception ici au lieu de cela. Une autre solution consiste à tenter d'échapper en modifiant les nouvelles valeurs bêta par ajustement en fonction de la moyenne des valeurs précédentes et les nouvelles valeurs.
La condition d'arrêt suivante vérifie si le changement de toutes les nouvelles valeurs de la version bêta est plus petit que certains petite valeur d'epsilon de paramètre, à l'aide de la méthode d'assistance tenants. Cela indique que Newton-Raphson a convergé et, en fait, il y a de bonnes chances que votre modèle est maintenant over-fitted. Au lieu de retourner le meilleur vecteur de bêta trouvé à ce stade, vous pouvez retourner le meilleur vecteur de bêta de l'itération précédente. La condition d'arrêt suivante vérifie si l'une des valeurs nouvelles bêta ont sauté d'un montant supérieur à une grande valeur donnée par le paramètre jumpFactor. Cela indique que Newton-Raphson a peut-être filé hors de contrôle et que vous souhaitez lancer une exception au lieu d'il faut relancer le meilleur vecteur de bêta trouvé.
Une autre condition de l'arrêt en ComputeBestBeta vérifie pour voir si les nouvelles valeurs bêta produisent effectivement une erreur plus grande que les valeurs de version bêta précédente a fait. Dans cet exemple, si de nouvelles versions bêta produire une plus grande erreur quatre fois d'affilée, l'algorithme se termine et renvoie le meilleur vecteur de bêta trouvé. Vous pouvez paramétrer la valeur pour le nombre maximal de hausses consécutives en erreur. Lorsqu'une augmentation de l'erreur est détectée, la méthode tente d'échapper à la situation en changeant les valeurs dans le vecteur actuel de la bêta à la moyenne des valeurs dans la bêta actuelle et les valeurs dans la bêta nouvellement calculée.
Il n'y a pas meilleur ensemble unique d'arrêter des conditions. Chaque problème de régression logistique nécessite un peu d'expérimentation à l'écoute de l'algorithme de Newton-Raphson.
Avantages vs. Inconvénients
Il existe plusieurs alternatives de Newton-Raphson pour estimer le meilleur ensemble de valeurs bêta dans la régression logistique. Newton-Raphson est une technique d'optimisation numérique déterministe. Vous pouvez également employer des techniques non déterministes (sens probabiliste) telles que l'optimisation par essaims particulaires, algorithmes évolutionnaires et l'optimisation de nourriture bactérienne.
Le principal avantage de Newton-Raphson par rapport aux solutions de rechange probabilistes est que, dans la plupart des situations, NR est beaucoup plus rapide. Mais Newton-Raphson a plusieurs inconvénients. Car NR utilise inversion de matrice, l'algorithme va échouer lors de la rencontre d'une matrice singulière au cours du calcul. Implémentations simples de Newton-Raphson exigent toutes les données en mémoire, ce qui signifie qu'il y a une limite à la taille de la formation et tester des ensembles de données, que vous pouvez utiliser. Bien qu'il soit rare, certains ensembles de données pourrait converge pas à un ensemble de meilleures valeurs bêta du tout à l'aide de NR.
Lorsque j'utilise la régression logistique, j'utilise souvent une attaque sur deux fronts. Je première expérience avec une approche de Newton-Raphson. Si cette technique échoue, je revenir à l'utilisation d'optimisation par essaims particulaires pour trouver le meilleur ensemble de valeurs bêta. Il est important de noter que la régression logistique n'est pas magique, et pas toutes les données s'insère un modèle de régression logistique. Autres techniques d'apprentissage-machine de données avec une variable binaire dépendante du modèle comprennent les réseaux de neurones, support vector machines et l'analyse discriminante linéaire.
L'explication de la procédure de mise à jour bêta vecteur de l'algorithme de Newton-Raphson présenté dans cet article et le téléchargement de code qui l'accompagne devrait recevoir vous permet de fonctionner avec la régression logistique à l'aide de NR. Régression logistique est un sujet fascinant, complexe et peut faire un ajout précieux à votre ensemble de compétences personnelles.
Dr. James McCaffrey travaille pour Volt Information Sciences Inc., où il gère la formation technique d'ingénieurs logiciels travaillant à la Microsoft Redmond, Wash., campus. Il a collaboré à plusieurs produits Microsoft, comme Internet Explorer et MSN Search. James McCaffrey est l'auteur de « .NET Test Automation Recipes » (en anglais) (Apress, 2006). Il peut être joint au jammc@microsoft.com.
Je remercie les experts techniques suivants d'avoir relu cet article : Dan Liebling et Anne Loomis Thompson