microsoftml.rx_fast_forest: Willekeurig forest

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

Snel forest voor Machine Learning

Bijzonderheden

Beslissingsstructuren zijn niet-parametrische modellen die een reeks eenvoudige tests op invoer uitvoeren. Deze beslissingsprocedure wijst deze toe aan uitvoer die in de trainingsgegevensset is gevonden waarvan de invoer vergelijkbaar is met het exemplaar dat wordt verwerkt. Er wordt een beslissing genomen op elk knooppunt van de binaire structuurgegevensstructuur op basis van een meting van overeenkomsten die elk exemplaar recursief toewijst via de vertakkingen van de boom totdat het juiste leaf-knooppunt is bereikt en de uitvoerbeslissing is geretourneerd.

Beslissingsstructuren hebben verschillende voordelen:

Ze zijn efficiënt in zowel berekeningen als geheugengebruik tijdens training en voorspelling.
Ze kunnen niet-lineaire beslissingsgrenzen vertegenwoordigen.
Ze voeren geïntegreerde functieselectie en -classificatie uit.
Ze zijn tolerant in aanwezigheid van lawaaierige functies.

Snelle forestregressie is een willekeurige forest en kwantiel regressieforest-implementatie met behulp van de regressiestructuurleerders in rx_fast_trees. Het model bestaat uit een ensemble van beslissingsstructuren. Elke boom in een beslissingsforest levert een Gaussiaanse verdeling door middel van voorspelling. Er wordt een aggregatie uitgevoerd over het ensemble van bomen om een Gaussiische verdeling te vinden die het dichtst bij de gecombineerde verdeling ligt voor alle bomen in het model.

Deze beslissingsforestclassificatie bestaat uit een ensemble van beslissingsstructuren. Over het algemeen bieden ensemblemodellen betere dekking en nauwkeurigheid dan enkele beslissingsstructuren. Elke boom in een beslissingsforest levert een Gaussiaanse distributie op.

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 Fast Tree aangeeft:

"binary" voor de standaard binaire classificatie van fast tree 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.

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.

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

split_fraction

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

num_bins

Maximum aantal afzonderlijke waarden (bins) per functie. De standaardwaarde is 255.

first_use_penalty

De functie gebruikt eerst een boetecoëfficiënt. De standaardwaarde is 0.

gain_conf_level

Boomfitting krijgt betrouwbaarheidsvereiste (moet binnen het bereik [0,1]liggen). De standaardwaarde is 0.

train_threads

Het aantal threads dat in de training moet worden gebruikt. Als Geen is opgegeven, wordt het aantal threads dat moet worden gebruikt intern bepaald. De standaardwaarde is None.

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 RxComputeContext. Momenteel worden lokale en RxInSqlServer rekencontexten ondersteund.

Ensemble

Besturingsparameters voor het opgeven van overeenkomsten.

Retouren

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

References

Wikipedia: Willekeurig forest

Kwantiel regressieforest

Van stumps naar bomen tot bossen

Voorbeeld van binaire classificatie

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

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

Voorbeeld van regressie

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