microsoftml.rx_fast_forest : Forêt aléatoire

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)

Descriptif

Forêt rapide Machine Learning

Détails

Les arbres de décision sont des modèles non paramétriques qui effectuent une séquence de tests simples sur les entrées. Cette procédure de décision les mappe aux sorties trouvées dans le jeu de données d’entraînement dont les entrées étaient similaires à l’instance en cours de traitement. Une décision est prise à chaque nœud de la structure de données d’arborescence binaire en fonction d’une mesure de similarité qui mappe chaque instance de manière récursive à travers les branches de l’arbre jusqu’à ce que le nœud feuille approprié soit atteint et que la décision de sortie retournée.

Les arbres de décision présentent plusieurs avantages :

Ils sont efficaces à la fois dans le calcul et l’utilisation de la mémoire pendant l’entraînement et la prédiction.
Ils peuvent représenter des limites de décision non linéaires.
Ils effectuent une sélection et une classification de fonctionnalités intégrées.
Elles sont résilientes en présence de caractéristiques bruyantes.

La régression de forêt rapide est une implémentation de forêt aléatoire et de régression quantile à l’aide de l’apprenant de l’arborescence de régression dans rx_fast_trees. Le modèle se compose d’un ensemble d’arbres de décision. Chaque arbre d’une forêt décisionnelle génère une distribution gaussienne par prédiction. Une agrégation est effectuée sur l’ensemble d’arbres pour trouver une distribution gaussienne la plus proche de la distribution combinée pour tous les arbres du modèle.

Ce classifieur de forêt de décision se compose d’un ensemble d’arbres de décision. En règle générale, les modèles d’ensemble offrent une meilleure couverture et une meilleure précision que des arbres de décision uniques. Chaque arbre d’une forêt décisionnelle génère une distribution gaussienne.

Arguments

formula

Formule décrite dans revoscalepy.rx_formula. Termes d’interaction et F() ne sont actuellement pas pris en charge dans microsoftml.

données

Objet source de données ou chaîne de caractères spécifiant un fichier .xdf ou un objet de trame de données.

method

Chaîne de caractères indiquant le type d’arborescence rapide :

"binary" pour la classification binaire de l’arborescence rapide par défaut ou
"regression" pour la régression d’arborescence rapide.

num_trees

Spécifie le nombre total d’arbres de décision à créer dans l’ensemble. En créant davantage d’arbres de décision, vous pouvez potentiellement obtenir une meilleure couverture, mais le temps de formation augmente. La valeur par défaut est 100.

num_leaves

Nombre maximal de feuilles (nœuds de terminal) qui peuvent être créées dans n’importe quelle arborescence. Des valeurs plus élevées augmentent potentiellement la taille de l’arbre et obtiennent une meilleure précision, mais les risques sont trop élevés et nécessitent des temps d’entraînement plus longs. La valeur par défaut est 20.

min_split

Nombre minimal d’instances d’entraînement requises pour former une feuille. Autrement dit, le nombre minimal de documents autorisés dans une feuille d’une arborescence de régression, hors des données sous-échantillonées. Un « fractionnement » signifie que les fonctionnalités de chaque niveau de l’arborescence (nœud) sont divisées de façon aléatoire. La valeur par défaut est 10.

example_fraction

Fraction des instances choisies de manière aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0,7.

feature_fraction

Fraction des fonctionnalités choisies de manière aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0,7.

split_fraction

Fraction des fonctionnalités choisies de manière aléatoire à utiliser sur chaque fractionnement. La valeur par défaut est 0,7.

num_bins

Nombre maximal de valeurs distinctes (bacs) par fonctionnalité. La valeur par défaut est 255.

first_use_penalty

La fonctionnalité utilise d’abord le coefficient de pénalité. La valeur par défaut est 0.

gain_conf_level

L’ajustement de l’arbre gagne en confiance (doit se trouver dans la plage [0,1]). La valeur par défaut est 0.

train_threads

Nombre de threads à utiliser lors de l’entraînement. Si aucun n’est spécifié, le nombre de threads à utiliser est déterminé en interne. La valeur par défaut est None.

random_seed

Spécifie la valeur initiale aléatoire. La valeur par défaut est None.

ml_transforms

Spécifie une liste des transformations MicrosoftML à effectuer sur les données avant l’entraînement ou None si aucune transformation n’est à effectuer. Consultez featurize_text, categoricalet , pour categorical_hashconnaître les transformations prises en charge. Ces transformations sont effectuées après les transformations Python spécifiées. La valeur par défaut est None.

ml_transform_vars

Spécifie un vecteur de caractères de noms de variables à utiliser dans ml_transforms ou Aucun si aucun doit être utilisé. La valeur par défaut est None.

row_selection

NON PRIS EN CHARGE. Spécifie les lignes (observations) du jeu de données à utiliser par le modèle avec le nom d’une variable logique à partir du jeu de données (entre guillemets) ou avec une expression logique à l’aide de variables dans le jeu de données. Par exemple:

row_selection = "old" utilise uniquement les observations dans lesquelles la valeur de la variable old est True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) utilise uniquement les observations dans lesquelles la valeur de la age variable est comprise entre 20 et 65 et la valeur de la logincome variable est supérieure à 10.

La sélection de lignes est effectuée après le traitement des transformations de données (voir les arguments transforms ou transform_function). Comme pour toutes les expressions, row_selection vous pouvez définir en dehors de l’appel de fonction à l’aide de la expression fonction.

Transforme

NON PRIS EN CHARGE. Expression du formulaire qui représente la première série de transformations de variables. Comme avec toutes les expressions, transforms (ou row_selection) peut être défini en dehors de l’appel de fonction à l’aide de la expression fonction.

transform_objects

NON PRIS EN CHARGE. Liste nommée qui contient des objets qui peuvent être référencés par transforms, transform_functionet row_selection.

transform_function

Fonction de transformation de variable.

transform_variables

Vecteur de caractères des variables de jeu de données d’entrée nécessaires pour la fonction de transformation.

transform_packages

NON PRIS EN CHARGE. Vecteur de caractères spécifiant des packages Python supplémentaires (en dehors de ceux spécifiés dans RxOptions.get_option("transform_packages")) à rendre disponibles et préchargés pour une utilisation dans les fonctions de transformation de variable. Par exemple, ceux définis explicitement dans les fonctions revoscalepy via leurs arguments et transform_function leurs transforms arguments ou ceux définis implicitement par leur ou row_selection leurs formula arguments. L’argument transform_packages peut également être None, ce qui indique qu’aucun package en dehors RxOptions.get_option("transform_packages") n’est préchargé.

transform_environment

NON PRIS EN CHARGE. Environnement défini par l’utilisateur pour servir de parent à tous les environnements développés en interne et utilisés pour la transformation des données variables. Si transform_environment = None, un nouvel environnement de « hachage » avec revoscalepy.baseenv parent est utilisé à la place.

blocks_per_read

Spécifie le nombre de blocs à lire pour chaque bloc de données lu à partir de la source de données.

report_progress

Valeur entière qui spécifie le niveau de création de rapports sur la progression du traitement des lignes :

0: aucune progression n’est signalée.
1: le nombre de lignes traitées est imprimé et mis à jour.
2: les lignes traitées et le minutage sont signalés.
3: lignes traitées et toutes les minutages sont signalées.

verbose

Valeur entière qui spécifie la quantité de sortie souhaitée. Si 0, aucune sortie détaillée n’est imprimée pendant les calculs. Valeurs entières allant de 1 à 4 fournir des quantités croissantes d’informations.

compute_context

Définit le contexte dans lequel les calculs sont exécutés, spécifiés avec une valeur valide RxComputeContext. Actuellement, les contextes locaux et RxInSqlServer de calcul sont pris en charge.

ensemble

Paramètres de contrôle pour l’ensembling.

Retours

Objet FastForest avec le modèle entraîné.

Note

Cet algorithme est multithread et tente toujours de charger l’ensemble du jeu de données en mémoire.

Voir aussi

rx_fast_trees, rx_predict

References

Wikipédia : Forêt aléatoire

Forêt de régression quantile

Des stumps aux arbres aux forêts

Exemple de classification binaire

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

Sortie:

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

Exemple de régression

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