microsoftml.rx_logistic_regression : Régression logistique

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)

Descriptif

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 catégorielle 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 (le type de sang donné les résultats des tests de diagnostic), la régression logistique est multinomiale.

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

Cet apprenant peut utiliser la régularisation de net élastique : combinaison linéaire des régularisations L1 (lasso) et L2 (crête). La régularisation est une méthode qui peut rendre un problème mal posé plus réductible en imposant des contraintes qui fournissent des informations pour compléter les données et qui empêchent le surajustement en pénalisant 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 de variance de biais. 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ême serait pénalisé plus, mais un modèle moins précis avec des valeurs plus conservatrices serait pénalisé moins. La régularisation L1 et L2 ont des effets et des utilisations différents qui sont complémentaires à certains égards.

l1_weight: peut être appliqué à des modèles partiellement alloués, lors de l’utilisation de données à haute dimension. Il tire de petites pondérations associées qui sont relativement peu importantes vers 0.
l2_weight: est préférable pour les données qui ne sont pas éparses. Il tire de gros poids vers zéro.

L’ajout de la pénalité de crête à la régularisation dépasse certaines des limitations de lasso. Il peut améliorer sa précision prédictive, par exemple, lorsque le nombre de prédicteurs 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 de x et y sont toutes les deux 1. Une régularisation agressive peut nuire à la capacité prédictive en excluant des variables importantes hors du modèle. Ainsi, le choix des valeurs optimales pour les paramètres de régularisation est important pour les performances du modèle de régression logistique.

Arguments

formula

La formule décrite dans revoscalepy.rx_formula termes d’interaction et F() n’est actuellement pas prise 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 de régression logistique : "binary" pour la régression logistique de classification binaire par défaut ou "multiClass" pour la régression logistique multinomiale.

l2_weight

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

l1_weight

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

opt_tol

Valeur de seuil pour la convergence de l’optimiseur. Si l’amélioration entre les itérations est inférieure au seuil, l’algorithme s’arrête et retourne 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 de la mémoire pour L-BFGS, en spécifiant le nombre de positions passées et de dégradés à stocker pour le calcul de l’étape suivante. Ce paramètre d’optimisation limite la quantité de mémoire utilisée pour calculer l’ampleur et la direction de l’étape suivante. Lorsque vous spécifiez moins de mémoire, l’entraînement 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 aux critères de convergence.

show_training_stats

Spécifiez True pour afficher les statistiques des données d’apprentissage et du modèle entraîné ; 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éfini sur un nombre supérieur à 0 pour utiliser la descente de dégradé stochastique (SGD) pour rechercher les paramètres initiaux. Un jeu de valeurs non zéro spécifie l’utilisation de SGD de tolérance pour déterminer la convergence. La valeur 0 par défaut spécifie que SGD n’est pas utilisé.

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 à partir de cette plage. Par exemple, si le diamètre est spécifié comme détant , les poids sont répartis uniformément entre -d/2 et d/2. La valeur par défaut est 0, qui spécifie que tous les poids sont initialisés sur 0.

train_threads

Nombre de threads à utiliser lors de l’apprentissage du modèle. Cela doit être défini sur le nombre de cœurs sur l’ordinateur. Notez que le multithreading L-BFGS tente de charger le jeu de données en mémoire. En cas de problèmes de mémoire insuffisante, définissez train_threads cette option pour 1 désactiver le multithreading. Si aucun nombre de threads à utiliser n’est déterminé en interne. La valeur par défaut est None.

dense_optimizer

Si True, force lansification des vecteurs d’optimisation interne. Si False, permet à l’optimiseur de régression logistique d’utiliser des états internes épars ou denses, car il trouve approprié. Le paramètre denseOptimizer pour True exiger 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 certaines variétés de problèmes plus importants.

Normaliser

Spécifie le type de normalisation automatique utilisé :

"Auto": si la normalisation est nécessaire, elle est effectuée automatiquement. Il s’agit du choix 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 met à l’échelle des 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 à diverses méthodes d’optimisation telles que la descente de dégradé de converger beaucoup plus rapidement. Si la normalisation est effectuée, un MaxMin normaliseur est utilisé. Il normalise les valeurs dans un intervalle [a, b] où -1 <= a <= 0 et 0 <= b <= 1b - a = 1. Ce normaliseur conserve l’éparse en mappant zéro à zéro.

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

Note

Cet algorithme tente de charger l’ensemble du jeu de données en mémoire quand train_threads > 1 (multithreading).

Voir aussi

rx_predict

References

Wikipédia : L-BFGS

Wikipédia : Régression logistique

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

Série de tests - L1 et L2 Regularization for Machine Learning

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