rxFastForest : Fast Forest

Forêt rapide Machine Learning

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

Les arguments

formula

Formule comme décrit dans rxFormula. 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 le type d’arborescence rapide :

• "binary" pour la classification binaire de l’arborescence rapide par défaut ou
• "regression" pour la régression d’arborescence rapide.

numTrees

Spécifie 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 de formation augmente. La valeur par défaut est 100.

numLeaves

Nombre maximal de feuilles (nœuds de terminal) qui peuvent être créées dans n’importe quelle arborescence. Des valeurs plus élevées augmentent potentiellement la taille de l’arbre et obtiennent une meilleure précision, mais les risques sont trop élevés et nécessitent des temps d’entraînement plus longs. La valeur par défaut est 20.

minSplit

Nombre minimal d’instances d’entraînement requises pour former une feuille. Autrement dit, le nombre minimal de documents autorisés dans une feuille d’une arborescence de régression, hors des données sous-échantillonées. Un « fractionnement » signifie que les fonctionnalités de chaque niveau de l’arborescence (nœud) sont divisées de façon aléatoire. La valeur par défaut est 10.

exampleFraction

Fraction des instances choisies de manière aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0.7.

featureFraction

Fraction des fonctionnalités choisies de manière aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0.7.

splitFraction

Fraction des fonctionnalités choisies de manière aléatoire à utiliser sur chaque fractionnement. La valeur par défaut est 0.7.

numBins

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

firstUsePenalty

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

gainConfLevel

L’ajustement de l’arbre gagne en confiance (doit se trouver dans la plage [0,1)). La valeur par défaut est 0.

trainThreads

Nombre de threads à utiliser lors de l’entraînement. Si NULL elle est spécifiée, le nombre de threads à utiliser est déterminé en interne. La valeur par défaut est NULL.

randomSeed

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

mlTransforms

Spécifie une liste des transformations MicrosoftML à effectuer sur les données avant l’entraînement ou NULL si aucune transformation n’est à effectuer. Pour connaître les transformations prises en charge, consultez featurizeText, catégorielles et catégoriellesHash. 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 de noms de variables à utiliser mlTransforms ou NULL s’il ne doit pas être utilisé. La valeur par défaut est NULL.

rowSelection

Spécifie les lignes (observations) du jeu de données à utiliser par le modèle avec le nom d’une variable logique à partir du jeu de données (entre guillemets) ou avec une expression logique à l’aide de 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 age variable est comprise entre 20 et 65 et la valeur de la logincome variable est supérieure à 10. La sélection de lignes est effectuée après le traitement des transformations de données (voir les arguments transforms ou transformFunc). Comme avec toutes les expressions, rowSelection peut être définie en dehors de l’appel de fonction à l’aide de la fonction d’expression.

transforms

Expression du formulaire list(name = expression, ``...) qui représente la première série de transformations de variables. Comme avec 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, transformsFuncet rowSelection.

transformFunc

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

transformVars

Vecteur de caractères 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 des packages R supplémentaires (en dehors de ceux spécifiés dans rxGetOption("transformPackages")) à rendre disponibles et préchargés pour une utilisation dans les fonctions de transformation de variable. Par exemple, celles définies explicitement dans les fonctions RevoScaleR via leurs arguments et transforms leurs transformFunc arguments ou implicitement via leurs arguments ou formula leurs rowSelection arguments. L’argument transformPackages peut également être NULL, indiquant qu’aucun package en dehors rxGetOption("transformPackages") n’est préchargé.

transformEnvir

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

blocksPerRead

Spécifie le nombre de blocs à lire pour chaque bloc 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 des lignes :

• 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 le minutage sont signalés.
• 3: lignes traitées et toutes les minutages sont signalées.

verbose

Valeur entière qui spécifie la quantité de sortie souhaitée. Si 0, aucune sortie détaillée n’est imprimée pendant les calculs. Valeurs entières allant de 1 à 4 fournir des quantités croissantes d’informations.

computeContext

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

ensemble

Paramètres de contrôle pour l’ensembling.

...

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 effectuent une séquence
de tests simples sur les entrées. Cette procédure de décision les mappe aux sorties trouvées dans le jeu de données d’entraînement dont les entrées étaient similaires à l’instance en cours de traitement. Une décision est prise à chaque nœud de la structure de données d’arborescence binaire en fonction d’une mesure de similarité qui mappe chaque instance de manière récursive à travers les branches de l’arbre jusqu’à ce que le nœud feuille approprié soit atteint et que la décision de sortie 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 de forêt rapide est une implémentation de forêt aléatoire et de régression quantile à l’aide de l’apprenant de l’arborescence de régression dans rxFastTrees. Le modèle se compose d’un ensemble d’arbres de décision. Chaque arbre d’une forêt décisionnelle génère une distribution gaussienne par 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 de décision 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 décisionnelle génère une distribution gaussienne par 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: objet rxFastForest avec le modèle entraîné.

FastForest: objet de spécification d’apprenant de classe maml pour l’entraîneur Fast Forest.

Remarques

Cet algorithme est multithread et tente toujours de charger l’ensemble du jeu de données en 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, 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)