microsoftml.rx_fast_trees: Förstärkta träd

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

Snabbträd för maskininlärning

Detaljer

rx_fast_trees är en implementering av FastRank. FastRank är en effektiv implementering av algoritmen för MART-toningshöjande. Gradient boost är en maskininlärningsteknik för regressionsproblem. Varje regressionsträd skapas stegvis med hjälp av en fördefinierad förlustfunktion för att mäta felet för varje steg och korrigerar för det i nästa steg. Så den här förutsägelsemodellen är faktiskt en ensemble av svagare förutsägelsemodeller. Vid regressionsproblem bygger en ökning av en serie sådana träd stegvis och väljer sedan det optimala trädet med hjälp av en godtycklig differentierbar förlustfunktion.

MART lär sig en ensemble av regressionsträd, vilket är ett beslutsträd med skalära värden i bladen. Ett beslutsträd (eller regressionsträd) är ett binärt trädliknande flödesdiagram, där man vid varje inre nod bestämmer vilken av de två underordnade noderna som ska fortsätta baserat på ett av funktionsvärdena från indata. Vid varje lövnod returneras ett värde. I de inre noderna baseras beslutet på testet "x <= v", där x är värdet för funktionen i indataexemplet och v är ett av de möjliga värdena för den här funktionen. De funktioner som kan skapas av ett regressionsträd är alla de styckevisa konstantfunktionerna.

Trädensemblen produceras av databehandling, i varje steg, ett regressionsträd som approximerar lutningen av förlustfunktionen och lägger till den i föregående träd med koefficienter som minimerar förlusten av det nya trädet. Utdata från ensemblen som produceras av MART på en viss instans är summan av trädutdata.

Vid problem med binär klassificering konverteras utdata till en sannolikhet med hjälp av någon form av kalibrering.
Vid regressionsproblem är utdata funktionens förutsagda värde.
Vid rangordningsproblem ordnas instanserna efter utdatavärdet för ensemblen.

Om method är inställt på "regression"används en regressionsversion av FastTree. Om anges till "ranking"används en rangordningsversion av FastTree. I rangordningsfallet ska instanserna sorteras efter utdata från trädensemblen. Den enda skillnaden i inställningarna för dessa versioner är i kalibreringsinställningarna, som endast behövs för klassificering.

Arguments

formel

Formeln som beskrivs i revoscalepy.rx_formula. Interaktionsvillkor och F() stöds för närvarande inte i microsoftml.

data

Ett datakällobjekt eller en teckensträng som anger en .xdf-fil eller ett dataramobjekt.

method

En teckensträng som anger typen av snabbt träd: "binary" för standardvärdet Fast Tree Binary Classification eller "regression" för Fast Tree Regression.

num_trees

Anger det totala antalet beslutsträd som ska skapas i ensemblen. Genom att skapa fler beslutsträd kan du eventuellt få bättre täckning, men träningstiden ökar. Standardvärdet är 100.

num_leaves

Det maximala antalet löv (terminalnoder) som kan skapas i valfritt träd. Högre värden kan öka trädstorleken och få bättre precision, men riskerar att överanpassas och kräva längre träningstider. Standardvärdet är 20.

inlärningshastighet

Avgör storleken på det steg som tagits i riktning mot toningen i varje steg i inlärningsprocessen. Detta avgör hur snabbt eller långsamt eleven konvergerar på den optimala lösningen. Om stegstorleken är för stor kan du överskrida den optimala lösningen. Om stegstorleken är för liten tar det längre tid att träna för att konvergera till den bästa lösningen.

min_split

Minsta antal träningsinstanser som krävs för att bilda ett löv. Det vill: det minimala antalet dokument som tillåts i ett löv i ett regressionsträd, från de underexempelbaserade data. En "delning" innebär att funktioner i varje nivå i trädet (noden) delas slumpmässigt. Standardvärdet är 10. Endast antalet instanser räknas även om instanserna är viktade.

example_fraction

Bråkdelen av slumpmässigt valda instanser som ska användas för varje träd. Standardvärdet är 0,7.

feature_fraction

Bråkdelen av slumpmässigt valda funktioner som ska användas för varje träd. Standardvärdet är 1.

split_fraction

Bråkdelen av slumpmässigt valda funktioner som ska användas vid varje delning. Standardvärdet är 1.

num_bins

Maximalt antal distinkta värden (intervall) per funktion. Om funktionen har färre värden än det angivna talet placeras varje värde i sin egen lagerplats. Om det finns fler värden skapar numBins algoritmen lagerplatser.

first_use_penalty

Funktionen använder först straffkoefficient. Det här är en form av regularisering som medför en straffavgift för att använda en ny funktion när du skapar trädet. Öka det här värdet för att skapa träd som inte använder många funktioner. Standardvärdet är 0.

gain_conf_level

Trädanpassning får förtroendekrav (bör ligga i intervallet [0,1)). Standardvärdet är 0.

unbalanced_sets

Om Trueanvänds derivat som är optimerade för obalanserade uppsättningar. Gäller endast när type det är lika med "binary". Standardvärdet är False.

train_threads

Antalet trådar som ska användas i träning. Standardvärdet är 8.

random_seed

Anger det slumpmässiga fröet. Standardvärdet är Ingen.

ml_transforms

Anger en lista över MicrosoftML-transformeringar som ska utföras på data före träning eller Ingen om inga transformeringar ska utföras. Se featurize_text, categoricaloch categorical_hash, för transformeringar som stöds. Dessa transformeringar utförs efter alla angivna Python-transformeringar. Standardvärdet är Ingen.

ml_transform_vars

Anger en teckenvektor med variabelnamn som ska användas i ml_transforms eller Ingen om ingen ska användas. Standardvärdet är Ingen.

row_selection

STÖDS INTE. Anger raderna (observationer) från datauppsättningen som ska användas av modellen med namnet på en logisk variabel från datauppsättningen (inom citattecken) eller med ett logiskt uttryck med variabler i datauppsättningen. Till exempel:

row_selection = "old" använder endast observationer där värdet för variabeln old är True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) använder endast observationer där variabelns age värde är mellan 20 och 65 och värdet för variabeln logincome är större än 10.

Radmarkeringen utförs efter bearbetning av datatransformeringar (se argumenten transforms eller transform_function). Som med alla uttryck kan definieras utanför funktionsanropet row_selection med hjälp av expression funktionen.

Förvandlar

STÖDS INTE. Ett uttryck för formuläret som representerar den första omgången av variabeltransformeringar. Precis som med alla uttryck kan (eller row_selection) definieras utanför funktionsanropet transforms med hjälp expression av funktionen.

transform_objects

STÖDS INTE. En namngiven lista som innehåller objekt som kan refereras till av transforms, transform_functionoch row_selection.

transform_function

Funktionen för variabeltransformeringen.

transform_variables

En teckenvektor för indatauppsättningsvariabler som behövs för transformeringsfunktionen.

transform_packages

STÖDS INTE. En teckenvektor som anger ytterligare Python-paket (utanför de som anges i RxOptions.get_option("transform_packages")) som ska göras tillgängliga och förinlästa för användning i variabeltransformeringsfunktioner. Till exempel de som uttryckligen definieras i revoscalepy-funktioner via deras transforms argument och transform_function argument eller de som definieras implicit via deras formula eller row_selection argument. Argumentet transform_packages kan också vara Ingen, vilket indikerar att inga paket utanför RxOptions.get_option("transform_packages") är förinstallerade.

transform_environment

STÖDS INTE. En användardefinierad miljö som fungerar som överordnad till alla miljöer som utvecklats internt och används för variabel datatransformering. Om transform_environment = Noneanvänds en ny "hash"-miljö med överordnad revoscalepy.baseenv i stället.

blocks_per_read

Anger antalet block som ska läsas för varje segment av data som läss från datakällan.

report_progress

Ett heltalsvärde som anger rapporteringsnivån för radbearbetningsförloppet:

0: Inga förlopp rapporteras.
1: Antalet bearbetade rader skrivs ut och uppdateras.
2: Rader som bearbetas och tidsinställningar rapporteras.
3: bearbetade rader och alla tidsinställningar rapporteras.

verbose

Ett heltalsvärde som anger önskad mängd utdata. Om 0skrivs inga utförliga utdata ut under beräkningar. Heltalsvärden från 1 för att 4 ge ökande mängder information.

compute_context

Anger kontexten där beräkningar körs, som anges med en giltig revoscalepy. RxComputeContext. För närvarande lokal och revoscalepy. RxInSqlServer-beräkningskontexter stöds.

Ensemble

Kontrollparametrar för montering.

Retur

Ett FastTrees objekt med den tränade modellen.

Anmärkning

Den här algoritmen är flertrådad och försöker alltid läsa in hela datamängden i minnet.

Se även

rx_fast_forest, rx_predict

Referenser

Wikipedia: Gradient boost (Gradient tree boost)

Girig funktionsövernärmning: En toningshöjande dator.

Exempel på binär klassificering

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

Utdata:

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

Regressionsexempel

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