microsoftml.rx_fast_trees : arbres optimisés

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)

Descriptif

Arborescence rapide du Machine Learning

Détails

rx_fast_trees est une implémentation de FastRank. FastRank est une implémentation efficace de l’algorithme de renforcement de dégradé MART. L’amélioration de dégradé est une technique d’apprentissage automatique pour les problèmes de régression. Il génère chaque arborescence de régression de manière pas à pas, à l’aide d’une fonction de perte prédéfinie pour mesurer l’erreur de chaque étape et la corriger dans la suite. Ainsi, 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, l’amélioration génère une série de ces arbres de manière pas à pas, puis sélectionne l’arbre optimal à l’aide d’une fonction de perte différente arbitraire.

MART apprend un ensemble d’arbres de régression, qui est un arbre de décision avec des valeurs scalaires dans ses feuilles. Une arborescence de décision (ou de régression) est un graphique de flux binaire de type arbre, où à chaque nœud intérieur, un nœud détermine lequel des deux nœuds enfants doit continuer à se baser sur l’une des valeurs de caractéristique de l’entrée. À chaque nœud feuille, 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’exemple d’entrée et v est l’une des valeurs possibles de cette fonctionnalité. Les fonctions qui peuvent être produites par une arborescence de régression sont toutes les fonctions constantes de manière fragmentée.

L’ensemble des arbres est produit par l’informatique, à chaque étape, un arbre de régression qui correspond approximativement au dégradé de la fonction de perte et l’ajoute à l’arbre précédent avec des coefficients qui réduisent la perte de l’arbre nouveau. La sortie de l’ensemble produit par MART sur une instance donnée est la somme des sorties de l’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 elle est définie "regression"sur , une version de régression de FastTree est utilisée. Si la valeur est définie "ranking", une version de classement de FastTree est utilisée. Dans le cas de classement, les instances doivent être classées par la sortie de l’ensemble d’arborescences. La seule différence dans les paramètres de ces versions est dans les paramètres d’étalonnage, qui sont nécessaires uniquement pour la classification.

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 qui spécifie le type d’arborescence rapide : "binary" pour la classification binaire d’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.

learning_rate

Détermine la taille de l’étape effectuée dans la direction du dégradé dans chaque étape du processus d’apprentissage. Cela détermine la rapidité ou la lenteur de l’apprenant sur la solution optimale. Si la taille de l’étape est trop grande, vous risquez de dépasser la solution optimale. Si la taille de l’étape est trop petite, l’entraînement prend plus de temps pour converger vers la meilleure solution.

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. Seul le nombre d’instances est compté même si les instances sont pondérées.

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 1.

split_fraction

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

num_bins

Nombre maximal de valeurs distinctes (bacs) par fonctionnalité. Si la fonctionnalité a moins de valeurs que le nombre indiqué, chaque valeur est placée dans son propre bac. S’il existe plus de valeurs, l’algorithme crée numBins des bacs.

first_use_penalty

La fonctionnalité utilise 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 fonctionnalité lors de la création de l’arborescence. Augmentez cette valeur pour créer des arborescences qui n’utilisent pas de nombreuses fonctionnalités. 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.

unbalanced_sets

Si True, les dérivés optimisés pour les jeux déséquilibrés sont utilisés. Applicable uniquement si type égal à "binary". La valeur par défaut est False.

train_threads

Nombre de threads à utiliser lors de l’entraînement. La valeur par défaut est 8.

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 révoscalepy valide. RxComputeContext. Actuellement local et revoscalepy. Les contextes de calcul RxInSqlServer sont pris en charge.

ensemble

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

Retours

Objet FastTrees 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_forest, rx_predict

References

Wikipédia : Boosting dégradé (boosting d’arbre dégradé)

Approximation de fonction gourmande : une machine de renforcement de dégradé.

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)