This documentation is for scikit-learn version 0.10Other versions

Citing

If you use the software, please consider citing scikit-learn.

This page

8.14.1.15. sklearn.linear_model.SGDClassifier

class sklearn.linear_model.SGDClassifier(loss='hinge', penalty='l2', alpha=0.0001, rho=0.85, fit_intercept=True, n_iter=5, shuffle=False, verbose=0, n_jobs=1, seed=0, learning_rate='optimal', eta0=0.0, power_t=0.5, class_weight=None)

Linear model fitted by minimizing a regularized empirical loss with SGD.

SGD stands for Stochastic Gradient Descent: the gradient of the loss is estimated each sample at a time and the model is updated along the way with a decreasing strength schedule (aka learning rate).

The regularizer is a penalty added to the loss function that shrinks model parameters towards the zero vector using either the squared euclidean norm L2 or the absolute norm L1 or a combination of both (Elastic Net). If the parameter update crosses the 0.0 value because of the regularizer, the update is truncated to 0.0 to allow for learning sparse models and achieve online feature selection.

This implementation works with data represented as dense numpy arrays of floating point values for the features.

Parameters :

loss : str, ‘hinge’ or ‘log’ or ‘modified_huber’

The loss function to be used. Defaults to ‘hinge’. The hinge loss is a margin loss used by standard linear SVM models. The ‘log’ loss is the loss of logistic regression models and can be used for probability estimation in binary classifiers. ‘modified_huber’ is another smooth loss that brings tolerance to outliers.

penalty : str, ‘l2’ or ‘l1’ or ‘elasticnet’

The penalty (aka regularization term) to be used. Defaults to ‘l2’ which is the standard regularizer for linear SVM models. ‘l1’ and ‘elasticnet’ migh bring sparsity to the model (feature selection) not achievable with ‘l2’.

alpha : float

Constant that multiplies the regularization term. Defaults to 0.0001

rho : float

The Elastic Net mixing parameter, with 0 < rho <= 1. Defaults to 0.85.

fit_intercept: bool :

Whether the intercept should be estimated or not. If False, the data is assumed to be already centered. Defaults to True.

n_iter: int, optional :

The number of passes over the training data (aka epochs). Defaults to 5.

shuffle: bool, optional :

Whether or not the training data should be shuffled after each epoch. Defaults to False.

seed: int, optional :

The seed of the pseudo random number generator to use when shuffling the data.

verbose: integer, optional :

The verbosity level

n_jobs: integer, optional :

The number of CPUs to use to do the OVA (One Versus All, for multi-class problems) computation. -1 means ‘all CPUs’. Defaults to 1.

learning_rate : string, optional

The learning rate: constant: eta = eta0 optimal: eta = 1.0/(t+t0) [default] invscaling: eta = eta0 / pow(t, power_t)

eta0 : double

The initial learning rate [default 0.01].

power_t : double

The exponent for inverse scaling learning rate [default 0.25].

class_weight : dict, {class_label

Preset for the class_weight fit parameter.

Weights associated with classes. If not given, all classes are supposed to have weight one.

The “auto” mode uses the values of y to automatically adjust weights inversely proportional to class frequencies.

See also

LinearSVC, LogisticRegression

Examples

>>> 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])
>>> clf = linear_model.SGDClassifier()
>>> clf.fit(X, Y)
... 
SGDClassifier(alpha=0.0001, class_weight=None, eta0=0.0,
        fit_intercept=True, learning_rate='optimal', loss='hinge',
        n_iter=5, n_jobs=1, penalty='l2', power_t=0.5, rho=0.85, seed=0,
        shuffle=False, verbose=0)
>>> print clf.predict([[-0.8, -1]])
[1]

Attributes

coef_ array, shape = [1, n_features] if n_classes == 2 else [n_classes,  
n_features]   Weights assigned to the features.
intercept_ array, shape = [1] if n_classes == 2 else [n_classes] Constants in decision function.

Methods

decision_function(X) Predict signed ‘distance’ to the hyperplane (aka confidence score)
fit(X, y[, coef_init, intercept_init, ...]) Fit linear model with Stochastic Gradient Descent.
predict(X) Predict using the linear model
predict_proba(X) Predict class membership probability
score(X, y) Returns the mean accuracy on the given test data and labels.
set_params(**params) Set the parameters of the estimator.
__init__(loss='hinge', penalty='l2', alpha=0.0001, rho=0.85, fit_intercept=True, n_iter=5, shuffle=False, verbose=0, n_jobs=1, seed=0, learning_rate='optimal', eta0=0.0, power_t=0.5, class_weight=None)
decision_function(X)

Predict signed ‘distance’ to the hyperplane (aka confidence score)

Parameters :

X : array, shape [n_samples, n_features]

Returns :

array, shape = [n_samples] if n_classes == 2 else [n_samples,n_classes] :

The signed ‘distances’ to the hyperplane(s).

fit(X, y, coef_init=None, intercept_init=None, class_weight=None, sample_weight=None)

Fit linear model with Stochastic Gradient Descent.

Parameters :

X : numpy array of shape [n_samples,n_features]

Training data

y : numpy array of shape [n_samples]

Target values

coef_init : array, shape = [n_classes,n_features]

The initial coeffients to warm-start the optimization.

intercept_init : array, shape = [n_classes]

The initial intercept to warm-start the optimization.

class_weight : dict, {class_label

Weights associated with classes. If not given, all classes are supposed to have weight one.

The “auto” mode uses the values of y to automatically adjust weights inversely proportional to class frequencies.

sample_weight : array-like, shape = [n_samples], optional

Weights applied to individual samples (1. for unweighted).

Returns :

self : returns an instance of self.

predict(X)

Predict using the linear model

Parameters :

X : array or scipy.sparse matrix of shape [n_samples, n_features]

Whether the numpy.array or scipy.sparse matrix is accepted depends on the actual implementation

Returns :

array, shape = [n_samples] :

Array containing the predicted class labels.

predict_proba(X)

Predict class membership probability

Parameters :

X : array or scipy.sparse matrix of shape [n_samples, n_features]

Returns :

array, shape = [n_samples] if n_classes == 2 else [n_samples, :

n_classes] :

Contains the membership probabilities of the positive class.

score(X, y)

Returns the mean accuracy on the given test data and labels.

Parameters :

X : array-like, shape = [n_samples, n_features]

Training set.

y : array-like, shape = [n_samples]

Labels for X.

Returns :

z : float

set_params(**params)

Set the parameters of the estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The former have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Returns :self :