microsoftml.rx_fast_trees: alberi con boosting

Articolo
05/23/2023

Utilizzo

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)

Descrizione

Fast Tree di Machine Learning

Dettagli

rx_fast_trees è un'implementazione di FastRank. FastRank e un'implementazione efficiente dell'algoritmo di gradient boosting MART. L'incremento dei gradienti è una tecnica di apprendimento automatico per i problemi di regressione. Crea ogni albero di regressione in maniera graduale, usando una funzione di perdita predefinita per misurare l'errore di ogni passaggio e correggerlo nel passaggio successivo. Questo modello di previsione è effettivamente costituito da un insieme di modelli di previsione più deboli. Nei problemi di regressione, il boosting crea una serie di tali alberi in maniera graduale e quindi seleziona l'albero ottimale usando una funzione di perdita differenziabile arbitraria.

L'algoritmo MART apprende un insieme di alberi di regressione, ovvero un albero delle decisioni con valori scalari nelle foglie. Un albero delle decisioni, o di regressione, è un diagramma di flusso analogo a un albero binario, in cui, in corrispondenza di ogni nodo interno, si decide con quale dei due nodi figlio proseguire, in base a uno dei valori di funzionalità dell'input. A ogni nodo foglia viene restituito un valore. Nei nodi interni, la decisione si basa sulla formula "x <= v" di test, dove x è il valore della funzionalità dell'esempio di input e v è uno dei possibili valori della funzionalità. Le funzioni che possono essere generate da un albero di regressione sono tutte le funzioni costanti a tratti.

L'insieme di alberi viene prodotto calcolando a ogni passaggio un albero di regressione che fornisce un'approssimazione del gradiente della funzione di perdita e aggiungendo tale albero a quello precedente con coefficienti che riducono al minimo la perdita del nuovo albero. L'output dell'insieme prodotto da MART in un'istanza specifica è la somma degli output degli alberi.

Nel caso di un problema di classificazione binaria, l'output viene convertito in una probabilità mediante una qualche forma di calibrazione.
Nel caso di un problema di regressione, l'output corrisponde al valore previsto della funzione.
Nel caso di un problema di classificazione, le istanze vengono ordinate in base al valore di output dell'insieme.

Se method è impostato su "regression", viene usata una versione di regressione di FastTree. Se è impostata su "ranking", viene usata una versione di classificazione di FastTree. In caso di classificazione, le istanze devono essere ordinate in base all'output dell'insieme di alberi. L'unica differenza tra le impostazioni di queste versioni riguarda le impostazioni di calibrazione, necessarie solo per la classificazione.

Argomenti

formula

Formula come descritto in revoscalepy.rx_formula. I termini di interazione e F() non sono attualmente supportati in microsoftml.

data

Oggetto origine dati o stringa di caratteri che specifica un file con estensione xdf o un oggetto frame di dati.

method

Stringa di caratteri che specifica il tipo di modello Fast Tree: "binary" per la classificazione binaria predefinita Fast Tree o "regression" per la regressione Fast Tree.

num_trees

Specifica il numero totale di alberi delle decisioni da creare nell'insieme. Creando più alberi delle decisioni, è possibile ottenere potenzialmente una copertura migliore, ma aumenta il tempo di training. Il valore predefinito è 100.

num_leaves

Numero massimo di foglie (nodi terminale) che possono essere create in un albero. Valori più elevati aumentano potenzialmente le dimensioni dell'albero e consentono di ottenere una precisione migliore, ma rischiano di causare un overfitting e di richiedere tempi di training più lunghi. Il valore predefinito è 20.

learning_rate

Determina le dimensioni del passaggio eseguito nella direzione del gradiente in ogni passaggio del processo di apprendimento. Questo valore determina quindi la velocità o la lentezza con cui lo strumento di apprendimento converge verso la soluzione ottimale. Se le dimensioni del passaggio sono eccessive, si rischia di oltrepassare la soluzione ottimale. Se le dimensioni sono troppo piccole, il training richiederà più tempo per convergere verso la soluzione migliore.

min_split

Numero minimo di istanze di training necessarie per formare una foglia. Si tratta del numero minimo di documenti consentiti in una foglia di un albero di regressione, al di là dei dati sotto-campionati. Uno split indica che le funzionalità di ogni livello dell'albero (nodo) vengono divise in modo casuale. Il valore predefinito è 10. Viene conteggiato solo il numero di istanze, anche se le istanze sono ponderate.

example_fraction

Frazione di istanze scelte in modo casuale da usare per ogni albero. Il valore predefinito è 0,7.

feature_fraction

Frazione di funzionalità scelte in modo casuale da usare per ogni albero. Il valore predefinito è 1.

split_fraction

Frazione di funzionalità scelte in modo casuale da usare in ogni divisione. Il valore predefinito è 1.

num_bins

Numero massimo di valori distinti (bin) per funzionalità. Se i valori della funzionalità sono di meno rispetto al numero indicato, ogni valore viene inserito nel bin corrispondente. Se sono presenti valori in più, l'algoritmo crea numBins bin.

first_use_penalty

Coefficiente di penalità per il primo utilizzo della funzionalità. Si tratta di una forma di regolarizzazione che comporta una penalità per l'uso di una nuova funzionalità durante la creazione dell'albero. Aumentare questo valore per creare alberi che non usano molte funzionalità. Il valore predefinito è 0.

gain_conf_level

Requisito di attendibilità del guadagno di adattamento dell'albero (deve essere compreso nell'intervallo [0,1]). Il valore predefinito è 0.

unbalanced_sets

Se True, vengono usate le derivate ottimizzate per i set non bilanciati. Si applica solo se type è uguale a "binary". Il valore predefinito è False.

train_threads

Numero di thread da usare nel training. Il valore predefinito è 8.

random_seed

Specifica il valore di inizializzazione casuale. Il valore predefinito è None.

ml_transforms

Specifica un elenco di trasformazioni di MicrosoftML da eseguire sui dati prima del training o None se non devono essere eseguite trasformazioni. Per informazioni sulle trasformazioni supportate, vedere featurize_text, categorical e categorical_hash. Queste trasformazioni vengono eseguite dopo eventuali trasformazioni Python specificate. Il valore predefinito è None.

ml_transform_vars

Specifica un vettore di caratteri di nomi di variabili da usare in ml_transforms o None se non è necessario usarne alcuno. Il valore predefinito è None.

row_selection

NON SUPPORTATO. Specifica le righe (osservazioni) dal set di dati che devono essere usate dal modello con il nome di una variabile logica dal set di dati (tra virgolette) o con un'espressione logica tramite variabili nel set di dati. Ad esempio:

row_selection = "old" userà solo osservazioni in cui il valore della variabile old è True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) usa solo osservazioni in cui il valore della variabile age è compreso tra 20 e 65 e il valore di log della variabile income è maggiore di 10.

La selezione delle righe viene eseguita dopo l'elaborazione di eventuali trasformazioni dei dati. Vedere gli argomenti transforms o transform_function. Analogamente a tutte le espressioni, è possibile definire row_selection all'esterno della chiamata alla funzione usando la funzione expression.

trasformazioni

NON SUPPORTATO. Espressione con un formato che rappresenta il primo ciclo di trasformazioni delle variabili. Analogamente a tutte le espressioni, è possibile definire transforms o row_selection all'esterno della chiamata alla funzione usando la funzione expression.

transform_objects

NON SUPPORTATO. Elenco denominato che contiene oggetti a cui transforms, transform_functione row_selection possono fare riferimento.

transform_function

Funzione di trasformazione della variabile.

transform_variables

Vettore di caratteri delle variabili del set di dati di input necessario per la funzione di trasformazione.

transform_packages

NON SUPPORTATO. Vettore di caratteri che specifica altri pacchetti Python, oltre a quelli specificati in RxOptions.get_option("transform_packages"), da rendere disponibili e precaricati per l'uso nelle funzioni di trasformazione delle variabili. Ad esempio, quelli definiti in modo esplicito nelle funzioni revoscalepy tramite i relativi argomenti transforms e transform_function o quelli definiti in modo implicito tramite i relativi argomenti formula o row_selection. L'argomento transform_packages può anche essere NoneRxOptions.get_option("transform_packages"), che indica che non vengono precaricati pacchetti esterni a .

transform_environment

NON SUPPORTATO. Ambiente definito dall'utente da usare come elemento padre di tutti gli ambienti sviluppati internamente e usati per la trasformazione dei dati delle variabili. Se transform_environment = None, viene usato un nuovo ambiente "hash" con revoscalepy.baseenv padre.

blocks_per_read

Specifica il numero di blocchi da leggere per ogni blocco di dati letto dall'origine dati.

report_progress

Valore intero che specifica il livello di creazione di report sullo stato di elaborazione delle righe:

0: non viene segnalato alcun avanzamento.
1: il numero di righe elaborate viene stampato e aggiornato.
2: vengono segnalate le righe elaborate e le tempistiche.
3: vengono segnalate le righe elaborate e tutte le tempistiche.

verbose

Valore intero che specifica la quantità di output desiderata. Se 0, non viene stampato alcun output dettagliato durante i calcoli. Valori interi da 1 a 4 per fornire quantità crescenti di informazioni.

compute_context

Imposta il contesto in cui vengono eseguiti i calcoli, specificato con un revoscalepy.RxComputeContext valido. Sono attualmente supportati contesti di calcolo locali e revoscalepy.RxInSqlServer.

ensemble

Parametri di controllo per l'ensembling.

Restituisce

Oggetto FastTrees con il modello sottoposto a training.

Nota

Questo algoritmo è multithreading e proverà sempre a caricare l'intero set di dati in memoria.

Vedi anche

rx_fast_forest, rx_predict

Riferimenti

Wikipedia: Gradient boosting (potenziamento dell'albero del gradiente)

Approssimazione della funzione Greedy: una macchina per il gradient boosting.

Esempio di classificazione 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))

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

Esempio di regressione

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