microsoftml.rx_fast_trees: Zesílené stromy

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

Rychlý strom strojového učení

Podrobnosti

rx_fast_trees je implementace FastRanku. FastRank je efektivní implementace algoritmu přechodu MART. Zvýšení přechodu je technika strojového učení pro regresní problémy. Sestaví každý regresní strom krokově, pomocí předdefinované funkce ztráty změří chybu pro každý krok a opraví ho v dalším kroku. Takže tento prediktivní model je ve skutečnosti soubor slabších prediktivních modelů. Při regresních problémech vytváří zvýšení řady takových stromů krokově moudrým způsobem a pak vybere optimální strom pomocí libovolné rozdílné funkce ztráty.

MART se učí soubor regresních stromů, což je rozhodovací strom se skalárními hodnotami v listech. Rozhodovací strom (neboli regrese) je vývojový diagram podobný binárnímu stromu, kde se v každém vnitřním uzlu rozhodne, který ze dvou podřízených uzlů bude pokračovat na základě jedné z hodnot funkcí ze vstupu. Na každém uzlu typu list se vrátí hodnota. V vnitřních uzlech je rozhodnutí založeno na testu "x <= v", kde x je hodnota funkce ve vstupní ukázce a v je jednou z možných hodnot této funkce. Funkce, které lze vytvořit regresním stromem, jsou všechny konstantní funkce po kusu.

Soubor stromů je vytvořen výpočtem, v každém kroku regresní strom, který přibližuje přechod funkce ztráty a přidá ho do předchozího stromu s koeficienty, které minimalizují ztrátu nového stromu. Výstupem souboru vytvořeného mart v dané instanci je součet výstupů stromu.

V případě problému s binární klasifikací se výstup převede na pravděpodobnost pomocí určité formy kalibrace.
V případě problému s regresí je výstup predikovanou hodnotou funkce.
V případě problému s řazením jsou instance seřazeny podle výstupní hodnoty souboru.

Pokud method je nastavena na "regression", použije se regresní verze FastTree. Pokud je nastavená hodnota "ranking", použije se verze řazení FastTree. V případě řazení by měly být instance seřazeny výstupem souboru stromu. Jediný rozdíl v nastavení těchto verzí je v nastavení kalibrace, které jsou potřeba pouze pro klasifikaci.

Arguments

vzorec

Vzorec, jak je popsáno v revoscalepy.rx_formula. Výrazy interakce a F() v microsoftml se v současné době nepodporují.

data

Objekt zdroje dat nebo řetězec znaku určující soubor .xdf nebo objekt datového rámce.

metoda

Řetězec znaků, který určuje typ Fast Tree: "binary" pro výchozí binární klasifikaci rychlého stromu nebo "regression" pro regresi fast tree.

num_trees

Určuje celkový počet rozhodovacích stromů, které se mají vytvořit v souboru. Vytvořením více rozhodovacích stromů můžete potenciálně získat lepší pokrytí, ale doba trénování se zvyšuje. Výchozí hodnota je 100.

num_leaves

Maximální počet listů (terminálových uzlů), které lze vytvořit v libovolném stromu. Vyšší hodnoty potenciálně zvětší velikost stromu a získají lepší přesnost, ale riskuje přeurčení a vyžaduje delší dobu trénování. Výchozí hodnota je 20.

míra učení

Určuje velikost kroku prováděného ve směru přechodu v každém kroku procesu učení. Určuje, jak rychle nebo pomalu se učení konverguje na optimálním řešení. Pokud je velikost kroku příliš velká, můžete optimální řešení překroutit. Pokud je velikost kroku příliš malá, trénování trvá déle, než se shodí s nejlepším řešením.

min_split

Minimální počet trénovacích instancí potřebných k vytvoření listu To znamená, že minimální počet dokumentů povolených v listu regresního stromu z dat s dílčím vzorkem. "rozdělením" se rozumí, že funkce na každé úrovni stromu (uzlu) jsou náhodně rozdělené. Výchozí hodnota je 10. Počítá se pouze počet instancí, i když jsou instance vážené.

example_fraction

Zlomek náhodně zvolených instancí, které se mají použít pro každý strom. Výchozí hodnota je 0,7.

feature_fraction

Zlomek náhodně zvolených funkcí, které se mají použít pro každý strom. Výchozí hodnota je 1.

split_fraction

Zlomek náhodně zvolených funkcí, které se mají použít pro každé rozdělení. Výchozí hodnota je 1.

num_bins

Maximální početjedinečných Pokud má funkce méně hodnot, než je uvedené číslo, každá hodnota se umístí do vlastního intervalu. Pokud existuje více hodnot, algoritmus vytvoří numBins intervaly.

first_use_penalty

Funkce nejprve používá penalizační koeficient. Jedná se o formu regularizace, která při vytváření stromu způsobuje pokutu za použití nové funkce. Zvyšte tuto hodnotu, abyste vytvořili stromy, které nepoužívají mnoho funkcí. Výchozí hodnota je 0.

gain_conf_level

Požadavek na získání spolehlivosti stromové fitovky (by měl být v rozsahu [0,1)). Výchozí hodnota je 0.

unbalanced_sets

Pokud Truese použijí deriváty optimalizované pro nevyrovnané sady. Platí pouze v případě, že type je "binary"rovno . Výchozí hodnota je False.

train_threads

Počet vláken, která se mají použít při trénování. Výchozí hodnota je 8.

random_seed

Určuje náhodné počáteční. Výchozí hodnota je None.

ml_transforms

Určuje seznam transformací MicrosoftML, které se mají provést s daty před trénováním nebo Žádná , pokud se neprovedou žádné transformace. Viz featurize_text, categoricala categorical_hash, pro transformace, které jsou podporovány. Tyto transformace se provádějí po všech zadaných transformacích Pythonu. Výchozí hodnota je None.

ml_transform_vars

Určuje vektor znaku názvů proměnných, který má být použit v ml_transforms nebo None , pokud se žádný použít. Výchozí hodnota je None.

row_selection

NEPODPORUJE SE. Určuje řádky (pozorování) ze sady dat, které má model používat s názvem logické proměnné ze sady dat (v uvozovkách) nebo logickým výrazem pomocí proměnných v sadě dat. Například:

row_selection = "old"použije pouze pozorování, ve kterých je Truehodnota proměnné old .
row_selection = (age > 20) & (age < 65) & (log(income) > 10) používá pouze pozorování, ve kterých je hodnota age proměnné mezi 20 a 65 a hodnotou logincome proměnné je větší než 10.

Výběr řádku se provede po zpracování všech transformací dat (viz argumenty transforms nebo transform_function). Stejně jako u všech výrazů row_selection je možné definovat mimo volání funkce pomocí expression funkce.

transformuje

NEPODPORUJE SE. Výraz formuláře, který představuje první kolo transformací proměnných. Stejně jako u všech výrazů transforms je možné definovat (nebo row_selection) mimo volání funkce pomocí expression funkce.

transform_objects

NEPODPORUJE SE. Pojmenovaný seznam obsahující objekty, na které lze odkazovat pomocí transforms, transform_functiona row_selection.

transform_function

Proměnná transformační funkce.

transform_variables

Znakový vektor vstupních proměnných množiny dat potřebných pro transformační funkci.

transform_packages

NEPODPORUJE SE. Vektor znaku určující další balíčky Pythonu (mimo balíčky zadané v RxOptions.get_option("transform_packages")) k dispozici a předem načtený pro použití v transformačních funkcích proměnných. Například explicitně definované v funkcích revoscalepy prostřednictvím jejich transforms a transform_function argumentů nebo těch, které jsou definovány implicitně prostřednictvím jejich formula nebo row_selection argumentů. Argumentem transform_packages může být také Žádný, což znamená, že nejsou předem načteny žádné balíčky mimo RxOptions.get_option("transform_packages") .

transform_environment

NEPODPORUJE SE. Uživatelem definované prostředí, které bude sloužit jako nadřazené všem prostředím vyvinutým interně a které se používají k transformaci proměnných dat. Pokud transform_environment = Nonese místo toho použije nové prostředí hash s nadřazeným revoscalepy.baseenv.

blocks_per_read

Určuje početblokůch

report_progress

Celočíselná hodnota, která určuje úroveň generování sestav o průběhu zpracování řádků:

0: Nebyl hlášen žádný průběh.
1: Počet zpracovaných řádků se vytiskne a aktualizuje.
2: Jsou hlášeny řádky zpracovávané a časování.
3: Jsou hlášeny řádky zpracovávané a všechna časování.

podrobný

Celočíselná hodnota, která určuje požadovanou velikost výstupu. Pokud 0se během výpočtů nevytiskne žádný podrobný výstup. Celočíselné hodnoty, od 1 které se 4 poskytují rostoucí množství informací.

compute_context

Nastaví kontext, ve kterém se výpočty spouštějí, zadané pomocí platné revoscalepy. RxComputeContext. V současné době místní a revoscalepy. Podporují se výpočetní kontexty RxInSqlServer .

Soubor

Kontrolní parametry pro přemíscení

Návraty

Objekt FastTrees s natrénovaným modelem.

Poznámka:

Tento algoritmus je vícevláknový a vždy se pokusí načíst celou datovou sadu do paměti.

Viz také

rx_fast_forest, rx_predict

Odkazy

Wikipedie: Zvýšení přechodu (zvýšení gradientní strom)

Aproximace funkce Greedy: Gradient boosting machine.

Příklad binární klasifikace

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

Výstup:

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

Příklad regrese

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