microsoftml.rx_fast_linear : modèle linéaire avec élévation stochastique à double coordonnée

Article
05/23/2023

Usage

microsoftml.rx_fast_linear()

Description

Système d'apprentissage à l'optimisation de l'élévation stochastique à double coordonnée (Stochastic Dual Coordinate Ascent - SDCA) pour la classification et la régression binaires linéaires.

Détails

rx_fast_linear est un système d'apprentissage basé sur la méthode de l'élévation stochastique à double coordonnée (Stochastic Dual Coordinate Ascent - SDCA), une technique d'optimisation de pointe pour les fonctions objectives convexes. L'algorithme peut être mis à l'échelle pour être utilisé sur des jeux de données volumineux hors mémoire grâce à une implémentation semi-asynchronisée qui prend en charge le multithreading. La convergence est assurée en appliquant périodiquement la synchronisation entre les mises à jour des solutions primale et duale dans un thread distinct. Plusieurs choix de fonctions de perte sont également proposés. La méthode SDCA combine plusieurs des meilleures propriétés et capacités des algorithmes de régression logistique et SVM. Pour plus d'informations sur la méthode SDCA, consultez les citations de la section de référence.

Les algorithmes d'optimisation traditionnels, comme la descente de gradient stochastique (SGD), optimisent directement la fonction de perte empirique. Le méthode SDCA choisit une approche différente qui optimise plutôt le problème dual. La fonction de perte du dual est paramétrée par des pondérations par exemple. Dans chaque itération, lorsqu'un exemple d'apprentissage du jeu de données d'apprentissage est lu, la pondération de l'exemple correspondant est ajustée de manière à ce que la fonction de perte du dual soit optimisée par rapport à l'exemple actuel. Aucun taux d'apprentissage n'est requis par la méthode SDCA pour déterminer la taille du pas comme c'est le cas pour les autres méthodes de descente de gradient.

rx_fast_linear prend actuellement en charge la classification binaire avec trois types de fonctions de perte : perte logarithmique, perte de charnière et perte de charnière lissée. La régression linéaire prend également en charge la fonction de perte au carré. La régularisation du réseau élastique peut être spécifiée par les paramètres l2_weight et l1_weight. Notez que l2_weight a un effet sur le taux de convergence. En général, plus l2_weight est important, plus la convergence de SDCA est rapide.

Notez que rx_fast_linear est un algorithme d'optimisation stochastique et de diffusion en continu. Les résultats dépendent de l'ordre des données d'apprentissage. Pour des résultats reproductibles, il est recommandé de définir shuffle sur False et train_threads sur 1.

Arguments

formula

Formule décrite dans revoscalepy.rx_formula. Les termes d'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

Spécifie le type de modèle avec une chaîne de caractères : "binary" pour la classification binaire par défaut ou "regression" pour la régression linéaire.

loss_function

Spécifie la fonction de perte empirique à optimiser. Pour la classification binaire, les choix suivants sont disponibles :

log_loss : la perte logarithmique. Il s’agit de la valeur par défaut.
hinge_loss : la perte de charnière SVM. Son paramètre représente la taille de la marge.
smooth_hinge_loss : la perte de la charnière lissée. Son paramètre représente la constante de lissage.

Pour la régression linéaire, la perte au carré squared_loss est actuellement prise en charge. Lorsque ce paramètre est défini sur None, sa valeur par défaut dépend du type d'apprentissage :

log_loss pour la classification binaire.
squared_loss pour la régression linéaire.

L'exemple suivant remplace la fonction de perte par hinge_loss : rx_fast_linear(..., loss_function=hinge_loss()).

l1_weight

Spécifie la pondération de la régularisation L1. La valeur doit être soit non négative, soit None. Si None est spécifié, la valeur réelle est automatiquement calculée en fonction du jeu de données. None est la valeur par défaut.

l2_weight

Spécifie la pondération de la régularisation L2. La valeur doit être soit non négative, soit None. Si None est spécifié, la valeur réelle est automatiquement calculée en fonction du jeu de données. None est la valeur par défaut.

train_threads

Spécifie le nombre de threads simultanés qui peuvent être utilisés pour exécuter l'algorithme. Lorsque ce paramètre est défini sur None, le nombre de threads utilisés est déterminé en fonction du nombre de processeurs logiques disponibles pour le processus, ainsi que de la densité des données. Définissez-le sur 1 pour exécuter l'algorithme dans un seul thread.

convergence_tolerance

Spécifie le seuil de tolérance utilisé comme critère de convergence. Il doit être compris entre 0 et 1. La valeur par défaut est 0.1. L'algorithme est considéré comme ayant convergé si le saut de dualité relatif, qui correspond au rapport entre le saut de dualité et la perte du primal, passe en dessous de la tolérance de convergence spécifiée.

max_iterations

Spécifie une limite supérieure pour le nombre d'itérations d'apprentissage. Ce paramètre doit être positif ou None. Si None est spécifié, la valeur réelle est automatiquement calculée en fonction du jeu de données. Chaque itération nécessite un passage complet sur les données d'apprentissage. L'apprentissage se termine lorsque le nombre total d'itérations atteint la limite supérieure spécifiée ou lorsque la fonction de perte converge, selon la première éventualité.

lecture aléatoire

Spécifie si les données d'apprentissage doivent être mélangées. Spécifiez True pour mélanger les données ou False pour ne pas les mélanger. La valeur par défaut est True. SDCA est un algorithme d'optimisation stochastique. Si la lecture aléatoire est activée, les données d'apprentissage sont mélangées à chaque itération.

check_frequency

Nombre d'itérations après lesquelles la fonction de perte est calculée et vérifiée pour déterminer si elle a convergé. La valeur spécifiée doit être un nombre entier positif ou None. Si None est spécifié, la valeur réelle est automatiquement calculée en fonction du jeu de données. Sinon, par exemple, si checkFrequency = 5 est spécifié, la fonction de perte est calculée et la convergence est vérifiée toutes les 5 itérations. Le calcul de la fonction de perte nécessite un passage complet distinct sur les données d'apprentissage.

normalize

Spécifie le type de normalisation automatique utilisé :

"Auto" : si la normalisation est nécessaire, elle est effectuée automatiquement. Il s’agit de la valeur par défaut.
"No" : aucune normalisation n’est effectuée.
"Yes" : la normalisation est effectuée.
"Warn" : si la normalisation est nécessaire, un message d’avertissement s’affiche, mais la normalisation n’est pas effectuée.

La normalisation redimensionne les plages de données disparates à une échelle standard. La mise à l’échelle des caractéristiques garantit que les distances entre les points de données sont proportionnelles et permet aux différentes méthodes d’optimisation, comme la descente de gradient, de converger beaucoup plus rapidement. Si la normalisation est effectuée, un normaliseur MaxMin est utilisé. Il normalise les valeurs dans un intervalle [a, b] où -1 <= a <= 0, 0 <= b <= 1 et b - a = 1. Ce normaliseur conserve la densité en mappant zéro à zéro.

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 FastLinear avec le modèle entraîné.

Notes

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

Voir aussi

hinge_loss, log_loss, smoothed_hinge_loss, squared_loss, rx_predict

Références

Mise à l'échelle avec élévation stochastique à double coordonnée

Méthodes d'élévation stochastique à double coordonnée pour la minimisation des pertes régularisées

Exemple de classification binaire

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_fast_linear, 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_linear(
    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 :

Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Using 2 threads to train.
Automatically choosing a check frequency of 2.
Auto-tuning parameters: maxIterations = 8064.
Auto-tuning parameters: L2 = 2.666837E-05.
Auto-tuning parameters: L1Threshold (L1/L2) = 0.
Using best model from iteration 568.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.5810985
Elapsed time: 00:00:00.0084876
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0292334
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: Less than .001 seconds 
  isCase PredictedLabel     Score  Probability
0   True           True  0.990544     0.729195
1  False          False -2.307120     0.090535
2  False          False -0.608565     0.352387
3   True           True  1.028217     0.736570
4   True          False -3.913066     0.019588

Exemple de régression

'''
Regression.
'''
import numpy
import pandas
from microsoftml import rx_fast_linear, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

attitude = get_dataset("attitude")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

attitudedf = attitude.as_df()
data_train, data_test = train_test_split(attitudedf)

model = rx_fast_linear(
    formula="rating ~ complaints + privileges + learning + raises + critical + advance",
    method="regression",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["rating"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))