microsoftml.rx_fast_forest: bosque aleatorio

Artículo
05/23/2023

Uso

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)

Descripción

Aprendizaje automático: Fast Forest

Detalles

Los árboles de decisión son modelos no paramétricos que realizan una secuencia de pruebas sencillas en 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 eficientes tanto en el cálculo como en la utilización de la 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 de bosque es una implementación de bosque aleatorio y bosque de regresión por cuantiles que usa el aprendiz de árbol de regresión en rx_fast_trees. El modelo consiste en un conjunto de árboles de decisión. Cada árbol de un bosque de decisión da como resultado una predicción en forma de distribución gaussiana. Se realiza una agregación sobre el conjunto de árboles para buscar la 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 mejor cobertura y precisión que los árboles de decisión únicos. Cada árbol de un bosque de decisión da como resultado una distribución gaussiana.

Argumentos

formula

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

datos

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

método

Cadena de caracteres que indica el tipo de Fast Tree:

"binary" para la clasificación binaria predeterminada de Fast Tree o
"regression" para la regresión de Fast Tree.

num_trees

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

num_leaves

Número máximo de hojas (nodos terminales) que se pueden crear en un árbol. Valores más altos pueden aumentar el tamaño del árbol y mejorar la precisión, pero corre el riesgo de sobreajuste y de necesitar tiempos de entrenamiento más prolongados. 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, de los datos de submuestreo. Una división (split) significa que las características de cada nivel del árbol (nodo) se dividen de forma aleatoria. El valor predeterminado es 10.

example_fraction

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

feature_fraction

Fracción de características elegidas aleatoriamente que se usarán 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

Coeficiente de penalización del primer uso de una característica. El valor predeterminado es 0.

gain_conf_level

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

train_threads

Número de subprocesos que se usan en el entrenamiento. Si se especifica None, el número de subprocesos que se va 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 deben realizarse en los datos antes del entrenamiento, o bien None si no hay que realizar ninguna transformación. Vea featurize_text, categorical y categorical_hash para saber las transformaciones que se admiten. Estas transformaciones se realizan después de cualquier transformación de Python especificada. El valor predeterminado es None.

ml_transform_vars

Especifica un vector de caracteres de nombres de variable que deben usarse en ml_transforms, o bien None si no hay que usar ninguno. El valor predeterminado es None.

row_selection

NO ADMITIDO. Especifica las filas (observaciones) del conjunto de datos que debe usar el modelo con el nombre de una variable lógica del conjunto de datos (entre comillas) o con una expresión lógica que usa variables en el conjunto de datos. Por ejemplo:

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

La selección de fila 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 función expression.

transformaciones

NO ADMITIDO. 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 función expression.

transform_objects

NO ADMITIDO. Lista con nombre que contiene objetos a los que pueden hacer referencia transforms, transform_function y 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 ADMITIDO. Vector de caracteres que especifica paquetes de Python adicionales (aparte de los especificados en RxOptions.get_option("transform_packages")) que deben cargarse previamente y estar disponibles para usarlos en las funciones de transformación de variables. Por ejemplo, los definidos explícitamente en las funciones de revoscalepy mediante los argumentos transforms y transform_function, o los definidos implícitamente con los argumentos formula y row_selection. El argumento transform_packages también puede ser None, que indica que no se cargan previamente más paquetes aparte de los de RxOptions.get_option("transform_packages").

transform_environment

NO ADMITIDO. Entorno definido por el usuario que sirve como primario de todos los entornos desarrollados internamente y que se usa para la transformación de datos variables. Si es transform_environment = None, se usa un nuevo entorno "hash" con revoscalepy.baseenv como primario.

blocks_per_read

Especifica el número de bloques que se leerán para cada fragmento de datos leídos del origen de datos.

report_progress

Valor entero que especifica el nivel de notificación del progreso del procesamiento de filas:

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

verbose

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

compute_context

Establece el contexto en el que se realizan los cálculos, especificado con RxComputeContext. Actualmente, se admiten los contextos de proceso local y RxInSqlServer.

ensemble

Parámetros de control para la formación de conjuntos.

Devoluciones

Objeto FastForest con el modelo entrenado.

Nota

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

Vea también

rx_fast_trees, rx_predict

Referencias

Wikipedia: Random forest

Bosque de regresión por cuantiles

De la cepa al árbol y al bosque

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)