microsoftml.rx_fast_forest: foresta casuale

Usage

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)

Description

Foresta veloce 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 in fase di elaborazione. Una decisione viene presa in ogni nodo della struttura di dati dell'albero binario in base a una misura di somiglianza che esegue il mapping ricorsivo di ogni istanza attraverso i rami dell'albero fino al raggiungimento del nodo foglia appropriato e alla decisione di output restituita.

Gli alberi delle decisioni presentano diversi vantaggi:

Sono efficienti sia nel calcolo che nell'utilizzo della memoria durante il training e la stima.
Possono rappresentare limiti decisionali non lineari.
Eseguono la selezione e la classificazione integrate delle funzionalità.
Sono resilienti in presenza di caratteristiche rumorose.

La regressione rapida della foresta è un'implementazione casuale della foresta di regressione e della regressione quantile usando lo learner dell'albero di regressione in rx_fast_trees. Il modello è costituito da un insieme di alberi delle decisioni. Ogni albero in una foresta decisionale restituisce una distribuzione gaussiana tramite la stima. Un'aggregazione viene eseguita sull'insieme di alberi per trovare una distribuzione gaussiana più vicina alla distribuzione combinata per tutti gli alberi nel modello.

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

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 denota il tipo di albero veloce:

"binary" per la classificazione binaria ad albero veloce predefinita o
"regression" per Regressione ad albero veloce.

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.

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.

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

split_fraction

Frazione delle 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

La caratteristica usa innanzitutto il coefficiente di penalità. Il valore predefinito è 0.

gain_conf_level

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

train_threads

Numero di thread da usare nel training. Se non è specificato Nessuno, 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 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 un oggetto valido RxComputeContext. Attualmente sono supportati contesti locali e RxInSqlServer di calcolo.

Ensemble

Parametri di controllo per l'incenso.

Restituzioni

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

References

Wikipedia: Foresta casuale

Foresta di regressione quantile

Da stub 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))

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