rxFastForest : Forêt rapide

Machine Learning forêt rapide

Utilisation

  rxFastForest(formula = NULL, data, type = c("binary", "regression"),
    numTrees = 100, numLeaves = 20, minSplit = 10, exampleFraction = 0.7,
    featureFraction = 0.7, splitFraction = 0.7, numBins = 255,
    firstUsePenalty = 0, gainConfLevel = 0, trainThreads = 8,
    randomSeed = NULL, 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 = 2,
    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 la classification binaire par défaut de FastTree ou
• "regression" pour une régression FastTree.

numTrees

Indique le nombre total d’arbres de décision à créer dans l’ensemble. En créant davantage d’arbres de décision, vous pouvez potentiellement obtenir une meilleure couverture, mais le temps d’apprentissage augmente. La valeur par défaut est 100.

numLeaves

Nombre maximal de feuilles (nœuds terminaux) qui peuvent être créées dans un arbre. Les valeurs plus élevées augmentent potentiellement la taille de l’arborescence et bénéficient d’une meilleure précision, mais entraîne le surajustement des risques, et les temps d’apprentissage sont plus longs. La valeur par défaut est 20.

minSplit

Nombre minimal d'instances de formation requises pour former une feuille. Autrement dit, le nombre minimal de documents autorisés dans une feuille d’un arbre de régression, en dehors des données sous-échantillonnées. Le fractionnement consiste à diviser de manière aléatoire les caractéristiques à chaque niveau de l’arbre (nœud). La valeur par défaut est 10.

exampleFraction

Fraction d’instances choisies de façon aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0,7.

featureFraction

Fraction de caractéristiques choisies de façon aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0,7.

splitFraction

Fraction de caractéristiques choisies de façon aléatoire à utiliser pour chaque fractionnement. La valeur par défaut est 0,7.

numBins

Nombre maximal de valeurs distinctes (emplacements) par fonctionnalité. La valeur par défaut est 255.

firstUsePenalty

La caractéristique utilise tout d’abord le coefficient de pénalité. La valeur par défaut est 0.

gainConfLevel

L’exigence de confiance de gain de l’arbre doit être comprise dans la plage (0,1). La valeur par défaut est 0.

trainThreads

Nombre de threads à utiliser pour la formation. Si NULL est défini, le nombre de threads utilisés est déterminé en interne. La valeur par défaut est NULL.

randomSeed

Spécifie la valeur de départ aléatoire. La valeur par défaut est NULL.

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

Les arbres de décision sont des modèles non paramétriques qui exécutent une séquence
de tests simples sur les entrées. Cette procédure de décision les mappe sur les résultats trouvés dans le jeu de données d’apprentissage dont les entrées étaient similaires à l’instance en cours de traitement. Une décision est prise sur chaque nœud de la structure de données de l’arborescence binaire en fonction d’une mesure de similarité qui mappe chaque instance de manière récursive dans les branches de l’arborescence jusqu’à ce que le nœud terminal approprié soit atteint et que la décision de sortie soit retournée.

Les arbres de décision présentent plusieurs avantages :

Ils sont efficaces en matière de calcul et d’utilisation de la mémoire, lors de la formation et de la prédiction.

Ils peuvent représenter des limites de décisions non linéaires.

Ils sélectionnent et classifient les fonctionnalités intégrées.

Ils sont résilients en cas de fonctionnalités bruyantes.

La régression rapide de forêt est une implémentation de forêt aléatoire et de forêt de régression quantile à l’aide de l’apprentissage de l’arbre de régression dans rxFastTrees. Ce modèle se compose d’un ensemble d’arbres de décision. Chaque arbre d’une forêt de décision génère une distribution gaussienne, sous la forme d’une prédiction. Une agrégation est effectuée sur l’ensemble des arbres, afin de trouver la distribution gaussienne la plus proche de la distribution combinée, pour tous les arbres du modèle.

Ce classifieur de forêt décisionnelle se compose d'un ensemble d'arbres de décision. En général, les modèles ensemblistes offrent une meilleure couverture et une précision plus élevée que les arbres de décision uniques. Chaque arbre d’une forêt de décision génère une distribution gaussienne, sous la forme d’une prédiction. Une agrégation est effectuée sur l’ensemble des arbres, afin de trouver la distribution gaussienne la plus proche de la distribution combinée, pour tous les arbres du modèle.

Valeur

rxFastForest : un objet rxFastForest avec le modèle entraîné.

FastForest : un objet de spécification d’apprenant de classe maml pour le formateur de forêt rapide.

Notes

Cet algorithme est multithread et tente toujours 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: Random forest

Quantile regression forest

From Stumps to Trees to Forests

Voir aussi

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

Exemples

 # Estimate a binary classification forest
 infert1 <- infert
 infert1$isCase = (infert1$case == 1)
 forestModel <- rxFastForest(formula = isCase ~ age + parity + education + spontaneous + induced,
         data = infert1)

 # Create text file with per-instance results using rxPredict
 txtOutFile <- tempfile(pattern = "scoreOut", fileext = ".txt")
 txtOutDS <- RxTextData(file = txtOutFile)
 scoreDS <- rxPredict(forestModel, data = infert1,
    extraVarsToWrite = c("isCase", "Score"), outData = txtOutDS)

 # Print the fist ten rows   
 rxDataStep(scoreDS, numRows = 10)

 # Clean-up
 file.remove(txtOutFile)

 ######################################################################
 # Estimate a regression fast forest

 # Use the built-in data set 'airquality' to create test and train data
 DF <- airquality[!is.na(airquality$Ozone), ]  
 DF$Ozone <- as.numeric(DF$Ozone)
 randomSplit <- rnorm(nrow(DF))
 trainAir <- DF[randomSplit >= 0,]
 testAir <- DF[randomSplit < 0,]
 airFormula <- Ozone ~ Solar.R + Wind + Temp

 # Regression Fast Forest for train data
 rxFastForestReg <- rxFastForest(airFormula, type = "regression", 
     data = trainAir)  

 # Put score and model variables in data frame
 rxFastForestScoreDF <- rxPredict(rxFastForestReg, data = testAir, 
     writeModelVars = TRUE)

 # Plot actual versus predicted values with smoothed line
 rxLinePlot(Score ~ Ozone, type = c("p", "smooth"), data = rxFastForestScoreDF)