microsoftml.rx_fast_trees: Árvores Aumentadas

Usage

microsoftml.rx_fast_trees(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'regression'] = 'binary', num_trees: int = 100,
    num_leaves: int = 20, learning_rate: float = 0.2,
    min_split: int = 10, example_fraction: float = 0.7,
    feature_fraction: float = 1, split_fraction: float = 1,
    num_bins: int = 255, first_use_penalty: float = 0,
    gain_conf_level: float = 0, unbalanced_sets: bool = False,
    train_threads: int = 8, random_seed: int = None,
    ml_transforms: list = None, ml_transform_vars: list = None,
    row_selection: str = None, transforms: dict = None,
    transform_objects: dict = None, transform_function: str = None,
    transform_variables: list = None,
    transform_packages: list = None,
    transform_environment: dict = None, blocks_per_read: int = None,
    report_progress: int = None, verbose: int = 1,
    ensemble: microsoftml.modules.ensemble.EnsembleControl = None,
    compute_context: revoscalepy.computecontext.RxComputeContext.RxComputeContext = None)

Description

Árvore Rápida do Machine Learning

Detalhes

rx_fast_trees é uma implementação do FastRank. FastRank é uma implementação eficiente do algoritmo de aumento de gradiente 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 de forma passo a passo, usando uma função de perda predefinida para medir o erro para cada etapa e corrige para ela na próxima. Portanto, esse modelo de previsão é, na verdade, um conjunto de modelos de previsão mais fracos. Em problemas de regressão, o aumento cria uma série dessas árvores de forma passo a passo e seleciona a árvore ideal usando uma função de perda arbitrariamente diferencial.

O MART aprende um conjunto de árvores de regressão, que é uma árvore de decisão com valores escalares em suas folhas. Uma árvore de decisão (ou regressão) é um fluxograma binário semelhante a uma árvore, em que em cada nó interior um decide qual dos dois nós filho continuará com base em um dos valores de recurso da entrada. Em cada nó folha, um valor é retornado. Nos nós interiores, a decisão é baseada no teste "x <= v", onde x está o valor do recurso na amostra de entrada e v é um dos valores possíveis desse recurso. As funções que podem ser produzidas por uma árvore de regressão são todas as funções constantes em termos de peça.

O conjunto de árvores é produzido pela computação, em cada etapa, de uma árvore de regressão que aproxima o gradiente da função de perda e adicionando-a à árvore anterior com coeficientes que minimizam a perda da nova árvore. A saída do conjunto produzido pelo MART em uma determinada instância é a soma das saídas de á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 method for definido como "regression", uma versão de regressão do FastTree será usada. Se definido como "ranking", uma versão de classificação do FastTree será 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 está nas configurações de calibragem, que são necessárias apenas para classificação.

Arguments

fórmula

A fórmula, conforme descrito em revoscalepy.rx_formula. No momento, não há suporte para termos F() de interação no microsoftml.

dados

Um objeto de fonte de dados ou uma cadeia de caracteres especificando um arquivo .xdf ou um objeto de quadro de dados.

método

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 Rápida de Árvore.

num_trees

Especifica o número total de árvores de decisão a serem criadas no conjunto. Ao criar mais árvores de decisão, você pode potencialmente obter uma melhor cobertura, mas o tempo de treinamento aumenta. O valor padrão é 100.

num_leaves

O número máximo de folhas (nós de terminal) que podem ser criadas em qualquer árvore. Valores mais altos potencialmente aumentam o tamanho da árvore e obtêm melhor precisão, mas correm o risco de sobreajustá-lo e exigir tempos de treinamento mais longos. O valor padrão é 20.

taxa de aprendizado

Determina o tamanho da etapa executada na direção do gradiente em cada etapa do processo de aprendizagem. Isso determina o quão rápido ou lento o aprendiz converge para a solução ideal. Se o tamanho da etapa for muito grande, você poderá superar a solução ideal. Se o tamanho da etapa for muito pequeno, o treinamento levará mais tempo para convergir para a melhor solução.

min_split

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 sub-amostrados. 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 se as instâncias forem ponderadas.

example_fraction

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

feature_fraction

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

split_fraction

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

num_bins

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 em seu próprio compartimento. Se houver mais valores, o algoritmo criará numBins compartimentos.

first_use_penalty

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

gain_conf_level

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

unbalanced_sets

Se True, derivativos otimizados para conjuntos desbalanceados são usados. Aplicável somente quando type igual a "binary". O valor padrão é False.

train_threads

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

random_seed

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

ml_transforms

Especifica uma lista de transformações do MicrosoftML a serem executadas nos dados antes do treinamento ou Nenhuma se nenhuma transformação deve ser executada. Consulte featurize_text, categoricale categorical_hash, para transformações com suporte. Essas transformações são executadas após quaisquer transformações do Python especificadas. O valor padrão é None.

ml_transform_vars

Especifica um vetor de caracteres de nomes de variáveis a serem usados ou ml_transformsNenhum se nenhum for usado. O valor padrão é None.

row_selection

SEM SUPORTE. 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:

row_selection = "old" usará apenas observações nas quais o valor da variável old é True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) usa apenas observações nas quais o valor da age variável está entre 20 e 65 e o valor da logincome variável é maior que 10.

A seleção de linha é executada após o processamento de transformações de dados (consulte os argumentos transforms ou transform_function). Assim como acontece com todas as expressões, row_selection pode ser definido fora da chamada de função usando a expression função.

Transforma

SEM SUPORTE. Uma expressão do formulário que representa a primeira rodada de transformações variáveis. Assim como acontece com todas as expressões, transforms (ou row_selection) pode ser definido fora da chamada de função usando a expression função.

transform_objects

SEM SUPORTE. Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transform_functione row_selection.

transform_function

A função de transformação variável.

transform_variables

Um vetor de caractere das variáveis de conjunto de dados de entrada necessárias para a função de transformação.

transform_packages

SEM SUPORTE. Um vetor de caracteres que especifica pacotes python adicionais (fora daqueles especificados em RxOptions.get_option("transform_packages")) a serem disponibilizados e pré-carregados para uso em funções de transformação variável. Por exemplo, aqueles explicitamente definidos em funções revoscalepy por meio de seus transforms argumentos ou transform_function argumentos ou aqueles definidos implicitamente por meio de seus formula argumentos ou row_selection argumentos. O transform_packages argumento também pode ser Nenhum, indicando que nenhum pacote externo RxOptions.get_option("transform_packages") está pré-carregado.

transform_environment

SEM SUPORTE. Um ambiente definido pelo usuário para servir como pai para todos os ambientes desenvolvidos internamente e usados para transformação de dados variáveis. Se transform_environment = None, um novo ambiente "hash" com parent revoscalepy.baseenv será usado em vez disso.

blocks_per_read

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

report_progress

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

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

detalhada

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

compute_context

Define o contexto no qual os cálculos são executados, especificado com um revoscalepy válido. RxComputeContext. Atualmente local e revoscalepy. Há suporte para contextos de computação RxInSqlServer .

Conjunto

Controlar parâmetros para ensembling.

Devoluções

Um FastTrees objeto com o modelo treinado.

Observação

Esse algoritmo tem vários threads e sempre tentará carregar todo o conjunto de dados na memória.

Consulte também

rx_fast_forest, rx_predict

Referências

Wikipédia: Aumento de gradiente (aumento de árvore de gradiente)

Aproximação de função greedy: uma máquina de aumento de gradiente.

Exemplo de Classificação Binária

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_fast_trees, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

infert = get_dataset("infert")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

infertdf = infert.as_df()
infertdf["isCase"] = infertdf.case == 1
data_train, data_test, y_train, y_test = train_test_split(infertdf, infertdf.isCase)

trees_model = rx_fast_trees(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(trees_model, data=data_test,
                     extra_vars_to_write=["isCase", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))

Saída:

Not adding a normalizer.
Making per-feature arrays
Changing data from row-wise to column-wise
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Processed 186 instances
Binning and forming Feature objects
Reserved memory for tree learner: 7020 bytes
Starting to train ...
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0949161
Elapsed time: 00:00:00.0112103
Beginning processing data.
Rows Read: 62, Read Time: 0.001, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0230457
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: 0.001 seconds 
  isCase PredictedLabel      Score  Probability
0  False          False  -4.722279     0.131369
1  False          False -11.550012     0.009757
2  False          False  -7.312314     0.050935
3   True           True   3.889991     0.825778
4  False          False  -6.361800     0.072782

Exemplo de regressão

'''
Regression.
'''
import numpy
import pandas
from microsoftml import rx_fast_trees, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

airquality = get_dataset("airquality")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

airquality = airquality.as_df()


######################################################################
# Estimate a regression fast forest
# Use the built-in data set 'airquality' to create test and train data

df = airquality[airquality.Ozone.notnull()]
df["Ozone"] = df.Ozone.astype(float)

data_train, data_test, y_train, y_test = train_test_split(df, df.Ozone)

airFormula = " Ozone ~ Solar_R + Wind + Temp "

# Regression Fast Forest for train data
ff_reg = rx_fast_trees(airFormula, method="regression", data=data_train)

# Put score and model variables in data frame
score_df = rx_predict(ff_reg, data=data_test, write_model_vars=True)
print(score_df.head())

# Plot actual versus predicted values with smoothed line
# Supported in the next version.
# rx_line_plot(" Score ~ Ozone ", type=["p", "smooth"], data=score_df)