microsoftml.rx_fast_trees: Versterkte bomen

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

Snelle boomstructuur voor Machine Learning

Bijzonderheden

rx_fast_trees is een implementatie van FastRank. FastRank is een efficiënte implementatie van het MART-gradiëntverhogingsalgoritmen. Gradiëntverhoging is een machine learning-techniek voor regressieproblemen. Elke regressiestructuur wordt stapsgewijs gebouwd met behulp van een vooraf gedefinieerde verliesfunctie om de fout voor elke stap te meten en in de volgende stap te corrigeren. Dit voorspellingsmodel is dus eigenlijk een ensemble van zwakkere voorspellingsmodellen. Bij regressieproblemen bouwt het stimuleren van een reeks dergelijke bomen stapsgewijs op en selecteert vervolgens de optimale boom met behulp van een willekeurige differentiabele verliesfunctie.

MART leert een ensemble van regressiebomen, een beslissingsstructuur met scalaire waarden in de bladeren. Een beslissingsstructuur (of regressiestructuur) is een binair stroomdiagram, waarbij op elk binnenknooppunt wordt bepaald welke van de twee onderliggende knooppunten moet worden voortgezet op basis van een van de functiewaarden uit de invoer. Op elk leaf-knooppunt wordt een waarde geretourneerd. In de binnenste knooppunten is de beslissing gebaseerd op de test "x <= v", waarbij x de waarde van de functie in het invoervoorbeeld is en v een van de mogelijke waarden van deze functie is. De functies die door een regressiestructuur kunnen worden geproduceerd, zijn alle stukgewijze constante functies.

Het ensemble van bomen wordt geproduceerd door computing, in elke stap, een regressiestructuur die de gradiënt van de verliesfunctie benadert en deze toevoegt aan de vorige boom met coëfficiënten die het verlies van de nieuwe boom minimaliseren. De uitvoer van het ensemble dat door MART op een bepaald exemplaar wordt geproduceerd, is de som van de boomuitvoer.

In het geval van een binair classificatieprobleem wordt de uitvoer geconverteerd naar een waarschijnlijkheid met behulp van een vorm van kalibratie.
In het geval van een regressieprobleem is de uitvoer de voorspelde waarde van de functie.
In het geval van een classificatieprobleem worden de exemplaren gerangschikt op basis van de uitvoerwaarde van het ensemble.

Als method dit is ingesteld "regression"op, wordt een regressieversie van FastTree gebruikt. Indien ingesteld op "ranking", wordt een classificatieversie van FastTree gebruikt. In het classificatiescenario moeten de exemplaren worden gerangschikt op basis van de uitvoer van het boomensemble. Het enige verschil in de instellingen van deze versies is in de kalibratie-instellingen, die alleen nodig zijn voor classificatie.

Arguments

formule

De formule zoals beschreven in revoscalepy.rx_formula. Interactietermen en F() worden momenteel niet ondersteund in microsoftml.

gegevens

Een gegevensbronobject of een tekenreeks die een .xdf-bestand of een gegevensframeobject opgeeft.

method

Een tekenreeks die het type Snelle boom aangeeft: "binary" voor de standaard binaire classificatie van snelle boomstructuur of "regression" voor snelle boomregressie.

num_trees

Hiermee geeft u het totale aantal beslissingsstructuren op dat in het ensemble moet worden gemaakt. Door meer beslissingsstructuren te creëren, kunt u mogelijk betere dekking krijgen, maar de trainingstijd neemt toe. De standaardwaarde is 100.

num_leaves

Het maximum aantal bladeren (terminalknooppunten) dat in elke boomstructuur kan worden gemaakt. Hogere waarden vergroten mogelijk de grootte van de boom en krijgen betere precisie, maar risico overfitting en vereisen langere trainingstijden. De standaardwaarde is 20.

leerpercentage

Bepaalt de grootte van de stap in de richting van de kleurovergang in elke stap van het leerproces. Dit bepaalt hoe snel of traag de cursist convergeert op de optimale oplossing. Als de stapgrootte te groot is, kunt u de optimale oplossing overslaan. Als de stapgrootte te klein is, duurt het langer om de training te convergeren naar de beste oplossing.

min_split

Minimaal aantal trainingsexemplaren dat nodig is om een blad te vormen. Dat wil gezegd: het minimale aantal documenten dat is toegestaan in een blad van een regressiestructuur, uit de subgemonsterde gegevens. Een 'split' betekent dat functies in elk niveau van de structuur (knooppunt) willekeurig worden verdeeld. De standaardwaarde is 10. Alleen het aantal exemplaren wordt geteld, zelfs als exemplaren worden gewogen.

example_fraction

Het deel van willekeurig gekozen exemplaren dat voor elke structuur moet worden gebruikt. De standaardwaarde is 0,7.

feature_fraction

De fractie van willekeurig gekozen functies die voor elke structuur moeten worden gebruikt. De standaardwaarde is 1.

split_fraction

De fractie van willekeurig gekozen functies die voor elke splitsing moeten worden gebruikt. De standaardwaarde is 1.

num_bins

Maximum aantal afzonderlijke waarden (bins) per functie. Als de functie minder waarden heeft dan het aangegeven getal, wordt elke waarde in een eigen bin geplaatst. Als er meer waarden zijn, maakt numBins het algoritme bins.

first_use_penalty

De functie gebruikt eerst een boetecoëfficiënt. Dit is een vorm van regularisatie waardoor een boete wordt opgelegd voor het gebruik van een nieuwe functie bij het maken van de structuur. Verhoog deze waarde om bomen te maken die niet veel functies gebruiken. De standaardwaarde is 0.

gain_conf_level

Boomfitting krijgt betrouwbaarheidsvereiste (moet zich in het bereik [0,1)) bevinden). De standaardwaarde is 0.

unbalanced_sets

Als Truederivaten die zijn geoptimaliseerd voor niet-gebalanceerde sets worden gebruikt. Alleen van toepassing indien type gelijk aan "binary". De standaardwaarde is False.

train_threads

Het aantal threads dat in de training moet worden gebruikt. De standaardwaarde is 8.

random_seed

Hiermee geeft u het willekeurige zaad. De standaardwaarde is None.

ml_transforms

Hiermee geeft u een lijst op met MicrosoftML-transformaties die moeten worden uitgevoerd op de gegevens vóór de training of Geen als er geen transformaties moeten worden uitgevoerd. Zie featurize_text, categoricalen categorical_hash, voor transformaties die worden ondersteund. Deze transformaties worden uitgevoerd na opgegeven Python-transformaties. De standaardwaarde is None.

ml_transform_vars

Hiermee geeft u een tekenvector op van namen van variabelen die moeten worden gebruikt in ml_transforms of Geen als er geen moet worden gebruikt. De standaardwaarde is None.

row_selection

NIET ONDERSTEUND. Hiermee geeft u de rijen (waarnemingen) op uit de gegevensset die door het model moeten worden gebruikt met de naam van een logische variabele uit de gegevensset (tussen aanhalingstekens) of met een logische expressie met behulp van variabelen in de gegevensset. Voorbeeld:

row_selection = "old" gebruikt alleen waarnemingen waarin de waarde van de variabele old is True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) gebruikt alleen waarnemingen waarbij de waarde van de age variabele tussen 20 en 65 ligt en de waarde van de logincome variabele groter is dan 10.

De rijselectie wordt uitgevoerd na het verwerken van gegevenstransformaties (zie de argumenten transforms of transform_function). Net als bij alle expressies row_selection kunt u buiten de functieoproep definiëren met behulp van de expression functie.

Transformeert

NIET ONDERSTEUND. Een expressie van het formulier dat de eerste ronde van variabeletransformaties vertegenwoordigt. Net als bij alle expressies transforms kan (of row_selection) buiten de functie-aanroep worden gedefinieerd met behulp van de expression functie.

transform_objects

NIET ONDERSTEUND. Een benoemde lijst met objecten waarnaar kan worden verwezen door transforms, transform_functionen row_selection.

transform_function

De functie voor variabeletransformatie.

transform_variables

Een tekenvector van variabelen voor invoergegevenssets die nodig zijn voor de transformatiefunctie.

transform_packages

NIET ONDERSTEUND. Een tekenvector die extra Python-pakketten opgeeft (buiten de pakketten die zijn opgegeven in RxOptions.get_option("transform_packages")) die beschikbaar moeten worden gemaakt en vooraf moeten worden geladen voor gebruik in functies voor variabele transformatie. Bijvoorbeeld degenen die expliciet zijn gedefinieerd in revoscalepy-functies via hun transforms en transform_function argumenten of die impliciet zijn gedefinieerd via hun formula of row_selection argumenten. Het transform_packages argument kan ook Geen zijn, wat aangeeft dat er geen pakketten buiten RxOptions.get_option("transform_packages") zijn geladen.

transform_environment

NIET ONDERSTEUND. Een door de gebruiker gedefinieerde omgeving die als bovenliggend element fungeert voor alle omgevingen die intern zijn ontwikkeld en worden gebruikt voor variabele gegevenstransformatie. Als transform_environment = Nonein plaats daarvan een nieuwe hash-omgeving met bovenliggende revoscalepy.baseenv wordt gebruikt.

blocks_per_read

Hiermee geeft u het aantal blokken op dat moet worden gelezen voor elk segment gegevens dat uit de gegevensbron wordt gelezen.

report_progress

Een geheel getal dat het rapportageniveau voor de voortgang van de rijverwerking aangeeft:

0: er wordt geen voortgang gerapporteerd.
1: het aantal verwerkte rijen wordt afgedrukt en bijgewerkt.
2: rijen verwerkt en tijdsinstellingen worden gerapporteerd.
3: rijen verwerkt en alle tijdsinstellingen worden gerapporteerd.

verbose

Een geheel getal dat de gewenste hoeveelheid uitvoer aangeeft. Als 0er tijdens berekeningen geen uitgebreide uitvoer wordt afgedrukt. Gehele getallen van waaruit 14 grotere hoeveelheden informatie moeten worden opgegeven.

compute_context

Hiermee stelt u de context in waarin berekeningen worden uitgevoerd, opgegeven met een geldige revoscalepy. RxComputeContext. Momenteel lokaal en opnieuw schalen. RxInSqlServer-rekencontexten worden ondersteund.

Ensemble

Besturingsparameters voor het opgeven van overeenkomsten.

Retouren

Een FastTrees object met het getrainde model.

Opmerking

Dit algoritme is multithreaded en probeert altijd de volledige gegevensset in het geheugen te laden.

Zie ook

rx_fast_forest, rx_predict

References

Wikipedia: Kleurovergangsverhoging (Kleurovergangsstructuur verhogen)

Benadering van greedy-functie: Een kleurovergangsverbeteringsmachine.

Voorbeeld van binaire classificatie

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

Uitvoer:

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

Voorbeeld van regressie

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