Condividi tramite

rxFastTrees: Fast Tree

  • Articolo

Metodo Fast Tree di Machine Learning

Utilizzo

  rxFastTrees(formula = NULL, data, type = c("binary", "regression"),
    numTrees = 100, numLeaves = 20, learningRate = 0.2, minSplit = 10,
    exampleFraction = 0.7, featureFraction = 1, splitFraction = 1,
    numBins = 255, firstUsePenalty = 0, gainConfLevel = 0,
    unbalancedSets = FALSE, 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

Formula descritta in rxFormula. I termini di interazione e F() non sono attualmente supportati in MicrosoftML.

data

Oggetto origine dati o stringa di caratteri che specifica un file con estensione xdf o un oggetto frame di dati.

type

Stringa di caratteri che specifica il tipo di modello Fast Tree: "binary" per la classificazione binaria predefinita Fast Tree o "regression" per la regressione Fast Tree.

numTrees

Specifica il numero totale di alberi delle decisioni da creare nell'ensemble. Creando più alberi delle decisioni, è possibile ottenere una migliore copertura, ma saranno necessari tempi di training prolungati. Il valore predefinito è 100.

numLeaves

Numero massimo di foglie (nodi di terminale) che è possibile creare in ogni albero. Valori più elevati aumentano potenzialmente le dimensioni dell'albero e consentono di ottenere una precisione migliore, ma rischiano di causare un overfitting e di richiedere tempi di training più lunghi. Il valore predefinito è 20.

learningRate

Determina le dimensioni del passaggio eseguito nella direzione del gradiente in ogni passaggio del processo di apprendimento. Questo valore determina quindi la velocità o la lentezza con cui lo strumento di apprendimento converge verso la soluzione ottimale. Se le dimensioni del passaggio sono eccessive, si rischia di oltrepassare la soluzione ottimale. Se la dimensione è troppo piccola, il training richiederà più tempo per convergere verso la soluzione migliore.

minSplit

Numero minimo di istanze di training necessarie per formare una foglia. Si tratta del numero minimo di documenti consentiti in una foglia di un albero di regressione, al di là dei dati sotto-campionati. Uno split indica che le funzionalità di ogni livello dell'albero (nodo) vengono divise in modo casuale. Il valore predefinito è 10. Viene conteggiato solo il numero di istanze, anche se le istanze sono ponderate.

exampleFraction

Frazione di istanze scelte in modo casuale da usare per ogni albero. Il valore predefinito è 0,7.

featureFraction

Frazione di funzionalità scelte in modo casuale da usare per ogni albero. Il valore predefinito è 1.

splitFraction

Frazione di funzionalità scelte in modo casuale da usare per ogni split. Il valore predefinito è 1.

numBins

Numero massimo di valori distinti (bin) per funzionalità. Se i valori della funzionalità sono di meno rispetto al numero indicato, ogni valore viene inserito nel bin corrispondente. Se sono presenti valori in più, l'algoritmo crea numBins bin.

firstUsePenalty

La funzionalità usa per primo il coefficiente di penalità. Si tratta di una forma di regolarizzazione che comporta una penalità per l'uso di una nuova funzionalità durante la creazione dell'albero. Aumentare questo valore per creare alberi che non usano molte funzionalità. Il valore predefinito è 0.

gainConfLevel

Requisito di attendibilità del guadagno di adattamento dell'albero. Il valore deve rientrare nell'intervallo [0,1]. Il valore predefinito è 0.

unbalancedSets

In caso di TRUE, vengono usati i derivati ottimizzati per i set non bilanciati. Si applica solo se type è uguale a "binary". Il valore predefinito è FALSE.

trainThreads

Numero di thread da usare nel training. Il valore predefinito è 8.

randomSeed

Specifica il valore di inizializzazione casuale. Il valore predefinito è NULL.

mlTransforms

Specifica un elenco di trasformazioni di MicrosoftML da eseguire sui dati prima del training o NULL se non devono essere eseguite trasformazioni. Per informazioni sulle trasformazioni supportate, vedere featurizeText, categorical e categoricalHash. Queste trasformazioni vengono eseguite dopo eventuali trasformazioni R specificate. Il valore predefinito è NULL.

mlTransformVars

Specifica un vettore di caratteri di nomi di variabili da usare in mlTransforms o NULL se non è necessario usarne alcuno. Il valore predefinito è NULL.

rowSelection

Specifica le righe (osservazioni) dal set di dati che devono essere usate dal modello con il nome di una variabile logica dal set di dati (tra virgolette) o con un'espressione logica tramite variabili nel set di dati. Ad esempio, rowSelection = "old" userà solo osservazioni in cui il valore della variabile old è TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) usa solo osservazioni in cui il valore della variabile age è compreso tra 20 e 65 e il valore di log della variabile income è maggiore di 10. La selezione delle righe viene eseguita dopo l'elaborazione di eventuali trasformazioni dei dati. Vedere gli argomenti transforms o transformFunc. Analogamente a tutte le espressioni, è possibile definire rowSelection all'esterno della chiamata alla funzione usando la funzione di espressione.

transforms

Espressione con formato list(name = expression, ``...) che rappresenta il primo ciclo di trasformazioni delle variabili. Analogamente a tutte le espressioni, è possibile definire transforms o rowSelection all'esterno della chiamata alla funzione usando la funzione di espressione.

transformObjects

Elenco denominato che contiene oggetti a cui transforms, transformsFunce rowSelection possono fare riferimento.

transformFunc

Funzione di trasformazione della variabile. Per informazioni dettagliate, vedere rxTransform.

transformVars

Vettore di caratteri delle variabili del set di dati di input necessario per la funzione di trasformazione. Per informazioni dettagliate, vedere rxTransform.

transformPackages

Vettore di caratteri che specifica altri pacchetti R, oltre a quelli specificati in rxGetOption("transformPackages"), da rendere disponibili e precaricati per l'uso nelle funzioni di trasformazione delle variabili. Ad esempio, quelli definiti in modo esplicito nelle funzioni RevoScaleR tramite i relativi argomenti transforms e transformFunc o quelli definiti in modo implicito tramite i relativi argomenti formula o rowSelection. L'argomento transformPackages può anche essere NULL, che indica che non vengono precaricati pacchetti esterni a rxGetOption("transformPackages").

transformEnvir

Ambiente definito dall'utente da usare come elemento padre di tutti gli ambienti sviluppati internamente e usati per la trasformazione dei dati delle variabili. Se transformEnvir = NULL, viene invece usato un nuovo ambiente "hash" con padre baseenv().

blocksPerRead

Specifica il numero di blocchi da leggere per ogni blocco di dati letto dall'origine dati.

reportProgress

Valore intero che specifica il livello di creazione di report sullo stato di elaborazione delle righe:

  • 0: non viene segnalato alcun avanzamento.
  • 1: il numero di righe elaborate viene stampato e aggiornato.
  • 2: vengono segnalate le righe elaborate e le tempistiche.
  • 3: vengono segnalate le righe elaborate e tutte le tempistiche.

verbose

Valore intero che specifica la quantità di output desiderata. Se 0, non viene stampato alcun output dettagliato durante i calcoli. Valori interi da 1 a 4 per fornire quantità crescenti di informazioni.

computeContext

Imposta il contesto in cui vengono eseguiti i calcoli, specificato con un RxComputeContext valido. Sono attualmente supportati contesti di calcolo locali e RxInSqlServer.

ensemble

Parametri di controllo per l'ensembling.

...

Argomenti aggiuntivi da passare direttamente al motore di calcolo Microsoft.

Dettagli

rxFastTrees è un'implementazione di FastRank. FastRank e un'implementazione efficiente dell'algoritmo di gradient boosting MART. L'incremento dei gradienti è una tecnica di apprendimento automatico per i problemi di regressione. Crea ogni albero di regressione in maniera graduale, usando una funzione di perdita predefinita per misurare l'errore di ogni passaggio e correggerlo nel passaggio successivo. Questo modello di previsione è effettivamente costituito da un insieme di modelli di previsione più deboli. Nei problemi di regressione, il boosting crea una serie di tali alberi in maniera graduale e quindi seleziona l'albero ottimale usando una funzione di perdita differenziabile arbitraria.

L'algoritmo MART apprende un insieme di alberi di regressione, ovvero un albero delle decisioni con valori scalari nelle foglie. Un albero delle decisioni, o di regressione, è un diagramma di flusso analogo a un albero binario, in cui, in corrispondenza di ogni nodo interno, si decide con quale dei due nodi figlio proseguire, in base a uno dei valori di funzionalità dell'input. A ogni nodo foglia viene restituito un valore. Nei nodi interni, la decisione si basa sulla formula "x <= v" di test, dove x è il valore della funzionalità dell'esempio di input e v è uno dei possibili valori della funzionalità. Le funzioni che possono essere generate da un albero di regressione sono tutte le funzioni costanti a tratti.

L'insieme di alberi viene prodotto calcolando a ogni passaggio un albero di regressione che fornisce un'approssimazione del gradiente della funzione di perdita e aggiungendo tale albero a quello precedente con coefficienti che riducono al minimo la perdita del nuovo albero. L'output dell'insieme prodotto da MART in un'istanza specifica è la somma degli output degli alberi.

Nel caso di un problema di classificazione binaria, l'output viene convertito in una probabilità mediante una qualche forma di calibrazione.

Nel caso di un problema di regressione, l'output corrisponde al valore previsto della funzione.

Nel caso di un problema di classificazione, le istanze vengono ordinate in base al valore di output dell'insieme.

Se type è impostato su "regression", viene usata una versione di regressione di FastTree. Se è impostata su "ranking", viene usata una versione di classificazione di FastTree. In caso di classificazione, le istanze devono essere ordinate in base all'output dell'insieme di alberi. L'unica differenza tra le impostazioni di queste versioni riguarda le impostazioni di calibrazione, necessarie solo per la classificazione.

Valore

rxFastTrees: oggetto rxFastTrees con il modello sottoposto a training.

FastTree: oggetto di specifica dello strumento di apprendimento con classe maml per il programma di training basato sul metodo Fast Tree.

Note

Questo algoritmo è multithreading e proverà sempre a caricare l'intero set di dati in memoria.

Autore/i

Microsoft Corporation Microsoft Technical Support

Riferimenti

Wikipedia: Gradient boosting (Gradient tree boosting)

Greedy function approximation: A gradient boosting machine.

Vedi anche

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

Esempi


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

 # Create xdf file with per-instance results using rxPredict
 xdfOut <- tempfile(pattern = "scoreOut", fileext = ".xdf")
 scoreDS <- rxPredict(treeModel, data = infert1,
    extraVarsToWrite = c("isCase", "Score"), 
    outData = xdfOut)

 rxDataStep(scoreDS, numRows = 10)

 # Clean-up
 file.remove(xdfOut)

 ######################################################################
 # Estimate a regression fast tree

 # 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 Tree for train data
 fastTreeReg <- rxFastTrees(airFormula, type = "regression", 
     data = trainAir)  

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

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