Teilen über


rxNeuralNet: Neural Net

Neuronale Netze für Regressionsmodellierung und für binäre Klassifizierung und Multiklassenklassifizierung

Verwendung

  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(), ...)

Argumente

formula

Die Formel, wie in rxFormula beschrieben. Interaktionsterme und F() werden derzeit in MicrosoftML nicht unterstützt.

data

Ein Datenquellenobjekt oder eine Zeichenfolge, die eine .xdf-Datei oder ein Datenrahmenobjekt angibt.

type

Eine Zeichenfolge, die den Typ „Fast Tree“ bezeichnet

  • "binary" für neuronale Standardnetze mit binärer Klassifizierung
  • "multiClass" für neuronale Netze mit mehrklassiger Klassifizierung
  • "regression" für neuronale Regressionsnetze

numHiddenNodes

Dies ist die Standardanzahl verborgener Knoten im neuronalen Netz. Der Standardwert ist 100.

numIterations

Dies ist die Anzahl an Iterationen für das vollständige Trainingsdataset. Der Standardwert ist 100.

optimizer

Dies ist eine Liste, die einen der Optimierungsalgorithmen sgd oder adaptive angibt. Diese Liste kann mithilfe von sgd oder adaDeltaSgd erstellt werden. Standardwert: sgd.

netDefinition

Dies ist die Net#-Definition der Struktur des neuronalen Netzes. Weitere Informationen zur Net#-Sprache finden Sie hier: Reference Guide.

initWtsDiameter

Hiermit wird der Durchmesser der anfänglichen Gewichtungen festgelegt, der den Bereich angibt, aus dem die Werte für die anfänglichen Lerngewichtungen stammen. Diese Gewichtungen werden innerhalb dieses Bereichs nach dem Zufallsprinzip initialisiert. Der Standardwert ist 0,1.

maxNorm

Hiermit wird eine obere Grenze angegeben, mit der die Norm des eingehenden Gewichtungsvektors für die einzelnen verborgenen Einheiten begrenzt wird. Dies kann sehr hilfreich bei maximierten neuronalen Netzen sowie in Fällen sein, in denen beim Training ungebundene Gewichtungen erzeugt werden.

acceleration

Hiermit wird der Typ der Hardwarebeschleunigung angegeben, der verwendet wird. Mögliche Werte sind „sse“und „gpu“. Es wird empfohlen, als GPU-Beschleunigung einen miniBatchSize-Wert größer als 1 zu verwenden. Wenn Sie die GPU-Beschleunigung verwenden möchten, sind zusätzliche Einrichtungsschritte erforderlich:

  • Herunterladen und Installieren der Version 6.5 des Nvidia-Toolkits „CUDA“ (CUDA Toolkit)
  • Herunterladen und Installieren der Bibliothek „NVidia cuDNN v2“ (cudnn Library).
  • Suchen des Bibliotheksverzeichnisses des MicrosoftRML-Pakets durch Aufrufen von system.file("mxLibs/x64", package = "MicrosoftML").
  • Kopieren von „cublas64_65.dll“, „cudart64_65.dll“ und „cusparse64_65.dll“ aus dem CUDA-Toolkit (Version 6.5) und Einfügen im Bibliotheksverzeichnis des MicrosoftRML-Pakets.
  • Kopieren von „cudnn64_65.dll“ aus der Bibliothek „cuDNN v2“ und Einfügen in das Bibliotheksverzeichnis des MicrosoftRML-Pakets.

miniBatchSize

Hiermit wird ein Wert für mini_batch_size festgelegt. Empfohlene Werte liegen in einem Bereich zwischen 1 und 256. Dieser Parameter wird nur verwendet, wenn die GPU-Beschleunigung verwendet wird. Wenn dieser Parameter auf einen höheren Wert festgelegt wird, verbessert dies die Geschwindigkeit des Trainings, es kann sich jedoch negativ auf die Genauigkeit auswirken. Der Standardwert ist 1.

normalize

Gibt den Typ der verwendeten automatischen Normalisierung an:

  • "auto": Wenn eine Normalisierung erforderlich ist, erfolgt sie automatisch. Dies ist die Standardoption.
  • "no": Es erfolgt keine Normalisierung.
  • "yes": Es erfolgt eine Normalisierung.
  • "warn": Wenn eine Normalisierung erforderlich ist, wird eine Warnmeldung angezeigt, ohne dass die Normalisierung erfolgt.
    Bei der Normalisierung werden unterschiedliche Datenbereiche anhand einer Standardskala neu skaliert. Die Featureskalierung stellt sicher, dass die Abstände zwischen den Datenpunkten proportional sind und ermöglicht verschiedene Optimierungsmethoden wie den Gradientenabstieg, um wesentlich schneller zu konvergieren. Wenn eine Normalisierung erfolgt, wird die Normalisierungsfunktion MaxMin verwendet. Sie normalisiert Werte im Intervall [a, b], wobei gilt: -1 <= a <= 0 und 0 <= b <= 1 und b - a = 1. Diese Normalisierungsfunktion behält geringe Datendichte bei, indem 0 zu 0 zugeordnet wird.

mlTransforms

Gibt eine Liste von MicrosoftML-Transformationen an, die vor dem Training für die Daten erfolgen sollen, oder NULL, wenn keine Transformationen erfolgen sollen. Für unterstützte Transformationen siehe featurizeText, categorical und categoricalHash. Diese Transformationen werden nach allen angegebenen R-Transformationen ausgeführt. Standardwert: NULL.

mlTransformVars

Gibt einen Zeichenvektor von Variablennamen an, die in mlTransforms verwendet werden sollen, oder NULL, wenn keine verwendet werden sollen. Standardwert: NULL.

rowSelection

Gibt die Zeilen (Beobachtungen) aus dem Dataset an, die vom Modell verwendet werden sollen, mit dem Namen einer logischen Variablen aus dem Dataset (in Anführungszeichen) oder mit einem logischen Ausdruck unter Verwendung von Variablen im Dataset. rowSelection = "old" verwendet z. B. nur Beobachtungen, bei denen TRUE der Wert der Variablen old ist. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) verwendet nur Beobachtungen, bei denen der Wert der Variablen age zwischen 20 und 65 liegt und der Wert von log der Variablen income größer als 10 ist. Die Zeilenauswahl erfolgt nach der Verarbeitung von Datentransformationen (siehe die Argumente transforms oder transformFunc). Wie bei allen Ausdrücken kann rowSelection außerhalb des Funktionsaufrufs mit der expression-Funktion definiert werden.

transforms

Ein Ausdruck der Form list(name = expression, ``...), der die erste Runde der Variablentransformationen darstellt. Wie bei allen Ausdrücken kann transforms (oder rowSelection) außerhalb des Funktionsaufrufs mit der expression-Funktion definiert werden.

transformObjects

Eine benannte Liste, die Objekte enthält, auf die mit transforms, transformsFunc und rowSelection verwiesen werden kann.

transformFunc

Die Variablentransformationsfunktionen. Weitere Informationen finden Sie unter „rxTransform“.

transformVars

Ein Zeichenvektor von Eingabedatasetvariablen, die für die Transformationsfunktion erforderlich sind. Weitere Informationen finden Sie unter „rxTransform“.

transformPackages

Ein Zeichenvektor, der zusätzliche R-Pakete (außerhalb der in rxGetOption("transformPackages") angegebenen) angibt, die für die Verwendung in Variablentransformationsfunktionen verfügbar gemacht und im Voraus geladen werden sollen. Zum Beispiel solche, die explizit in RevoScaleR-Funktionen über ihre Argumente transforms und transformFunc definiert sind oder solche, die implizit über ihre Argumente formula oder rowSelection definiert sind. Das Argument transformPackages kann auch NULL lauten, was angibt, dass keine Pakete außerhalb von rxGetOption("transformPackages") im Voraus geladen werden.

transformEnvir

Eine benutzerdefinierte Umgebung, die als übergeordnete Umgebung für alle intern entwickelten Umgebungen dient und für die Transformation von Variablendaten verwendet wird. Falls transformEnvir = NULL, wird stattdessen eine neue „hash“-Umgebung mit der übergeordneten baseenv() verwendet.

blocksPerRead

Gibt die Anzahl der Blöcke an, die für jeden Datenblock gelesen werden, der aus der Datenquelle gelesen wird.

reportProgress

Ein ganzzahliger Wert, der die Berichtsebene für den Status der Zeilenverarbeitung angibt:

  • 0: Es wird kein Status gemeldet.
  • 1: Die Anzahl der verarbeiteten Zeilen wird ausgegeben und aktualisiert.
  • 2: Verarbeitete Zeilen und Zeitsteuerungen werden gemeldet.
  • 3: Verarbeitete Zeilen und alle Zeitsteuerungen werden gemeldet.

verbose

Ein ganzzahliger Wert, der die gewünschte Ausgabemenge angibt. Falls 0, erfolgt während der Berechnungen keine ausführliche Ausgabe. Ganzzahlige Werte von 1 bis 4 liefern zunehmend mehr Informationen.

computeContext

Legt den Kontext fest, in dem Berechnungen erfolgen, angegeben mit einer gültigen Angabe für RxComputeContext. Derzeit werden lokale und RxInSqlServer-Computekontexte unterstützt.

ensemble

Steuerungsparameter für die Bildung von Ensembles.

...

Zusätzliche Argumente, die direkt an die Microsoft-Compute-Engine übergeben werden sollen.

Details

Bei einem neuronalen Netz handelt es sich um eine Klasse von Vorhersagemodellen, die vom menschlichen Gehirn inspiriert wurden. Ein neuronales Netz kann als gewichteter und ausgerichteter Graph dargestellt werden. Jeder Knoten des Graphen wird als Neuron bezeichnet. Die Neuronen des Graphen werden in Ebenen angeordnet. Neuronen einer Ebene werden dabei von einer gewichteten Kante mit Neuronen der nächsten Ebene verbunden. Die Gewichtungen können 0 oder eine positive Zahl sein. Die erste Ebene wird als Eingabeebene bezeichnet, und jedes Neuron auf der Eingabeebene entspricht einem der Features. Die letzte Ebene der Funktion wird als Ausgabeebene bezeichnet. Im Fall binärer neuronaler Netze sind also zwei Ausgabeneuronen enthalten, eines für jede Klasse, deren Werte die Wahrscheinlichkeiten sind, zu den einzelnen Klassen zu gehören. Die übrigen Ebenen werden verborgene Ebenen genannt. Die Werte der Neuronen in den verborgenen Ebenen und in der Ausgabeebene werden festgelegt, indem die gewichtete Summe der Werte der Neuronen in der vorherigen Ebene berechnet wird und eine Aktivierungsfunktion auf diese gewichtete Summe angewendet wird. Das Modell eines neuronalen Netzes wird von der Struktur des dazugehörigen Graphen (der Anzahl verborgener Ebenen und der Anzahl an Neuronen in den einzelnen verborgenen Ebenen), der ausgewählten Aktivierungsfunktion und der Gewichtungen der Graphenkanten definiert. Der Algorithmus des neuronalen Netzes versucht anhand der Trainingsdaten zu lernen, welche Gewichtungen für die Kanten optimal sind.

Neuronale Netze sind zwar weithin für ihre Verwendung bei Deep Learning und der Modellierung komplexer Probleme wie Bilderkennung bekannt, sie lassen sich aber auch einfach für Regressionsprobleme anpassen. Jede Klasse statistischer Modelle kann als neuronales Netz bezeichnet werden, sofern sie adaptive Gewichtungen verwenden und eine Annäherung an nicht lineare Funktionen in ihren Eingaben darstellen können. Die Regression mit neuronalen Netzen ist besonders für Probleme geeignet, für die traditionellere Regressionsmodelle keine passende Lösung bieten.

Wert

rxNeuralNet: Ein rxNeuralNet-Objekt mit dem trainierten Modell.
NeuralNet: Ein Learnerspezifikationsobjekt der Klasse maml für den Neural Net-Trainer.

Notizen

Dieser Algorithmus ist ein Singlethread-Algorithmus, der nicht versucht, das gesamte Dataset in den Arbeitsspeicher zu laden.

Autor(en)

Microsoft Corporation Microsoft Technical Support

References

Wikipedia: Artificial neural network

Weitere Informationen

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

Beispiele


 # 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,]