Partager via

  • Article

Cet article a fait l'objet d'une traduction automatique.

Série de tests

Régularisations L1 et L2 pour l'apprentissage automatique

James McCaffrey

Téléchargez l'exemple de Code

James McCaffreyRégularisation de L1 et régularisation de L2 sont deux techniques apparentées qui peuvent être utilisés par les algorithmes de formation (ML) en apprentissage automatique pour réduire le surapprentissage modèle. L'élimination de surapprentissage conduit à un modèle qui permet de meilleures prévisions. Dans cet article, j'expliquerai ce que régularisation est du point de vue du développeur logiciel. Les idées derrière la régularisation sont un peu difficiles à expliquer, non pas parce qu'ils sont difficiles, mais plutôt parce qu'il y a plusieurs idées liés entre eux

Dans cet article, j'illustre régularisation avec la classification de la régression logistique (LR), mais la régularisation peut être utilisée avec plusieurs types de machine learning, notamment les classification de réseau neuronal. La classification de LR vise à créer un modèle qui prédit une variable qui peut prendre l'une des deux valeurs possibles. Par exemple, vous pourriez vouloir prédire le résultat pour une équipe de football (perdre = 0, gagner = 1) dans un prochain jeu issu de l'équipe actuelle pourcentage de victoires (x 1), location de terrain (x 2) et nombre de joueurs absents en raison de la blessure (x 3).

Si Y est la valeur prédite, un modèle LR pour ce problème prendrait la forme :

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

Ici, b0, b1, b2 et b3 sont poids, qui sont des valeurs numériques juste qui doivent être déterminées. Dans les mots, vous calculer une valeur z qui est la somme des valeurs d'entrée fois b-poids, ajoutez une constante b0, puis passez la valeur de z à l'équation qui utilise les mathématiques e constante. Il s'avère que Y sera toujours comprise entre 0 et 1. Si Y est inférieur à 0,5, vous concluez la sortie prévue est 0 et si Y est supérieure à 0,5 vous concluez que la sortie est 1. Notez que s'il y a n éléments, il y aura n + 1 b-poids.

Par exemple, supposons qu'une équipe actuellement a un pourcentage de victoires de 0,75, jouera au champ adverse (-1) et a 3 joueurs sur blessure. Et supposons que b0 = 5.0, b1 = 8,0, b2 = 3.0 et b3 =-2.0. Alors z = 5.0 + (8.0)(0.75) + (3.0)(-1) + (-2.0)(3) = 2.0 et donc Y = 1,0 / (1.0 + e ^-2.0) = 0,88. Car Y est supérieure à 0,5, vous prédirait que l'équipe va gagner leur prochain jeu.

Je pense que la meilleure façon d'expliquer la régularisation est en examinant un exemple concret. Jetez un oeil à la capture d'écran d'un programme de démonstration en Figure 1. Plutôt que d'utiliser des données réelles, le programme de démonstration commence en générant des 1 000 points de données synthétiques. Chaque élément a 12 variables prédictives (souvent appelées « fonctionnalités » dans la terminologie de ML). La valeur de la variable dépendante est dans la dernière colonne. Après avoir créé les éléments de données de 1 000, l'ensemble des données a été aléatoirement divisé en un ensemble de 800-point formation permettant de trouver que les modèle b-poids et un 200-point d'essai ensemble à utiliser pour évaluer la qualité du modèle qui en résulte.

Régularisation de la avec la Classification de la régression logistique
Régularisation de la figure 1 avec la Classification de la régression logistique

Ensuite, le programme de démonstration formés le classificateur de LR, sans utiliser de régularisation. Le modèle obtenu avait 85,00 % exactitude sur les données d'apprentissage et à 80,50 % sur les données de test. La précision de 80,50 % est le plus pertinent des deux valeurs et est une estimation approximative du degré de précision, on pourrait espérer le modèle quand présenté avec de nouvelles données. Comme je l'expliquerai bientôt, le modèle était trop ajusté, conduisant à la précision de prédiction médiocre.

Ensuite, la démo a fait un traitement pour trouver un bon poids de régularisation de L1 et un bon poids de régularisation de L2. Poids de régularisation sont des valeurs numériques uniques qui sont utilisés par le processus de régularisation. Dans la démo, un bon poids de L1 a été établi à 0,005 et un bon poids de L2 est 0,001.

La démo pour la première fois en utilisant la régularisation de la L1 de formation et puis de nouveau avec la régularisation de la L2. Avec régularisation de L1, le modèle résultant de la LR avait 95,00 % exactitude sur les données de test, et avec la régularisation de la L2, le modèle LR avait 94.50 % exactitude sur les données de test. Les deux formes de régularisation amélioré significativement la précision de prédiction.

Cet article suppose que vous avez des compétences en programmation au moins intermédiaires, mais ne suppose que vous savez quelque chose sur la régularisation de L1 ou L2. Le programme de démonstration est codé à l'aide de c#, mais vous ne devriez pas avoir trop de difficultés la refactorisation du code dans une autre langue tel que JavaScript ou Python.

Le code de démo est trop long de présenter ici, mais le code source complet est disponible dans le téléchargement de code qui accompagne cet article. Le code de démo a enlevé à limiter les principales idées aussi claire que possible et la taille du code de vérification des erreurs normales tous les.

Structure globale du programme

La structure globale du programme, avec quelques modifications mineures pour économiser l'espace, est présentée en Figure 2. Pour créer la démo, j'ai lancé Visual Studio et créé une nouvelle application de console c# nommée régularisation. La démo n'a aucune dépendance significative de Microsoft .NET Framework, donc toute version récente de Visual Studio fonctionnera.

Figure 2 Structure globale du programme

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

Après le code du modèle chargé dans l'éditeur de Visual Studio , dans la fenêtre de l'Explorateur de solutions, j'ai renommé fichier Program.cs pour l'auto plus descriptif de RegularizationProgram.cs et Visual Studio ­matiquement renommé classe programme pour moi. En haut du code source, j'ai supprimé tout à l'aide de déclarations qui pointait vers des espaces de noms inutiles, en laissant juste la référence à l'espace de noms System niveau supérieur.

Toute la logique de la régression logistique est contenue dans une seule classe de LogisticClassifier. La logistique­classifieur classe contient un helper imbriqué classe particule pour encapsuler l'optimisation essaim de particules (PSO), l'algorithme d'optimisation utilisé pour l'entraînement. Notez que la classe LogisticClassifier contient une méthode qui accepte des paramètres appelés alpha1 et alpha2. Ces paramètres sont les poids de régularisation pour la régularisation de L1 et L2.

Dans la méthode Main, les données synthétiques sont créées avec ces déclarations :

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

La valeur de départ de 42 a été utilisée seulement parce que cette valeur a donné à nice, représentant démo sortie. Méthode MakeAllData génère 13 caractères aléatoires entre-10, 0 et + 10,0 (un poids pour chaque fonctionnalité, plus le poids de b0). Puis la méthode parcourt 1 000 fois. À chaque itération, un ensemble aléatoire de 12 valeurs d'entrée est généré, puis une valeur de sortie de régression logistique intermédiaire est calculée en utilisant les poids aléatoires. Une valeur aléatoire supplémentaire est ajoutée à la sortie pour rendre les données bruyant et plus enclins à surapprentissage.

Les données se divise en un ensemble de 800-point pour la formation et un ensemble de 200-point pour l'évaluation d'un modèle à ces affirmations :

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

Un modèle de prédiction de la régression logistique est créé avec ces déclarations :

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 est un compteur de boucle limitant la valeur pour l'algorithme de formation PSO. Les deux 0.0 arguments passés à la méthode Train sont les poids de régularisation L1 et L2. En définissant ces poids à 0.0, aucune régularisation n'est utilisée. Qualité du modèle est évaluée avec ces deux énoncés :

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

Un des inconvénients à l'utilisation de régularisation est que les poids de régularisation doivent être déterminées. Une approche pour trouver le poids de la bonne régularisation consiste à utiliser le manuel tâtonnements, mais une technique de programmation est généralement mieux. Un bon poids de régularisation de L1 est trouvé et utilisé avec ces déclarations :

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);

Les instructions pour la formation le classifieur LR en utilisant la régularisation de L2 sont comme ceux pour l'utilisation de régularisation de L1 :

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);

Dans la démo, l'alpha1 et alpha2 valeurs ont été déterminées en utilisant les méthodes de portée publique LR en objet FindGoodL1Weight et FindGoodL2Weight et ensuite passé à la méthode Train. Une autre conception est suggérée par appeler ce code :

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

Cette approche de conception permet à la méthode de formation déterminer les poids de la régularisation et conduit à l'interface un peu plus.

Régularisation de compréhension

Parce que la régularisation de L1 et L2 sont les techniques permettant de réduire le surapprentissage modèle, afin de comprendre la régularisation, vous devez comprendre surapprentissage. Lâchement parlant, si vous vous entraînez un modèle trop, vous obtiendrez par la suite de caractères qui correspondent à des données de formation extrêmement bien, mais lorsque vous appliquez le modèle résultant de nouvelles données, la précision de prédiction est très pauvre.

Surapprentissage est illustrée par les deux graphiques dans Figure 3. Le premier graphique montre une situation hypothétique où le but est de classer les deux types d'éléments, indiqués par des points rouges et verts. La courbe bleue représente la véritable séparation des deux classes, avec des points rouges appartenance au-dessus de la courbe et les points verts appartenance au-dessous de la courbe. Notez qu'en raison des erreurs aléatoires dans les données, deux d'entre les points rouges sont au-dessous de la courbe et deux points verts sont au-dessus de la courbe. Bonne formation, où ne se produit pas surapprentissage, entraînerait de caractères qui correspondent à la courbe bleue. Supposons qu'un nouveau point de données s'est établi à (3, 7). L'élément de données serait au-dessus de la courbe et être correctement prévu pour être classe rouge.

modèle surapprentissage
Figure 3 modèle surapprentissage

Le deuxième graphique en Figure 3 a les mêmes points mais une courbe bleue différente qui est un résultat de surapprentissage. Cette fois, tous les points rouges sont au-dessus de la courbe et tous les points verts sont au-dessous de la courbe. Mais la courbe est trop complexe. Un nouvel élément de données à (3, 7) serait en dessous de la courbe et être correctement prédit comme classe vert.

Surapprentissage génère des courbes de prédiction non lisse, en d'autres termes, ceux qui ne sont pas « ordinaire ». Ces courbes de prédiction médiocre, complexes sont généralement caractérisées par des poids qui ont des valeurs très grandes ou très petites. Par conséquent, réduire le surapprentissage consiste pour empêcher des poids modèle de devenir très petites ou grandes. Il s'agit de la motivation de régularisation.

Lorsqu'un modèle ML est formé, vous devez utiliser une certaine erreur pour déterminer le bons poids. Il y a plusieurs façons de mesurer l'erreur. Une des techniques plus courantes est l'erreur quadratique moyenne, où vous trouvez la somme des différences quadratiques entre les valeurs de sortie calculées pour un ensemble de valeurs de poids et les valeurs de sortie connus, correct dans les données d'apprentissage et ensuite divisez cette somme par le nombre d'éléments de formation. Par exemple, supposons que pour un ensemble de candidats de poids de régression logistique, avec seulement trois points de la formation, les sorties calculées et sortie correcte valeurs (parfois appelé le désiré ou valeurs cibles) sont :

computed  desired
  0.60      1.0
  0.30      0.0
  0.80      1.0

Ici, l'erreur quadratique moyenne serait :

((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

Exprimée symboliquement, veut dire erreur quadratique peut être écrite :

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

où somme représente la somme accumulée au cours de tous les éléments de formation, o représente la production calculée, t est sortie de la cible et n est le nombre d'éléments de données de formation. L'erreur est quelle formation minimise en utilisant l'un d'une douzaine de techniques numériques avec des noms comme descente de gradient, itératif de Newton-Raphson, L-BFGS, optimisation de rétropropagation et essaim.

Afin d'éviter la grandeur des valeurs de poids modèle de devenir grands, l'idée de régularisation est de pénaliser les valeurs de poids en ajoutant les valeurs de poids pour le calcul de la durée de l'erreur. Si les valeurs de poids sont incluses dans le terme d'erreur totale qui est étant réduit au minimum, puis de petites valeurs de poids vont générer des valeurs d'erreur plus petites. Régularisation de poids L1 pénalise les valeurs de poids en ajoutant la somme de leurs valeurs absolues dans le terme d'erreur. Symboliquement :

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

Régularisation de L2 poids pénalise les valeurs de poids en ajoutant la somme de leurs valeurs au carré dans le terme d'erreur. Symboliquement :

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

Supposons que pour cet exemple, il y a quatre graisses à déterminer et à leurs valeurs actuelles sont (-3.0, 1.0, 2.0,-4.0). La pénalité de poids L1 ajoutée à l'erreur quadratique moyenne 0,097 serait (2.0 + 3,0 + 1.0 + 4.0) = 10.0. La pénalité de poids L2 serait 2.0 ^ 2 + - 3.0 ^ 2 + 1 ^ 2 + - 4.0 ^ 2 = 4.0 + 9.0 + 1.0 + 16,0 = 30,0.

Pour résumer, poids grand modèle peuvent conduire à surapprentissage, qui mène à la précision de prédiction médiocre. Régularisation limite l'ampleur des poids du modèle en ajoutant une pénalité pour les poids à la fonction d'erreur de modèle. Régularisation de L1 utilise la somme des valeurs absolues des poids. Régularisation de L2 utilise la somme des valeurs des poids au carré.

Pourquoi deux types différents de régularisation ?

L1 et régularisation de L2 sont similaires. Quel est le meilleur ? L'essentiel est que même si il y a quelques directives de théorie sur quelle forme de régularisation est préférable dans certains scénarios de problème, à mon avis, dans la pratique vous devez expérimenter pour trouver quel type de régularisation est mieux, ou si, en utilisant la régularisation du tout est mieux.

Il s'avère que, en utilisant la régularisation de L1 peut parfois avoir un effet secondaire bénéfique de la conduite d'une ou plusieurs valeurs de poids à 0.0, ce qui signifie en fait que la fonction associé n'est pas nécessaire. Il s'agit d'une forme de ce qu'on appelle la sélection des fonctionnalités. Par exemple, dans la démo en Figure 1, avec la régularisation de la L1, le dernier poids de modèle est 0,0. Autrement dit, que la dernière valeur de la variable explicative ne contribue pas au modèle LR. Régularisation de L2 limite les valeurs du poids du modèle, mais habituellement ne taille n'importe quel poids entièrement en les définissant à 0.0.

Ainsi, il semblerait que L1 régularisation est mieux que la régularisation de la L2. Cependant, un inconvénient de l'utilisation de régularisation de la L1 est que la technique ne peut pas être facilement utilisée avec quelques ML d'algorithmes, de la formation en particulier les algorithmes de calcul permet de calculer ce qu'on appelle un gradient. Régularisation de L2 peut être utilisée avec n'importe quel type d'algorithme de formation.

Pour résumer, L1 régularisation parfois a un agréable effet secondaire d'élagage les fonctionnalités inutiles en définissant leurs poids associés à 0.0, mais L1 régularisation ne fonctionne facilement avec toutes les formes de la formation. L2 régularisation fonctionne avec toutes les formes de formation, mais ne donne pas de sélection de fonction implicite. Dans la pratique, vous devez utiliser tâtonnements pour déterminer quel formulaire de régularisation (ou aucun) est préférable pour un problème particulier.

Mise en œuvre de la régularisation

Il est relativement facile de mise en œuvre de la régularisation de L1 et L2. Le programme de démonstration utilise la formation PSO avec une fonction d'erreur explicite, donc tout ce qui est nécessaire est d'ajouter les peines de poids L1 et L2. La définition de méthode erreur commence par :

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);
  }
...

La première étape consiste à calculer l'erreur quadratique moyenne en additionnant les différences quadratiques entre les sorties calculées et sorties de la cible. (Une autre forme courante d'erreur est appelée entropie croisée erreur.) Ensuite, la peine de L1 est calculée :

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

Puis la peine de L2 est calculée :

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

Erreur de méthode retourne le MSE plus les pénalités :

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

La démonstration utilise une fonction d'erreur explicite. Certains algorithmes de formation, tels que la descente de gradient et rétropropagation, utilisent la fonction d'erreur implicitement en calculant la dérivée partielle de calcul (appelée le gradient) de la fonction erreur. Pour les algorithmes de formation, d'utiliser L2 régularisation (parce que la dérivée de w ^ 2 est de 2w), vous il suffit d'ajouter un terme 2w au gradient (bien que les détails peuvent être un peu compliquées).

Trouver la bonne régularisation de caractères

Il y a plusieurs façons de trouver un poids de régularisation bonne (mais pas nécessairement optimale). Le programme de démonstration met en place un ensemble de valeurs de candidat, calcule l'erreur associée à chaque candidat et retourne le meilleur candidat trouvé. La méthode pour trouver un bon poids de L1 commence :

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);

Ajout d'autres candidats vous donnerait une meilleure chance de trouver un poids optimal de régularisation au détriment du temps. Ensuite, chaque candidat est évalué et trouvé le candidat le mieux placé est retourné :

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;
}

Notez le poids de régularisation du candidat est utilisé pour former le classificateur d'évaluation, mais l'erreur est calculée sans le poids de la régularisation.

Jaquette en haut

Régularisation peut être utilisée avec n'importe quelle technique de classification ML qui repose sur une équation mathématique. Exemples : régression logistique, classification probit et réseaux de neurones. Parce qu'elle réduit l'ampleur des valeurs de poids dans un modèle, régularisation est parfois appelée carie de poids. Le principal avantage de l'utilisation de régularisation est qu'elle aboutit souvent à un modèle plus précis. L'inconvénient majeur est qu'il introduit une valeur de paramètre supplémentaire qui doit être déterminée, le poids de la régularisation. Dans le cas de la régression logistique ce n'est pas trop grave car il y a habituellement seulement l'apprentissage taux paramètre, mais lors de l'utilisation des techniques de classification plus complexes, neural des réseaux en particulier, ajout d'un autre hyperparameter ce que l'on appelle peut créer beaucoup de travail supplémentaire pour régler les somme des valeurs des paramètres.

Dr. James McCaffrey travaille pour Microsoft Research à Redmond, Washington  Il a travaillé sur plusieurs produits Microsoft, y compris Internet Explorer et Bing. Dr. McCaffrey est joignable au jammc@microsoft.com.

Grâce à l'expert technique suivante Microsoft Research pour avoir relu cet article : Richard Hughes