rxFastTrees: árvore rápida

Árvore rápida de machine learning

Uso

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

Argumentos

formula

A fórmula como descrita em rxFormula. No momento, não há suporte para termos de interação nem para F() no MicrosoftML.

data

Um objeto de fonte de dados ou uma cadeia de caracteres que especifica um arquivo .xdf ou um objeto de dataframe.

type

Uma cadeia de caracteres que especifica o tipo de árvore rápida: "binary" para a classificação binária de árvore rápida padrão ou "regression" para regressão de árvore rápida.

numTrees

Especifica o número total de árvores de decisão a serem criadas no ensemble. Criando mais árvores de decisão, você tem o potencial de obter uma melhor cobertura, mas o tempo de treinamento aumenta. O valor padrão é 100.

numLeaves

O número máximo de folhas (nós de terminal) que podem ser criadas em uma árvore. Valores mais altos podem aumentar o tamanho da árvore e melhorar a precisão, mas há um risco de sobreajuste e de necessidade de mais tempo de treinamento. O valor padrão é 20.

learningRate

Determina o tamanho da etapa realizada na direção do gradiente em cada etapa do processo de aprendizado. Determina a velocidade em que o aprendiz é convergido na solução ideal. Se o tamanho da etapa for muito grande, você poderá exceder a solução ideal. Se o tamanho da etapa muito pequeno, o treinamento vai demorar mais para ser convergido na melhor solução.

minSplit

Número mínimo de instâncias de treinamento necessárias para formar uma folha. Ou seja, o número mínimo de documentos permitidos em uma folha de uma árvore de regressão, fora dos dados subamostrados. Uma "divisão" significa que os recursos em cada nível da árvore (nó) são divididos aleatoriamente. O valor padrão é 10. Somente o número de instâncias é contado, mesmo que as instâncias sejam ponderadas.

exampleFraction

A fração de instâncias escolhidas aleatoriamente a ser usada para cada árvore. O valor padrão é 0,7.

featureFraction

A fração de recursos escolhidos aleatoriamente a ser usada para cada árvore. O valor padrão é 1.

splitFraction

A fração de recursos escolhidos aleatoriamente a ser usada em cada divisão. O valor padrão é 1.

numBins

Número máximo de valores distintos (compartimentos) por recurso. Se o recurso tiver menos valores do que o número indicado, cada valor será colocado no respectivo compartimento. Se houver mais valores, o algoritmo criará numBins compartimentos.

firstUsePenalty

O recurso primeiro usa o coeficiente de penalidade. Essa é uma forma de regularização que gera uma penalidade pelo uso de um novo recurso ao criar a árvore. Aumente esse valor para criar árvores que não usam muitos recursos. O valor padrão é 0.

gainConfLevel

Requisito de confiança de ganho de ajuste da árvore (deve estar no intervalo [0,1]). O valor padrão é 0.

unbalancedSets

Se definido como TRUE, as derivadas otimizadas para conjuntos não balanceadas são usadas. Aplicável somente quando type é igual a "binary". O valor padrão é FALSE.

trainThreads

O número de threads a serem usados no treinamento. O valor padrão é 8.

randomSeed

Especifica a semente aleatória. O valor padrão é NULL.

mlTransforms

Especifica uma lista de transformações do MicrosoftML a serem executadas nos dados antes do treinamento ou NULL para que nenhuma transformação seja executada. Confira featurizeText, categorical e categoricalHash, para ver as transformações com suporte. Essas transformações são executadas após as transformações R especificadas. O valor padrão é NULL.

mlTransformVars

Especifica um vetor de caracteres de nomes de variáveis a serem usados em mlTransforms ou NULL quando não é usado nenhum nome. O valor padrão é NULL.

rowSelection

Especifica as linhas (observações) do conjunto de dados que devem ser usadas pelo modelo com o nome de uma variável lógica do conjunto de dados (entre aspas) ou com uma expressão lógica usando variáveis no conjunto de dados. Por exemplo, rowSelection = "old" usará apenas observações nas quais o valor da variável old seja TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) apenas usa observações nas quais o valor da variável age está entre 20 e 65 e o valor de log da variável income é maior que 10. A seleção de linha é executada após o processamento de todas as transformações de dados (confira os argumentos transforms ou transformFunc). Assim como acontece com todas as expressões, é possível definir rowSelection fora da chamada de função usando a função de expressão.

transforms

Uma expressão do formato list(name = expression, ``...) que representa a primeira rodada de transformações de variável. Assim como acontece com todas as expressões, é possível definir transforms (ou rowSelection) fora da chamada de função usando a função de expressão.

transformObjects

Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transformsFunc e rowSelection.

transformFunc

A função de transformação de variável. Confira rxTransform para obter detalhes.

transformVars

Um vetor de caracteres de variáveis do conjunto de dados de entrada necessário para a função de transformação. Confira rxTransform para obter detalhes.

transformPackages

Um vetor de caracteres que especifica pacotes R adicionais (fora aqueles especificados em rxGetOption("transformPackages")) a serem disponibilizados e pré-carregados para uso em funções de transformação de variável. Por exemplo, os definidos explicitamente nas funções RevoScaleR por meio dos respectivos argumentos transforms e transformFunc ou os definidos implicitamente por meio dos respectivos argumentos formula ou rowSelection. O argumento transformPackages também pode ser NULL, indicando que nenhum pacote fora de rxGetOption("transformPackages") é pré-carregado.

transformEnvir

Um ambiente definido pelo usuário para funcionar como um pai de todos os ambientes desenvolvidos internamente e usados para transformação de dados de variável. Se transformEnvir = NULL, um novo ambiente de “hash” com baseenv() pai é usado.

blocksPerRead

Especifica o número de blocos a serem lidos em cada parte dos dados lidos da fonte de dados.

reportProgress

Um valor inteiro que especifica o nível de relatório sobre o progresso do processamento de linha:

• 0: não é relatado nenhum progresso.
• 1: o número de linhas processadas é impresso e atualizado.
• 2: as linhas processadas e os tempos são relatados.
• 3: as linhas processadas e todos os tempos são relatados.

verbose

Um valor inteiro que especifica a quantidade de saída desejada. Se definido como 0, não será impressa nenhuma saída detalhada durante os cálculos. Valores inteiros de 1 a 4 fornecem quantidades crescentes de informações.

computeContext

Define o contexto no qual as computações são executadas, especificado com um RxComputeContext válido. No momento, há suporte para os contextos de computação local e RxInSqlServer.

ensemble

Parâmetros de controle para conjuntos.

...

Argumentos adicionais a serem passados diretamente para o Microsoft Compute Engine.

Detalhes

rxFastTrees é uma implementação de FastRank. FastRank é uma implementação eficiente do algoritmo de gradient boosting MART. O aumento de gradiente é uma técnica de aprendizado de máquina para problemas de regressão. Ele cria cada árvore de regressão por etapas usando uma função de perda predefinida para medir o erro em cada etapa e corrigi-lo na próxima. Portanto, o modelo de previsão é na verdade um conjunto de modelos de previsão mais fracos. Nos problemas de regressão, o aumento cria uma série dessas árvores por etapas e seleciona a árvore ideal usando uma função de perda diferenciável arbitrária.

O MART aprende um conjunto de árvores de regressão, que é uma árvore de decisão com valores escalares nas folhas. Uma árvore de decisão (ou de regressão) é um fluxograma semelhante a uma árvore binária, na qual em cada nó interior é decidido para qual dos dois nós filho o processo deve continuar com base em um dos valores de recurso da entrada. Em cada nó folha, um valor é retornado. No nó interior, a decisão se baseia no teste "x <= v", onde x é o valor do recurso no exemplo de entrada e v é um dos possíveis valores desse recurso. As funções que podem ser produzidas por uma árvore de regressão são constante funções de partes.

O conjunto de árvores é produzido por computação, em cada etapa, uma árvore de regressão que aproxima o gradiente da função de perda e o adiciona à árvore anterior com coeficientes que minimizam a perda da nova árvore. A saída do ensemble produzido por MART em uma determinada instância é a soma das saídas da árvore.

No caso de um problema de classificação binária, a saída é convertida em uma probabilidade usando alguma forma de calibragem.

No caso de um problema de regressão, a saída é o valor previsto da função.

No caso de um problema de classificação, as instâncias são ordenadas pelo valor de saída do conjunto.

Se o type é definido como "regression", uma versão de regressão de FastTree é usada. Se definido como "ranking", uma versão de classificação de FastTree é usada. No caso de classificação, as instâncias devem ser ordenadas pela saída do conjunto de árvores. A única diferença nas configurações dessas versões é nas configurações de calibragem, que são necessárias apenas para classificação.

Valor

rxFastTrees: um objeto rxFastTrees com o modelo treinado.

FastTree: um objeto de especificação de aluno da classe maml para o treinador Árvore Rápida.

Observações

Esse algoritmo é multithreading e sempre tentará carregar o conjunto de dados inteiro na memória.

Autor(es)

Microsoft Corporation Microsoft Technical Support

Referências

Wikipedia: Gradient boosting (Gradient tree boosting)

Greedy function approximation: A gradient boosting machine.

Confira também

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

Exemplos

 # 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)