rxNeuralNet : réseau neuronal

  • Article

Réseaux neuronaux pour la modélisation de régression et pour la classification binaire et multiclasse.

Utilisation

  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

La formule telle que décrite dans rxFormula. Les termes d’interaction et F() ne sont actuellement pas pris en charge dans MicrosoftML.

data

Objet source de données ou chaîne de caractères spécifiant un fichier .xdf ou un objet de trame de données.

type

Chaîne de caractères indiquant un type FastTree :

  • "binary" pour le réseau neuronal de classification binaire par défaut.
  • "multiClass" pour le réseau neuronal de classification multiclasse.
  • "regression" pour un réseau neuronal de régression.

numHiddenNodes

Nombre par défaut de nœuds masqués dans le réseau neuronal. La valeur par défaut est 100.

numIterations

Nombre d’itérations sur le jeu d’apprentissage complet. La valeur par défaut est 100.

optimizer

Liste spécifiant l’algorithme d’optimisation sgd ou adaptive. Cette liste peut être créée en utilisant sgd ou adaDeltaSgd. La valeur par défaut est sgd.

netDefinition

Définition Net# de la structure du réseau neuronal. Pour plus d’informations sur le langage Net#, consultez Reference Guide

initWtsDiameter

Définit le diamètre des pondérations initiales qui spécifie la plage à partir de laquelle les valeurs sont dessinées pour les pondérations d’apprentissage initiales. Les pondérations sont initialisées de façon aléatoire dans cette plage. La valeur par défaut est 0,1.

maxNorm

Spécifie une limite supérieure pour contraindre la norme du vecteur de pondération entrant à chaque unité cachée. Cela peut être très important dans les réseaux neuronaux à couche maxout et dans les cas où l’apprentissage produit des pondérations illimités.

acceleration

Spécifie le type d’accélération matérielle à utiliser. Les valeurs possibles sont « sse » et « gpu ». Pour l’accélération GPU, il est recommandé d’utiliser une taille de lot minimale (miniBatchSize) supérieure à un. Si vous souhaitez utiliser l’accélération GPU, des étapes de configuration manuelles supplémentaires sont requises :

  • Téléchargez et installez NVidia CUDA Toolkit 6.5 (CUDA Toolkit).
  • Téléchargez et installez la bibliothèque NVidia cuDNN v2 (cudnn Library).
  • Recherchez le répertoire libs du package MicrosoftRML en appelant system.file("mxLibs/x64", package = "MicrosoftML").
  • Copiez cublas64_65.dll, cudart64_65.dll et cusparse64_65.dll à partir du CUDA Toolkit 6.5 dans le répertoire libs du package MicrosoftML.
  • Copiez cudnn64_65.dll à partir de la bibliothèque cuDNN v2 dans le répertoire libs du package MicrosoftML.

miniBatchSize

Définit la taille de lot minimal. Les valeurs recommandées sont comprises entre 1 et 256. Ce paramètre est utilisé uniquement lorsque l’accélération est de type GPU. La définition de ce paramètre sur une valeur plus élevée améliore la vitesse de l’apprentissage, mais peut nuire à la précision. La valeur par défaut est 1.

normalize

Spécifie le type de normalisation automatique utilisé :

  • "auto" : si la normalisation est nécessaire, elle est effectuée automatiquement. Il s’agit de la valeur par défaut.
  • "no" : aucune normalisation n’est effectuée.
  • "yes" : la normalisation est effectuée.
  • "warn" : si la normalisation est nécessaire, un message d’avertissement s’affiche, mais la normalisation n’est pas effectuée.
    La normalisation redimensionne les plages de données disparates à une échelle standard. La mise à l’échelle des caractéristiques garantit que les distances entre les points de données sont proportionnelles et permet aux différentes méthodes d’optimisation, comme la descente de gradient, de converger beaucoup plus rapidement. Si la normalisation est effectuée, un normaliseur MaxMin est utilisé. Celui-ci normalise les valeurs dans un intervalle [a, b] où -1 <= a <= 0, 0 <= b <= 1 et b - a = 1. Ce normaliseur conserve la densité en mappant zéro à zéro.

mlTransforms

Spécifie la liste des transformations MicrosoftML à effectuer sur les données avant l’entraînement, ou NULL si aucune transformation ne doit être effectuée. Consultez featurizeText, categorical et categoricalHash pour les transformations prises en charge. Ces transformations sont effectuées après les transformations R spécifiées. La valeur par défaut est NULL.

mlTransformVars

Spécifie un vecteur de caractères des noms de variables à utiliser dans mlTransforms ou NULL si aucun ne doit être utilisé. La valeur par défaut est NULL.

rowSelection

Spécifie les lignes (observations) du jeu de données qui doivent être utilisées par le modèle avec le nom d’une variable logique du jeu de données (entre guillemets) ou avec une expression logique utilisant des variables dans le jeu de données. Par exemple, rowSelection = "old" utilise uniquement les observations dans lesquelles la valeur de la variable old est TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) utilise uniquement les observations dans lesquelles la valeur de la variable age est comprise entre 20 et 65, et la valeur log de la variable income est supérieure à 10. La sélection de ligne est effectuée après le traitement de toutes les transformations de données (consultez les arguments transforms ou transformFunc). Comme pour toutes les expressions, rowSelection peut être défini en dehors de l’appel de fonction à l’aide de la fonction d’expression.

transforms

Expression de la forme list(name = expression, ``...) qui représente la première série de transformations de variables. Comme pour toutes les expressions, transforms (ou rowSelection) peut être défini en dehors de l’appel de fonction à l’aide de la fonction d’expression.

transformObjects

Liste nommée qui contient des objets qui peuvent être référencés par transforms, transformsFunc et rowSelection.

transformFunc

Fonction de transformation de variables. Pour plus d’informations, consultez rxTransform.

transformVars

Vecteur de caractère des variables de jeu de données d’entrée nécessaires pour la fonction de transformation. Pour plus d’informations, consultez rxTransform.

transformPackages

Vecteur de caractères spécifiant les packages R supplémentaires (en dehors de ceux spécifiés dans rxGetOption("transformPackages")) qui doivent être mis à disposition et préchargés pour être utilisés dans les fonctions de transformation de variables. Par exemple, ceux définis explicitement dans les fonctions RevoScaleR via leurs arguments transforms et transformFunc ou ceux définis implicitement via leurs arguments formula ou rowSelection. L’argument transformPackages peut également être NULL, ce qui indique qu’aucun package n’est préchargé en dehors de rxGetOption("transformPackages").

transformEnvir

Environnement défini par l’utilisateur qui sert de parent à tous les environnements développés en interne et qui est utilisé pour la transformation de données variables. Si transformEnvir = NULL, un nouvel environnement de « hachage » avec le parent baseenv() est utilisé à la place.

blocksPerRead

Spécifie le nombre de blocs à lire pour chaque segment de données lu à partir de la source de données.

reportProgress

Valeur entière qui spécifie le niveau de création de rapports sur la progression du traitement de la ligne :

  • 0 : aucune progression n’est signalée.
  • 1 : le nombre de lignes traitées est imprimé et mis à jour.
  • 2 : les lignes traitées et les minutages sont signalés.
  • 3 : les lignes traitées et l’ensemble des minutages sont signalés.

verbose

Valeur entière qui spécifie la quantité de sortie souhaitée. Si la valeur est 0, aucune sortie détaillée n’est imprimée au cours des calculs. Les valeurs entières de 1 à 4 fournissent des quantités d’informations croissantes.

computeContext

Définit le contexte dans lequel les calculs sont exécutés, spécifiés avec un contexte RxComputeContext valide. Actuellement, les contextes de calcul locaux et RxInSqlServer sont pris en charge.

ensemble

Paramètres de contrôle pour l’apprentissage ensembliste.

...

Arguments supplémentaires à passer directement au moteur de calcul Microsoft.

Détails

Un réseau neuronal est une classe de modèles de prédiction inspirée par le cerveau humain. Un réseau neuronal peut être représenté sous la forme d’un graphe orienté pondéré. Chaque nœud du graphe est appelé un neurone. Les neurones du graphe sont disposés en couches, où les neurones d’une couche donnée sont reliés par un bord pondéré (les pondérations peuvent être égales à 0 ou à des nombres positifs) aux neurones de la couche suivante. La première couche est appelée couche d’entrée, et chaque neurone de la couche d’entrée correspond à l’une des fonctionnalités. La dernière couche de la fonction est appelée couche de sortie. Ainsi, dans le cas des réseaux neuronaux binaires, elle contient deux neurones de sortie, un pour chaque classe, dont les valeurs sont les probabilités d’appartenir à chaque classe. Les autres couches sont appelées couches masquées. Les valeurs des neurones dans les couches masquées et dans la couche de sortie sont définies en calculant la somme pondérée des valeurs des neurones de la couche précédente et en appliquant une fonction d’activation à cette somme pondérée. Un modèle de réseau neuronal est défini par la structure de son graphe (à savoir, le nombre de couches masquées et le nombre de neurones dans chaque couche masquée), le choix de la fonction d’activation et les pondérations sur les bords du graphe. L’algorithme de réseau neuronal tente d’apprendre les pondérations optimales sur les bords en fonction des données d’apprentissage.

Bien que les réseaux neuronaux soient largement connus pour une utilisation dans le Deep Learning et la modélisation de problèmes complexes tels que la reconnaissance d’image, ils s’adaptent également facilement aux problèmes de régression. Une classe de modèles statistiques peut être considérée comme un réseau neuronal si elle utilise des pondérations adaptatives et est en mesure d’estimer des fonctions non linéaires de leurs entrées. La régression de réseau neuronal convient ainsi spécifiquement aux problèmes pour lesquels un modèle de régression plus traditionnel ne parvient pas à trouver de solution.

Valeur

rxNeuralNet : un objet rxNeuralNet avec le modèle entraîné.
NeuralNet : un objet de spécification d’apprenant de classe maml pour le formateur de réseau neuronal.

Notes

Cet algorithme est à thread unique et ne tente pas de charger l’intégralité du jeu de données dans la mémoire.

Auteur(s)

Microsoft Corporation Microsoft Technical Support

Références

Wikipedia: Artificial neural network

Voir aussi

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

Exemples


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