rxNeuralNet : réseau neuronal
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 normaliseurMaxMinest utilisé. Celui-ci normalise les valeurs dans un intervalle [a, b] où-1 <= a <= 0,0 <= b <= 1etb - 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,]
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour