Scikit Learn - Descente de gradient stochastique

Ici, nous allons découvrir un algorithme d'optimisation dans Sklearn, appelé Stochastic Gradient Descent (SGD).

La descente de gradient stochastique (SGD) est un algorithme d'optimisation simple mais efficace utilisé pour trouver les valeurs de paramètres / coefficients de fonctions qui minimisent une fonction de coût. En d'autres termes, il est utilisé pour l'apprentissage discriminatif des classificateurs linéaires sous des fonctions de perte convexe telles que SVM et régression logistique. Il a été appliqué avec succès aux ensembles de données à grande échelle car la mise à jour des coefficients est effectuée pour chaque instance d'entraînement, plutôt qu'à la fin des instances.

Classificateur SGD

Le classificateur SGD (Stochastic Gradient Descent) implémente essentiellement une routine d'apprentissage SGD simple prenant en charge diverses fonctions de perte et pénalités pour la classification. Scikit-learn fournitSGDClassifier module pour implémenter la classification SGD.

Paramètres

Le tableau suivant comprend les paramètres utilisés par SGDClassifier module -

Sr.Non Paramètre et description
1

loss - str, default = 'charnière'

Il représente la fonction de perte à utiliser lors de la mise en œuvre. La valeur par défaut est 'hinge' qui nous donnera un SVM linéaire. Les autres options qui peuvent être utilisées sont -

  • log - Cette perte nous donnera une régression logistique c'est-à-dire un classificateur probabiliste.

  • modified_huber - une perte régulière qui apporte une tolérance aux valeurs aberrantes ainsi que des estimations de probabilité.

  • squared_hinge - similaire à la perte «charnière» mais elle est pénalisée de façon quadratique.

  • perceptron - comme son nom l'indique, il s'agit d'une perte linéaire qui est utilisée par l'algorithme du perceptron.
2

penalty - str, 'aucun', 'l2', 'l1', 'élastiquenet'

C'est le terme de régularisation utilisé dans le modèle. Par défaut, c'est L2. Nous pouvons utiliser L1 ou 'Elasticnet; aussi mais les deux peuvent apporter une parcimonie au modèle, donc impossible à réaliser avec L2.
3

alpha - flottant, par défaut = 0,0001

Alpha, la constante qui multiplie le terme de régularisation, est le paramètre de réglage qui décide à quel point nous voulons pénaliser le modèle. La valeur par défaut est 0,0001.
4

l1_ratio - flottant, par défaut = 0,15

C'est ce qu'on appelle le paramètre de mixage ElasticNet. Son intervalle est 0 <= l1_ratio <= 1. Si l1_ratio = 1, la pénalité serait une pénalité L1. Si l1_ratio = 0, la pénalité serait une pénalité L2.
5

fit_intercept - Booléen, par défaut = True

Ce paramètre spécifie qu'une constante (biais ou interception) doit être ajoutée à la fonction de décision. Aucune interception ne sera utilisée dans le calcul et les données seront supposées déjà centrées, si elles sont définies sur false.
6

tol - float ou aucun, facultatif, par défaut = 1.e-3

Ce paramètre représente le critère d'arrêt des itérations. Sa valeur par défaut est False mais si elle est définie sur None, les itérations s'arrêteront lorsqueloss > best_loss - tol for n_iter_no_changeépoques successives.
sept

shuffle - Booléen, facultatif, par défaut = True

Ce paramètre représente cela si nous voulons que nos données d'entraînement soient mélangées après chaque époque ou non.
8

verbose - entier, par défaut = 0

Il représente le niveau de verbosité. Sa valeur par défaut est 0.
9

epsilon - flottant, par défaut = 0,1

Ce paramètre spécifie la largeur de la région insensible. Si loss = 'epsilon-insensitive', toute différence, entre la prédiction actuelle et l'étiquette correcte, inférieure au seuil serait ignorée.
dix

max_iter - int, facultatif, par défaut = 1000

Comme son nom l'indique, il représente le nombre maximum de passages sur les époques, c'est-à-dire les données d'apprentissage.
11

warm_start - booléen, facultatif, par défaut = faux

Avec ce paramètre défini sur True, nous pouvons réutiliser la solution de l'appel précédent pour l'ajuster comme initialisation. Si nous choisissons default, c'est-à-dire false, cela effacera la solution précédente.
12

random_state - int, instance RandomState ou None, facultatif, par défaut = aucun

Ce paramètre représente la graine du nombre pseudo aléatoire généré qui est utilisé lors du brassage des données. Voici les options.

  • int - Dans ce cas, random_state est la graine utilisée par le générateur de nombres aléatoires.

  • RandomState instance - Dans ce cas, random_state est le générateur de nombres aléatoires.

  • None - Dans ce cas, le générateur de nombres aléatoires est l'instance RandonState utilisée par np.random.
13

n_jobs - int ou aucun, facultatif, par défaut = aucun

Il représente le nombre de processeurs à utiliser dans le calcul OVA (One Versus All), pour les problèmes multi-classes. La valeur par défaut est aucune, ce qui signifie 1.
14

learning_rate - chaîne, facultatif, par défaut = 'optimal'

  • Si le taux d'apprentissage est «constant», eta = eta0;

  • Si le taux d'apprentissage est «optimal», eta = 1.0 / (alpha * (t + t0)), où t0 est choisi par Léon Bottou;

  • Si le taux d'apprentissage = 'invscalling', eta = eta0 / pow (t, power_t).

  • Si le taux d'apprentissage = 'adaptatif', eta = eta0.
15

eta0 - double, par défaut = 0,0

Il représente le taux d'apprentissage initial pour les options de taux d'apprentissage mentionnées ci-dessus, c'est-à-dire «constant», «invscall» ou «adaptatif».
16

power_t - idouble, par défaut = 0,5

C'est l'exposant du taux d'apprentissage «incscalling».
17

early_stopping - booléen, par défaut = False

Ce paramètre représente l'utilisation de l'arrêt anticipé pour mettre fin à l'entraînement lorsque le score de validation ne s'améliore pas. Sa valeur par défaut est false mais lorsqu'elle est définie sur true, elle met automatiquement de côté une fraction stratifiée des données d'entraînement comme validation et arrête la formation lorsque le score de validation ne s'améliore pas.
18

validation_fraction - flottant, par défaut = 0,1

Il n'est utilisé que lorsque early_stopping est vrai. Il représente la proportion de données d'entraînement à mettre de côté comme ensemble de validation pour l'arrêt prématuré des données d'entraînement.
19

n_iter_no_change - int, par défaut = 5

Il représente le nombre d'itérations sans amélioration si l'algorithme doit s'exécuter avant l'arrêt prématuré.
20

classs_weight - dict, {class_label: weight} ou "balancé", ou Aucun, facultatif

Ce paramètre représente les poids associés aux classes. Si elles ne sont pas fournies, les classes sont censées avoir un poids de 1.
20

warm_start - booléen, facultatif, par défaut = faux

Avec ce paramètre défini sur True, nous pouvons réutiliser la solution de l'appel précédent pour l'ajuster comme initialisation. Si nous choisissons default, c'est-à-dire false, cela effacera la solution précédente.
21

average - iBoolean ou int, facultatif, par défaut = false

Il représente le nombre de processeurs à utiliser dans le calcul OVA (One Versus All), pour les problèmes multi-classes. La valeur par défaut est aucune, ce qui signifie 1.

Les attributs

Le tableau suivant comprend les attributs utilisés par SGDClassifier module -

Sr.Non Attributs et description
1

coef_ - tableau, forme (1, n_features) si n_classes == 2, sinon (n_classes, n_features)

Cet attribut fournit le poids attribué aux entités.
2

intercept_ - tableau, forme (1,) si n_classes == 2, sinon (n_classes,)

Il représente le terme indépendant dans la fonction de décision.
3

n_iter_ - int

Il donne le nombre d'itérations pour atteindre le critère d'arrêt.

Implementation Example

Comme les autres classificateurs, la descente de gradient stochastique (SGD) doit être équipée des deux tableaux suivants -

  • Un tableau X contenant les échantillons d'apprentissage. Il est de taille [n_samples, n_features].

  • Un tableau Y contenant les valeurs cibles, c'est-à-dire des étiquettes de classe pour les échantillons d'apprentissage. Il est de taille [n_samples].

Example

Le script Python suivant utilise le modèle linéaire SGDClassifier -

import numpy as np
from sklearn import linear_model
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
Y = np.array([1, 1, 2, 2])
SGDClf = linear_model.SGDClassifier(max_iter = 1000, tol=1e-3,penalty = "elasticnet")
SGDClf.fit(X, Y)

Output

SGDClassifier(
   alpha = 0.0001, average = False, class_weight = None,
   early_stopping = False, epsilon = 0.1, eta0 = 0.0, fit_intercept = True,
   l1_ratio = 0.15, learning_rate = 'optimal', loss = 'hinge', max_iter = 1000,
   n_iter = None, n_iter_no_change = 5, n_jobs = None, penalty = 'elasticnet',
   power_t = 0.5, random_state = None, shuffle = True, tol = 0.001,
   validation_fraction = 0.1, verbose = 0, warm_start = False
)

Example

Maintenant, une fois ajusté, le modèle peut prédire de nouvelles valeurs comme suit -

SGDClf.predict([[2.,2.]])

Output

array([2])

Example

Pour l'exemple ci-dessus, nous pouvons obtenir le vecteur de poids à l'aide du script python suivant -

SGDClf.coef_

Output

array([[19.54811198, 9.77200712]])

Example

De même, nous pouvons obtenir la valeur de l'interception à l'aide du script python suivant -

SGDClf.intercept_

Output

array([10.])

Example

Nous pouvons obtenir la distance signée par rapport à l'hyperplan en utilisant SGDClassifier.decision_function tel qu'utilisé dans le script python suivant -

SGDClf.decision_function([[2., 2.]])

Output

array([68.6402382])

Régresseur SGD

Le régresseur SGD (Stochastic Gradient Descent) implémente essentiellement une routine d'apprentissage SGD simple prenant en charge diverses fonctions de perte et pénalités pour s'adapter aux modèles de régression linéaire. Scikit-learn fournitSGDRegressor module pour implémenter la régression SGD.

Paramètres

Paramètres utilisés par SGDRegressorsont presque les mêmes que ceux utilisés dans le module SGDClassifier. La différence réside dans le paramètre «perte». PourSGDRegressor paramètre de perte des modules les valeurs positives sont les suivantes -

  • squared_loss - Il se réfère à l'ajustement ordinaire des moindres carrés.

  • huber: SGDRegressor- corriger les valeurs aberrantes en passant de la perte quadratique à la perte linéaire au-delà d'une distance de epsilon. Le travail de «huber» est de modifier «squared_loss» afin que l'algorithme se concentre moins sur la correction des valeurs aberrantes.

  • epsilon_insensitive - En fait, il ignore les erreurs moins que epsilon.

  • squared_epsilon_insensitive- C'est la même chose que epsilon_insensitive. La seule différence est qu'elle devient une perte au carré au-delà d'une tolérance d'epsilon.

Une autre différence est que le paramètre nommé 'power_t' a la valeur par défaut de 0,25 au lieu de 0,5 comme dans SGDClassifier. De plus, il n'a pas de paramètres 'class_weight' et 'n_jobs'.

Les attributs

Les attributs de SGDRegressor sont également les mêmes que ceux du module SGDClassifier. Il a plutôt trois attributs supplémentaires comme suit -

  • average_coef_ - tableau, forme (n_features,)

Comme son nom l'indique, il fournit les poids moyens attribués aux fonctionnalités.

  • average_intercept_ - tableau, forme (1,)

Comme son nom l'indique, il fournit le terme d'interception moyen.

  • t_ - int

Il fournit le nombre de mises à jour de poids effectuées pendant la phase d'entraînement.

Note - les attributs average_coef_ et average_intercept_ fonctionneront après avoir activé le paramètre 'average' sur True.

Implementation Example

Suivre les utilisations de script Python SGDRegressor modèle linéaire -

import numpy as np
from sklearn import linear_model
n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)
SGDReg =linear_model.SGDRegressor(
   max_iter = 1000,penalty = "elasticnet",loss = 'huber',tol = 1e-3, average = True
)
SGDReg.fit(X, y)

Output

SGDRegressor(
   alpha = 0.0001, average = True, early_stopping = False, epsilon = 0.1,
   eta0 = 0.01, fit_intercept = True, l1_ratio = 0.15,
   learning_rate = 'invscaling', loss = 'huber', max_iter = 1000,
   n_iter = None, n_iter_no_change = 5, penalty = 'elasticnet', power_t = 0.25,
   random_state = None, shuffle = True, tol = 0.001, validation_fraction = 0.1,
   verbose = 0, warm_start = False
)

Example

Maintenant, une fois ajusté, nous pouvons obtenir le vecteur de poids à l'aide du script python suivant -

SGDReg.coef_

Output

array([-0.00423314, 0.00362922, -0.00380136, 0.00585455, 0.00396787])

Example

De même, nous pouvons obtenir la valeur de l'interception à l'aide du script python suivant -

SGReg.intercept_

Output

SGReg.intercept_

Example

Nous pouvons obtenir le nombre de mises à jour de poids pendant la phase d'entraînement à l'aide du script python suivant -

SGDReg.t_

Output

61.0

Avantages et inconvénients de SGD

Suivre les pros de SGD -

  • La descente de gradient stochastique (SGD) est très efficace.

  • Il est très facile à mettre en œuvre car il existe de nombreuses possibilités de réglage du code.

Suite aux inconvénients de SGD -

  • La descente de gradient stochastique (SGD) nécessite plusieurs hyperparamètres comme les paramètres de régularisation.

  • Il est sensible à la mise à l'échelle des fonctionnalités.