microsoftml.rx_fast_trees: alberi con boosting

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

Albero rapido di Machine Learning

Dettagli

rx_fast_trees è un'implementazione di FastRank. FastRank è un'implementazione efficiente dell'algoritmo di boosting del gradiente MART. Il gradient boosting è una tecnica di Machine Learning per i problemi di regressione. Compila ogni albero di regressione in modo dettagliato, usando una funzione di perdita predefinita per misurare l'errore per ogni passaggio e correggerlo nel successivo. Pertanto, questo modello di stima è in realtà un insieme di modelli di stima più deboli. Nei problemi di regressione, l'aumento delle prestazioni crea una serie di alberi di questo tipo in modo dettagliato e quindi seleziona l'albero ottimale usando una funzione di perdita arbitraria differenziabile.

MART apprende un insieme di alberi di regressione, ovvero un albero delle decisioni con valori scalari nelle foglie. Un albero delle decisioni (o regressione) è un grafico di flusso binario simile all'albero, in cui in ogni nodo interno uno decide quale dei due nodi figlio continuare a usare in base a uno dei valori di funzionalità dell'input. In ogni nodo foglia viene restituito un valore. Nei nodi interni la decisione si basa sul test "x <= v", dove x è il valore della funzionalità nell'esempio di input ed v è uno dei valori possibili di questa funzionalità. Le funzioni che possono essere prodotte da un albero di regressione sono tutte le funzioni costanti a fasi.

L'insieme di alberi viene prodotto dal calcolo, in ogni passaggio, un albero di regressione che approssima la sfumatura della funzione di perdita e lo aggiunge all'albero precedente con coefficienti che riducono al minimo la perdita del nuovo albero. L'output dell'ensemble prodotto da MART in una determinata istanza è la somma degli output dell'albero.

In caso di problema di classificazione binaria, l'output viene convertito in una probabilità usando una qualche forma di calibrazione.
In caso di problema di regressione, l'output è il valore stimato della funzione.
In caso di problema di classificazione, le istanze vengono ordinate in base al valore di output dell'ensemble.

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

Arguments

formula

Formula come descritto in revoscalepy.rx_formula. 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 albero veloce: "binary" per la classificazione binaria ad albero veloce predefinita o "regression" per fast tree regression.

num_trees

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

num_leaves

Numero massimo di foglie (nodi terminal) che possono essere create in qualsiasi albero. I valori più elevati aumentano potenzialmente le dimensioni dell'albero e ottengono una maggiore precisione, ma rischino l'overfitting e richiedono tempi di training più lunghi. Il valore predefinito è 20.

tasso di apprendimento

Determina le dimensioni del passaggio eseguito nella direzione della sfumatura in ogni passaggio del processo di apprendimento. Ciò determina la velocità o la lentezza con cui l'apprendimento converge sulla soluzione ottimale. Se le dimensioni del passaggio sono troppo grandi, è possibile superare la soluzione ottimale. Se le dimensioni del passaggio sono troppo piccole, il training richiede più tempo per convergere nella soluzione migliore.

min_split

Numero minimo di istanze di training necessarie per formare una foglia. Ovvero, il numero minimo di documenti consentiti in una foglia di un albero di regressione, dai dati sotto campionati. Una "divisione" indica che le funzionalità in ogni livello dell'albero (nodo) sono suddivise in modo casuale. Il valore predefinito è 10. Viene conteggiato solo il numero di istanze anche se vengono ponderate le istanze.

example_fraction

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

feature_fraction

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

split_fraction

Frazione delle 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 la funzionalità ha meno valori rispetto al numero indicato, ogni valore viene inserito nel proprio contenitore. Se sono presenti più valori, l'algoritmo crea numBins bin.

first_use_penalty

La caratteristica usa innanzitutto il coefficiente di penalità. 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à per l'adattamento ad albero (deve essere compreso nell'intervallo [0,1)). Il valore predefinito è 0.

unbalanced_sets

Se True, vengono utilizzati derivati ottimizzati per i set non bilanciati. Applicabile solo quando 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 MicrosoftML da eseguire sui dati prima del training o Nessuna se non devono essere eseguite trasformazioni. Per le trasformazioni supportate, vedere featurize_text, categoricale categorical_hash. Queste trasformazioni vengono eseguite dopo le trasformazioni Python specificate. Il valore predefinito è None.

ml_transform_vars

Specifica un vettore di caratteri di nomi di variabile da utilizzare in ml_transforms o Nessuno se non è necessario usare nessuno. Il valore predefinito è None.

row_selection

NON SUPPORTATO. Specifica le righe (osservazioni) del set di dati che devono essere usate dal modello con il nome di una variabile logica del set di dati (tra virgolette) o con un'espressione logica usando variabili nel set di dati. Per 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 age variabile è compreso tra 20 e 65 e il valore della logincome variabile è maggiore di 10.

La selezione delle righe viene eseguita dopo l'elaborazione di tutte le trasformazioni dei dati (vedere gli transforms argomenti o transform_function). Come per tutte le espressioni, row_selection può essere definito all'esterno della chiamata di funzione usando la expression funzione .

Trasforma

NON SUPPORTATO. Espressione del form che rappresenta il primo round delle trasformazioni delle variabili. Come per tutte le espressioni, transforms (o row_selection) può essere definito all'esterno della chiamata di funzione usando la expression funzione .

transform_objects

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

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 pacchetti Python aggiuntivi (al di fuori di 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 transforms argomenti e transform_function o quelli definiti in modo implicito tramite i rispettivi formula argomenti o row_selection . L'argomento transform_packages può anche essere Nessuno, a indicare che non vengono precaricati pacchetti esterni RxOptions.get_option("transform_packages") .

transform_environment

NON SUPPORTATO. Ambiente definito dall'utente da usare come padre per tutti gli ambienti sviluppati internamente e usati per la trasformazione dei dati delle variabili. Se transform_environment = None, viene invece 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 per 4 fornire quantità crescenti di informazioni.

compute_context

Imposta il contesto in cui vengono eseguiti i calcoli, specificati con una revoscalepy valida. RxComputeContext. Attualmente locale e revoscalepy. Sono supportati i contesti di calcolo RxInSqlServer.

Ensemble

Parametri di controllo per l'incenso.

Restituzioni

Oggetto FastTrees con il modello sottoposto a training.

Annotazioni

Questo algoritmo è multithread e tenterà sempre di caricare l'intero set di dati in memoria.

Vedere anche

rx_fast_forest, rx_predict

References

Wikipedia: Boosting delle sfumature (boosting dell'albero delle sfumature)

Approssimazione della funzione Greedy: macchina a 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))

Risultato:

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)