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 do Machine Learning

Detalhes

Árvores de decisão são modelos não paramétricos que executam uma sequência de testes simples em entradas. Esse procedimento de decisão os mapeia para saídas encontradas no conjunto de dados de treinamento cujas entradas eram semelhantes à instância que está sendo processada. Uma decisão é tomada em cada nó da estrutura de dados de árvore binária com base em uma medida de similaridade que mapeia cada instância recursivamente pelos branches da árvore até que o nó folha apropriado seja atingido e a decisão de saída seja retornada.

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

Elas são eficientes tanto na computação quanto no uso de memória durante o treinamento e a previsão.
Eles podem representar limites de decisão não lineares.
Eles executam a seleção e a classificação de recursos integrados.
Eles são resilientes na presença de recursos barulhentos.

A regressão rápida da floresta é uma floresta aleatória e uma implementação de floresta de regressão quantile usando o aprendiz de árvore de regressão em rx_fast_trees. O modelo consiste em um conjunto de árvores de decisão. Cada árvore em uma floresta de decisão gera uma distribuição gaussiana por meio da previsão. Uma agregação é executada sobre o conjunto de árvores para localizar uma distribuição gaussiana mais próxima da distribuição combinada para todas as árvores no modelo.

Esse classificador de floresta de decisão consiste em um conjunto de árvores de decisão. Geralmente, os modelos de conjunto fornecem melhor cobertura e precisão do que árvores de decisão única. Cada árvore em uma floresta de decisão gera uma distribuição gaussiana.

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 indica o tipo á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.

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.

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

split_fraction

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

num_bins

Número máximo de valores distintos (compartimentos) por recurso. O valor padrão é 255.

first_use_penalty

O recurso usa primeiro o coeficiente de penalidade. 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.

train_threads

O número de threads a serem usados no treinamento. Se Nenhum for especificado, o número de threads a serem usados será determinado internamente. O valor padrão é None.

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 valor válido RxComputeContext. Atualmente, há suporte para contextos locais e RxInSqlServer de computação.

Conjunto

Controlar parâmetros para ensembling.

Devoluções

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

Referências

Wikipédia: floresta aleatória

Floresta de regressão quantile

De tocos a árvores a 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))

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