microsoftml.rx_fast_trees : arborescences optimisées

Article
05/23/2023

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

Fast Tree Machine Learning

Détails

rx_fast_trees est une implémentation de FastRank. FastRank est une implémentation efficace de l’algorithme de boosting de gradient MART. Le boosting de gradient est une technique d’apprentissage automatique pour les problèmes de régression. Il génère chaque arbre de régression de manière progressive, en utilisant une fonction de perte prédéfinie pour mesurer l'erreur à chaque étape et la corriger à la suivante. Par conséquent, ce modèle de prédiction est en fait un ensemble de modèles de prédiction plus faibles. Dans les problèmes de régression, le boosting génère une série d’arborescences de ce type par étapes, puis sélectionne l’arbre optimal à l’aide d’une fonction de perte dérivable arbitraire.

MART apprend un ensemble d’arbres de régression qui est un arbre de décision dont les feuilles contiennent des valeurs scalaires. Un arbre de décision (ou de régression) est un graphique de flux binaire de forme arborescente où, à chaque nœud intérieur, quelqu'un choisir l’un des deux nœuds enfants vers lesquels continuer, en fonction de la valeur de l'une des caractéristiques de l'entrée. Au niveau de chaque nœud terminal, une valeur est retournée. Dans les nœuds intérieurs, la décision est basée sur le test "x <= v", où x est la valeur de la fonctionnalité dans l'échantillon d'entrée, et v l'une des valeurs possibles de cette fonctionnalité. Les fonctions qui peuvent être générées par un arbre de régression sont toutes les fonctions de constante successives.

L’ensemble d’arbres est obtenu en calculant à chaque étape un arbre de régression qui est une approximation du gradient de la fonction de perte et en l’ajoutant à l’arbre précédent avec des coefficients qui minimisent la perte du nouvel arbre. La sortie de l'ensemble produit par MART sur une instance donnée est la somme des sorties d'arborescence.

En cas de problème de classification binaire, la sortie est convertie en probabilité à l'aide d'une forme d'étalonnage.
En cas de problème de régression, la sortie est la valeur prédite de la fonction.
En cas de problème de classement, les instances sont classées par la valeur de sortie de l’ensemble.

Si method est définie sur "regression", une version de régression de FastTree est utilisée. Si elle est définie sur "ranking", une version de classement de FastTree est utilisée. Dans le cas du classement, les instances doivent être classées sur la sortie de l’ensemble d’arborescence. La seule différence dans les paramètres de ces versions réside dans les paramètres d'étalonnage, qui ne sont nécessaires que pour la classification.

Arguments

formule

La formule est décrite dans revoscalepy.rx_formula. Les termes de l’interaction et F() ne sont actuellement pas pris en charge dans microsoftml.

data

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 qui indique le type d’arborescence Fast Tree : "binary" pour la classification binaire Fast Tree par défaut ou "regression" pour la régression rapide Fast Tree.

num_trees

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

num_leaves

Nombre maximal de feuilles (nœuds terminaux) qui peuvent être créées dans un arbre. Les valeurs plus élevées augmentent potentiellement la taille de l’arborescence et bénéficient d’une meilleure précision, mais entraîne le surajustement des risques, et les temps d’apprentissage sont plus longs. La valeur par défaut est 20.

learning_rate

Détermine la taille de l’étape effectuée dans le sens du gradient à chaque étape du processus d’apprentissage. ioCela détermine la rapidité ou le ralentissement de la convergence de l’apprenant sur la solution optimale. Si la taille d’étape est trop grande, vous risquez de passer à côté de la solution optimale. Si la taille d’étape est trop petite, la formation prend plus de temps pour converger vers la meilleure solution.

min_split

Nombre minimal d'instances de formation requises pour former une feuille. Autrement dit, le nombre minimal de documents autorisés dans une feuille d’un arbre de régression, en dehors des données sous-échantillonnées. Le fractionnement consiste à diviser de manière aléatoire les caractéristiques à chaque niveau de l’arbre (nœud). La valeur par défaut est 10. Seul le nombre d’instances est compté même si les instances sont pondérées.

example_fraction

Fraction d’instances choisies de façon aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 0,7.

feature_fraction

Fraction de caractéristiques choisies de façon aléatoire à utiliser pour chaque arborescence. La valeur par défaut est 1.

split_fraction

Fraction de caractéristiques choisies de façon aléatoire à utiliser pour chaque fractionnement. La valeur par défaut est 1.

num_bins

Nombre maximal de valeurs distinctes (emplacements) par caractéristique. Si la caractéristique a moins de valeurs que le nombre indiqué, chaque valeur est placée dans son propre emplacement. Si le nombre de valeurs est supérieur, l’algorithme crée numBins emplacements.

first_use_penalty

La caractéristique utilise tout d’abord le coefficient de pénalité. Il s’agit d’une forme de régularisation qui entraîne une pénalité pour l’utilisation d’une nouvelle caractéristique lors de la création de l’arborescence. Augmentez cette valeur pour créer des arborescences qui n’utilisent pas beaucoup de caractéristiques. La valeur par défaut est 0.

gain_conf_level

L’exigence de confiance de gain de l’arbre doit être comprise dans la plage (0,1). La valeur par défaut est 0.

unbalanced_sets

Si True, les dérivées optimisées pour les ensembles déséquilibrés sont utilisés. S'applique uniquement quand type est égal à "binary". La valeur par défaut est False.

train_threads

Nombre de threads à utiliser pour la formation. La valeur par défaut est 8.

random_seed

Spécifie la valeur de départ aléatoire. La valeur par défaut est Aucun.

ml_transforms

Spécifie la liste des transformations MicrosoftML à effectuer sur les données avant l’apprentissage ou Aucune si aucune transformation ne doit être effectuée. Consultez featurize_text, categorical et categorical_hash pour connaî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 Aucun.

ml_transform_vars

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

row_selection

NON PRIS EN CHARGE. Spécifie les lignes (observations) du jeu de données qui doivent être utilisées par le modèle avec le nom d’une variable logique du jeu de données (entre guillemets) ou avec une expression logique utilisant des 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 variable age est comprise entre 20 et 65, et la valeur log de la variable income est supérieure à 10.

La sélection de ligne est effectuée après le traitement de toutes les transformations de données (consultez les arguments transforms ou transform_function). Comme avec toutes les expressions, row_selection peut être défini en dehors de l’appel de fonction à l’aide de la fonction expression.

transformations

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

transform_objects

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

transform_function

Fonction de transformation de variables.

transform_variables

Vecteur de caractère 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ère spécifiant des packages Python supplémentaires (en dehors de ceux spécifiés dans RxOptions.get_option("transform_packages")) qui doivent être disponibles et préchargés pour l’utilisation dans les fonctions de transformation de variables. Par exemple, ceux définis explicitement dans les fonctions revoscalepy via leurs arguments transforms et transform_function ou ceux définis implicitement via leurs arguments formula ou row_selection. L’argument transform_packages peut également être Aucun, ce qui indique qu’aucun package n’est préchargé en dehors de RxOptions.get_option("transform_packages").

transform_environment

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

blocks_per_read

Spécifie le nombre de blocs à lire pour chaque segment 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 de la ligne :

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 les minutages sont signalés.
3 : les lignes traitées et l’ensemble des minutages sont signalés.

verbose

Valeur entière qui spécifie la quantité de sortie souhaitée. Si la valeur est 0, aucune sortie détaillée n’est imprimée au cours des calculs. Les valeurs entières de 1 à 4 fournissent des quantités d’informations croissantes.

compute_context

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

ensemble

Paramètres de contrôle pour l’apprentissage ensembliste.

Retours

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

Notes

Cet algorithme est multithread et tente toujours de charger l’intégralité du jeu de données dans la mémoire.

Voir aussi

rx_fast_forest, rx_predict

Références

Wikipédia : boosting de gradient (boosting de l’arborescence de gradient)

Estimation de fonction gourmande : machine à boosting de gradient.

Exemple de classification binaire

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

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

Exemple de régression

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