microsoftml.rx_fast_trees: Árboles ampliados

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

Árbol rápido de Machine Learning

Detalles

rx_fast_trees es una implementación de FastRank. FastRank es una implementación eficaz del algoritmo de potenciación de degradado MART. La potenciación de degradado es una técnica de aprendizaje automático para problemas de regresión. Compila cada árbol de regresión de forma paso a paso, mediante una función de pérdida predefinida para medir el error de cada paso y lo corrige en el siguiente. Por lo tanto, este modelo de predicción es realmente un conjunto de modelos de predicción más débiles. En los problemas de regresión, aumentar crea una serie de árboles de este tipo de manera paso a paso y, a continuación, selecciona el árbol óptimo mediante una función arbitraria de pérdida diferente.

MART aprende un conjunto de árboles de regresión, que es un árbol de decisión con valores escalares en sus hojas. Un árbol de decisión (o regresión) es un gráfico de flujo de tipo árbol binario, donde en cada nodo interior uno decide cuál de los dos nodos secundarios debe seguir basándose en uno de los valores de características de la entrada. En cada nodo hoja, se devuelve un valor. En los nodos interiores, la decisión se basa en la prueba "x <= v", donde x es el valor de la característica en el ejemplo de entrada y v es uno de los posibles valores de esta característica. Las funciones que puede generar un árbol de regresión son todas las funciones constantes por partes.

El conjunto de árboles se genera mediante la computación, en cada paso, un árbol de regresión que aproxima el degradado de la función de pérdida y lo agrega al árbol anterior con coeficientes que minimizan la pérdida del nuevo árbol. La salida del conjunto generado por MART en una instancia determinada es la suma de las salidas del árbol.

En el caso de un problema de clasificación binaria, la salida se convierte en una probabilidad mediante alguna forma de calibración.
En el caso de un problema de regresión, la salida es el valor previsto de la función.
En el caso de un problema de clasificación, las instancias se ordenan por el valor de salida del conjunto.

Si method se establece en "regression", se usa una versión de regresión de FastTree. Si se establece en "ranking", se usa una versión de clasificación de FastTree. En el caso de clasificación, las instancias deben ordenarse por la salida del conjunto de árbol. La única diferencia en la configuración de estas versiones es en la configuración de calibración, que solo son necesarias para la clasificación.

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 especifica el tipo de Árbol rápido: "binary" para la clasificación binaria de árbol rápido predeterminada o "regression" para regresión rápida de árbol.

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.

tasa de aprendizaje

Determina el tamaño del paso realizado en la dirección del degradado en cada paso del proceso de aprendizaje. Esto determina la rapidez o ralentización que converge el aprendiz en la solución óptima. Si el tamaño del paso es demasiado grande, es posible que supere la solución óptima. Si el tamaño del paso es demasiado pequeño, el entrenamiento tarda más tiempo en converger en la mejor solución.

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. Solo se cuenta el número de instancias incluso si se ponderan las instancias.

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 1.

split_fraction

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

num_bins

Número máximo de valores distintos (intervalos) por característica. Si la característica tiene menos valores que el número indicado, cada valor se coloca en su propio contenedor. Si hay más valores, el algoritmo crea numBins contenedores.

first_use_penalty

La característica usa primero el coeficiente de penalización. Se trata de una forma de regularización que conlleva una penalización por usar una nueva característica al crear el árbol. Aumente este valor para crear árboles que no usen muchas características. 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.

unbalanced_sets

Si Truees , se usan derivados optimizados para conjuntos desequilibrados. Solo se aplica cuando type es igual a "binary". El valor predeterminado es False.

train_threads

Número de subprocesos que se van a usar en el entrenamiento. El valor predeterminado es 8.

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 una revoscalepy válida. RxComputeContext. Actualmente local y revoscalepy. Se admiten contextos de proceso RxInSqlServer.

conjunto

Parámetros de control para el montaje.

Devoluciones

Objeto FastTrees 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_forest, rx_predict

Referencias

Wikipedia: Aumento de degradado (aumento de árbol de degradado)

Aproximación de función expansa: una máquina de potenciación de degradado.

Ejemplo de clasificación binaria

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

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

Ejemplo de regresión

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