microsoftml.rx_fast_forest: Floresta Aleatória

Usage

microsoftml.rx_fast_forest(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'regression'] = 'binary', num_trees: int = 100,
    num_leaves: int = 20, 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,
    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

Floresta Rápida de Aprendizagem Automática

Detalhes

As árvores de decisão são modelos não paramétricos que realizam uma sequência de testes simples sobre entradas. Este procedimento de decisão mapeia-as para saídas encontradas no conjunto de dados de treino cujos inputs eram semelhantes à instância em processamento. É tomada uma decisão em cada nó da estrutura de dados da árvore binária com base numa medida de similaridade que mapeia cada instância recursivamente pelos ramos da árvore até que o nó folha apropriado seja alcançado e a decisão de saída devolvida.

As árvores de decisão têm várias vantagens:

São eficientes tanto na computação como na utilização da memória durante o treino e a previsão.
Podem representar limites de decisão não lineares.
Realizam seleção e classificação integradas de funcionalidades.
São resistentes à presença de elementos ruidosos.

A regressão rápida de floresta é uma implementação de floresta aleatória e regressão quantile usando o aprendiz da árvore de regressão em rx_fast_trees. O modelo consiste num conjunto de árvores de decisão. Cada árvore numa floresta de decisão produz uma distribuição Gaussiana através de previsão. É realizada uma agregação sobre o conjunto de árvores para encontrar uma distribuição Gaussiana mais próxima da distribuição combinada para todas as árvores do modelo.

Este classificador de floresta de decisão consiste num conjunto de árvores de decisão. Geralmente, os modelos de conjunto oferecem melhor cobertura e precisão do que as árvores de decisão individuais. Cada árvore numa floresta de decisão produz uma distribuição Gaussian.

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 indica 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 de Árvores.

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.

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.

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 é 0,7.

split_fraction

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

num_bins

Número máximo de valores distintos (bins) por característica. O valor padrão é 255.

first_use_penalty

A funcionalidade usa primeiro o coeficiente de penalização. O valor padrão é 0.

gain_conf_level

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

train_threads

O número de fios a usar no treino. Se Nenhum for especificado, o número de threads a usar é determinado internamente. O valor predefinido é None.

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 um válido RxComputeContext. Atualmente, são suportados contextos locais e RxInSqlServer de computação.

Ensemble

Parâmetros de controlo para a montagem.

Devoluções

Um FastForest 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_trees, rx_predict

Referências

Wikipédia: Floresta aleatória

Floresta de regressão quantile

De Tocos a Árvores e Florestas

Exemplo de classificação binária

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_fast_forest, 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)

forest_model = rx_fast_forest(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(forest_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: 7176 bytes
Starting to train ...
Not training a calibrator because a valid calibrator trainer was not provided.
Elapsed time: 00:00:00.2704185
Elapsed time: 00:00:00.0443884
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0253862
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: Less than .001 seconds 
  isCase PredictedLabel      Score
0  False          False -36.205067
1   True          False -40.396084
2  False          False -33.242531
3  False          False -87.212494
4   True          False -13.100666

Exemplo de regressão

'''
Regression.
'''
import numpy
import pandas
from microsoftml import rx_fast_forest, 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_forest(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)