microsoftml.rx_logistic_regression : régression logistique

Article
05/23/2023

Usage

microsoftml.rx_logistic_regression(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'multiClass'] = 'binary', l2_weight: float = 1,
    l1_weight: float = 1, opt_tol: float = 1e-07,
    memory_size: int = 20, init_wts_diameter: float = 0,
    max_iterations: int = 2147483647,
    show_training_stats: bool = False, sgd_init_tol: float = 0,
    train_threads: int = None, dense_optimizer: bool = False,
    normalize: ['No', 'Warn', 'Auto', 'Yes'] = 'Auto',
    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

Régression logistique Machine Learning

Détails

La régression logistique est une méthode de classification utilisée pour prédire la valeur d’une variable dépendante d’une catégorie et de sa relation à une ou plusieurs variables indépendantes supposées avoir une distribution logistique. Si la variable dépendante n’a que deux valeurs possibles (réussite/échec), la régression logistique est binaire. Si la variable dépendante a plus de deux valeurs possibles (groupe sanguin en fonction de résultats de tests de diagnostic), la régression logistique est polynomiale.

La technique d’optimisation utilisée pour rx_logistic_regression est la Broyden-Fletcher-Goldfarb-Shanno (L-BFGS) à mémoire limitée. Les algorithmes L-BFGS et BFGS standard utilisent des méthodes quasi-newtoniennes pour estimer la matrice Hessian nécessitant beaucoup de ressources de calcul dans l’équation utilisée par la méthode de Newton pour calculer les étapes. Toutefois, l’approximation L-BFGS utilise uniquement une quantité limitée de mémoire pour calculer la direction de l’étape suivante, et elle est dont particulièrement adaptée aux problèmes avec un grand nombre de variables. Le paramètre memory_size indique le nombre de positions passées et de gradients à stocker pour utilisation dans le calcul de l’étape suivante.

Cet apprenant peut utiliser la régularisation élastique nette : une combinaison linéaire de L1 (Lasso) et de régularisations L2 (Ridge). La régularisation est une méthode qui peut rendre un problème mal posé plus exploitable en imposant des contraintes qui fournissent des informations pour compléter les données et empêcher le surajustement en sanctionnant les modèles avec des valeurs de coefficient extrêmes. Cela peut améliorer la généralisation du modèle appris en sélectionnant la complexité optimale dans le compromis décalage/variance. La régularisation fonctionne en ajoutant la pénalité associée aux valeurs de coefficient à l’erreur de l’hypothèse. Un modèle précis avec des valeurs de coefficient extrêmes est pénalisé davantage, alors qu’un modèle moins précis avec des valeurs plus conservatrices est moins pénalisé. Les régularisations L1 et L2 ont des effets et des utilisations complémentaires à certains égards.

l1_weight : applicable aux modèles dispersés, lorsque vous travaillez avec des données de grande dimension. Elle extrait les fonctionnalités associées de pondération réduite qui sont relativement peu importantes vers 0.
l2_weight : préférable pour les données qui ne sont pas éparses. Elle extrait les grandes pondérations vers zéro.

L’ajout de la pénalité Ridge à la régularisation atténue certaines limitations de Lasso. Elle peut améliorer la précision de prédiction, par exemple lorsque le nombre de prédictions est supérieur à la taille de l’échantillon. Si x = l1_weight et y = l2_weight, ax + by = c définit l’étendue linéaire des termes de régularisation. Les valeurs par défaut x et y sont toutes les deux 1. Une régularisation agressive peut nuire à la capacité prédictive en excluant les variables importantes du modèle. Par conséquent, il est important de choisir les valeurs optimales pour les paramètres de régularisation pour de bonnes performances du modèle de régression logistique.

Arguments

formule

La formule telle que décrite dans les termes d’interaction revoscalepy.rx_formula et F() est pas prise en charge actuellement 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 spécifie le type de régression logistique : "binary" pour la régression logistique de classification binaire par défaut ou "multiClass" pour la régression logistique polynomiale.

l2_weight

Pondération de régularisation L2. Sa valeur doit être supérieure ou égale à 0 et la valeur par défaut est 1.

l1_weight

Pondération de régularisation L1. Sa valeur doit être supérieure ou égale à 0 et la valeur par défaut est 1.

opt_tol

Valeur de seuil de convergence de l’optimiseur. Si l’amélioration entre les itérations est inférieure à ce seuil, l’algorithme s’arrête et renvoie le modèle actuel. Les valeurs plus petites sont plus lentes, mais plus précises. La valeur par défaut est 1e-07.

memory_size

Taille mémoire pour L-BFGS, qui indique le nombre de positions passées et de gradients à stocker pour le calcul de l’étape suivante. Ce paramètre d’optimisation limite la quantité de mémoire utilisée pour calculer l’importance et la direction de l’étape suivante. Lorsque vous spécifiez moins de mémoire, l’apprentissage est plus rapide mais moins précis. Doit être supérieur ou égal à 1 et la valeur par défaut est 20.

max_iterations

Définit le nombre maximal d’itérations. Après ce nombre d’étapes, l’algorithme s’arrête même s’il n’a pas satisfait les critères de convergence.

show_training_stats

Spécifiez True pour afficher les statistiques des données d’apprentissage et le modèle formé, sinon False. La valeur par défaut est False. Pour plus d’informations sur les statistiques de modèle, consultez summary.ml_model().

sgd_init_tol

Définissez sur un nombre supérieur à 0 pour utiliser la descente de gradient stochastique pour rechercher les paramètres initiaux. Une valeur différente de zéro spécifie la tolérance utilisée par la descente de gradient stochastique pour déterminer la convergence. La valeur par défaut 0 spécifie que la descente de gradient stochastique n’est pas utilisée.

init_wts_diameter

Définit le diamètre des pondérations initiales qui spécifie la plage à partir de laquelle les valeurs sont dessinées pour les pondérations initiales. Ces pondérations sont initialisées de façon aléatoire dans cette plage. Par exemple, si le diamètre est spécifié comme étant d, les pondérations sont distribuées uniformément entre -d/2 et d/2. La valeur par défaut est 0, qui spécifie que toutes les pondérations sont initialisées à 0.

train_threads

Nombre de threads à utiliser pour la formation du modèle. Ce nombre doit être défini sur le nombre de cœurs présents sur l’ordinateur. Notez que le multi-threading de L-BFGS tente de charger le jeu de données en mémoire. En cas de problèmes de mémoire insuffisante, affectez à train_threads la valeur 1 pour désactiver le multi-threading. Si aucune valeur n’est définie, le nombre de threads utilisés est déterminé en interne. La valeur par défaut est Aucun.

dense_optimizer

Si True, force la densification des vecteurs d’optimisation internes. Si False, permet à l’optimiseur de régression logistique d’utiliser des États internes éparpillés ou denses lorsqu’il le trouve approprié. L’affectation de la valeur denseOptimizer à True exige que l’optimiseur interne utilise un état interne dense, ce qui peut aider à réduire la charge sur le récupérateur de mémoire pour certains types de problèmes plus importants.

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

Notes

Cet algorithme tente de charger l’intégralité du jeu de données dans la mémoire lorsque train_threads > 1 (multithread).

Voir aussi

rx_predict

Références

Wikipedia : L-BFGS

Wikipédia : régression logistique

Formation évolutive des modèles de Log-Linear L1-Regularized

Série de tests : régularisations L1 et L2 pour l’apprentissage automatique

Exemple de classification binaire

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, 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)

model = rx_logistic_regression(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)

print(model.coef_)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(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.001, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory issues, turn off multi-threading by setting trainThreads to 1.
Beginning optimization
num vars: 6
improvement criterion: Mean Improvement
L1 regularization selected 5 of 6 weights.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0646405
Elapsed time: 00:00:00.0083991
OrderedDict([('(Bias)', -1.2366217374801636), ('spontaneous', 1.9391206502914429), ('induced', 0.7497404217720032), ('parity', -0.31517016887664795), ('age', -3.162723260174971e-06)])
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0287290
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 -1.341681     0.207234
1   True           True  0.597440     0.645070
2  False           True  0.544912     0.632954
3  False          False -1.289152     0.215996
4  False          False -1.019339     0.265156

Exemple de classification multiclasse

'''
MultiClass Classification
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

iris = get_dataset("iris")

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

irisdf = iris.as_df()
irisdf["Species"] = irisdf["Species"].astype("category")
data_train, data_test, y_train, y_test = train_test_split(irisdf, irisdf.Species)

model = rx_logistic_regression(
    formula="  Species ~ Sepal_Length + Sepal_Width + Petal_Length + Petal_Width ",
    method="multiClass",
    data=data_train)

print(model.coef_)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["Species", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))