microsoftml.rx_fast_forest: Bosque aleatorio

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

Bosque rápido de Machine Learning

Detalles

Los árboles de decisión son modelos no paramétricos que realizan una secuencia de pruebas simples en las entradas. Este procedimiento de decisión los asigna a las salidas encontradas en el conjunto de datos de entrenamiento cuyas entradas eran similares a la instancia que se está procesando. Se toma una decisión en cada nodo de la estructura de datos del árbol binario en función de una medida de similitud que asigna cada instancia de forma recursiva a través de las ramas del árbol hasta que se alcanza el nodo hoja adecuado y se devuelve la decisión de salida.

Los árboles de decisión tienen varias ventajas:

Son eficaces tanto en el cálculo como en el uso de memoria durante el entrenamiento y la predicción.
Pueden representar límites de decisión no lineales.
Realizan la selección y clasificación de características integradas.
Son resistentes en presencia de características ruidosas.

La regresión rápida del bosque es un bosque aleatorio y una implementación de bosque de regresión cuantil mediante el aprendiz de árbol de regresión en rx_fast_trees. El modelo consta de un conjunto de árboles de decisión. Cada árbol de un bosque de decisión genera una distribución gaussiana mediante la predicción. Una agregación se realiza sobre el conjunto de árboles para encontrar una distribución gaussiana más cercana a la distribución combinada de todos los árboles del modelo.

Este clasificador de bosque de decisión consta de un conjunto de árboles de decisión. Por lo general, los modelos de conjunto proporcionan una mejor cobertura y precisión que los árboles de decisión únicos. Cada árbol de un bosque de decisión genera una distribución gaussiana.

Arguments

formula

Fórmula tal como se describe en revoscalepy.rx_formula. Los términos de interacción y F() no se admiten actualmente en microsoftml.

datos

Objeto de origen de datos o cadena de caracteres que especifica un archivo .xdf o un objeto de trama de datos.

method

Cadena de caracteres que indica el tipo de árbol rápido:

"binary" para la clasificación binaria de árbol rápido predeterminada o
"regression" para Regresión de árbol rápido.

num_trees

Especifica el número total de árboles de decisión que se van a crear en el conjunto. Al crear más árboles de decisión, puede obtener una mejor cobertura, pero el tiempo de entrenamiento aumenta. El valor predeterminado es 100.

num_leaves

Número máximo de hojas (nodos terminales) que se pueden crear en cualquier árbol. Los valores más altos pueden aumentar el tamaño del árbol y obtener una mejor precisión, pero corre el riesgo de sobreajustar y requerir tiempos de entrenamiento más largos. El valor predeterminado es 20.

min_split

Número mínimo de instancias de entrenamiento necesarias para formar una hoja. Es decir, el número mínimo de documentos permitidos en una hoja de un árbol de regresión, fuera de los datos sub muestreados. Una "división" significa que las características de cada nivel del árbol (nodo) se dividen aleatoriamente. El valor predeterminado es 10.

example_fraction

Fracción de instancias elegidas aleatoriamente que se van a usar para cada árbol. El valor predeterminado es 0,7.

feature_fraction

Fracción de características elegidas aleatoriamente que se van a usar para cada árbol. El valor predeterminado es 0,7.

split_fraction

Fracción de características elegidas aleatoriamente que se usarán en cada división. El valor predeterminado es 0,7.

num_bins

Número máximo de valores distintos (intervalos) por característica. El valor predeterminado es 255.

first_use_penalty

La característica usa primero el coeficiente de penalización. El valor predeterminado es 0.

gain_conf_level

Requisito de confianza de ganancia de ajuste de árbol (debe estar en el intervalo [0,1]). El valor predeterminado es 0.

train_threads

Número de subprocesos que se van a usar en el entrenamiento. Si se especifica None , el número de subprocesos que se van a usar se determina internamente. El valor predeterminado es None.

random_seed

Especifica la inicialización aleatoria. El valor predeterminado es None.

ml_transforms

Especifica una lista de transformaciones de MicrosoftML que se van a realizar en los datos antes del entrenamiento o None si no se va a realizar ninguna transformación. Consulte featurize_text, categoricaly categorical_hash, para ver las transformaciones admitidas. Estas transformaciones se realizan después de las transformaciones de Python especificadas. El valor predeterminado es None.

ml_transform_vars

Especifica un vector de caracteres de nombres de variable que se van a usar en ml_transforms o Ninguno si no se va a usar ninguno. El valor predeterminado es None.

row_selection

NO SE ADMITE. Especifica las filas (observaciones) del conjunto de datos que va a usar el modelo con el nombre de una variable lógica del conjunto de datos (entre comillas) o con una expresión lógica mediante variables del conjunto de datos. Por ejemplo:

row_selection = "old" solo usará observaciones en las que el valor de la variable old es True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) solo usa observaciones en las que el valor de la age variable está comprendido entre 20 y 65 y el valor de log la income variable es mayor que 10.

La selección de filas se realiza después de procesar las transformaciones de datos (vea los argumentos transforms o transform_function). Al igual que con todas las expresiones, row_selection se puede definir fuera de la llamada de función mediante la expression función .

Transforma

NO SE ADMITE. Expresión del formulario que representa la primera ronda de transformaciones de variables. Al igual que con todas las expresiones, transforms (o row_selection) se puede definir fuera de la llamada de función mediante la expression función .

transform_objects

NO SE ADMITE. Lista con nombre que contiene objetos a los que puede hacer referencia transforms, transform_functiony row_selection.

transform_function

Función de transformación de variables.

transform_variables

Vector de caracteres de variables del conjunto de datos de entrada necesarias para la función de transformación.

transform_packages

NO SE ADMITE. Vector de caracteres que especifica paquetes adicionales de Python (fuera de los especificados en RxOptions.get_option("transform_packages")) que se van a poner a disposición y cargar previamente para su uso en las funciones de transformación de variables. Por ejemplo, los definidos explícitamente en funciones de revoscalepy a través de sus transforms argumentos y transform_function o los definidos implícitamente a través de sus formula argumentos o row_selection . El transform_packages argumento también puede ser None, lo que indica que no hay paquetes externos RxOptions.get_option("transform_packages") cargados previamente.

transform_environment

NO SE ADMITE. Un entorno definido por el usuario que sirve como elemento primario para todos los entornos desarrollados internamente y se usa para la transformación de datos variables. Si transform_environment = Nonees , se usa en su lugar un nuevo entorno "hash" con revoscalepy.baseenv primario.

blocks_per_read

Especifica el número de bloques que se van a leer para cada fragmento de datos leídos desde el origen de datos.

report_progress

Valor entero que especifica el nivel de informes sobre el progreso del procesamiento de filas:

0: no se notifica ningún progreso.
1: el número de filas procesadas se imprime y actualiza.
2: se notifican filas procesadas y tiempos.
3: se notifican filas procesadas y todos los intervalos.

verbose

Valor entero que especifica la cantidad de salida deseada. Si 0es , no se imprime ninguna salida detallada durante los cálculos. Valores enteros de 1 para 4 proporcionar cantidades crecientes de información.

compute_context

Establece el contexto en el que se ejecutan los cálculos, especificados con un valor válido RxComputeContext. Actualmente se admiten contextos locales y RxInSqlServer de proceso.

conjunto

Parámetros de control para el montaje.

Devoluciones

Objeto FastForest con el modelo entrenado.

Nota:

Este algoritmo es multiproceso y siempre intentará cargar todo el conjunto de datos en la memoria.

Consulte también

rx_fast_trees, rx_predict

Referencias

Wikipedia: Bosque aleatorio

Bosque de regresión cuantil

De totumps a árboles a bosques

Ejemplo de clasificación binaria

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

Salida:

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

Ejemplo de regresión

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