microsoftml.rx_fast_forest: foresta casuale

Articolo
05/23/2023

Utilizzo

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)

Descrizione

Fast Forest di Machine Learning

Dettagli

Gli alberi delle decisioni sono modelli non parametrici che eseguono una sequenza di test semplici sugli input. Questa procedura decisionale ne esegue il mapping agli output trovati nel set di dati di training i cui input sono simili all'istanza da elaborare. Viene presa una decisione in ogni nodo della struttura dei dati ad albero binario in base a una misura di somiglianza che esegue il mapping ricorsivo di ogni istanza attraverso i rami dell'albero fino a quando non viene raggiunto il nodo foglia appropriato e non viene restituita la decisione di output.

Gli alberi delle decisioni presentano diversi vantaggi:

Sono efficienti sia nel calcolo che nell'uso della memoria durante il training e la stima.
Possono rappresentare limiti di decisione non lineari.
Eseguono la selezione e la classificazione integrata di funzionalità
e sono resilienti in caso di funzionalità rumorose.

La regressione Fast Forest è un'implementazione della foresta casuale e della foresta di regressione quantile che usa lo strumento di apprendimento dell'albero di regressione in rx_fast_trees. Il modello è costituito da un insieme di alberi delle decisioni. Ogni albero di una foresta delle decisioni restituisce una distribuzione gaussiana come previsione. Viene eseguita un'aggregazione sull'insieme di alberi per trovare una distribuzione gaussiana più vicina alla distribuzione combinata per tutti gli alberi del modello.

Il classificatore delle foreste delle decisioni è costituito da un insieme di alberi delle decisioni. In genere, i modelli di insieme offrono una copertura e un'accuratezza migliori rispetto a singoli alberi delle decisioni. Ogni albero di una foresta delle decisioni restituisce una distribuzione gaussiana.

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

Una stringa di caratteri che indica il tipo Fast Tree:

"binary" per la classificazione binaria Fast Tree predefinita 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.

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.

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 è 0,7.

split_fraction

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

num_bins

Numero massimo di valori distinti (bin) per funzionalità. Il valore predefinito è 255.

first_use_penalty

Coefficiente di penalità per il primo utilizzo della funzionalità. Il valore predefinito è 0.

gain_conf_level

Requisito di attendibilità del montaggio ad albero (deve trovarsi nell'intervallo [0,1]). Il valore predefinito è 0.

train_threads

Numero di thread da usare nel training. Se viene specificato None, il numero di thread da usare viene determinato internamente. Il valore predefinito è None.

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 oggetto RxComputeContext valido. Sono attualmente supportati i contesti di calcolo locali e RxInSqlServer.

ensemble

Parametri di controllo per l'ensembling.

Restituisce

Oggetto FastForest 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_trees, rx_predict

Riferimenti

Wikipedia: Foresta casuale

Foresta di regressione quantile

Da ceppi ad alberi a foreste

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

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

Esempio di regressione

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