Il presente articolo è stato tradotto automaticamente.

Esecuzione di test

Regolarizzazione L1 e L2 per Machine Learning

James McCaffrey

Scaricare il codice di esempio

Regolarizzazione L1 e L2 regolarizzazione sono due tecniche strettamente correlate che consentono di algoritmi di addestramento (ML) di apprendimento automatico per ridurre il sovradattamento modello. Eliminando il sovradattamento conduce ad un modello che fa le migliori previsioni. In questo articolo spiegherò cosa regolarizzazione è da punto di vista di uno sviluppatore di software. Le idee dietro la regolarizzazione sono un po ' complicate da spiegare, non perché sono difficili, ma piuttosto perché ci sono parecchie idee interconnessi

In questo articolo illustro la regolarizzazione con classificazione di regressione logistica (LR), ma la regolarizzazione può essere utilizzato con molti tipi di macchina di apprendimento, in particolare classificazione di rete neurale. L'obiettivo della classificazione di LR è quello di creare un modello che predice la variabile che può assumere uno dei due valori possibili. Ad esempio, si potrebbe voler predire il risultato per una squadra di calcio (perdere = 0, vincere = 1) in un prossimo gioco basato sulla squadra attuale percentuale di vincita (1), la posizione di campo (2) e numero di giocatori assenti per infortunio (3).

Se Y è il valore previsto, un modello di LR per questo problema assumerebbe la forma:

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

Qui b0, b1, b2 e b3 sono pesi, che sono valori numerici solo che devono essere determinati. In parole, calcolare un valore z che è la somma dei valori di input volte b-pesi, aggiungere una costante b0, poi passare il valore z dell'equazione che utilizza la matematica e costante. Si scopre che Y sarà sempre compreso tra 0 e 1. Se Y è inferiore a 0.5, si concludono l'uscita prevista è 0 e se Y è maggiore di 0,5 si concludono che l'output è 1. Si noti che se ci sono caratteristiche n, ci sarà n + 1 b-pesi.

Si supponga, ad esempio, una squadra attualmente ha una percentuale di vincita di 0,75, si esibiranno al campo dell'avversario (-1) e ha 3 giocatori fuori per infortunio. E supponiamo che b0 = 5.0, b1 = 8.0, b2 = 3.0 e b3 =-2.0. Quindi z = 5.0 + (8.0)(0.75) + (3.0)(-1) + (-2.0)(3) = 2.0 e quindi Y = 1.0 / (1.0 + e ^-2.0) = 0.88. Perché Y è maggiore di 0,5, si sarebbe prevedere che la squadra vincerà il loro prossimo gioco.

Penso che il modo migliore per spiegare la regolarizzazione è esaminando un esempio concreto. Guarda lo screenshot di un programma demo in Figura 1. Invece di utilizzare dati reali, il programma demo inizia generando 1.000 elementi di dati sintetici. Ogni elemento ha 12 variabili predittive (spesso chiamate "caratteristiche" nella terminologia ML). Il valore della variabile dipendente è nell'ultima colonna. Dopo aver creato gli elementi di dati di 1.000, il set di dati in modo casuale venne divisa in un set di training 800-elemento da utilizzare per trovare che i modello b-pesi e un 200 elementi prova insieme per essere utilizzati per valutare la qualità del modello risultante.

Figura 1 regolarizzazione con classificazione di regressione logistica

Successivamente, il programma demo addestrato il classificatore LR, senza utilizzare la regolarizzazione. Il modello risultante aveva 85.00 per cento di accuratezza dei dati di training e 80.50 percento su dati di test. Il percento di 80.50 è il più rilevante dei due valori ed è una stima approssimativa di come precisa si potrebbe aspettare che il modello sia quando sono presentati con nuovi dati. Come spiegherò in breve, il modello era troppo montato, che conduce all'accuratezza di previsione mediocri.

Successivamente, la demo ha alcune elaborazioni per trovare un buon peso di regolarizzazione L1 e L2 regolarizzazione peso buono. Regolarizzazione pesi sono solo valori numerici che vengono utilizzati dal processo di regolarizzazione. Nella demo, un buon peso L1 è stato determinato per essere 0,005 e un buon peso L2 è stato 0.001.

La demo per la prima volta formazione mediante regolarizzazione L1 e poi nuovamente con regolarizzazione di L2. Con regolarizzazione L1, modello LR risultante aveva 95.00 percento su dati di test, e con regolarizzazione di L2, il modello LR aveva 94.50 percento su dati di test. Entrambe le forme di regolarizzazione significativamente migliorata la precisione di stima.

Questo articolo presuppone che si hanno competenze di programmazione almeno intermedie, ma non si assume che si sa nulla di regolarizzazione L1 o L2. Il programma demo è codificato utilizzando c#, ma non dovreste avere troppe difficoltà refactoring del codice ad un altro linguaggio come JavaScript o Python.

Il codice demo è troppo lungo per presentare qui, ma il codice sorgente completo è disponibile nel download del codice che accompagna questo articolo. Il codice demo ha tutti rimossi per mantenere piccole le idee più chiaro possibile e la dimensione del codice di controllo degli errori normali.

Struttura generale del programma

La struttura generale del programma, con alcune modifiche minori per risparmiare spazio, è presentata Figura 2. Per creare la demo, lanciato Visual Studio e creato una nuova applicazione console c# denominata regolarizzazione. La demo non ha significative Microsoft .NET Framework dipendenze, quindi ogni versione recente di Visual Studio funzionerà.

Figura 2 struttura generale del programma

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

Dopo il codice del modello caricato nell'editor Visual Studio , nella finestra Solution Explorer sono stati rinominati file Program.cs per la auto più descrittivo di RegularizationProgram.cs e Visual Studio ­maticamente ribattezzata classe programma per me. All'inizio del codice sorgente, ho eliminato tutti utilizzando le istruzioni che puntava a spazi dei nomi non necessari, lasciando solo il riferimento per il primo livello dello spazio dei nomi System.

Tutta la logica di regressione logistica è contenuto in una singola classe di LogisticClassifier. La logistica­classe classificatore contiene un helper annidato classe particella per incapsulare l'ottimizzazione di sciame di particelle (PSO), l'algoritmo di ottimizzazione utilizzato per la formazione. Si noti che la classe LogisticClassifier contiene un errore, che accetta parametri denominati alfa1 e alfa2 del metodo. Questi parametri sono i pesi di regolarizzazione per regolarizzazione L1 e L2.

Nel metodo Main, i dati sintetici sono creati con queste istruzioni:

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

Il valore di inizializzazione di 42 è stato utilizzato solo perché tale valore dato uscita demo bello, rappresentante. Metodo MakeAllData genera 13 pesi casuali tra-10.0 e + 10,0 (un peso per ogni caratteristica, più il b0). Quindi il metodo scorre 1.000 volte. Ad ogni iterazione, viene generato un insieme casuale di 12 valori di input, quindi un valore di output di regressione logistica intermedia viene calcolato utilizzando i pesi casuali. Un valore casuale aggiuntivo viene aggiunto all'uscita per rendere i dati rumorosi e più inclini a sovradattamento.

I dati sono divisa in un set di item-800 per la formazione e un set di 200 elementi per la valutazione del modello con queste istruzioni:

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

Un modello di previsione di regressione logistica è creato con queste istruzioni:

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

MaxEpochs variabile è un contatore di cicli limitando il valore per l'algoritmo di training PSO. I due 0.0 argomenti passati al metodo treno sono i pesi di regolarizzazione L1 e L2. Impostando questi pesi a 0.0, nessuna regolarizzazione viene utilizzato. Qualità del modello viene valutato con queste due istruzioni:

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

Uno degli svantaggi di usando la regolarizzazione è che i pesi di regolarizzazione devono essere determinati. Per trovare i pesi buona regolarizzazione è possibile utilizzare manuale prova ed errore, ma una tecnica programmatica è solitamente migliore. Un buon peso di regolarizzazione L1 è trovato e poi utilizzato con queste istruzioni:

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

Le istruzioni per la formazione del classificatore LR usando L2 regolarizzazione sono proprio come quelli per l'utilizzo di regolarizzazione 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);

Nella demo, i valori di alfa1 e alfa2 sono stati determinati utilizzando i metodi di pubblico-ambito oggetto LR FindGoodL1Weight e FindGoodL2Weight e quindi passato al metodo treno. Un design alternativo è suggerito chiamando questo codice:

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

Questo approccio progettuale consente il metodo di allenamento determinare i pesi di regolarizzazione e conduce all'interfaccia un po' più pulito.

Regolarizzazione di comprensione

Perché la regolarizzazione L1 e L2 sono le tecniche per ridurre il modello sovradattamento, al fine di comprendere la regolarizzazione, è necessario capire il sovradattamento. Senza bloccare parlando, se ti alleni un modello troppo, alla fine si ottengono pesi che inseriscono i dati di allenamento estremamente bene, ma quando si applica il modello risultante a nuovi dati, l'accuratezza della previsione è molto povera.

Sovradattamento è illustrata da due grafici in Figura 3. Il primo grafico mostra una situazione ipotetica dove l'obiettivo è quello di classificare due tipi di elementi, indicati da puntini rossi e verdi. La curva blu uniforme rappresenta la vera separazione delle due classi, con puntini rossi, appartenendo di sopra della curva e punti verdi, appartenendo di sotto della curva. Si noti che a causa di errori casuali nei dati, due dei punti rossi sono di sotto della curva e due punti verdi sono di sopra della curva. Buon allenamento, dove sovradattamento non si verifica, si tradurrebbe in pesi che corrispondono alla curva blu liscia. Supponiamo che un nuovo punto di dati arriva a (3, 7). L'elemento di dati sarebbe sopra la curva e preveduta correttamente essere classe rosso.

Figura 3 modello sovradattamento

Il secondo grafico in Figura 3 ha i puntini stessi ma una diversa curva blu che è un risultato di sovradattamento. Questa volta tutti i puntini rossi sono di sopra della curva e tutti i punti verdi sono di sotto della curva. Ma la curva è troppo complessa. Un nuovo elemento di dati a (3, 7) sarebbe sotto la curva e di essere stimato in modo errato come verde di classe.

Sovradattamento genera curve di previsione non-liscia, in altre parole, quelli che non sono "regolari". Tali curve di poveri, complesso di previsione sono solitamente caratterizzati da pesi che hanno valori molto grandi o molto piccoli. Quindi, un modo per ridurre il sovradattamento deve evitare pesi modello diventi molto piccolo o grande. Questa è la motivazione per la regolarizzazione.

Quando un modello ML è allenato, è necessario utilizzare qualche misura di errore per determinare pesi buoni. Ci sono diversi modi per misurare l'errore. Una delle tecniche più comuni è l'errore medio al quadrato, dove trovare la somma delle differenze al quadrato tra i valori di output computata per un set di valori di peso e i valori di output corretto, noto in dati di training e quindi dividere tale somma per il numero di elementi di formazione. Ad esempio, supponiamo che per un insieme di candidati di pesi di regressione logistica, con solo tre elementi di formazione, le uscite calcolate e output corretto valori (a volte chiamato il desiderato o valori-obiettivo) sono:

computed  desired
  0.60      1.0
  0.30      0.0
  0.80      1.0

Qui, sarebbe l'errore medio al quadrato:

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

Espresso simbolicamente, significa errore quadrato può essere scritta:

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

dove somma rappresenta la somma accumulata nel corso di tutti gli elementi di formazione, o rappresenta l'uscita calcolata, t è l'output di destinazione e n è il numero di elementi di dati di addestramento. L'errore è che tipo di formazione minimizza utilizzando una delle tecniche numeriche di una decina con nomi come gradiente di discesa, iterativo di Newton-Raphson, L-BFGS, retro-propagazione e sciame di ottimizzazione.

Al fine di evitare la grandezza dei valori di peso modello diventi grande, l'idea della regolarizzazione è di penalizzare i valori di peso aggiungendo quei valori di peso per il calcolo del termine di errore. Se i valori di peso sono inclusi nel termine errore totale che è essere minimizzato, valori di peso inferiori genererà più piccoli valori di errore. Regolarizzazione del peso L1 penalizza i valori di peso aggiungendo la somma dei loro valori assoluti per il termine di errore. Simbolicamente:

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

Regolarizzazione del peso L2 penalizza i valori di peso aggiungendo la somma dei loro valori al quadrato per il termine di errore. Simbolicamente:

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

Suppongo che questo esempio ci sono quattro pesi da determinarsi e loro valori correnti sono (2.0,-3.0, 1.0,-4.0). La pena di peso L1 aggiunta per errore al quadrato medio 0.097 sarebbe (2.0 + 3.0 + 1.0 + 4.0) = 10.0. La pena di peso L2 sarebbe 2.0 ^ 2 + - 3.0 ^ 2 + 1.0 ^ 2 + - 4.0 ^ 2 = 4.0 + 9,0 + 1.0 + 16.0 = 30.0.

Per riassumere, pesi grande modello possono portare a sovradattamento, che conduce alla precisione scarsa stima. Regolarizzazione limita la grandezza dei pesi modello aggiungendo una penalità per i pesi per la funzione di errore di modello. Regolarizzazione L1 utilizza la somma dei valori assoluti dei pesi. Regolarizzazione L2 utilizza la somma dei valori al quadrato dei pesi.

Perché due tipi diversi di regolarizzazione?

L1 e L2 regolarizzazione sono simili. Quale è meglio? La linea di fondo è che anche se ci sono alcune linee guida teoria su quale forma di regolarizzazione è meglio in determinati scenari di problema, a mio parere, in pratica che si deve sperimentare per individuare quale tipo di regolarizzazione è meglio, o se usando la regolarizzazione a tutti è meglio.

Come si scopre, mediante regolarizzazione L1 a volte può avere un effetto benefico sul lato di guida di uno o più valori di peso a 0.0, che in pratica significa che non è necessaria la funzionalità associato. Questa è una forma di quello che ha chiamato la funzionalità di selezione. Ad esempio, nella demo eseguito Figura 1, con regolarizzazione L1 l'ultimo modello peso è 0.0. Questo significa che l'ultimo valore predittive non contribuisce al modello LR. Regolarizzazione L2 limita i valori di peso modello, ma di solito non potare qualsiasi pesi interamente impostando loro 0.0.

Quindi, sembrerebbe che la regolarizzazione L1 è meglio di regolarizzazione di L2. Tuttavia, un aspetto negativo dell'utilizzo di regolarizzazione L1 è che la tecnica non può essere utilizzata facilmente con alcuni ML formazione algoritmi, in particolare quelli algoritmi che utilizzano il calcolo per calcolare quello che ha chiamato un gradiente. Regolarizzazione L2 può essere utilizzato con qualsiasi tipo di algoritmo di training.

Per riassumere, regolarizzazione L1 a volte ha un piacevole effetto collaterale di potatura le funzionalità non necessarie impostando loro pesi associati a 0.0 ma regolarizzazione L1 non funziona facilmente con tutte le forme di allenamento. Regolarizzazione L2 funziona con tutte le forme di addestramento, ma non ti dà la caratteristica implicita di selezione. In pratica, è necessario utilizzare tentativi per determinare quale forma di regolarizzazione (o nessuno) è meglio per un problema particolare.

Implementazione di regolarizzazione

L'implementazione di regolarizzazione L1 e L2 è relativamente facile. Il programma demo utilizza formazione PSO con una funzione di errore esplicito, quindi tutto ciò che è necessario è quello di aggiungere le sanzioni di peso L1 e L2. La definizione del metodo errore inizia con:

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

Il primo passo è quello di calcolare l'errore di medio quadrato sommando le differenze al quadrato tra uscite calcolate e destinazione. (Un'altra forma comune di errore è chiamata errore di croce-entropia). Successivamente, la pena di L1 è calcolata:

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

Quindi la pena di L2 è calcolata:

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

Errore del metodo restituisce il MSE più le sanzioni:

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

La demo utilizza una funzione di errore esplicito. Alcuni algoritmi di addestramento, come discesa gradiente e retro-propagazione, utilizzano la funzione di errore implicitamente calcolando la derivata parziale calcolo (chiamata il gradiente) della funzione errore. Per questi algoritmi di addestramento, utilizzare L2 regolarizzazione (perché la derivata di w ^ 2 è 2w), basta aggiungere un termine 2w al gradiente (anche se i dettagli possono essere un po' complicati).

Trovando buona regolarizzazione pesi

Ci sono diversi modi per trovare un peso di regolarizzazione buona (ma non necessariamente ottimale). Il programma demo imposta un insieme di valori di candidato, calcola l'errore associato a ciascun candidato e restituisce il miglior candidato trovato. Il metodo per trovare un buon peso L1 inizia:

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

L'aggiunta di ulteriori candidati si darebbe una migliore possibilità di trovare un peso ottimale regolarizzazione a scapito del tempo. Successivamente, ogni candidato viene valutato e viene restituito il miglior candidato trovato:

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

Notare il peso di regolarizzazione del candidato è usato per addestrare il classificatore di valutazione, ma l'errore è calcolato senza il peso di regolarizzazione.

Il confezionamento

Regolarizzazione può essere utilizzato con qualsiasi tecnica di classificazione ML che si basa su un'equazione matematica. Gli esempi includono la regressione logistica, classificazione probit e reti neurali. Perché riduce le magnitudini dei valori di peso in un modello, regolarizzazione è talvolta chiamato decadimento di peso. Il principale vantaggio dell'utilizzo di regolarizzazione è che spesso conduce ad un modello più preciso. Lo svantaggio principale è che introduce un valore di parametro aggiuntivo che deve essere determinato, il peso di regolarizzazione. Nel caso di regressione logistica non è troppo grave perché di solito c'è solo l'apprendimento tasso parametro, ma quando si utilizza tecniche di classificazione più complesse, neurale reti in particolare, aggiungendo un altro cosiddetto hyperparameter può creare un sacco di lavoro aggiuntivo per ottimizzare i valori combinati di parametri.

Dr. James McCaffrey lavora per la ricerca di Microsoft di Redmond, WA  Ha lavorato su diversi prodotti Microsoft, inclusi Internet Explorer e Bing. Dr. McCaffrey può essere raggiunto a jammc@microsoft.com.

Grazie all'esperto tecnica seguente presso Microsoft Research per la revisione di questo articolo: Richard Hughes