rxNeuralNet: Red neuronal

  • Artículo

Redes neuronales para el modelado de regresión y para la clasificación binaria y de varias clases.

Uso

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

Argumentos

formula

Se refiere a la fórmula tal como se describe en rxFormula. Los términos de interacción y F() no se admiten actualmente en MicrosoftML.

data

Objeto de origen de datos o cadena de caracteres que especifica un archivo .xdf o un objeto de trama de datos.

type

Cadena de caracteres que indica el tipo de Fast Tree:

  • "binary" para la red neuronal de clasificación binaria predeterminada.
  • "multiClass" para la red neuronal de clasificación de varias clases.
  • "regression" para una red neuronal de regresión.

numHiddenNodes

Número predeterminado de nodos ocultos de la red neuronal. El valor predeterminado es 100.

numIterations

Número de iteraciones del conjunto de entrenamiento completo. El valor predeterminado es 100.

optimizer

Lista que especifica el algoritmo de optimización sgd o adaptive. Esta lista se puede crear mediante sgd o adaDeltaSgd. El valor predeterminado es sgd.

netDefinition

Definición de Net# de la estructura de la red neuronal. Para más información sobre el lenguaje Net#, consulte Reference Guide.

initWtsDiameter

Establece el diámetro de pesos inicial que especifica el intervalo desde el que se dibujan los valores para los pesos de aprendizaje iniciales. Los pesos se inicializan aleatoriamente desde este intervalo. El valor predeterminado es 0.1.

maxNorm

Especifica un límite superior para restringir la norma del vector de peso entrante en cada unidad oculta. Esto puede ser muy importante en el número máximo de redes neuronales, así como en los casos en los que el entrenamiento genera pesos sin límite.

acceleration

Especifica el tipo de aceleración de hardware que se usará. Los valores posibles son "sse" y "gpu". En el caso de la aceleración de GPU, se recomienda usar un miniBatchSize mayor que uno. Si desea usar la aceleración de GPU, se requieren pasos de configuración manuales adicionales:

  • Descargue e instale NVidia CUDA Toolkit 6.5 (CUDA Toolkit).
  • Descargue e instale la biblioteca NVidia cuDNN v2 (cudnn Library).
  • Busque el directorio de bibliotecas del paquete MicrosoftRML llamando a system.file("mxLibs/x64", package = "MicrosoftML").
  • Copie cublas64_65.dll, cudart64_65.dll y cusparse64_65.dll de CUDA Toolkit 6.5 en el directorio de bibliotecas del paquete MicrosoftML.
  • Copie cudnn64_65.dll de la biblioteca cuDNN v2 en el directorio de bibliotecas del paquete MicrosoftML.

miniBatchSize

Establece el tamaño mínimo del lote. Los valores recomendados están comprendidos entre 1 y 256. Este parámetro solo se usa cuando la aceleración es GPU. El establecimiento de este parámetro en un valor mayor mejora la velocidad de entrenamiento, pero podría afectar negativamente a la precisión. El valor predeterminado es 1.

normalize

Especifica el tipo de normalización automática que se usa:

  • "auto": si la normalización es necesaria, se realiza automáticamente. Esta es la opción predeterminada.
  • "no": no se realiza ninguna normalización.
  • "yes": se lleva a cabo la normalización.
  • "warn": si la normalización es necesaria, se muestra un mensaje de advertencia, pero no se lleva a cabo la normalización.
    La normalización aplica una escala estándar a intervalos de datos dispares. El escalado de características asegura que las distancias entre los puntos de datos sean proporcionales y permite que varios métodos de optimización, como el descenso del gradiente, converjan mucho más rápido. Si se lleva a cabo la normalización, se usa un normalizador MaxMin. Normaliza los valores de un intervalo [a, b], donde -1 <= a <= 0, 0 <= b <= 1 y b - a = 1. Este normalizador mantiene la dispersión asignando cero a cero.

mlTransforms

Especifica una lista de transformaciones de MicrosoftML que deben realizarse en los datos antes del entrenamiento, o bien NULL si no hay que realizar ninguna transformación. Consulte featurizeText, categorical y categoricalHash para saber cuáles son las transformaciones compatibles. Estas transformaciones se realizan después de cualquier transformación de R especificada. El valor predeterminado es NULL.

mlTransformVars

Especifica un vector de caracteres de nombres de variable que deben usarse en mlTransforms, o NULL si no hay que usar ninguno. El valor predeterminado es NULL.

rowSelection

Especifica las filas (observaciones) del conjunto de datos que debe usar el modelo con el nombre de una variable lógica del conjunto de datos (entre comillas) o con una expresión lógica que usa variables en el conjunto de datos. Por ejemplo, rowSelection = "old" solo usará observaciones en las que el valor de la variable old sea TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) solo usa observaciones en las que el valor de la variable age está entre 20 y 65, y el valor de log de la variable income es mayor que 10. La selección de fila se realiza después de procesar las transformaciones de datos (vea los argumentos transforms o transformFunc). Al igual que con todas las expresiones, rowSelection se puede definir fuera de la llamada de función mediante la función de expresión.

transforms

Expresión del formulario list(name = expression, ``...) que representa la primera ronda de transformaciones de variables. Al igual que con todas las expresiones, transforms (o rowSelection) se puede definir fuera de la llamada de función mediante la función de expresión.

transformObjects

Lista con nombre que contiene objetos a los que pueden hacer referencia transforms, transformsFunc y rowSelection.

transformFunc

Función de transformación de variables. Consulte rxTransform para más detalles.

transformVars

Vector de caracteres de variables del conjunto de datos de entrada necesarias para la función de transformación. Consulte rxTransform para más detalles.

transformPackages

Vector de caracteres que especifica paquetes de R adicionales (aparte de los especificados en rxGetOption("transformPackages")) que deben cargarse previamente y estar disponibles para usarlos en las funciones de transformación de variables. Por ejemplo, los definidos explícitamente en las funciones de RevoScaleR mediante los argumentos transforms y transformFunc, o los definidos implícitamente con los argumentos formula o rowSelection. El argumento transformPackages también puede ser NULL, que indica que no se cargan previamente más paquetes aparte de los de rxGetOption("transformPackages").

transformEnvir

Entorno definido por el usuario que sirve como primario de todos los entornos desarrollados internamente y que se usa para la transformación de datos variables. Si transformEnvir = NULL, un entorno "hash" nuevo con baseenv() primario se usa en su lugar.

blocksPerRead

Especifica el número de bloques que se leerán para cada fragmento de datos leídos del origen de datos.

reportProgress

Valor entero que especifica el nivel de notificación del progreso del procesamiento de filas:

  • 0: no se notifica el progreso.
  • 1: se imprime y actualiza el número de filas procesadas.
  • 2: se notifican las filas procesadas y los intervalos.
  • 3: se notifican las filas procesadas y todos los intervalos.

verbose

Valor entero que especifica la cantidad de salida deseada. Si es 0, no se imprime ninguna salida detallada durante los cálculos. Los valores enteros de 1 a 4 proporcionan cantidades crecientes de información.

computeContext

Establece el contexto en el que se ejecutan los cálculos, especificado con un RxComputeContext válido. Actualmente, se admiten los contextos de proceso local y RxInSqlServer.

ensemble

Parámetros de control para la formación de conjuntos.

...

Argumentos adicionales que se pasarán directamente al motor de proceso de Microsoft.

Detalles

Una red neuronal es una clase de modelos de predicción que se inspira en el cerebro humano. Una red neuronal se puede representar como un grafo dirigido ponderado. Cada nodo del grafo se denomina neurona. Las neuronas del grafo se organizan en capas, en las que las neuronas de una capa están conectadas por un borde ponderado (los pesos pueden ser 0 o números positivos) a las neuronas de la capa siguiente. La primera capa se denomina capa de entrada, y cada neurona de la capa de entrada corresponde a una de las características. La última capa de la función se denomina capa de salida. Por lo tanto, en el caso de las redes neuronales binarias, contiene dos neuronas de salida, una para cada clase, cuyos valores son las probabilidades de pertenecer a cada clase. Los demás niveles se denominan niveles ocultos. Los valores de las neuronas de las capas ocultas y de la capa de salida se establecen calculando la suma ponderada de los valores de las neuronas de la capa anterior y aplicando una función de activación a esa suma ponderada. Un modelo de red neuronal se define mediante la estructura de su grafo (es decir, el número de capas ocultas y el número de neuronas de cada capa oculta), la elección de la función de activación y los pesos de los bordes del grafo. El algoritmo de la red neuronal intenta aprender los pesos óptimos en los bordes en función de los datos de entrenamiento.

Aunque las redes neuronales son ampliamente conocidas por su uso en problemas complejos de aprendizaje profundo y modelado, como el reconocimiento de imágenes, también se adaptan fácilmente a los problemas de regresión. Cualquier clase de modelos estadísticos se puede considerar una red neuronal si usa pesos adaptables y puede aproximar funciones no lineales de sus entradas. La regresión de red neuronal es especialmente adecuada en los problemas para los que un modelo de regresión más tradicional no puede encontrar una solución.

Value

rxNeuralNet: objeto rxNeuralNet con el modelo entrenado.
NeuralNet: objeto de especificación de aprendiz de clase maml para el entrenador de Red neuronal.

Notas

Este algoritmo es de un solo subproceso y no intentará cargar todo el conjunto de datos en la memoria.

Autores

Microsoft Corporation Microsoft Technical Support

Referencias

Wikipedia: Artificial neural network

Consulte también

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

Ejemplos


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