Febbraio 2018
Volume 33 Numero 2
Il presente articolo è stato tradotto automaticamente.
Machine Learning - Classificatori di rete neurale profonda con CNTK
La libreria Microsoft cognitivi Toolkit (CNTK) è un potente set di funzioni che consente di creare una stima di machine learning (ML) sistemi. Fornita un'introduzione alla versione 2 nel numero di luglio 2017 (msdn.com/magazine/mt784662). In questo articolo illustrano come utilizzare CNTK per creare un classificatore deep neural network. È un buon metodo per visualizzare in questo articolo è a due punte per esaminare la schermata in figura 1.
.png "Demo di stima frumento valore di inizializzazione diversi")
Figura 1 frumento valore di inizializzazione diversi stima Demo
La libreria CNTK è scritta in C++ per motivi di prestazioni, ma la modalità più standard per chiamare le funzioni di libreria consiste nell'utilizzare il linguaggio Python CNTK API. Richiamato il programma demo eseguendo il comando seguente in un normale di Windows 10 nella shell dei comandi:
> python seeds_dnn.py
L'obiettivo del programma demo consiste nel creare una rete neurale profonde grado di stimare la varietà di un valore di inizializzazione frumento. Dietro le quinte, il programma demo utilizza un set di dati di training sono simile al seguente:
|properties 15.26 14.84 ... 5.22 |variety 1 0 0
|properties 14.88 14.57 ... 4.95 |variety 1 0 0
...
|properties 17.63 15.98 ... 6.06 |variety 0 1 0
...
|properties 10.59 12.41 ... 4.79 |variety 0 0 1
150 elemento sui dati di training. Ogni riga rappresenta uno dei tre tipi di valore di inizializzazione frumento: "Kama," "Rosa" o "Canada". I primi sette valori numerici per ogni riga sono i valori predittive, detti attributi o le funzionalità nella terminologia di machine learning. I predittori sono area valore di inizializzazione, perimetrale, compattezza, lunghezza, larghezza, il coefficiente asimmetria e groove lunghezza. L'elemento-a-stimare (spesso chiamato la classe o l'etichetta) riempie le ultime tre colonne e viene codificato come 1 0 0 per Kama, 0 1 0 per Rosa e 0 0 1 per canadese.
Il programma demo utilizza anche un set di dati di test degli elementi di 60, 20 di varietà ogni valore di inizializzazione. I dati di test hanno lo stesso formato di dati di training.
Il programma demo crea una rete di neurali profonde-(4-4-4) 3 7. La rete è illustrata figura 2. Esistono sette nodi di input (uno per ogni valore predittive), tre livelli nascosti, ognuno dei quali dispone di quattro nodi di elaborazione, e tre i nodi che corrispondono alle tre tipi di valore di inizializzazione di possibili frumento codificato di output.
.png "Struttura Deep Neural Network")
Figura 2 Deep Neural Network struttura
Il programma demo esegue il training di rete mediante 5000 batch di 10 elementi utilizzando l'algoritmo descent con sfumatura stocastica (SGD). Dopo che è stato eseguito il modello di stima, viene applicato al set di dati di prova di 60-item. Il modello ottenuta accuratezza 78.33 percentuale, vale a dire che stimati correttamente dal 47 degli elementi di test 60.
Il programma demo si conclude con effettua una stima per un valore di inizializzazione frumento sconosciuto. I valori di input sette sono (17,6 15.9, 0,8, 6.2, 3.5, 4.1, 6.1). I valori di nodo di output non elaborato calcolate sono (1.0530, 2.5276,-3.6578) e valori di probabilità del nodo di output associata sono (0.1859, 0.8124, 0.0017). Poiché il valore medio è più grande, l'output viene eseguito il mapping su (0, 1, 0) che è Rosa diversi.
In questo articolo presuppone che intermedie o migliori programmazione competenze con una lingua della famiglia C e una conoscenza di base con le reti neurali. Tuttavia, indipendentemente dal fatto di sfondo, deve essere in grado di seguire la procedura senza problemi. Il codice sorgente completo per il programma seeds_dnn.py verrà presentato in questo articolo. Il codice e associati file di dati training e di test sono anche disponibili nel download di file che accompagna questo articolo.
L'installazione CNTK v2
Poiché CNTK v2 è relativamente nuovo, non si ha familiarità con il processo di installazione. In breve, installare innanzitutto una Python language distribuzione (distribuzione Anaconda fortemente consigliabile) che contiene i componenti di base del linguaggio Python e pacchetti Python richiesti e quindi si installa CNTK come un altro pacchetto di Python. In altre parole, CNTK non è un'installazione autonoma.
Al momento della redazione del presente documento, la versione corrente di CNTK è versione 2.3. Poiché CNTK è in fase di sviluppo violenta, nel momento in cui che leggere, possono anche essere una versione più recente. È stata utilizzata Anaconda versione distribuzione 4.1.1 (che contiene Python versione 3.5.2, NumPy versione 1.11.1 e SciPy versione 0.17.1). Dopo l'installazione Anaconda, è installata la versione di CPU-only di CNTK utilizzando il programma di utilità pip. L'installazione CNTK può essere difficile se si incauta alla compatibilità delle versioni, ma la documentazione di CNTK descrive in dettaglio il processo di installazione.
Informazioni sui dati
Creazione di sistemi di apprendimento automatico la maggior parte inizia con il processo richiede molto tempo ed è spesso fastidioso di impostazione della formazione e i file di dati di test. Il set di dati non elaborati frumento i valori di inizializzazione è reperibile in bit.ly/2idhoRK. I dati non elaborati di delimitato da tabulazione 210-item sono simile al seguente:
14.11 14.1 0.8911 5.42 3.302 2.7 5 1
16.63 15.46 0.8747 6.053 3.465 2.04 5.877 1
Ho scritto un programma di utilità per generare un file in un formato che può essere facilmente gestito da CNTK. Il file 210 elemento risultante è simile:
|properties 14.1100 14.1000 ... 5.0000 |variety 1 0 0
|properties 16.6300 15.4600 ... 5.8770 |variety 1 0 0
Il programma di utilità aggiunto iniziale "| proprietà" tag per identificare la posizione delle funzioni e un "| varietà" tag per identificare la posizione della classe per la stima. I valori di classe non elaborati sono stati 1-di-N con codificata (talvolta denominate hot una codifica), le schede sono state sostituite da caratteri di spazio vuoto e tutti i valori predittive sono stati formattati per esattamente quattro cifre decimali.
Nella maggior parte dei casi è opportuno normalizzare i valori numerici predittive pertanto tutti hanno all'incirca lo stesso intervallo. Non normalizzare i dati, per mantenere un po' più semplice in questo articolo. Due forme comuni di normalizzazione sono normalizzazione del punteggio z e normalizzazione min-max. In scenari non demo in generale, è necessario normalizzare i valori predittive.
Successivamente, ho scritto un altro programma di utilità che ha richiesto il file di dati dell'elemento 210 nel formato CNTK e quindi il file viene usata per generare un file di dati di training 150 elemento denominato seeds_train_data.txt (i primi 50 di ogni serie) e un file di test di 60-elemento denominato seeds_test_data.txt (la ultimi 20 di ogni serie).
Poiché esistono sette variabili predittive, non è possibile creare un grafico completo dei dati. È tuttavia possibile ottenere un'idea approssimativa della struttura dei dati dal grafico di dati parziali figura 3. Utilizzato solo il perimetro di valore di inizializzazione e i valori predittive compattezza di inizializzazione del set di dati di prova di 60-item.
.png "Grafico parziale dei dati di Test")
Figura 3 grafico parziale dei dati di Test
Il programma Demo Deep Neural Network
Utilizzato il blocco note per scrivere il programma demo. Ad esempio Blocco note, ma la maggior parte dei colleghi preferisce uno dei molti eccellente editor Python disponibili. L'editor di codice di Visual Studio disponibile con il componente aggiuntivo linguaggio Python è particolarmente utile. Il codice sorgente di programma demo completo, con poche modifiche secondarie per risparmiare spazio, viene visualizzato figura 4. Si noti che il carattere barra rovesciata sia usato da Python per la continuazione di riga.
Figura 4 completa inizializzazione classificazione Demo programma
# seeds_dnn.py
# classify wheat seed variety
import numpy as np
import cntk as C
def create_reader(path, is_training, input_dim, output_dim):
strm_x = C.io.StreamDef(field='properties',
shape=input_dim, is_sparse=False)
strm_y = C.io.StreamDef(field='variety',
shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=strm_x,
y_src=strm_y)
deserial = C.io.CTFDeserializer(path, streams)
sweeps = C.io.INFINITELY_REPEAT if is_training else 1
mb_source = C.io.MinibatchSource(deserial,
randomize=is_training, max_sweeps=sweeps)
return mb_source
def main():
print("\nBegin wheat seed classification demo \n")
print("Using CNTK verson = " + str(C.__version__) + "\n")
input_dim = 7
hidden_dim = 4
output_dim = 3
train_file = ".\\Data\\seeds_train_data.txt"
test_file = ".\\Data\\seeds_test_data.txt"
# 1. create network and model
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
print("Creating a 7-(4-4-4)-3 tanh softmax NN for seed data ")
with C.layers.default_options(init= \
C.initializer.normal(scale=0.1, seed=2)):
h1 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer1')(X)
h2 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer2')(h1)
h3 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer3')(h2)
oLayer = C.layers.Dense(output_dim, activation=None,
name='outLayer')(h3)
nnet = oLayer
model = C.softmax(nnet)
# 2. create learner and trainer
print("Creating a cross entropy, SGD with LR=0.01, \
batch=10 Trainer \n")
tr_loss = C.cross_entropy_with_softmax(nnet, Y)
tr_clas = C.classification_error(nnet, Y)
learn_rate = 0.01
learner = C.sgd(nnet.parameters, learn_rate)
trainer = C.Trainer(nnet, (tr_loss, tr_clas), [learner])
max_iter = 5000 # maximum training iterations
batch_size = 10 # mini-batch size
# 3. create data reader
rdr = create_reader(train_file, True, input_dim,
output_dim)
my_input_map = {
X : rdr.streams.x_src,
Y : rdr.streams.y_src
}
# 4. train
print("Starting training \n")
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size,
input_map=my_input_map)
trainer.train_minibatch(curr_batch)
if i % 1000 == 0:
mcee = trainer.previous_minibatch_loss_average
pmea = trainer.previous_minibatch_evaluation_average
macc = (1.0 - pmea) * 100
print("batch %6d: mean loss = %0.4f, \
mean accuracy = %0.2f%% " % (i,mcee, macc))
print("\nTraining complete")
# 5. evaluate model on the test data
print("\nEvaluating test data \n")
rdr = create_reader(test_file, False, input_dim, output_dim)
my_input_map = {
X : rdr.streams.x_src,
Y : rdr.streams.y_src
}
numTest = 60
allTest = rdr.next_minibatch(numTest, input_map=my_input_map)
acc = (1.0 - trainer.test_minibatch(allTest)) * 100
print("Classification accuracy on the \
60 test items = %0.2f%%" % acc)
# (could save model here)
# 6. use trained model to make prediction
np.set_printoptions(precision = 4)
unknown = np.array([[17.6, 15.9, 0.8, 6.2, 3.5, 4.1, 6.1]],
dtype=np.float32)
print("\nPredicting variety for (non-normalized) seed features: ")
print(unknown[0])
raw_out = nnet.eval({X: unknown})
print("\nRaw output values are: ")
for i in range(len(raw_out[0])):
print("%0.4f " % raw_out[0][i])
pred_prob = model.eval({X: unknown})
print("\nPrediction probabilities are: ")
for i in range(len(pred_prob[0])):
print("%0.4f " % pred_prob[0][i])
print("\nEnd demo \n ")
# main()
if __name__ == "__main__":
main()
La dimostrazione ha inizio importando i pacchetti richiesti NumPy e CNTK e assegnandogli gli alias di scelta rapida di np e C. Funzione create_reader è un helper definito dal programma che può essere usato per leggere i dati di training (se il parametro is_training è impostato su True) o dati di test (se is_training è impostata su False).
È possibile considerare la funzione create_reader come codice boilerplate per problemi di classificazione neurale. Gli unici elementi, devi modificare nella maggior parte dei casi sono i due valori stringa degli argomenti campo nelle chiamate a funzione StreamDef "proprietà" e "tipi" nella demo.
Tutta la logica di controllo di programma è contenuta in una singola funzione principale. Deselezionare tutti normale di errore del codice di verifica è stata rimossa per mantenere ridotte le dimensioni della demo e per mantenere i concetti principali. Si noti che impostare I rientri in due spazi anziché i consueto più quattro spazi per risparmiare spazio.
Creazione della rete e il modello
La funzione principale inizia impostando le dimensioni di architettura di rete neurale:
def main():
print("Begin wheat seed classification demo")
print("Using CNTK verson = " + str(C.__version__) )
input_dim = 7
hidden_dim = 4
output_dim = 3
...
Poiché CNTK è in fase di sviluppo rapido, è consigliabile stampare o come commento la versione in uso. La dimostrazione ha tre livelli nascosti, che hanno tutti e quattro i nodi. Il numero di livelli nascosti e il numero di nodi in ogni livello, deve essere determinate dal prove ed errori. Se si desidera, si può avere un numero diverso di nodi in ogni livello. Ad esempio, hidden_dim = [10, 8, 10, 12] corrisponde a una rete completa con quattro livelli nascosti e non prevede 10, 8, 10 e 12 nodi rispettivamente.
Viene specificato il percorso dei file di dati di training e di test e la rete di input e vengono creati i vettori di output:
train_file = ".\\Data\\seeds_train_data.txt"
test_file = ".\\Data\\seeds_test_data.txt"
# 1. create network and model
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
Si noti è inserito il training e prova i file in una sottodirectory dati separata, che è una pratica comune perché spesso molti file di dati diverso durante la creazione del modello. Utilizzando i dati np.float32 il tipo è molto più comuni rispetto al tipo np.float64 aggiungere ulteriore precisione ottenuto utilizzando in genere 64 bit non sono vale la pena la riduzione delle prestazioni che costo.
Successivamente, viene creata la rete:
print("Creating a 7-(4-4-4)-3 NN for seed data ")
with C.layers.default_options(init= \
C.initializer.normal(scale=0.1, seed=2)):
h1 = C.layers.Dense(hidden_dim,
activation=C.ops.tanh, name='hidLayer1')(X)
h2 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer2')(h1)
h3 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer3')(h2)
oLayer = C.layers.Dense(output_dim, activation=None,
name='outLayer')(h3)
nnet = oLayer
model = C.softmax(nnet)
È molto succedendo. La versione di Python con l'istruzione è la sintassi di scelta rapida per applicare un set di valori comuni a più livelli di una rete. In questo caso, tutti i pesi assegnati a un valore casuale di Gauss (curva a campana) con una deviazione standard di 0,1 e una media pari a 0. L'impostazione di un valore di inizializzazione assicura la riproducibilità. CNTK supporta un numero elevato di algoritmi di inizializzazione, tra cui "uniforme", "glorot," "he" e "xavier". Le reti neurali sono sorprendentemente sensibili per la scelta dell'algoritmo di inizializzazione, spesso in modo durante il training ha esito negativo, una delle operazioni prima di provare a è un algoritmo di inizializzazione alternativo.
Tre livelli nascosti vengono definiti utilizzando la funzione di densità, così definita perché ogni nodo è completamente connesso per i nodi nei livelli prima e dopo. La sintassi utilizzata può generare confusione. Il simbolo X funge da input per h1 livello nascosto. Il livello h1 funge da input h2 livello nascosto e così via.
Si noti che il livello di output viene utilizzata alcuna funzione di attivazione in modo che i nodi di output abbia valori che non necessariamente la somma di 1. Se si ha esperienza con altre librerie di rete neurale, è necessaria una spiegazione. In molte altre librerie neurale utilizzare softmax attivazione nel livello di output in modo che l'output valore sempre somme su 1 e può essere interpretato come probabilità. Quindi, durante il training, utilizzare un'entropia incrociata errore (denominata anche perdita logaritmica), che richiede un set di valori che rappresenta la somma di 1.
Tuttavia, la versione 2.3 CNTK non dispone di una funzione di errore di entropia incrociata di base per il training. Al contrario, CNTK include un'entropia incrociata con funzione softmax. Ciò significa che durante il training, i valori di nodo di output vengono convertiti in tempo reale alle probabilità utilizzando softmax per calcolare un termine di errore.
In tal caso, con CNTK, eseguire il training di una rete completa sui valori di nodo di output non elaborato, ma quando si eseguono stime, se si desidera che le probabilità di stima come accade di solito, è necessario applicare la funzione softmax in modo esplicito. L'approccio utilizzato dalla demo consiste nel training per l'oggetto "nnet" (Nessuna attivazione nel livello di output), ma creare un oggetto supplementare "modello", con softmax applicato, da utilizzare quando si eseguono stime.
A questo punto, è, infatti, possibile utilizzare l'attivazione softmax sul livello di output e quindi utilizzare entropia incrociata con softmax durante il training. Questo approccio comporta softmax viene applicata a due volte, per prima per valori di output non elaborati e quindi nuovamente i valori di nodo di output normalizzato. In realtà, sebbene questo approccio funziona, per motivi tecnici piuttosto complesse, non è efficiente training.
Concatenamento di livelli nascosti è possibile fino a un punto. Per le reti molto profonda, CNTK supporta una funzione di metadati denominata sequenziale che fornisce una sintassi di scelta rapida per la creazione di reti a più livelli. La libreria CNTK include anche una funzione ritirato che può essere usata per prevenire l'overfitting del modello. Per aggiungere ritirato il primo livello nascosto, ad esempio, è possibile modificare il codice demo simile al seguente:
h1 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer1')(X)
d1 = C.layers.Dropout(0.50, name='drop1')(h1)
h2 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer2')(d1)
h3 = C.layers.Dense(hidden_dim, activation=C.ops.tanh,
name='hidLayer3')(h2)
oLayer = C.layers.Dense(output_dim, activation=None,
name='outLayer')(h3)
Molti dei colleghi preferiscono utilizzare sempre sequenziale, anche per le reti neurali profonde solo con pochi livelli nascosti. Preferisco concatenamento manuale, ma si tratta di un aspetto dello stile.
Training della rete
Dopo aver creato una rete neurale e un modello, il programma demo crea un oggetto strumento di apprendimento e un oggetto di sistema di training:
print("Creating a Trainer \n")
tr_loss = C.cross_entropy_with_softmax(nnet, Y)
tr_clas = C.classification_error(nnet, Y)
learn_rate = 0.01
learner = C.sgd(nnet.parameters, learn_rate)
trainer = C.Trainer(nnet, (tr_loss, tr_clas), [learner])
È possibile considerare uno strumento di apprendimento come un algoritmo e un certificato. un oggetto che utilizza l'algoritmo di apprendimento. L'oggetto tr_loss ("perdita di formazione") definisce la modalità misurare l'errore tra i valori calcolati rete output e valori di output corretto noti nei dati di training. Per la classificazione, entropia incrociata è quasi sempre usata, ma CNTK supporta varie alternative. La parte "with_softmax" del nome della funzione indica che la funzione prevede valori di nodo di output non elaborato anziché i valori normalizzati con softmax. Ecco perché il livello di output non utilizza una funzione di attivazione.
L'oggetto tr_clas ("errore di classificazione formazione") definisce calcolata il numero di stime corrette e non corretti durante il training. CNTK definisce una funzione di classificazione (percentuale di stime corrette) errore libreria anziché una funzione di accuratezza della classificazione utilizzata da alcune altre librerie. In tal caso, esistono due tipi di errore viene calcolato durante il training. L'errore tr_loss viene utilizzato per modificare i pesi e i pregiudizi. Il tr_clas viene utilizzato per monitorare l'accuratezza della stima.
L'oggetto strumento di apprendimento Usa l'algoritmo SGD con una costante di apprendimento velocità è impostata su 0,01. SGD è l'algoritmo di training più semplice ma raramente è quello di prestazioni migliori. CNTK supporta un numero elevato di algoritmi di apprendimento, alcuni dei quali risalenti a molto complesse. Come regola generale, è consigliabile partire SGD e cercando solo gli algoritmi più originali se il training ha esito negativo. L'algoritmo di Adam (Adam non è l'acronimo) è in genere la scelta di secondo.
Si noti la sintassi per la creazione di un oggetto Trainer insolita. Gli oggetti funzione di due perdita vengono passati come una tupla di Python, indicata dalle parentesi, ma l'oggetto strumento di apprendimento viene passato come un elenco di Python, indicata da parentesi quadre. È possibile passare più oggetti più snelli a un sistema di training, anche se il programma demo passa solo uno.
Il codice che esegue effettivamente training è:
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size,
input_map=my_input_map)
trainer.train_minibatch(curr_batch)
if i % 1000 == 0:
mcee = trainer.previous_minibatch_loss_average
pmea = trainer.previous_minibatch_evaluation_average
macc = (1.0 - pmea) * 100
print("batch %6d: mean loss = %0.4f, \
mean accuracy = %0.2f%% " % (i, mcee, macc))
È importante monitorare lo stato di avanzamento di training in training spesso ha esito negativo. In questo caso, in cui viene visualizzato l'errore di entropia incrociata medio sul batch di 10 elementi training utilizzato appena ogni 1000 iterazioni. La dimostrazione consente di visualizzare l'accuratezza della classificazione Media (percentuale di stime corrette sugli 10 elementi corrente), che è una metrica più naturale di errore di classificazione (percentuale di stime non corrette).
Salvataggio del modello con training
Poiché sono presenti solo gli elementi di training 150, della rete neurale demo possibile eseguire il training in pochi secondi. Ma in scenari non demo, la formazione di una rete neurale molto approfondita può richiedere ore, giorni o anche più tempo. Dopo il training, si desidera salvare il modello in modo non sarà necessario ripetere il training da zero. Salvataggio e caricamento di un modello con training di CNTK è molto semplice. Per salvare, è possibile aggiungere codice simile al seguente per il programma demo:
mdl = ".\\Models\\seed_dnn.model"
model.save(mdl, format=C.ModelFormat.CNTKv2)
Il primo argomento passato per il salvataggio funzione è un filename, magari con un percorso. Non vi è alcuna estensione di file necessari, ma utilizzando "Model" senso. Il parametro di formato è il valore predefinito ModelFormat.CNTKv2, pertanto potrebbe aver stato omesso. In alternativa è possibile utilizzare il nuovo formato di scambio di rete neurale aprire = ONNX.
Tenere presente che il programma demo creato sia un oggetto nnet (con nessun softmax nell'output) e un oggetto modello (con softmax). In genere è opportuno salvare la versione softmax di un modello con training, ma se si desidera, è possibile salvare l'oggetto non softmax.
Dopo aver salvato un modello, è possibile caricare in memoria come segue:
model = C.ops.functions.Function.Load(".\\Models\\seed_dnn.model")
E quindi il modello può essere utilizzato come se solo training. Si noti che vi sia un bit di asimmetria nelle chiamate a salvare e caricare-Salva è un metodo su un oggetto funzione e di carico è un metodo statico della classe di funzione.
Conclusioni
Molti problemi di classificazione possono essere gestiti tramite una rete neurale feedforward semplice (FNN) con un singolo livello nascosto. In teoria, alcune ipotesi, un FNN può gestire qualsiasi problema in grado di gestire una rete neurale approfondita. Tuttavia, in pratica, a volte una rete neurale deep è più semplice eseguire il training di un FNN. La base matematica per questi concetti viene chiamata il teorema di approssimazione universale (o talvolta il teorema di Cybenko).
Se si ha familiarità con la classificazione di rete neurale, il numero delle decisioni, che è necessario apportare può apparire difficoltosa. È necessario decidere il numero di livelli nascosti, il numero di nodi in ogni livello, una funzione di inizializzazione lo schema e di attivazione per ogni livello nascosto, un algoritmo di training e l'algoritmo di training parametri, ad esempio frequenza e momentum termine di apprendimento. Tuttavia, procedure consigliate si viene sviluppata rapidamente un set di regole per i tipi di problemi con cui si gestiscono.
Dr. James McCaffreyfunziona per Microsoft Research Redmond, WA Ha lavorato su diversi prodotti Microsoft, tra cui Internet Explorer e Bing. Dr. McCaffrey può essere raggiunto al jamccaff@microsoft.com.
Grazie per i seguenti esperti Microsoft che ha revisionato in questo articolo: Chris Lee, Ricky Loynd Kenneth Tran
Viene illustrato in questo articolo nel forum di MSDN Magazine