microsoftml.rx_fast_trees: Árvores Potenciadas

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 de Aprendizagem Automática

Detalhes

rx_fast_trees é uma implementação do FastRank. O FastRank é uma implementação eficiente do algoritmo de aumento de gradiente MART. O gradient boosting é uma técnica de aprendizagem automática para problemas de regressão. Constrói cada árvore de regressão de forma passo a passo, usando uma função de perda pré-definida para medir o erro em cada passo e corrigi-lo no seguinte. Portanto, este modelo de previsão é, na verdade, um conjunto de modelos de predição mais fracos. Em problemas de regressão, o boosting constrói uma série dessas árvores de forma gradual e depois seleciona a árvore ótima 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 suas folhas. Uma árvore de decisão (ou regressão) é um diagrama de fluxo binário em forma de árvore, onde, em cada nó interior, se decide qual dos dois nós filhos continuar com base num dos valores das características da entrada. Em cada nó folha, é devolvido um valor. Nos nós interiores, a decisão baseia-se no teste "x <= v", onde x é o valor da característica na amostra de entrada e v é um dos valores possíveis desta característica. As funções que podem ser produzidas por uma árvore de regressão são todas as funções constantes por partes.

O conjunto de árvores é produzido ao calcular, em cada etapa, uma árvore de regressão que aproxima o gradiente da função de perda, e adicioná-la à árvore anterior com coeficientes que minimizam a perda da nova árvore. A saída do conjunto produzida pelo MART numa dada instância é a soma das saídas da árvore.

No caso de um problema de classificação binária, a saída é convertida numa probabilidade usando algum tipo de calibração.
No caso de um problema de regressão, a saída é o valor previsto da função.
No caso de um problema de ordenação, as instâncias são ordenadas pelo valor de saída do conjunto.

Se method for definido para "regression", é usada uma versão regressiva do FastTree. Se definido para "ranking", é usada uma versão classificada do FastTree. No caso de classificação, as instâncias devem ser ordenadas pela saída do conjunto de árvores. A única diferença nas definições destas versões está nas de calibração, que são necessárias apenas para classificação.

Arguments

fórmula

A fórmula descrita em revoscalepy.rx_formula. Termos de interação e F() não são atualmente suportados no microsoftml.

dados

Um objeto fonte de dados ou uma cadeia de caracteres que especifica um ficheiro .xdf ou um objeto data frame.

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 por defeito ou "regression" para Regressão Rápida em Árvore.

num_trees

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

num_leaves

O número máximo de folhas (nós terminais) que podem ser criadas em qualquer árvore. Valores mais elevados podem aumentar o tamanho da árvore e obter melhor precisão, mas correm o risco de sobreajustamento e de demorar tempos de treino mais longos. O valor padrão é 20.

taxa de aprendizagem

Determina o tamanho do passo dado na direção do gradiente em cada etapa do processo de aprendizagem. Isto determina quão rápido ou lentamente o aprendiz converge para a solução ótima. Se o tamanho do passo for demasiado grande, podes ultrapassar a solução ideal. Se o tamanho do passo for demasiado pequeno, o treino demora mais a convergir para a melhor solução.

min_split

Número mínimo de instâncias de treino necessárias para formar uma folha. Ou seja, o número mínimo de documentos permitidos numa folha de uma árvore de regressão, a partir dos dados subamostrados. Uma 'divisão' significa que as características em cada nível da árvore (nó) são divididas aleatoriamente. O valor padrão é 10. Apenas o número de instâncias é contado, mesmo que as instâncias sejam ponderadas.

example_fraction

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

feature_fraction

A fração de características escolhidas aleatoriamente para usar em cada árvore. O valor padrão é 1.

split_fraction

A fração de características escolhidas aleatoriamente para usar em cada divisão. O valor padrão é 1.

num_bins

Número máximo de valores distintos (bins) por característica. Se a característica tiver menos valores do que o número indicado, cada valor é colocado no seu próprio bin. Se houver mais valores, o algoritmo cria numBins bins.

first_use_penalty

A funcionalidade usa primeiro o coeficiente de penalização. Esta é uma forma de regularização que acarreta uma penalização por usar uma nova funcionalidade ao criar a árvore. Aumente este valor para criar árvores que não utilizem muitas funcionalidades. O valor padrão é 0.

gain_conf_level

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

unbalanced_sets

Se True, são usadas derivadas otimizadas para conjuntos desequilibrados. Aplicável apenas quando type iguais a "binary". O valor predefinido é False.

train_threads

O número de fios a usar no treino. O valor padrão é 8.

random_seed

Especifica a semente aleatória. O valor predefinido é None.

ml_transforms

Especifica uma lista de transformações MicrosoftML a realizar nos dados antes do treino ou Nenhuma se não forem realizadas transformações. Veja featurize_text, categorical, e categorical_hash, para transformações que são suportadas. Estas transformações são realizadas após quaisquer transformações em Python especificadas. O valor predefinido é None.

ml_transform_vars

Especifica um vetor de caracteres com nomes de variáveis a serem usados em ml_transforms ou Nenhum se não for necessário usar nenhum. O valor predefinido é None.

row_selection

NÃO SUPORTADO. Especifica as linhas (observações) do conjunto de dados que serão 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 do conjunto de dados. Por exemplo:

row_selection = "old" só usará observações em que o valor da variável old é True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) só utiliza observações em que o valor da age variável está entre 20 e 65 e o valor log da income variável é superior a 10.

A seleção de linhas é realizada após o processamento de quaisquer transformações de dados (ver os argumentos transforms ou transform_function). Como em todas as expressões, row_selection pode ser definido fora da chamada de função usando a expression função.

transforma

NÃO SUPORTADO. Uma expressão da forma que representa a primeira ronda de transformações de variáveis. Como em todas as expressões, transforms (ou row_selection) pode ser definido fora da chamada de função usando a expression função.

transform_objects

NÃO SUPORTADO. Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transform_function, e row_selection.

transform_function

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

transform_variables

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

transform_packages

NÃO SUPORTADO. Um vetor de caracteres que especifica pacotes Python adicionais (para além dos especificados em RxOptions.get_option("transform_packages")) a serem disponibilizados e pré-carregados para uso em funções de transformação de variáveis. Por exemplo, aquelas definidas explicitamente em funções revoscalepy através dos argumentos e transformstransform_function ou aquelas definidas implicitamente através dos argumentos ou formularow_selection . O transform_packages argumento pode também ser Nenhum, indicando que nenhum pacote externo RxOptions.get_option("transform_packages") está pré-carregado.

transform_environment

NÃO SUPORTADO. Um ambiente definido pelo utilizador para servir como pai de todos os ambientes desenvolvidos internamente e usados para transformação de dados variáveis. Se transform_environment = None, é utilizado um novo ambiente "hash" com o pai revoscalepy.baseenv.

blocks_per_read

Especifica o número de blocos a ler para cada bloco de dados lido da fonte de dados.

report_progress

Um valor inteiro que especifica o nível de reporte sobre o progresso do processamento da linha:

0: Não há progresso reportado.
1: o número de linhas processadas é impresso e atualizado.
2: as linhas processadas e os tempos são reportados.
3: linhas processadas e todos os tempos são reportados.

verbose

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

compute_context

Define o contexto em que os cálculos são executados, especificado com uma revoscalpy válida. RxComputeContext. Atualmente local e revoscalepy. São suportados contextos de computação RxInSqlServer .

Ensemble

Parâmetros de controlo para a montagem.

Devoluções

Um FastTrees objeto com o modelo treinado.

Observação

Este algoritmo é multi-thread e tentará sempre 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 da função gananciosa: 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))

Output:

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)