Condividi tramite

rxNeuralNet: rete neurale

  • Articolo

Reti neurali per la modellazione di regressione e per la classificazione binaria e multiclasse.

Utilizzo

  rxNeuralNet(formula = NULL, data, type = c("binary", "multiClass",
    "regression"), numHiddenNodes = 100, numIterations = 100,
    optimizer = sgd(), netDefinition = NULL, initWtsDiameter = 0.1,
    maxNorm = 0, acceleration = c("sse", "gpu"), miniBatchSize = 1,
    normalize = "auto", mlTransforms = NULL, mlTransformVars = NULL,
    rowSelection = NULL, transforms = NULL, transformObjects = NULL,
    transformFunc = NULL, transformVars = NULL, transformPackages = NULL,
    transformEnvir = NULL, blocksPerRead = rxGetOption("blocksPerRead"),
    reportProgress = rxGetOption("reportProgress"), verbose = 1,
    computeContext = rxGetOption("computeContext"),
    ensemble = ensembleControl(), ...)

Arguments

formula

Formula descritta in rxFormula. I termini di interazione e F() non sono attualmente supportati in MicrosoftML.

data

Oggetto origine dati o stringa di caratteri che specifica un file con estensione xdf o un oggetto frame di dati.

type

Una stringa di caratteri che indica il tipo Fast Tree:

  • "binary" per la rete neurale di classificazione binaria predefinita.
  • "multiClass" per la rete neurale di classificazione multiclasse.
  • "regression" per una rete neurale di regressione.

numHiddenNodes

Numero predefinito di nodi nascosti nella rete neurale. Il valore predefinito è 100.

numIterations

Numero di iterazioni nel set di training completo. Il valore predefinito è 100.

optimizer

Elenco che specifica l'algoritmo di ottimizzazione sgd o adaptive. Questo elenco può essere creato usando sgd o adaDeltaSgd. Il valore predefinito è sgd.

netDefinition

Definizione Net# della struttura della rete neurale. Per ulteriori informazioni sul linguaggio Net#, vedere Reference Guide

initWtsDiameter

Imposta il diametro dei pesi iniziali che specifica l'intervallo da cui vengono estratti i valori per i pesi di apprendimento iniziali. I pesi vengono inizializzati in modo casuale all'interno di questo intervallo. Il valore predefinito è 0,1.

maxNorm

Specifica un limite superiore per vincolare la norma del vettore di peso in ingresso a ciascuna unità nascosta. Questo può essere molto importante nelle reti neurali maxout e nei casi in cui il training produca pesi illimitati.

acceleration

Specifica il tipo di accelerazione hardware da usare. I valori possibili sono "sse" e "gpu". Per l'accelerazione GPU, si consiglia di usare un miniBatchSize maggiore di uno. Se si intende usare l'accelerazione GPU, sono necessari ulteriori passaggi di configurazione manuale:

  • Scaricare e installare NVidia CUDA Toolkit 6.5 (CUDA Toolkit).
  • Scaricare e installare NVidia cuDNN v2 Library (cudnn Library).
  • Trovare la directory libs del pacchetto MicrosoftRML chiamando system.file("mxLibs/x64", package = "MicrosoftML").
  • Copiare cublas64_65.dll, cudart64_65.dll e cusparse64_65.dll da CUDA Toolkit 6.5 nella directory libs del pacchetto MicrosoftML.
  • Copiare cudnn64_65.dll dalla libreria cuDNN v2 nella directory libs del pacchetto MicrosoftML.

miniBatchSize

Imposta la dimensione del mini-batch. I valori consigliati sono compresi tra 1 e 256. Questo parametro viene utilizzato solo quando l'accelerazione è GPU. L'impostazione di questo parametro su un valore più alto migliora la velocità del training, ma potrebbe influire negativamente sulla precisione. Il valore predefinito è 1.

normalize

Specifica il tipo di normalizzazione automatica usata:

  • "auto": se la normalizzazione è necessaria, viene eseguita automaticamente. Questa è l'opzione predefinita.
  • "no": non viene eseguita alcuna normalizzazione.
  • "yes": la normalizzazione viene eseguita.
  • "warn": se la normalizzazione è necessaria, viene visualizzato un avviso ma la normalizzazione non viene eseguita.
    La normalizzazione ridimensiona diversi intervalli di dati in base a una scala standard. Il ridimensionamento delle funzioni assicura che le distanze tra i punti dati siano proporzionali e consente di accelerare significativamente la convergenza di diversi metodi di ottimizzazione, tra cui la discesa di gradiente. Se la normalizzazione viene eseguita, viene usato un normalizzatore MaxMin. I valori vengono normalizzati in un intervallo [a, b], dove -1 <= a <= 0 e 0 <= b <= 1 e b - a = 1. Questo normalizzatore mantiene la sparsità eseguendo il mapping di zero a zero.

mlTransforms

Specifica un elenco di trasformazioni di MicrosoftML da eseguire sui dati prima del training o NULL se non devono essere eseguite trasformazioni. Per informazioni sulle trasformazioni supportate, vedere featurizeText, categorical e categoricalHash. Queste trasformazioni vengono eseguite dopo eventuali trasformazioni R specificate. Il valore predefinito è NULL.

mlTransformVars

Specifica un vettore di caratteri di nomi di variabili da usare in mlTransforms o NULL se non è necessario usarne alcuno. Il valore predefinito è NULL.

rowSelection

Specifica le righe (osservazioni) dal set di dati che devono essere usate dal modello con il nome di una variabile logica dal set di dati (tra virgolette) o con un'espressione logica tramite variabili nel set di dati. Ad esempio, rowSelection = "old" userà solo osservazioni in cui il valore della variabile old è TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) usa solo osservazioni in cui il valore della variabile age è compreso tra 20 e 65 e il valore di log della variabile income è maggiore di 10. La selezione delle righe viene eseguita dopo l'elaborazione di eventuali trasformazioni dei dati. Vedere gli argomenti transforms o transformFunc. Analogamente a tutte le espressioni, è possibile definire rowSelection all'esterno della chiamata alla funzione usando la funzione di espressione.

transforms

Espressione con formato list(name = expression, ``...) che rappresenta il primo ciclo di trasformazioni delle variabili. Analogamente a tutte le espressioni, è possibile definire transforms o rowSelection all'esterno della chiamata alla funzione usando la funzione di espressione.

transformObjects

Elenco denominato che contiene oggetti a cui transforms, transformsFunce rowSelection possono fare riferimento.

transformFunc

Funzione di trasformazione della variabile. Per informazioni dettagliate, vedere rxTransform.

transformVars

Vettore di caratteri delle variabili del set di dati di input necessario per la funzione di trasformazione. Per informazioni dettagliate, vedere rxTransform.

transformPackages

Vettore di caratteri che specifica altri pacchetti R, oltre a quelli specificati in rxGetOption("transformPackages"), da rendere disponibili e precaricati per l'uso nelle funzioni di trasformazione delle variabili. Ad esempio, quelli definiti in modo esplicito nelle funzioni RevoScaleR tramite i relativi argomenti transforms e transformFunc o quelli definiti in modo implicito tramite i relativi argomenti formula o rowSelection. L'argomento transformPackages può anche essere NULL, che indica che non vengono precaricati pacchetti esterni a rxGetOption("transformPackages").

transformEnvir

Ambiente definito dall'utente da usare come elemento padre di tutti gli ambienti sviluppati internamente e usati per la trasformazione dei dati delle variabili. Se transformEnvir = NULL, viene invece usato un nuovo ambiente "hash" con padre baseenv().

blocksPerRead

Specifica il numero di blocchi da leggere per ogni blocco di dati letto dall'origine dati.

reportProgress

Valore intero che specifica il livello di creazione di report sullo stato di elaborazione delle righe:

  • 0: non viene segnalato alcun avanzamento.
  • 1: il numero di righe elaborate viene stampato e aggiornato.
  • 2: vengono segnalate le righe elaborate e le tempistiche.
  • 3: vengono segnalate le righe elaborate e tutte le tempistiche.

verbose

Valore intero che specifica la quantità di output desiderata. Se 0, non viene stampato alcun output dettagliato durante i calcoli. Valori interi da 1 a 4 per fornire quantità crescenti di informazioni.

computeContext

Imposta il contesto in cui vengono eseguiti i calcoli, specificato con un RxComputeContext valido. Sono attualmente supportati contesti di calcolo locali e RxInSqlServer.

ensemble

Parametri di controllo per l'ensembling.

...

Argomenti aggiuntivi da passare direttamente al motore di calcolo Microsoft.

Dettagli

Una rete neurale è una classe di modelli di previsione ispirati al cervello umano. Una rete neurale può essere rappresentata come un grafico diretto ponderato. Ogni nodo nel grafico è chiamato neurone. I neuroni nel grafico sono disposti in livelli, dove i neuroni di un livello sono collegati da un margine ponderato (i pesi possono essere 0 o numeri positivi) ai neuroni del livello successivo. Il primo livello è chiamato livello di input e ogni neurone nel livello di input corrisponde a una delle caratteristiche. L'ultimo livello della funzione è chiamato livello di output. Quindi nel caso delle reti neurali binarie contiene due neuroni di output, uno per ogni classe, i cui valori sono le probabilità di appartenere a ciascuna classe. I livelli rimanenti vengono definiti livelli nascosti. I valori dei neuroni nei livelli nascosti e nel livello di output vengono impostati calcolando la somma ponderata dei valori dei neuroni nel livello precedente e applicando una funzione di attivazione a quella somma ponderata. Un modello di rete neurale è definito dalla struttura del suo grafico (vale a dire, il numero di livelli nascosti e il numero di neuroni in ogni livello nascosto), dalla scelta della funzione di attivazione e dai pesi sui margini del grafico. L'algoritmo della rete neurale cerca di apprendere i pesi ottimali sui margini in base ai dati di training.

Anche se le reti neurali siano ampiamente conosciute per l'uso nel Deep Learning e nella modellazione di problemi complessi come il riconoscimento delle immagini, sono anche facilmente adattabili ai problemi di regressione. Qualsiasi classe di modelli statistici può essere considerata una rete neurale se usa pesi adattivi e può approssimare funzioni non lineari dei relativi input. La regressione della rete neurale è particolarmente adatta a problemi in cui un modello di regressione più tradizionale non può adattarsi a una soluzione.

Valore

rxNeuralNet: oggetto rxNeuralNet con il modello sottoposto a training.
NeuralNet: oggetto di specifica dello strumento di apprendimento con classe maml per il programma di training Neural Net.

Note

Questo algoritmo è a thread singolo e non tenterà di caricare l'intero set di dati in memoria.

Autore/i

Microsoft Corporation Microsoft Technical Support

Riferimenti

Wikipedia: Artificial neural network

Vedi anche

rxFastTrees, rxFastForest, rxFastLinear, rxLogisticRegression, rxOneClassSvm, featurizeText, categorical, categoricalHash, rxPredict.mlModel.

Esempi


 # Estimate a binary neural net
 rxNeuralNet1 <- rxNeuralNet(isCase ~ age + parity + education + spontaneous + induced,
                   transforms = list(isCase = case == 1),
                   data = infert)

 # Score to a data frame
 scoreDF <- rxPredict(rxNeuralNet1, data = infert, 
     extraVarsToWrite = "isCase",
     outData = NULL) # return a data frame

 # Compute and plot the Radio Operator Curve and AUC
 roc1 <- rxRoc(actualVarName = "isCase", predVarNames = "Probability", data = scoreDF) 
 plot(roc1)
 rxAuc(roc1)

 #########################################################################
 # Regression neural net

 # Create an xdf file with the attitude data
 myXdf <- tempfile(pattern = "tempAttitude", fileext = ".xdf")
 rxDataStep(attitude, myXdf, rowsPerRead = 50, overwrite = TRUE)
 myXdfDS <- RxXdfData(file = myXdf)

 attitudeForm <- rating ~ complaints + privileges + learning + 
     raises + critical + advance

 # Estimate a regression neural net 
 res2 <- rxNeuralNet(formula = attitudeForm,  data = myXdfDS, 
     type = "regression")

 # Score to data frame
 scoreOut2 <- rxPredict(res2, data = myXdfDS, 
     extraVarsToWrite = "rating")

 # Plot the rating versus the score with a regression line
 rxLinePlot(rating~Score, type = c("p","r"), data = scoreOut2)

 # Clean up   
 file.remove(myXdf)    

 #############################################################################
 # Multi-class neural net
 multiNN <- rxNeuralNet(
     formula = Species~Sepal.Length + Sepal.Width + Petal.Length + Petal.Width,
     type = "multiClass", data = iris)
 scoreMultiDF <- rxPredict(multiNN, data = iris, 
     extraVarsToWrite = "Species", outData = NULL)    
 # Print the first rows of the data frame with scores
 head(scoreMultiDF)
 # Compute % of incorrect predictions
 badPrediction = scoreMultiDF$Species != scoreMultiDF$PredictedLabel
 sum(badPrediction)*100/nrow(scoreMultiDF)
 # Look at the observations with incorrect predictions
 scoreMultiDF[badPrediction,]