Il presente articolo è stato tradotto automaticamente.

Esecuzione di test

Classificazione e previsione mediante reti neurali

James McCaffrey

Scarica il codice di esempio

In mese questo, spiegherò come utilizzare le reti neurali per risolvere i problemi di classificazione e previsione. L'obiettivo della classificazione è meglio spiegato da esempio. Si supponga di che disporre di alcuni dati storici sui fiori di iris che assomiglia a:

5.1 3,5 1,4 0,2 Setosa
7.0 3.2 4.7 1,4 Versicolor
6,3 3,3 6,0 2,5 Virginica
6,4 3.2 4,5 1,5 Versicolor
...

Ogni riga di dati delimitati da spazi ha cinque campi. I primi quattro campi numerici sono sepalo (il rivestimento verde germoglio), sepalo lunghezza, lunghezza petalo (la parte colorata del fiore) e larghezza del petalo. Il quinto campo è la specie: Setosa, Versicolor o Virginica. L'obiettivo della classificazione è quello di determinare un'equazione o un insieme di regole che predice quale specie o classe un iride appartiene al. Quindi il set di regole può essere utilizzato per predire la classe di un nuovo iris basata sui suoi valori per larghezza e lunghezza del petalo e sepalo. Questi dati di pianta di iris sono un classico esempio la prima volta da R. A. Fisher nel 1936. Esso non può eccitare, ma la classificazione è estremamente importante. Esempi di classificazione di rating di credito del richiedente, basata su variabili quali spese mensili e di reddito (o, equivalentemente, predicendo loro merito di credito) e la classificazione di un paziente ospedaliero ha il cancro sulla base dei valori da un esame del sangue.

Ci sono molti approcci per la classificazione dei dati, compreso l'uso delle reti neurali. Un modo per pensare a reti neurali è che essi sono dispositivi di input-output virtuali che accettano qualsiasi numero di input numerico e producono qualsiasi numero di uscite numeriche. Il modo migliore per vedere dove sono diretto è quello di esaminare lo screenshot in Figura 1 e l'immagine in Figura 2. Figura 1 Mostra la classificazione di rete neurale in azione. Per mantenere i concetti di classificazione utilizzando reti neurali chiaro, io non uso i dati reali. Invece ho usato dati artificiali dove i valori di input x sono quattro valori numerici arbitrari con nessun significato particolare. Y-variabile di output di classificare è colore, e si può prendere uno dei tre valori categorici: rosso, verde o blu. Il programma mostrato Figura 1 inizia con la generazione di un file di testo con 100 righe di dati artificiali (ad esempio, "8,0 5,0 9,0 5,0 verde") e quindi Visualizza le prime quattro righe di dati. Successivamente, il programma legge il file di dati raw in memoria come una matrice di formazione con 80 righe di dati e una matrice di test con 20 righe. Si noti che due trasformazioni vengono applicate ai dati grezzi. I dati grezzi di input numerici sono normalizzati, così che tutti i valori sono compresi tra-1.00 e +1.00, e i dati di output raw (come il "rosso") sono codificati in un vettore con tre valori ("1,0 0,0 0,0").

Figura 1 classificazione rete neurale in azione

Figura 2 struttura di rete neurale

Dopo la creazione del training e test matrici, il programma demo crea una rete neurale feed-forward completamente connessa con tre neuroni di input, cinque neuroni nascosti per calcolo e tre neuroni di output. Si scopre che un 4-5-3 rete neurale completamente collegato richiede 43 pesi e pregiudizi. Successivamente, il programma di classificazione analizza i dati di allenamento per trovare i migliori 43 pesi e pregiudizi (quelli che minimizzano l'errore di classificazione totale). Il programma utilizza particle swarm optimization insieme a cross-entropy errore per stimare i valori migliori dei pesi e pregiudizi.

Il programma di classificazione quindi carica i migliori pesi e pregiudizi nella rete neurale e valuta l'accuratezza predittiva del modello su 20 righe di dati nella matrice del test. Si noti che l'output della rete neurale è stato progettato affinché i valori di tre output somma a 1.0. In questo esempio, il modello predice correttamente 17 dei vettori 20 test. L'immagine in Figura 2 illustra la rete neurale accettare input (-1.00, 1.00, 0,25 -0,50) e generando un output previsto (0,9, 0.1, 0.0), che corrisponde al rosso.

Il programma di esempio fa notare che ci sono cinque principali decisioni da prendere quando si utilizzano reti neurali per la classificazione dove i dati di input sono di tipo numerici e la data di uscita è categorico:

1. Come normalizzare i dati di input numerici
2. Come codificare i dati in uscita categorico
3. Come generare output neurali nell'intervallo [0.0, 1.0]
4. Come si misura l'errore quando ci si allena
5. Come misurare la precisione durante il test

Nelle sezioni che seguono ti spiego che le scelte fatte nel programma di esempio sono:

1. Eseguire una trasformazione lineare su dati di input numerici
2. 1-Di-N codifica per dati categoriali output
3. Utilizzare una funzione di attivazione Softmax per il livello di output
4. Utilizzare cross-entropy errore per determinare i migliori pesi
5. Utilizzare un approccio winner-take-all per determinare la precisione

Il codice di programma che ha generato lo screenshot in Figura 1 è un po' troppo lunga per presentare in questo articolo, in modo da concentrarsi sugli algoritmi utilizzati invece. La fonte del programma completo è disponibile dal sito di download di codice MSDN a archive.msdn.microsoft.com/mag201207TestRun. Questo articolo presuppone che si sono avanzate competenze di programmazione e una conoscenza di base delle reti neurali. Spiego basi rete neurale nel numero di maggio 2012 di MSDN Magazine (msdn.microsoft.com/magazine/hh975375).

Struttura generale del programma

Figura 3 elenca la struttura del programma di esempio illustrato in esecuzione in Figura 1. Ho utilizzato Visual Studio 2010 per creare una singola applicazione console c# denominata NeuralClassification. Nella finestra Esplora soluzioni, ho rinominato il file Program. cs per il NeuralClassificationProgram.cs più descrittivo, che automaticamente rinominato la classe contenente principale. Rimosso non necessari utilizzando le istruzioni che sono state generate dal modello di Visual Studio e aggiunto un riferimento allo spazio dei nomi System. io.

Figura 3 struttura di programma di classificazione neurale

using System;
using System.IO;
namespace NeuralClassification
{
  class NeuralClassificationProgram
  {
    static Random rnd = null;
    static void Main(string[] args)
    {
      try
      {
        Console.WriteLine("\nBegin Neural network classification\n");
        rnd = new Random(159); // 159 makes a nice example
        string dataFile = "..
\\..
\\colors.txt";
        MakeData(dataFile, 100);
        double[][] trainMatrix = null;
        double[][] testMatrix = null;
        MakeTrainAndTest(dataFile, out trainMatrix, out testMatrix);
        NeuralNetwork nn = new NeuralNetwork(4, 5, 3);
        double[] bestWeights = nn.Train(trainMatrix);
        nn.SetWeights(bestWeights);
        double accuracy = nn.Test(testMatrix);
        Console.WriteLine("\nEnd neural network classification\n");
      }
      catch (Exception ex)
      {
        Console.WriteLine("Fatal: " + ex.Message);
      }
    } // Main()
    static void MakeData(string dataFile, int numLines) { ...
}
    static void MakeTrainAndTest(string file, out double[][] trainMatrix,
      out double[][] testMatrix) { ...
}
  }
  class NeuralNetwork
  {
    // Class member fields here
    public NeuralNetwork(int numInput, int numHidden,
      int numOutput) { ...
}
    public void SetWeights(double[] weights) { ...
}
    public double[] ComputeOutputs(double[] currInputs) { ...
}
    private static double SigmoidFunction(double x) { ...
}
    private static double[] Softmax(double[] hoSums) { ...
}
    public double[] Train(double[][] trainMatrix) { ...
}
    private double CrossEntropy(double[][] trainData,
      double[] weights) { ...
}
    public double Test(double[][] testMatrix) { ...
}
  }
  public class Helpers
  {
    static Random rnd = new Random(0);
    public static double[][] MakeMatrix(int rows, int cols) { ...
}
    public static void ShuffleRows(double[][] matrix) { ...
}
    public static int IndexOfLargest(double[] vector) { ...
}
    public static void ShowVector(double[] vector, int decimals,
      bool newLine) { ...
}
    public static void ShowMatrix(double[][] matrix, int numRows) { ...
}
    public static void ShowTextFile(string textFile, int numLines) { ...
}
  }
  public class Particle
  {
    // Class member fields here
    public Particle(double[] position, double fitness,
      double[] velocity, double[] bestPosition,
     double bestFitness) { ...
}
    public override string ToString() { ...
}
  }
} // ns

Oltre alla classe che contiene il metodo Main, il programma ha altre tre classi. Classe NeuralNetwork incapsula una rete neurale feed-forward completamente collegata. Tutta la logica del programma di nucleo è contenuto in questa classe. Classe helper contiene sei utility routines. Classe particella definisce un oggetto particella che viene utilizzato dall'algoritmo di ottimizzazione sciame particella nel metodo treno della classe NeuralNetwork. Una caratteristica dei programmi di classificazione è che ci sono molte strutture di programma possibile; l'organizzazione ha presentato qui è solo una possibilità.

Generare il file di dati Raw.

Nella maggior parte degli scenari di classificazione si avrà già un set di dati grezzi, ma per questo articolo ho creato fittizi dati raw utilizzando il metodo MakeData. Qui è il processo in pseudo-codice:

create 43 arbitrary weights between -2.0 and +2.0
create a 4-5-3 neural network
load weights into the neural network
open a result file for writing
loop 100 times
  generate four random inputs x0, x1, x2, x3 between 1.0 and 9.0
  compute the y0, y1, y2 neural outputs for the input values
  determine largest of y0, y1, y2
  if y0 is largest write x0, x1, x2, x3, red
  else if y1 is largest write x0, x1, x2, x3, green
  else if y2 is largest write x0, x1, x2, x3, blue
end loop
close result file

L'obiettivo qui è quello di ottenere alcuni dati che sono sicuramente classificabili con una precisione del 100 per cento, piuttosto che dati casuali dove ha non è chiaro quanto efficace sarebbe qualsiasi approccio di classificazione. In altre parole, utilizzare una rete neurale per creare dati raw e poi ricominciare e utilizzare una rete neurale per tentare di classificare i dati.

Creazione del Training e test matrici

Durante l'esecuzione di analisi di classificazione con un set di dati esistenti, un approccio comune, chiamato convalida di dati di controllo, è di dividere i dati in un set di dati più grande (spesso 80 per cento) per la formazione della rete neurale e un set di dati più piccolo (20 per cento) per il test del modello. Formazione significa trovare i pesi della rete neurale e pregiudizi che minimizzare qualche valore di errore. Test significa valutare la rete neurale con i migliori pesi trovati durante l'allenamento, con qualche misura di precisione. Qui, il metodo MakeTrainAndTest crea training e test matrici e inoltre normalizza i dati di input numerici e codifica i dati di output categorico. In pseudo-codice, il metodo funziona come questo:

determine how many rows to split data into
create a matrix to hold all data
loop
  read a line of data
  parse each field
  foreach numeric input
    normalize input to between -1.0 and +1.0
  end foreach
  encode categorical output using 1-of-N
  place normalized and encoded data in matrix
end loop
shuffle matrix
create train and test matrices
transfer first 80% rows of matrix to train, remaining rows to test

La firma del metodo è:

static void MakeTrainAndTest(string file, out double[][] trainMatrix,
  out double[][] testMatrix)

Il parametro chiamato file è il nome del file di dati raw per creare. TestMatrix e trainMatrix i parametri sono parametri di output dove sono collocati i risultati. Il metodo inizia con:

int numLines = 0;
FileStream ifs = new FileStream(file, FileMode.Open);
StreamReader sr = new StreamReader(ifs);
while (sr.ReadLine() != null)
  ++numLines;
sr.Close(); ifs.Close();
int numTrain = (int)(0.80 * numLines);
int numTest = numLines - numTrain;

Questo codice conta il numero di righe nel file di dati raw e quindi Calcola quante linee costituiscono l'80 per cento e 20 per cento dei dati. Qui, le percentuali sono hard-coded; si consiglia di impostare parametri per loro. Successivamente, viene allocata una matrice che conterrà tutti i dati:

double[][] allData = new double[numLines][];
  for (int i = 0; i < allData.Length; ++i)
    allData[i] = new double[7];

Ci sono sette colonne: una colonna per ciascuna delle quattro input numerico e tre colonne per il valore codificato 1-di-N della variabile categoriale colore. Ricordiamo che in questo esempio, l'obiettivo è di predire il colore, che può essere uno dei tre valori categorici: rosso, verde o blu. Codifica utilizzando la tecnica 1-di-N in questa situazione significa codifica verde rosso (1.0, 0.0, 0.0), come (1.0, 0.0, 0.0) e blu (0.0, 0.0, 1.0). Dati categoriali devono essere codificati numericamente perché le reti neurali occupano direttamente solo valori numerici. Si scopre che codifica colore utilizzando un approccio semplice, ad esempio 1 per il rosso, 2 per il verde e 3 per l'azzurro è una cattiva idea. La spiegazione del perché questo è cattivo è un po ' lunga e di fuori della portata di questo articolo.

Un'eccezione alla direttiva codifica 1-di-N per i dati di output categorico è che quando ci sono solo due possibili valori, ad esempio "maschio" o "femmina", è possibile utilizzare 1-of-(N-1) codifica dove avete un valore singolo output numerici che, ad esempio, 0.0 significa maschio e 1,0 significa femmina.

La codifica viene eseguita da questo codice:

tokens = line.Split(' ');
allData[row][0] = double.Parse(tokens[0]);
allData[row][1] = double.Parse(tokens[1]);
allData[row][2] = double.Parse(tokens[2]);
allData[row][3] = double.Parse(tokens[3]);
for (int i = 0; i < 4; ++i)
  allData[row][i] = 0.25 * allData[row][i] - 1.25;
if (tokens[4] == "red") {
  allData[row][4] = 1.0; 
  allData[row][5] = 0.0; 
  allData[row][6] = 0.0; }
else if (tokens[4] == "green") {
  allData[row][4] = 0.0; 
  allData[row][5] = 1.0; 
  allData[row][6] = 0.0; }
else if (tokens[4] == "blue") {
  allData[row][4] = 0.0; 
  allData[row][5] = 0.0; 
  allData[row][6] = 1.0; }

Ricordiamo che una riga di dati grezzi assomiglia a questo:

8.0 5.0 9.0 5.0 green

I cinque campi sono analizzati utilizzando split. L'esperienza ha dimostrato che nella maggior parte dei casi, risultati migliori si ottengono quando l'input numerico è ridotta a valori tra -1.0 e 1,0. Ognuno dei primi quattro input numerico viene convertito da moltiplicare per 0,25 e sottraendo 1.25. Ricordiamo che l'input numerico nel file di dati fittizi sono tutti fra 1.0 e 9.0. In un problema di classificazione real, si avrebbe analizzare i dati grezzi e determinare i valori minimo e massimo. Vogliamo -1,0 per corrispondere all'1.0 e 1,0 per corrispondere alla 9.0. Facendo una trasformazione lineare significa trovare la pendenza (0,25 qui) e l'intercetta (1,25). Questi valori possono essere calcolati come:

slope = 2 / (max value - min value) = 2 / (9.0 - 1.0) = 0.25
intercept = 1.0 - (slope * max value) = 1 - (0.25 * 9.0) = -1.25

Ci sono molte alternative all'esecuzione di una trasformazione lineare su valori di input numerici, ma l'approccio qui presentato è semplice e un buon punto di partenza nella maggior parte delle situazioni.

Dopo che sono stati trasformati i quattro valori di input numerici, il valore del colore dal file di dati raw viene codificato utilizzando la codifica 1-di-N. Quando tutti i valori nel file di dati raw sono stati calcolati e inseriti nella matrice allData, che matrix ha proprie righe riorganizzate in modo casuale utilizzando il metodo di utilità ShuffleRows nella classe helper. Dopo che l'ordine delle righe allData è stato mischiato, viene allocato spazio per matrici trainMatrix e testMatrix, poi le prime righe di numTrain di allData vengono copiate in trainMatrix e le rimanenti righe numTest di allData vengono copiate in testMatrix.

Un'alternativa di progettazione importante per l'approccio al treno-test è di dividere i dati grezzi in tre set: treno, convalidare e test. L'idea è di utilizzare i dati del treno per determinare il migliore set di pesi della rete neurale in combinazione con i dati di convalida, che viene utilizzati per sapere quando smettere di formazione. Ci sono altri approcci pure, collettivamente chiamati tecniche di cross-validazione.

La funzione di attivazione Softmax

Quando si esegue la classificazione utilizzando una rete neurale dove la variabile di output è categorica, c'è una relazione piuttosto difficile tra la funzione di attivazione uscita rete neurale, errore di calcolo durante l'addestramento e l'accuratezza predittiva della rete neurale di calcolo. Quando i dati di output categoriali (ad esempio colore con valori rosso, verde o blu) sono codificati utilizzando la codifica 1-di-N — per esempio, (1.0 0.0 0.0) per rosso — si desidera che la rete neurale di emettere tre valori numerici, quindi è possibile determinare un errore quando la rete di formazione. Non, tuttavia, volete tre valori numerici arbitrari per essere emesso, perché allora non è interamente chiaro come calcolare un termine di errore. Ma supponiamo che la rete neurale emette tre valori numerici che sono tutti tra 0.0 e 1.0 e tale somma a 1.0. Poi i valori emessi possono essere interpretati come probabilità, che, come si scopre, rende più semplice calcolare un termine di errore quando ci si allena e per calcolare la precisione durante il test. La funzione di attivazione Softmax emette i valori di output in questa forma. La funzione Softmax accetta neurale nascoste-uscita riassume e restituisce i valori di output neurali finale; può essere implementato come questo:

private static double[] Softmax(double[] hoSums)
{
  double max = hoSums[0];
  for (int i = 0; i < hoSums.Length; ++i)
    if (hoSums[i] > max) max = hoSums[i];
  double scale = 0.0;
    for (int i = 0; i < hoSums.Length; ++i)
      scale += Math.Exp(hoSums[i] - max);
  double[] result = new double[hoSums.Length];
    for (int i = 0; i < hoSums.Length; ++i)
      result[i] = Math.Exp(hoSums[i] - max) / scale;
  return result;
}

In linea di principio, la funzione Softmax calcola un fattore di scala prendere Exp di ogni somma nascosta-uscita, sommando loro e quindi dividendo l'Exp di ogni valore per il fattore di scala. Si supponga, ad esempio, di tre somme nascoste-uscita sono (-1,0, 2,0, 4,0). Il fattore di scala sarebbe Exp(2.0) + Exp(-1.0) + Exp(4.0) = 7.39 + 0,37 + 54.60 = 62.36. Poi i valori di output Softmax sarebbe Exp (2.0) / 62.36, Exp(-1.0)/62.36, Exp(4.0)/62.36) = (0,12, 0.01, 0,87). Si noti che l'output finale sono tutti tra 0.0 e 1.0 e infatti sommare a 1.0 e ulteriore che la più grande somma nascosta-uscita (4.0) è la più grande uscita/probabilità (0,87), e il rapporto è simile per i valori di secondo e terzo.

Purtroppo, un'implementazione naïve di Softmax spesso può fallire perché la funzione Exp diventa molto grande, molto rapidamente e può produrre overflow aritmetico. L'implementazione precedente utilizza il fatto che Exp (a - b) = Exp(a) / Exp(b) per calcolare l'output in modo da evitare overflow. Se si traccia l'esecuzione dell'applicazione utilizzando (-1,0, 2,0, 4,0) come input, si otterrà lo stesso (0,12, 0.01, 0.87) uscite come spiegato nella sezione precedente.

Errore di cross-Entropy

L'essenza della formazione una rete neurale è di trovare il set di pesi che produce il più piccolo errore per i dati in set di training. Si supponga, ad esempio, di una riga di dati di training normalizzato, codificato è (0,75 -0,25 0,25 -0,50 0,00 1,00 0,00). Ricordiamo che i primi quattro valori sono gli ingressi normalizzati e gli ultimi tre valori rappresentano verde nella codifica 1-di-N. Ora supponiamo che gli ingressi sono alimentati attraverso la rete neurale, che è stato caricato con alcuni set di pesi e l'output Softmax è (0,20 0,70 0,10). Un approccio tradizionale all'errore di calcolo per questo vettore di prova è quello di utilizzare la somma delle differenze al quadrato, che in questo caso sarebbe (0.00 - 0.20) ^ 2 + (1,00 - 0.70) ^ 2 + (0.00 - 0.10) ^ 2 = 0,14. Ma supponiamo che l'uscita Softmax era (0,30 0,00 0,70). Sia questo vettore ed il vettore precedente prevedere che l'output è verde perché la probabilità di verde è 0,70. Tuttavia, la somma delle deviazioni al quadrato di questo secondo vettore è 0,18, che è diverso dal primo termine di errore. Anche se la somma delle deviazioni al quadrato può essere utilizzato per calcolare l'errore di formazione, alcuni dei risultati della ricerca suggeriscono che utilizzando una misura alternativa chiamato cross -­errore di entropia è preferibile.

In linea di principio, l'errore di croce-entropia per una data rete neurale uscita vettore v e un test di uscita t vector è calcolato determinando la somma negativa del prodotto di ogni componente del vettore v e componente del vettore t corrispondente. Come al solito, questo è meglio compreso da esempio. Se un vettore di test è (-0,25 0,75 0,25 -0,50 0,00 1,00 0,00) e il corrispondente Softmax è uscita della rete neurale (0,20 0,70 0,10), allora l'errore di cross-entropy è -1 * (0.00 * Log(0.20)) + (1.00 * Log(0.70)) + (0.00 * Log(0.10)) = -1 * (-0.15 + 0 + 0) = 0,15. Si noti che tutti, ma uno dei termini nella somma sarà sempre zero quando viene utilizzata la codifica 1-di-N. L'errore di croce-entropia per il set intero addestramento può essere calcolata come la somma di croce-entropia di tutti i vettori di test, o la media cross-entropia di ogni vettore di test. Un'implementazione di cross-entropy errore è elencata Figura 4.

Figura 4 Cross-Entropy errore

private double CrossEntropy(double[][] trainData, 
  double[] weights)
{
  this.SetWeights(weights);
  double sce = 0.0; // sum of cross entropies
  for (int i = 0; i < trainData.Length; ++i)
  {
    double[] currInputs = new double[4];
    currInputs[0] = trainData[i][0];
    currInputs[1] = trainData[i][1];
    currInputs[2] = trainData[i][2];
    currInputs[3] = trainData[i][3];
    double[] currExpected = new double[3];
    currExpected[0] = trainData[i][4];
    currExpected[1] = trainData[i][5];
    currExpected[2] = trainData[i][6];
    double[] currOutputs = this.ComputeOutputs(currInputs);
    double currSum = 0.0;
    for (int j = 0; j < currOutputs.Length; ++j)
    {
      if (currExpected[j] != 0.0)
        currSum += currExpected[j] * Math.Log(currOutputs[j]);
    }
    sce += currSum; // accumulate
  }
  return -sce;
}

Formazione della rete neurale

Ci sono molti modi per addestrare un classificatore di rete neurale per trovare il set di pesi che corrisponde meglio i dati di training (o, equivalentemente, rese il più piccolo errore di croce-entropia). A un alto livello di astrazione, formazione una rete neurale assomiglia a questo:

create an empty neural network
loop
  generate a candidate set of weights
  load weights into neural network
  foreach training vector
    compute the neural output
    compute cross-entropy error
    accumulate total error
  end foreach
  if current weights are best found so far
    save current weights
  end if
until some stopping condition
return best weights found

Di gran lunga, la tecnica più comune usata per addestrare reti neurali è chiamata retro-propagazione. Questa tecnica è il soggetto di un gran numero di articoli di ricerca — così molti, infatti, che se siete nuovi nel campo della classificazione di rete neurale, potrebbe facilmente essere indotti a credere che retro-propagazione è la sola tecnica utilizzata per la formazione. Stimare il migliore set di pesi per una rete neurale è un problema di minimizzazione numerica. Due comuni alternative all'utilizzo di retro-propagazione utilizzando un algoritmo genetico valori reali (chiamato anche un algoritmo di ottimizzazione evolutiva) e usando particle swarm optimization. Ogni tecnica di stima ha punti di forza e di debolezza. Il programma mostrato Figura 1 utilizza particle swarm optimization. Descrivere gli algoritmi di ottimizzazione evolutiva nel numero di giugno 2012 di MSDN Magazine (msdn.microsoft.com/magazine/jj133825) e particle swarm optimization nel numero di agosto 2011 (msdn.microsoft.com/magazine/hh335067).

Ci sono molte tecniche per determinare quando smettere di formazione una rete neurale. Anche se si potrebbe semplicemente lasciare che un algoritmo di training fino a quando l'errore di cross-entropy è molto vicino allo zero, che indica una forma quasi perfetta, il pericolo è che i pesi risultanti saranno over-fit i dati di training e i pesi creerà una rete neurale che mal si classifica per i dati che non sono nel set di training. Inoltre, fino a quando non vi è alcun cambiamento nell'errore cross-entropia di formazione può facilmente condurre a over-fitting modello. Un approccio semplice e quello utilizzato dal programma di esempio, è quello di limitare la formazione di un numero fisso di iterazioni. Nella maggior parte dei casi, una tattica molto meglio per evitare di over-fitting è di dividere il set di dati di origine in treno-convalidare-test set. Questi tre insiemi di dati utilizzano in genere il 60 per cento, il 20 per cento e 20 per cento dei dati di origine, rispettivamente. La tecnica calcola errore sul training set come descritto in precedenza, ma dopo ogni iterazione del ciclo principale la tecnica consente di calcolare l'errore di cross-entropy sul set di dati di convalida. Quando l'errore di cross-entropy sul set di convalida inizia a mostrare un aumento consistente in errore, c'è una buona probabilità che l'algoritmo di formazione ha cominciato a over-fit i dati e la formazione dovrebbe arrestare. Ci sono molte altre tecniche di arresto possibile.

Valutando il classificatore di rete neurale

Dopo che il classificatore di rete neurale è stato addestrato e ha prodotto un set di pesi migliori e pregiudizi, il passo successivo è determinare quanto il modello risultante (dove il modello significa la rete neurale con il set di pesi migliori) è preciso sui dati del test. Sebbene misure come la somma delle deviazioni al quadrato o cross-entropy errore possono essere utilizzati, una misura ragionevole di precisione è semplicemente la percentuale di previsioni corrette fatta dal modello. Ancora una volta, ci sono diversi approcci per la misurazione di precisione, ma una tecnica semplice è usare quello che ha chiamato l'approccio winner-take-all. E, come al solito, la tecnica è meglio spiegata da esempio. Suppongo che è un vettore di test (-1.00 1,00 0,25 -0,50 1.00 0.00 0.00), come mostrato nel primo set di dati di previsione in Figura 1. Con il set di pesi migliori, la rete neurale genera un output Softmax previsto di (0,9 0,0 0,1). Se ogni uscita viene interpretata come una probabilità, allora la probabilità più alta è 0,9 e l'output previsto può essere pensato come (1 0 0), quindi il modello rende il pronostico corretto. Mettere un altro modo, il vincitore prende tutto tecnica determina la rete neurale output component con il valore più grande, rende tale componente un 1 e tutte le altre componenti 0 e confronta il risultato con i dati effettivi nel vettore di formazione. Nel terzo set di dati di analisi di precisione in Figura 1, è il vettore di test (-0,50 0,75 0,75 0,25 0.0 0.0 1.0). I dati di output effettivo (0.0 0.0 1.0), che corrisponde al blu. L'uscita prevista è (0,3 0,1 0,6). Il componente più grande è la 0.6, quindi la stima del modello è (0 1 0), che corrisponde al verde. Il modello realizzato un'errata previsione.

Conclusioni

Classificazione con reti neurali è un argomento importante, affascinante e complesso. L'esempio presentato qui dovrebbe darvi una base solida per sperimentare con classificazione di rete neurale. Tuttavia, questo articolo viene descritto solo uno scenario di rete neurale molto specifica classificazione — variabili di input numeriche con una variabile categorica output — ed è un punto di partenza. Altri scenari richiedono tecniche leggermente differenti. Ad esempio, se i dati di input contengano una variabile categoriale, si potrebbe aspettare che sarebbe essere codificato utilizzando la codifica di 1-di-N come una variabile di output categorico. In questo caso, tuttavia, i dati di input devono essere codificati utilizzando la tecnica di 1-of-(N-1). Se volete saperne di più su classificazione usando reti neurali, vi consiglio il set di sette domande frequenti su reti neurali disponibili presso faqs.org. I collegamenti a queste FAQ tendono a muoversi, ma si dovrebbe essere in grado di trovare facilmente con una ricerca su Internet.

Dr. James McCaffrey  funziona per Volt Information Sciences Inc., dove gestisce la formazione tecnica per gli ingegneri software della Microsoft di Redmond, Washington, campus. Siè occupato di diversi prodotti Microsoft, inclusi Internet Explorer e MSN Search. McCaffrey è l'autore di ".NET Test Automation Recipes" (Apress, 2006). Può essere raggiunto aindirizzo jmccaffrey@volt.com o jammc@microsoft.com.

Grazie all'esperto tecnica seguente della Microsoft per la revisione di questo articolo: Matthew Richardson