class sklearn.neural_network.MLPClassifier(hidden_layer_sizes=100, activation='relu', *, solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10, max_fun=15000) [source]

Multi-layer Perceptron classifier. This model optimizes the log-loss function using LBFGS or stochastic gradient descent.  New in version 0.18.   Parameters

hidden_layer_sizestuple, length = n_layers - 2, default=(100,)

The ith element represents the number of neurons in the ith hidden layer.
activation{‘identity’, ‘logistic’, ‘tanh’, ‘relu’}, default=’relu’

Activation function for the hidden layer.  ‘identity’, no-op activation, useful to implement linear bottleneck, returns f(x) = x ‘logistic’, the logistic sigmoid function, returns f(x) = 1 / (1 + exp(-x)). ‘tanh’, the hyperbolic tan function, returns f(x) = tanh(x). ‘relu’, the rectified linear unit function, returns f(x) = max(0, x)
solver{‘lbfgs’, ‘sgd’, ‘adam’}, default=’adam’

The solver for weight optimization.  ‘lbfgs’ is an optimizer in the family of quasi-Newton methods. ‘sgd’ refers to stochastic gradient descent. ‘adam’ refers to a stochastic gradient-based optimizer proposed by Kingma, Diederik, and Jimmy Ba  Note: The default solver ‘adam’ works pretty well on relatively large datasets (with thousands of training samples or more) in terms of both training time and validation score. For small datasets, however, ‘lbfgs’ can converge faster and perform better.
alphafloat, default=0.0001

L2 penalty (regularization term) parameter.
batch_sizeint, default=’auto’

Size of minibatches for stochastic optimizers. If the solver is ‘lbfgs’, the classifier will not use minibatch. When set to “auto”, batch_size=min(200, n_samples)
learning_rate{‘constant’, ‘invscaling’, ‘adaptive’}, default=’constant’

Learning rate schedule for weight updates.  ‘constant’ is a constant learning rate given by ‘learning_rate_init’. ‘invscaling’ gradually decreases the learning rate at each time step ‘t’ using an inverse scaling exponent of ‘power_t’. effective_learning_rate = learning_rate_init / pow(t, power_t) ‘adaptive’ keeps the learning rate constant to ‘learning_rate_init’ as long as training loss keeps decreasing. Each time two consecutive epochs fail to decrease training loss by at least tol, or fail to increase validation score by at least tol if ‘early_stopping’ is on, the current learning rate is divided by 5.  Only used when solver='sgd'.
learning_rate_initdouble, default=0.001

The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
power_tdouble, default=0.5

The exponent for inverse scaling learning rate. It is used in updating effective learning rate when the learning_rate is set to ‘invscaling’. Only used when solver=’sgd’.
max_iterint, default=200

Maximum number of iterations. The solver iterates until convergence (determined by ‘tol’) or this number of iterations. For stochastic solvers (‘sgd’, ‘adam’), note that this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.
shufflebool, default=True

Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
random_stateint, RandomState instance, default=None

Determines random number generation for weights and bias initialization, train-test split if early stopping is used, and batch sampling when solver=’sgd’ or ‘adam’. Pass an int for reproducible results across multiple function calls. See Glossary.
tolfloat, default=1e-4

Tolerance for the optimization. When the loss or score is not improving by at least tol for n_iter_no_change consecutive iterations, unless learning_rate is set to ‘adaptive’, convergence is considered to be reached and training stops.
verbosebool, default=False

Whether to print progress messages to stdout.
warm_startbool, default=False

When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
momentumfloat, default=0.9

Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
nesterovs_momentumbool, default=True

Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
early_stoppingbool, default=False

Whether to use early stopping to terminate training when validation score is not improving. If set to true, it will automatically set aside 10% of training data as validation and terminate training when validation score is not improving by at least tol for n_iter_no_change consecutive epochs. The split is stratified, except in a multilabel setting. Only effective when solver=’sgd’ or ‘adam’
validation_fractionfloat, default=0.1

The proportion of training data to set aside as validation set for early stopping. Must be between 0 and 1. Only used if early_stopping is True
beta_1float, default=0.9

Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
beta_2float, default=0.999

Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
epsilonfloat, default=1e-8

Value for numerical stability in adam. Only used when solver=’adam’
n_iter_no_changeint, default=10

Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’  New in version 0.20.
max_funint, default=15000

Only used when solver=’lbfgs’. Maximum number of loss function calls. The solver iterates until convergence (determined by ‘tol’), number of iterations reaches max_iter, or this number of loss function calls. Note that number of loss function calls will be greater than or equal to the number of iterations for the MLPClassifier.  New in version 0.22.     Attributes

classes_ndarray or list of ndarray of shape (n_classes,)

Class labels for each output.
loss_float

The current loss computed with the loss function.
best_loss_float

The minimum loss reached by the solver throughout fitting.
loss_curve_list of shape (n_iter_,)

The ith element in the list represents the loss at the ith iteration.
t_int

The number of training samples seen by the solver during fitting.
coefs_list of shape (n_layers - 1,)

The ith element in the list represents the weight matrix corresponding to layer i.
intercepts_list of shape (n_layers - 1,)

The ith element in the list represents the bias vector corresponding to layer i + 1.
n_iter_int

The number of iterations the solver has ran.
n_layers_int

Number of layers.
n_outputs_int

Number of outputs.
out_activation_str

Name of the output activation function.     Notes MLPClassifier trains iteratively since at each time step the partial derivatives of the loss function with respect to the model parameters are computed to update the parameters. It can also have a regularization term added to the loss function that shrinks model parameters to prevent overfitting. This implementation works with data represented as dense numpy arrays or sparse scipy arrays of floating point values. References  Hinton, Geoffrey E.

“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.  Glorot, Xavier, and Yoshua Bengio. “Understanding the difficulty of

training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.  He, Kaiming, et al. “Delving deep into rectifiers: Surpassing human-level

performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).  Kingma, Diederik, and Jimmy Ba. “Adam: A method for stochastic

optimization.” arXiv preprint arXiv:1412.6980 (2014).   Examples >>> from sklearn.neural_network import MLPClassifier
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import train_test_split
>>> X, y = make_classification(n_samples=100, random_state=1)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y,
...                                                     random_state=1)
>>> clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train)
>>> clf.predict_proba(X_test[:1])
array([[0.038..., 0.961...]])
>>> clf.predict(X_test[:5, :])
array([1, 0, 1, 0, 1])
>>> clf.score(X_test, y_test)
0.8...
 Methods
fit(X, y) Fit the model to data matrix X and target(s) y.
get_params([deep]) Get parameters for this estimator.
predict(X) Predict using the multi-layer perceptron classifier
predict_log_proba(X) Return the log of probability estimates.
predict_proba(X) Probability estimates.
score(X, y[, sample_weight]) Return the mean accuracy on the given test data and labels.
set_params(**params) Set the parameters of this estimator.
fit(X, y) [source]

Fit the model to data matrix X and target(s) y.  Parameters

Xndarray or sparse matrix of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,) or (n_samples, n_outputs)

The target values (class labels in classification, real numbers in regression).    Returns

selfreturns a trained MLP model.

get_params(deep=True) [source]

Get parameters for this estimator.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsdict

Parameter names mapped to their values.

property partial_fit
Update the model with a single iteration over the given data.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.
yarray-like of shape (n_samples,)

The target values.
classesarray of shape (n_classes,), default=None

Classes across all calls to partial_fit. Can be obtained via np.unique(y_all), where y_all is the target vector of the entire dataset. This argument is required for the first call to partial_fit and can be omitted in the subsequent calls. Note that y doesn’t need to contain all labels in classes.    Returns

selfreturns a trained MLP model.

predict(X) [source]

Predict using the multi-layer perceptron classifier  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

yndarray, shape (n_samples,) or (n_samples, n_classes)

The predicted classes.

predict_log_proba(X) [source]

Return the log of probability estimates.  Parameters

Xndarray of shape (n_samples, n_features)

The input data.    Returns

log_y_probndarray of shape (n_samples, n_classes)

The predicted log-probability of the sample for each class in the model, where classes are ordered as they are in self.classes_. Equivalent to log(predict_proba(X))

predict_proba(X) [source]

Probability estimates.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

y_probndarray of shape (n_samples, n_classes)

The predicted probability of the sample for each class in the model, where classes are ordered as they are in self.classes_.

score(X, y, sample_weight=None) [source]

Return the mean accuracy on the given test data and labels. In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted.  Parameters

Xarray-like of shape (n_samples, n_features)

Test samples.
yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True labels for X.
sample_weightarray-like of shape (n_samples,), default=None

Sample weights.    Returns

scorefloat

Mean accuracy of self.predict(X) wrt. y.

set_params(**params) [source]

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

**paramsdict

Estimator parameters.    Returns

selfestimator instance

Estimator instance.


sklearn.neural_network.MLPClassifier
class sklearn.neural_network.MLPClassifier(hidden_layer_sizes=100, activation='relu', *, solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10, max_fun=15000) [source]

Multi-layer Perceptron classifier. This model optimizes the log-loss function using LBFGS or stochastic gradient descent.  New in version 0.18.   Parameters

hidden_layer_sizestuple, length = n_layers - 2, default=(100,)

The ith element represents the number of neurons in the ith hidden layer.
activation{‘identity’, ‘logistic’, ‘tanh’, ‘relu’}, default=’relu’

Activation function for the hidden layer.  ‘identity’, no-op activation, useful to implement linear bottleneck, returns f(x) = x ‘logistic’, the logistic sigmoid function, returns f(x) = 1 / (1 + exp(-x)). ‘tanh’, the hyperbolic tan function, returns f(x) = tanh(x). ‘relu’, the rectified linear unit function, returns f(x) = max(0, x)
solver{‘lbfgs’, ‘sgd’, ‘adam’}, default=’adam’

The solver for weight optimization.  ‘lbfgs’ is an optimizer in the family of quasi-Newton methods. ‘sgd’ refers to stochastic gradient descent. ‘adam’ refers to a stochastic gradient-based optimizer proposed by Kingma, Diederik, and Jimmy Ba  Note: The default solver ‘adam’ works pretty well on relatively large datasets (with thousands of training samples or more) in terms of both training time and validation score. For small datasets, however, ‘lbfgs’ can converge faster and perform better.
alphafloat, default=0.0001

L2 penalty (regularization term) parameter.
batch_sizeint, default=’auto’

Size of minibatches for stochastic optimizers. If the solver is ‘lbfgs’, the classifier will not use minibatch. When set to “auto”, batch_size=min(200, n_samples)
learning_rate{‘constant’, ‘invscaling’, ‘adaptive’}, default=’constant’

Learning rate schedule for weight updates.  ‘constant’ is a constant learning rate given by ‘learning_rate_init’. ‘invscaling’ gradually decreases the learning rate at each time step ‘t’ using an inverse scaling exponent of ‘power_t’. effective_learning_rate = learning_rate_init / pow(t, power_t) ‘adaptive’ keeps the learning rate constant to ‘learning_rate_init’ as long as training loss keeps decreasing. Each time two consecutive epochs fail to decrease training loss by at least tol, or fail to increase validation score by at least tol if ‘early_stopping’ is on, the current learning rate is divided by 5.  Only used when solver='sgd'.
learning_rate_initdouble, default=0.001

The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
power_tdouble, default=0.5

The exponent for inverse scaling learning rate. It is used in updating effective learning rate when the learning_rate is set to ‘invscaling’. Only used when solver=’sgd’.
max_iterint, default=200

Maximum number of iterations. The solver iterates until convergence (determined by ‘tol’) or this number of iterations. For stochastic solvers (‘sgd’, ‘adam’), note that this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.
shufflebool, default=True

Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
random_stateint, RandomState instance, default=None

Determines random number generation for weights and bias initialization, train-test split if early stopping is used, and batch sampling when solver=’sgd’ or ‘adam’. Pass an int for reproducible results across multiple function calls. See Glossary.
tolfloat, default=1e-4

Tolerance for the optimization. When the loss or score is not improving by at least tol for n_iter_no_change consecutive iterations, unless learning_rate is set to ‘adaptive’, convergence is considered to be reached and training stops.
verbosebool, default=False

Whether to print progress messages to stdout.
warm_startbool, default=False

When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
momentumfloat, default=0.9

Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
nesterovs_momentumbool, default=True

Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
early_stoppingbool, default=False

Whether to use early stopping to terminate training when validation score is not improving. If set to true, it will automatically set aside 10% of training data as validation and terminate training when validation score is not improving by at least tol for n_iter_no_change consecutive epochs. The split is stratified, except in a multilabel setting. Only effective when solver=’sgd’ or ‘adam’
validation_fractionfloat, default=0.1

The proportion of training data to set aside as validation set for early stopping. Must be between 0 and 1. Only used if early_stopping is True
beta_1float, default=0.9

Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
beta_2float, default=0.999

Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
epsilonfloat, default=1e-8

Value for numerical stability in adam. Only used when solver=’adam’
n_iter_no_changeint, default=10

Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’  New in version 0.20.
max_funint, default=15000

Only used when solver=’lbfgs’. Maximum number of loss function calls. The solver iterates until convergence (determined by ‘tol’), number of iterations reaches max_iter, or this number of loss function calls. Note that number of loss function calls will be greater than or equal to the number of iterations for the MLPClassifier.  New in version 0.22.     Attributes

classes_ndarray or list of ndarray of shape (n_classes,)

Class labels for each output.
loss_float

The current loss computed with the loss function.
best_loss_float

The minimum loss reached by the solver throughout fitting.
loss_curve_list of shape (n_iter_,)

The ith element in the list represents the loss at the ith iteration.
t_int

The number of training samples seen by the solver during fitting.
coefs_list of shape (n_layers - 1,)

The ith element in the list represents the weight matrix corresponding to layer i.
intercepts_list of shape (n_layers - 1,)

The ith element in the list represents the bias vector corresponding to layer i + 1.
n_iter_int

The number of iterations the solver has ran.
n_layers_int

Number of layers.
n_outputs_int

Number of outputs.
out_activation_str

Name of the output activation function.     Notes MLPClassifier trains iteratively since at each time step the partial derivatives of the loss function with respect to the model parameters are computed to update the parameters. It can also have a regularization term added to the loss function that shrinks model parameters to prevent overfitting. This implementation works with data represented as dense numpy arrays or sparse scipy arrays of floating point values. References  Hinton, Geoffrey E.

“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.  Glorot, Xavier, and Yoshua Bengio. “Understanding the difficulty of

training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.  He, Kaiming, et al. “Delving deep into rectifiers: Surpassing human-level

performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).  Kingma, Diederik, and Jimmy Ba. “Adam: A method for stochastic

optimization.” arXiv preprint arXiv:1412.6980 (2014).   Examples >>> from sklearn.neural_network import MLPClassifier
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import train_test_split
>>> X, y = make_classification(n_samples=100, random_state=1)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y,
...                                                     random_state=1)
>>> clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train)
>>> clf.predict_proba(X_test[:1])
array([[0.038..., 0.961...]])
>>> clf.predict(X_test[:5, :])
array([1, 0, 1, 0, 1])
>>> clf.score(X_test, y_test)
0.8...
 Methods
fit(X, y) Fit the model to data matrix X and target(s) y.
get_params([deep]) Get parameters for this estimator.
predict(X) Predict using the multi-layer perceptron classifier
predict_log_proba(X) Return the log of probability estimates.
predict_proba(X) Probability estimates.
score(X, y[, sample_weight]) Return the mean accuracy on the given test data and labels.
set_params(**params) Set the parameters of this estimator.
fit(X, y) [source]

Fit the model to data matrix X and target(s) y.  Parameters

Xndarray or sparse matrix of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,) or (n_samples, n_outputs)

The target values (class labels in classification, real numbers in regression).    Returns

selfreturns a trained MLP model.

get_params(deep=True) [source]

Get parameters for this estimator.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsdict

Parameter names mapped to their values.

property partial_fit
Update the model with a single iteration over the given data.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.
yarray-like of shape (n_samples,)

The target values.
classesarray of shape (n_classes,), default=None

Classes across all calls to partial_fit. Can be obtained via np.unique(y_all), where y_all is the target vector of the entire dataset. This argument is required for the first call to partial_fit and can be omitted in the subsequent calls. Note that y doesn’t need to contain all labels in classes.    Returns

selfreturns a trained MLP model.

predict(X) [source]

Predict using the multi-layer perceptron classifier  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

yndarray, shape (n_samples,) or (n_samples, n_classes)

The predicted classes.

predict_log_proba(X) [source]

Return the log of probability estimates.  Parameters

Xndarray of shape (n_samples, n_features)

The input data.    Returns

log_y_probndarray of shape (n_samples, n_classes)

The predicted log-probability of the sample for each class in the model, where classes are ordered as they are in self.classes_. Equivalent to log(predict_proba(X))

predict_proba(X) [source]

Probability estimates.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

y_probndarray of shape (n_samples, n_classes)

The predicted probability of the sample for each class in the model, where classes are ordered as they are in self.classes_.

score(X, y, sample_weight=None) [source]

Return the mean accuracy on the given test data and labels. In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted.  Parameters

Xarray-like of shape (n_samples, n_features)

Test samples.
yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True labels for X.
sample_weightarray-like of shape (n_samples,), default=None

Sample weights.    Returns

scorefloat

Mean accuracy of self.predict(X) wrt. y.

set_params(**params) [source]

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

**paramsdict

Estimator parameters.    Returns

selfestimator instance

Estimator instance.

 Examples using sklearn.neural_network.MLPClassifier

  Classifier comparison

  Visualization of MLP weights on MNIST

  Compare Stochastic learning strategies for MLPClassifier

  Varying regularization in Multi-layer Perceptron


fit(X, y) [source]

Fit the model to data matrix X and target(s) y.  Parameters

Xndarray or sparse matrix of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,) or (n_samples, n_outputs)

The target values (class labels in classification, real numbers in regression).    Returns

selfreturns a trained MLP model.


get_params(deep=True) [source]

Get parameters for this estimator.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsdict

Parameter names mapped to their values.


property partial_fit
Update the model with a single iteration over the given data.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.
yarray-like of shape (n_samples,)

The target values.
classesarray of shape (n_classes,), default=None

Classes across all calls to partial_fit. Can be obtained via np.unique(y_all), where y_all is the target vector of the entire dataset. This argument is required for the first call to partial_fit and can be omitted in the subsequent calls. Note that y doesn’t need to contain all labels in classes.    Returns

selfreturns a trained MLP model.


predict(X) [source]

Predict using the multi-layer perceptron classifier  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

yndarray, shape (n_samples,) or (n_samples, n_classes)

The predicted classes.


predict_log_proba(X) [source]

Return the log of probability estimates.  Parameters

Xndarray of shape (n_samples, n_features)

The input data.    Returns

log_y_probndarray of shape (n_samples, n_classes)

The predicted log-probability of the sample for each class in the model, where classes are ordered as they are in self.classes_. Equivalent to log(predict_proba(X))


predict_proba(X) [source]

Probability estimates.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

y_probndarray of shape (n_samples, n_classes)

The predicted probability of the sample for each class in the model, where classes are ordered as they are in self.classes_.


score(X, y, sample_weight=None) [source]

Return the mean accuracy on the given test data and labels. In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted.  Parameters

Xarray-like of shape (n_samples, n_features)

Test samples.
yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True labels for X.
sample_weightarray-like of shape (n_samples,), default=None

Sample weights.    Returns

scorefloat

Mean accuracy of self.predict(X) wrt. y.


set_params(**params) [source]

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

**paramsdict

Estimator parameters.    Returns

selfestimator instance

Estimator instance.


class sklearn.neural_network.MLPRegressor(hidden_layer_sizes=100, activation='relu', *, solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10, max_fun=15000) [source]

Multi-layer Perceptron regressor. This model optimizes the squared-loss using LBFGS or stochastic gradient descent.  New in version 0.18.   Parameters

hidden_layer_sizestuple, length = n_layers - 2, default=(100,)

The ith element represents the number of neurons in the ith hidden layer.
activation{‘identity’, ‘logistic’, ‘tanh’, ‘relu’}, default=’relu’

Activation function for the hidden layer.  ‘identity’, no-op activation, useful to implement linear bottleneck, returns f(x) = x ‘logistic’, the logistic sigmoid function, returns f(x) = 1 / (1 + exp(-x)). ‘tanh’, the hyperbolic tan function, returns f(x) = tanh(x). ‘relu’, the rectified linear unit function, returns f(x) = max(0, x)
solver{‘lbfgs’, ‘sgd’, ‘adam’}, default=’adam’

The solver for weight optimization.  ‘lbfgs’ is an optimizer in the family of quasi-Newton methods. ‘sgd’ refers to stochastic gradient descent. ‘adam’ refers to a stochastic gradient-based optimizer proposed by Kingma, Diederik, and Jimmy Ba  Note: The default solver ‘adam’ works pretty well on relatively large datasets (with thousands of training samples or more) in terms of both training time and validation score. For small datasets, however, ‘lbfgs’ can converge faster and perform better.
alphafloat, default=0.0001

L2 penalty (regularization term) parameter.
batch_sizeint, default=’auto’

Size of minibatches for stochastic optimizers. If the solver is ‘lbfgs’, the classifier will not use minibatch. When set to “auto”, batch_size=min(200, n_samples)
learning_rate{‘constant’, ‘invscaling’, ‘adaptive’}, default=’constant’

Learning rate schedule for weight updates.  ‘constant’ is a constant learning rate given by ‘learning_rate_init’. ‘invscaling’ gradually decreases the learning rate learning_rate_ at each time step ‘t’ using an inverse scaling exponent of ‘power_t’. effective_learning_rate = learning_rate_init / pow(t, power_t) ‘adaptive’ keeps the learning rate constant to ‘learning_rate_init’ as long as training loss keeps decreasing. Each time two consecutive epochs fail to decrease training loss by at least tol, or fail to increase validation score by at least tol if ‘early_stopping’ is on, the current learning rate is divided by 5.  Only used when solver=’sgd’.
learning_rate_initdouble, default=0.001

The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
power_tdouble, default=0.5

The exponent for inverse scaling learning rate. It is used in updating effective learning rate when the learning_rate is set to ‘invscaling’. Only used when solver=’sgd’.
max_iterint, default=200

Maximum number of iterations. The solver iterates until convergence (determined by ‘tol’) or this number of iterations. For stochastic solvers (‘sgd’, ‘adam’), note that this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.
shufflebool, default=True

Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
random_stateint, RandomState instance, default=None

Determines random number generation for weights and bias initialization, train-test split if early stopping is used, and batch sampling when solver=’sgd’ or ‘adam’. Pass an int for reproducible results across multiple function calls. See Glossary.
tolfloat, default=1e-4

Tolerance for the optimization. When the loss or score is not improving by at least tol for n_iter_no_change consecutive iterations, unless learning_rate is set to ‘adaptive’, convergence is considered to be reached and training stops.
verbosebool, default=False

Whether to print progress messages to stdout.
warm_startbool, default=False

When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
momentumfloat, default=0.9

Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
nesterovs_momentumbool, default=True

Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
early_stoppingbool, default=False

Whether to use early stopping to terminate training when validation score is not improving. If set to true, it will automatically set aside 10% of training data as validation and terminate training when validation score is not improving by at least tol for n_iter_no_change consecutive epochs. Only effective when solver=’sgd’ or ‘adam’
validation_fractionfloat, default=0.1

The proportion of training data to set aside as validation set for early stopping. Must be between 0 and 1. Only used if early_stopping is True
beta_1float, default=0.9

Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
beta_2float, default=0.999

Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
epsilonfloat, default=1e-8

Value for numerical stability in adam. Only used when solver=’adam’
n_iter_no_changeint, default=10

Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’  New in version 0.20.
max_funint, default=15000

Only used when solver=’lbfgs’. Maximum number of function calls. The solver iterates until convergence (determined by ‘tol’), number of iterations reaches max_iter, or this number of function calls. Note that number of function calls will be greater than or equal to the number of iterations for the MLPRegressor.  New in version 0.22.     Attributes

loss_float

The current loss computed with the loss function.
best_loss_float

The minimum loss reached by the solver throughout fitting.
loss_curve_list of shape (n_iter_,)

The ith element in the list represents the loss at the ith iteration.
t_int

The number of training samples seen by the solver during fitting.
coefs_list of shape (n_layers - 1,)

The ith element in the list represents the weight matrix corresponding to layer i.
intercepts_list of shape (n_layers - 1,)

The ith element in the list represents the bias vector corresponding to layer i + 1.
n_iter_int

The number of iterations the solver has ran.
n_layers_int

Number of layers.
n_outputs_int

Number of outputs.
out_activation_str

Name of the output activation function.
loss_curve_list of shape (n_iters,)

Loss value evaluated at the end of each training step.
t_int

Mathematically equals n_iters * X.shape[0], it means time_step and it is used by optimizer’s learning rate scheduler.     Notes MLPRegressor trains iteratively since at each time step the partial derivatives of the loss function with respect to the model parameters are computed to update the parameters. It can also have a regularization term added to the loss function that shrinks model parameters to prevent overfitting. This implementation works with data represented as dense and sparse numpy arrays of floating point values. References  Hinton, Geoffrey E.

“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.  Glorot, Xavier, and Yoshua Bengio. “Understanding the difficulty of

training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.  He, Kaiming, et al. “Delving deep into rectifiers: Surpassing human-level

performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).  Kingma, Diederik, and Jimmy Ba. “Adam: A method for stochastic

optimization.” arXiv preprint arXiv:1412.6980 (2014).   Examples >>> from sklearn.neural_network import MLPRegressor
>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import train_test_split
>>> X, y = make_regression(n_samples=200, random_state=1)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y,
...                                                     random_state=1)
>>> regr = MLPRegressor(random_state=1, max_iter=500).fit(X_train, y_train)
>>> regr.predict(X_test[:2])
array([-0.9..., -7.1...])
>>> regr.score(X_test, y_test)
0.4...
 Methods
fit(X, y) Fit the model to data matrix X and target(s) y.
get_params([deep]) Get parameters for this estimator.
predict(X) Predict using the multi-layer perceptron model.
score(X, y[, sample_weight]) Return the coefficient of determination \(R^2\) of the prediction.
set_params(**params) Set the parameters of this estimator.
fit(X, y) [source]

Fit the model to data matrix X and target(s) y.  Parameters

Xndarray or sparse matrix of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,) or (n_samples, n_outputs)

The target values (class labels in classification, real numbers in regression).    Returns

selfreturns a trained MLP model.

get_params(deep=True) [source]

Get parameters for this estimator.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsdict

Parameter names mapped to their values.

property partial_fit
Update the model with a single iteration over the given data.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,)

The target values.    Returns

selfreturns a trained MLP model.

predict(X) [source]

Predict using the multi-layer perceptron model.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

yndarray of shape (n_samples, n_outputs)

The predicted values.

score(X, y, sample_weight=None) [source]

Return the coefficient of determination \(R^2\) of the prediction. The coefficient \(R^2\) is defined as \((1 - \frac{u}{v})\), where \(u\) is the residual sum of squares ((y_true - y_pred)
** 2).sum() and \(v\) is the total sum of squares ((y_true -
y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a \(R^2\) score of 0.0.  Parameters

Xarray-like of shape (n_samples, n_features)

Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.
yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True values for X.
sample_weightarray-like of shape (n_samples,), default=None

Sample weights.    Returns

scorefloat

\(R^2\) of self.predict(X) wrt. y.     Notes The \(R^2\) score used when calling score on a regressor uses multioutput='uniform_average' from version 0.23 to keep consistent with default value of r2_score. This influences the score method of all the multioutput regressors (except for MultiOutputRegressor).

set_params(**params) [source]

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

**paramsdict

Estimator parameters.    Returns

selfestimator instance

Estimator instance.


sklearn.neural_network.MLPRegressor
class sklearn.neural_network.MLPRegressor(hidden_layer_sizes=100, activation='relu', *, solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10, max_fun=15000) [source]

Multi-layer Perceptron regressor. This model optimizes the squared-loss using LBFGS or stochastic gradient descent.  New in version 0.18.   Parameters

hidden_layer_sizestuple, length = n_layers - 2, default=(100,)

The ith element represents the number of neurons in the ith hidden layer.
activation{‘identity’, ‘logistic’, ‘tanh’, ‘relu’}, default=’relu’

Activation function for the hidden layer.  ‘identity’, no-op activation, useful to implement linear bottleneck, returns f(x) = x ‘logistic’, the logistic sigmoid function, returns f(x) = 1 / (1 + exp(-x)). ‘tanh’, the hyperbolic tan function, returns f(x) = tanh(x). ‘relu’, the rectified linear unit function, returns f(x) = max(0, x)
solver{‘lbfgs’, ‘sgd’, ‘adam’}, default=’adam’

The solver for weight optimization.  ‘lbfgs’ is an optimizer in the family of quasi-Newton methods. ‘sgd’ refers to stochastic gradient descent. ‘adam’ refers to a stochastic gradient-based optimizer proposed by Kingma, Diederik, and Jimmy Ba  Note: The default solver ‘adam’ works pretty well on relatively large datasets (with thousands of training samples or more) in terms of both training time and validation score. For small datasets, however, ‘lbfgs’ can converge faster and perform better.
alphafloat, default=0.0001

L2 penalty (regularization term) parameter.
batch_sizeint, default=’auto’

Size of minibatches for stochastic optimizers. If the solver is ‘lbfgs’, the classifier will not use minibatch. When set to “auto”, batch_size=min(200, n_samples)
learning_rate{‘constant’, ‘invscaling’, ‘adaptive’}, default=’constant’

Learning rate schedule for weight updates.  ‘constant’ is a constant learning rate given by ‘learning_rate_init’. ‘invscaling’ gradually decreases the learning rate learning_rate_ at each time step ‘t’ using an inverse scaling exponent of ‘power_t’. effective_learning_rate = learning_rate_init / pow(t, power_t) ‘adaptive’ keeps the learning rate constant to ‘learning_rate_init’ as long as training loss keeps decreasing. Each time two consecutive epochs fail to decrease training loss by at least tol, or fail to increase validation score by at least tol if ‘early_stopping’ is on, the current learning rate is divided by 5.  Only used when solver=’sgd’.
learning_rate_initdouble, default=0.001

The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
power_tdouble, default=0.5

The exponent for inverse scaling learning rate. It is used in updating effective learning rate when the learning_rate is set to ‘invscaling’. Only used when solver=’sgd’.
max_iterint, default=200

Maximum number of iterations. The solver iterates until convergence (determined by ‘tol’) or this number of iterations. For stochastic solvers (‘sgd’, ‘adam’), note that this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.
shufflebool, default=True

Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
random_stateint, RandomState instance, default=None

Determines random number generation for weights and bias initialization, train-test split if early stopping is used, and batch sampling when solver=’sgd’ or ‘adam’. Pass an int for reproducible results across multiple function calls. See Glossary.
tolfloat, default=1e-4

Tolerance for the optimization. When the loss or score is not improving by at least tol for n_iter_no_change consecutive iterations, unless learning_rate is set to ‘adaptive’, convergence is considered to be reached and training stops.
verbosebool, default=False

Whether to print progress messages to stdout.
warm_startbool, default=False

When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
momentumfloat, default=0.9

Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
nesterovs_momentumbool, default=True

Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
early_stoppingbool, default=False

Whether to use early stopping to terminate training when validation score is not improving. If set to true, it will automatically set aside 10% of training data as validation and terminate training when validation score is not improving by at least tol for n_iter_no_change consecutive epochs. Only effective when solver=’sgd’ or ‘adam’
validation_fractionfloat, default=0.1

The proportion of training data to set aside as validation set for early stopping. Must be between 0 and 1. Only used if early_stopping is True
beta_1float, default=0.9

Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
beta_2float, default=0.999

Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
epsilonfloat, default=1e-8

Value for numerical stability in adam. Only used when solver=’adam’
n_iter_no_changeint, default=10

Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’  New in version 0.20.
max_funint, default=15000

Only used when solver=’lbfgs’. Maximum number of function calls. The solver iterates until convergence (determined by ‘tol’), number of iterations reaches max_iter, or this number of function calls. Note that number of function calls will be greater than or equal to the number of iterations for the MLPRegressor.  New in version 0.22.     Attributes

loss_float

The current loss computed with the loss function.
best_loss_float

The minimum loss reached by the solver throughout fitting.
loss_curve_list of shape (n_iter_,)

The ith element in the list represents the loss at the ith iteration.
t_int

The number of training samples seen by the solver during fitting.
coefs_list of shape (n_layers - 1,)

The ith element in the list represents the weight matrix corresponding to layer i.
intercepts_list of shape (n_layers - 1,)

The ith element in the list represents the bias vector corresponding to layer i + 1.
n_iter_int

The number of iterations the solver has ran.
n_layers_int

Number of layers.
n_outputs_int

Number of outputs.
out_activation_str

Name of the output activation function.
loss_curve_list of shape (n_iters,)

Loss value evaluated at the end of each training step.
t_int

Mathematically equals n_iters * X.shape[0], it means time_step and it is used by optimizer’s learning rate scheduler.     Notes MLPRegressor trains iteratively since at each time step the partial derivatives of the loss function with respect to the model parameters are computed to update the parameters. It can also have a regularization term added to the loss function that shrinks model parameters to prevent overfitting. This implementation works with data represented as dense and sparse numpy arrays of floating point values. References  Hinton, Geoffrey E.

“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.  Glorot, Xavier, and Yoshua Bengio. “Understanding the difficulty of

training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.  He, Kaiming, et al. “Delving deep into rectifiers: Surpassing human-level

performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).  Kingma, Diederik, and Jimmy Ba. “Adam: A method for stochastic

optimization.” arXiv preprint arXiv:1412.6980 (2014).   Examples >>> from sklearn.neural_network import MLPRegressor
>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import train_test_split
>>> X, y = make_regression(n_samples=200, random_state=1)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y,
...                                                     random_state=1)
>>> regr = MLPRegressor(random_state=1, max_iter=500).fit(X_train, y_train)
>>> regr.predict(X_test[:2])
array([-0.9..., -7.1...])
>>> regr.score(X_test, y_test)
0.4...
 Methods
fit(X, y) Fit the model to data matrix X and target(s) y.
get_params([deep]) Get parameters for this estimator.
predict(X) Predict using the multi-layer perceptron model.
score(X, y[, sample_weight]) Return the coefficient of determination \(R^2\) of the prediction.
set_params(**params) Set the parameters of this estimator.
fit(X, y) [source]

Fit the model to data matrix X and target(s) y.  Parameters

Xndarray or sparse matrix of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,) or (n_samples, n_outputs)

The target values (class labels in classification, real numbers in regression).    Returns

selfreturns a trained MLP model.

get_params(deep=True) [source]

Get parameters for this estimator.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsdict

Parameter names mapped to their values.

property partial_fit
Update the model with a single iteration over the given data.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,)

The target values.    Returns

selfreturns a trained MLP model.

predict(X) [source]

Predict using the multi-layer perceptron model.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

yndarray of shape (n_samples, n_outputs)

The predicted values.

score(X, y, sample_weight=None) [source]

Return the coefficient of determination \(R^2\) of the prediction. The coefficient \(R^2\) is defined as \((1 - \frac{u}{v})\), where \(u\) is the residual sum of squares ((y_true - y_pred)
** 2).sum() and \(v\) is the total sum of squares ((y_true -
y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a \(R^2\) score of 0.0.  Parameters

Xarray-like of shape (n_samples, n_features)

Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.
yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True values for X.
sample_weightarray-like of shape (n_samples,), default=None

Sample weights.    Returns

scorefloat

\(R^2\) of self.predict(X) wrt. y.     Notes The \(R^2\) score used when calling score on a regressor uses multioutput='uniform_average' from version 0.23 to keep consistent with default value of r2_score. This influences the score method of all the multioutput regressors (except for MultiOutputRegressor).

set_params(**params) [source]

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

**paramsdict

Estimator parameters.    Returns

selfestimator instance

Estimator instance.

 Examples using sklearn.neural_network.MLPRegressor

  Partial Dependence and Individual Conditional Expectation Plots

  Advanced Plotting With Partial Dependence


property partial_fit
Update the model with a single iteration over the given data.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.
yndarray of shape (n_samples,)

The target values.    Returns

selfreturns a trained MLP model.


predict(X) [source]

Predict using the multi-layer perceptron model.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.    Returns

yndarray of shape (n_samples, n_outputs)

The predicted values.


score(X, y, sample_weight=None) [source]

Return the coefficient of determination \(R^2\) of the prediction. The coefficient \(R^2\) is defined as \((1 - \frac{u}{v})\), where \(u\) is the residual sum of squares ((y_true - y_pred)
** 2).sum() and \(v\) is the total sum of squares ((y_true -
y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a \(R^2\) score of 0.0.  Parameters

Xarray-like of shape (n_samples, n_features)

Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.
yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True values for X.
sample_weightarray-like of shape (n_samples,), default=None

Sample weights.    Returns

scorefloat

\(R^2\) of self.predict(X) wrt. y.     Notes The \(R^2\) score used when calling score on a regressor uses multioutput='uniform_average' from version 0.23 to keep consistent with default value of r2_score. This influences the score method of all the multioutput regressors (except for MultiOutputRegressor).


class sklearn.pipeline.FeatureUnion(transformer_list, *, n_jobs=None, transformer_weights=None, verbose=False) [source]

Concatenates results of multiple transformer objects. This estimator applies a list of transformer objects in parallel to the input data, then concatenates the results. This is useful to combine several feature extraction mechanisms into a single transformer. Parameters of the transformers may be set using its name and the parameter name separated by a ‘__’. A transformer may be replaced entirely by setting the parameter with its name to another transformer, or removed by setting to ‘drop’. Read more in the User Guide.  New in version 0.13.   Parameters

transformer_listlist of (string, transformer) tuples

List of transformer objects to be applied to the data. The first half of each tuple is the name of the transformer. The tranformer can be ‘drop’ for it to be ignored.  Changed in version 0.22: Deprecated None as a transformer in favor of ‘drop’.
n_jobsint, default=None

Number of jobs to run in parallel. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.  Changed in version v0.20: n_jobs default changed from 1 to None
transformer_weightsdict, default=None

Multiplicative weights for features per transformer. Keys are transformer names, values the weights. Raises ValueError if key not present in transformer_list.
verbosebool, default=False

If True, the time elapsed while fitting each transformer will be printed as it is completed.    Attributes
 n_features_in_
    See also
make_union

Convenience function for simplified feature union construction.    Examples >>> from sklearn.pipeline import FeatureUnion
>>> from sklearn.decomposition import PCA, TruncatedSVD
>>> union = FeatureUnion([("pca", PCA(n_components=1)),
...                       ("svd", TruncatedSVD(n_components=2))])
>>> X = [[0., 1., 3], [2., 2., 5]]
>>> union.fit_transform(X)
array([[ 1.5       ,  3.0...,  0.8...],
       [-1.5       ,  5.7..., -0.4...]])
 Methods
fit(X[, y]) Fit all transformers using X.
fit_transform(X[, y]) Fit all transformers, transform the data and concatenate results.
get_feature_names() Get feature names from all transformers.
get_params([deep]) Get parameters for this estimator.
set_params(**kwargs) Set the parameters of this estimator.
transform(X) Transform X separately by each transformer, concatenate results.
fit(X, y=None, **fit_params) [source]

Fit all transformers using X.  Parameters

Xiterable or array-like, depending on transformers

Input data, used to fit transformers.
yarray-like of shape (n_samples, n_outputs), default=None

Targets for supervised learning.    Returns

selfFeatureUnion

This estimator

fit_transform(X, y=None, **fit_params) [source]

Fit all transformers, transform the data and concatenate results.  Parameters

Xiterable or array-like, depending on transformers

Input data to be transformed.
yarray-like of shape (n_samples, n_outputs), default=None

Targets for supervised learning.    Returns

X_tarray-like or sparse matrix of shape (n_samples, sum_n_components)

hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.

get_feature_names() [source]

Get feature names from all transformers.  Returns

feature_nameslist of strings

Names of the features produced by transform.

get_params(deep=True) [source]

Get parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the transformer_list of the FeatureUnion.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsmapping of string to any

Parameter names mapped to their values.

set_params(**kwargs) [source]

Set the parameters of this estimator. Valid parameter keys can be listed with get_params(). Note that you can directly set the parameters of the estimators contained in tranformer_list.  Returns
 self

transform(X) [source]

Transform X separately by each transformer, concatenate results.  Parameters

Xiterable or array-like, depending on transformers

Input data to be transformed.    Returns

X_tarray-like or sparse matrix of shape (n_samples, sum_n_components)

hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.


sklearn.pipeline.FeatureUnion
class sklearn.pipeline.FeatureUnion(transformer_list, *, n_jobs=None, transformer_weights=None, verbose=False) [source]

Concatenates results of multiple transformer objects. This estimator applies a list of transformer objects in parallel to the input data, then concatenates the results. This is useful to combine several feature extraction mechanisms into a single transformer. Parameters of the transformers may be set using its name and the parameter name separated by a ‘__’. A transformer may be replaced entirely by setting the parameter with its name to another transformer, or removed by setting to ‘drop’. Read more in the User Guide.  New in version 0.13.   Parameters

transformer_listlist of (string, transformer) tuples

List of transformer objects to be applied to the data. The first half of each tuple is the name of the transformer. The tranformer can be ‘drop’ for it to be ignored.  Changed in version 0.22: Deprecated None as a transformer in favor of ‘drop’.
n_jobsint, default=None

Number of jobs to run in parallel. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.  Changed in version v0.20: n_jobs default changed from 1 to None
transformer_weightsdict, default=None

Multiplicative weights for features per transformer. Keys are transformer names, values the weights. Raises ValueError if key not present in transformer_list.
verbosebool, default=False

If True, the time elapsed while fitting each transformer will be printed as it is completed.    Attributes
 n_features_in_
    See also
make_union

Convenience function for simplified feature union construction.    Examples >>> from sklearn.pipeline import FeatureUnion
>>> from sklearn.decomposition import PCA, TruncatedSVD
>>> union = FeatureUnion([("pca", PCA(n_components=1)),
...                       ("svd", TruncatedSVD(n_components=2))])
>>> X = [[0., 1., 3], [2., 2., 5]]
>>> union.fit_transform(X)
array([[ 1.5       ,  3.0...,  0.8...],
       [-1.5       ,  5.7..., -0.4...]])
 Methods
fit(X[, y]) Fit all transformers using X.
fit_transform(X[, y]) Fit all transformers, transform the data and concatenate results.
get_feature_names() Get feature names from all transformers.
get_params([deep]) Get parameters for this estimator.
set_params(**kwargs) Set the parameters of this estimator.
transform(X) Transform X separately by each transformer, concatenate results.
fit(X, y=None, **fit_params) [source]

Fit all transformers using X.  Parameters

Xiterable or array-like, depending on transformers

Input data, used to fit transformers.
yarray-like of shape (n_samples, n_outputs), default=None

Targets for supervised learning.    Returns

selfFeatureUnion

This estimator

fit_transform(X, y=None, **fit_params) [source]

Fit all transformers, transform the data and concatenate results.  Parameters

Xiterable or array-like, depending on transformers

Input data to be transformed.
yarray-like of shape (n_samples, n_outputs), default=None

Targets for supervised learning.    Returns

X_tarray-like or sparse matrix of shape (n_samples, sum_n_components)

hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.

get_feature_names() [source]

Get feature names from all transformers.  Returns

feature_nameslist of strings

Names of the features produced by transform.

get_params(deep=True) [source]

Get parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the transformer_list of the FeatureUnion.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsmapping of string to any

Parameter names mapped to their values.

set_params(**kwargs) [source]

Set the parameters of this estimator. Valid parameter keys can be listed with get_params(). Note that you can directly set the parameters of the estimators contained in tranformer_list.  Returns
 self

transform(X) [source]

Transform X separately by each transformer, concatenate results.  Parameters

Xiterable or array-like, depending on transformers

Input data to be transformed.    Returns

X_tarray-like or sparse matrix of shape (n_samples, sum_n_components)

hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.

 Examples using sklearn.pipeline.FeatureUnion

  Concatenating multiple feature extraction methods


fit(X, y=None, **fit_params) [source]

Fit all transformers using X.  Parameters

Xiterable or array-like, depending on transformers

Input data, used to fit transformers.
yarray-like of shape (n_samples, n_outputs), default=None

Targets for supervised learning.    Returns

selfFeatureUnion

This estimator


fit_transform(X, y=None, **fit_params) [source]

Fit all transformers, transform the data and concatenate results.  Parameters

Xiterable or array-like, depending on transformers

Input data to be transformed.
yarray-like of shape (n_samples, n_outputs), default=None

Targets for supervised learning.    Returns

X_tarray-like or sparse matrix of shape (n_samples, sum_n_components)

hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.


get_feature_names() [source]

Get feature names from all transformers.  Returns

feature_nameslist of strings

Names of the features produced by transform.


get_params(deep=True) [source]

Get parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the transformer_list of the FeatureUnion.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsmapping of string to any

Parameter names mapped to their values.


set_params(**kwargs) [source]

Set the parameters of this estimator. Valid parameter keys can be listed with get_params(). Note that you can directly set the parameters of the estimators contained in tranformer_list.  Returns
 self


transform(X) [source]

Transform X separately by each transformer, concatenate results.  Parameters

Xiterable or array-like, depending on transformers

Input data to be transformed.    Returns

X_tarray-like or sparse matrix of shape (n_samples, sum_n_components)

hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.


sklearn.pipeline.make_pipeline(*steps, memory=None, verbose=False) [source]

Construct a Pipeline from the given estimators. This is a shorthand for the Pipeline constructor; it does not require, and does not permit, naming the estimators. Instead, their names will be set to the lowercase of their types automatically.  Parameters

*stepslist of estimators.

memorystr or object with the joblib.Memory interface, default=None

Used to cache the fitted transformers of the pipeline. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute named_steps or steps to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming.
verbosebool, default=False

If True, the time elapsed while fitting each step will be printed as it is completed.    Returns

pPipeline
    See also
Pipeline

Class for creating a pipeline of transforms with a final estimator.    Examples >>> from sklearn.naive_bayes import GaussianNB
>>> from sklearn.preprocessing import StandardScaler
>>> make_pipeline(StandardScaler(), GaussianNB(priors=None))
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('gaussiannb', GaussianNB())])


sklearn.pipeline.make_union(*transformers, n_jobs=None, verbose=False) [source]

Construct a FeatureUnion from the given transformers. This is a shorthand for the FeatureUnion constructor; it does not require, and does not permit, naming the transformers. Instead, they will be given names automatically based on their types. It also does not allow weighting.  Parameters

*transformerslist of estimators

n_jobsint, default=None

Number of jobs to run in parallel. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.  Changed in version v0.20: n_jobs default changed from 1 to None
verbosebool, default=False

If True, the time elapsed while fitting each transformer will be printed as it is completed.    Returns

fFeatureUnion
    See also
FeatureUnion

Class for concatenating the results of multiple transformer objects.    Examples >>> from sklearn.decomposition import PCA, TruncatedSVD
>>> from sklearn.pipeline import make_union
>>> make_union(PCA(), TruncatedSVD())
 FeatureUnion(transformer_list=[('pca', PCA()),
                               ('truncatedsvd', TruncatedSVD())])


class sklearn.pipeline.Pipeline(steps, *, memory=None, verbose=False) [source]

Pipeline of transforms with a final estimator. Sequentially apply a list of transforms and a final estimator. Intermediate steps of the pipeline must be ‘transforms’, that is, they must implement fit and transform methods. The final estimator only needs to implement fit. The transformers in the pipeline can be cached using memory argument. The purpose of the pipeline is to assemble several steps that can be cross-validated together while setting different parameters. For this, it enables setting parameters of the various steps using their names and the parameter name separated by a ‘__’, as in the example below. A step’s estimator may be replaced entirely by setting the parameter with its name to another estimator, or a transformer removed by setting it to ‘passthrough’ or None. Read more in the User Guide.  New in version 0.5.   Parameters

stepslist

List of (name, transform) tuples (implementing fit/transform) that are chained, in the order in which they are chained, with the last object an estimator.
memorystr or object with the joblib.Memory interface, default=None

Used to cache the fitted transformers of the pipeline. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute named_steps or steps to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming.
verbosebool, default=False

If True, the time elapsed while fitting each step will be printed as it is completed.    Attributes

named_stepsBunch

Dictionary-like object, with the following attributes. Read-only attribute to access any step parameter by user given name. Keys are step names and values are steps parameters.      See also
make_pipeline

Convenience function for simplified pipeline construction.    Examples >>> from sklearn.svm import SVC
>>> from sklearn.preprocessing import StandardScaler
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import Pipeline
>>> X, y = make_classification(random_state=0)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y,
...                                                     random_state=0)
>>> pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC())])
>>> # The pipeline can be used as any other estimator
>>> # and avoids leaking the test set into the train set
>>> pipe.fit(X_train, y_train)
Pipeline(steps=[('scaler', StandardScaler()), ('svc', SVC())])
>>> pipe.score(X_test, y_test)
0.88
 Methods
decision_function(X) Apply transforms, and decision_function of the final estimator
fit(X[, y]) Fit the model
fit_predict(X[, y]) Applies fit_predict of last step in pipeline after transforms.
fit_transform(X[, y]) Fit the model and transform with the final estimator
get_params([deep]) Get parameters for this estimator.
predict(X, **predict_params) Apply transforms to the data, and predict with the final estimator
predict_log_proba(X) Apply transforms, and predict_log_proba of the final estimator
predict_proba(X) Apply transforms, and predict_proba of the final estimator
score(X[, y, sample_weight]) Apply transforms, and score with the final estimator
score_samples(X) Apply transforms, and score_samples of the final estimator.
set_params(**kwargs) Set the parameters of this estimator.
decision_function(X) [source]

Apply transforms, and decision_function of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorearray-like of shape (n_samples, n_classes)

fit(X, y=None, **fit_params) [source]

Fit the model Fit all the transforms one after the other and transform the data, then fit the transformed data using the final estimator.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

selfPipeline

This estimator

fit_predict(X, y=None, **fit_params) [source]

Applies fit_predict of last step in pipeline after transforms. Applies fit_transforms of a pipeline to the data, followed by the fit_predict method of the final estimator in the pipeline. Valid only if the final estimator implements fit_predict.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

y_predarray-like

fit_transform(X, y=None, **fit_params) [source]

Fit the model and transform with the final estimator Fits all the transforms one after the other and transforms the data, then uses fit_transform on transformed data with the final estimator.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

Xtarray-like of shape (n_samples, n_transformed_features)

Transformed samples

get_params(deep=True) [source]

Get parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the steps of the Pipeline.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsmapping of string to any

Parameter names mapped to their values.

property inverse_transform
Apply inverse transformations in reverse order All estimators in the pipeline must support inverse_transform.  Parameters

Xtarray-like of shape (n_samples, n_transformed_features)

Data samples, where n_samples is the number of samples and n_features is the number of features. Must fulfill input requirements of last step of pipeline’s inverse_transform method.    Returns

Xtarray-like of shape (n_samples, n_features)

predict(X, **predict_params) [source]

Apply transforms to the data, and predict with the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.
**predict_paramsdict of string -> object

Parameters to the predict called at the end of all transformations in the pipeline. Note that while this may be used to return uncertainties from some models with return_std or return_cov, uncertainties that are generated by the transformations in the pipeline are not propagated to the final estimator.  New in version 0.20.     Returns

y_predarray-like

predict_log_proba(X) [source]

Apply transforms, and predict_log_proba of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorearray-like of shape (n_samples, n_classes)

predict_proba(X) [source]

Apply transforms, and predict_proba of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_probaarray-like of shape (n_samples, n_classes)

score(X, y=None, sample_weight=None) [source]

Apply transforms, and score with the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Targets used for scoring. Must fulfill label requirements for all steps of the pipeline.
sample_weightarray-like, default=None

If not None, this argument is passed as sample_weight keyword argument to the score method of the final estimator.    Returns

scorefloat

score_samples(X) [source]

Apply transforms, and score_samples of the final estimator.  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorendarray of shape (n_samples,)

set_params(**kwargs) [source]

Set the parameters of this estimator. Valid parameter keys can be listed with get_params(). Note that you can directly set the parameters of the estimators contained in steps.  Returns
 self

property transform
Apply transforms, and transform with the final estimator This also works where final estimator is None: all prior transformations are applied.  Parameters

Xiterable

Data to transform. Must fulfill input requirements of first step of the pipeline.    Returns

Xtarray-like of shape (n_samples, n_transformed_features)


sklearn.pipeline.Pipeline
class sklearn.pipeline.Pipeline(steps, *, memory=None, verbose=False) [source]

Pipeline of transforms with a final estimator. Sequentially apply a list of transforms and a final estimator. Intermediate steps of the pipeline must be ‘transforms’, that is, they must implement fit and transform methods. The final estimator only needs to implement fit. The transformers in the pipeline can be cached using memory argument. The purpose of the pipeline is to assemble several steps that can be cross-validated together while setting different parameters. For this, it enables setting parameters of the various steps using their names and the parameter name separated by a ‘__’, as in the example below. A step’s estimator may be replaced entirely by setting the parameter with its name to another estimator, or a transformer removed by setting it to ‘passthrough’ or None. Read more in the User Guide.  New in version 0.5.   Parameters

stepslist

List of (name, transform) tuples (implementing fit/transform) that are chained, in the order in which they are chained, with the last object an estimator.
memorystr or object with the joblib.Memory interface, default=None

Used to cache the fitted transformers of the pipeline. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute named_steps or steps to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming.
verbosebool, default=False

If True, the time elapsed while fitting each step will be printed as it is completed.    Attributes

named_stepsBunch

Dictionary-like object, with the following attributes. Read-only attribute to access any step parameter by user given name. Keys are step names and values are steps parameters.      See also
make_pipeline

Convenience function for simplified pipeline construction.    Examples >>> from sklearn.svm import SVC
>>> from sklearn.preprocessing import StandardScaler
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import Pipeline
>>> X, y = make_classification(random_state=0)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y,
...                                                     random_state=0)
>>> pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC())])
>>> # The pipeline can be used as any other estimator
>>> # and avoids leaking the test set into the train set
>>> pipe.fit(X_train, y_train)
Pipeline(steps=[('scaler', StandardScaler()), ('svc', SVC())])
>>> pipe.score(X_test, y_test)
0.88
 Methods
decision_function(X) Apply transforms, and decision_function of the final estimator
fit(X[, y]) Fit the model
fit_predict(X[, y]) Applies fit_predict of last step in pipeline after transforms.
fit_transform(X[, y]) Fit the model and transform with the final estimator
get_params([deep]) Get parameters for this estimator.
predict(X, **predict_params) Apply transforms to the data, and predict with the final estimator
predict_log_proba(X) Apply transforms, and predict_log_proba of the final estimator
predict_proba(X) Apply transforms, and predict_proba of the final estimator
score(X[, y, sample_weight]) Apply transforms, and score with the final estimator
score_samples(X) Apply transforms, and score_samples of the final estimator.
set_params(**kwargs) Set the parameters of this estimator.
decision_function(X) [source]

Apply transforms, and decision_function of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorearray-like of shape (n_samples, n_classes)

fit(X, y=None, **fit_params) [source]

Fit the model Fit all the transforms one after the other and transform the data, then fit the transformed data using the final estimator.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

selfPipeline

This estimator

fit_predict(X, y=None, **fit_params) [source]

Applies fit_predict of last step in pipeline after transforms. Applies fit_transforms of a pipeline to the data, followed by the fit_predict method of the final estimator in the pipeline. Valid only if the final estimator implements fit_predict.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

y_predarray-like

fit_transform(X, y=None, **fit_params) [source]

Fit the model and transform with the final estimator Fits all the transforms one after the other and transforms the data, then uses fit_transform on transformed data with the final estimator.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

Xtarray-like of shape (n_samples, n_transformed_features)

Transformed samples

get_params(deep=True) [source]

Get parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the steps of the Pipeline.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsmapping of string to any

Parameter names mapped to their values.

property inverse_transform
Apply inverse transformations in reverse order All estimators in the pipeline must support inverse_transform.  Parameters

Xtarray-like of shape (n_samples, n_transformed_features)

Data samples, where n_samples is the number of samples and n_features is the number of features. Must fulfill input requirements of last step of pipeline’s inverse_transform method.    Returns

Xtarray-like of shape (n_samples, n_features)

predict(X, **predict_params) [source]

Apply transforms to the data, and predict with the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.
**predict_paramsdict of string -> object

Parameters to the predict called at the end of all transformations in the pipeline. Note that while this may be used to return uncertainties from some models with return_std or return_cov, uncertainties that are generated by the transformations in the pipeline are not propagated to the final estimator.  New in version 0.20.     Returns

y_predarray-like

predict_log_proba(X) [source]

Apply transforms, and predict_log_proba of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorearray-like of shape (n_samples, n_classes)

predict_proba(X) [source]

Apply transforms, and predict_proba of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_probaarray-like of shape (n_samples, n_classes)

score(X, y=None, sample_weight=None) [source]

Apply transforms, and score with the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Targets used for scoring. Must fulfill label requirements for all steps of the pipeline.
sample_weightarray-like, default=None

If not None, this argument is passed as sample_weight keyword argument to the score method of the final estimator.    Returns

scorefloat

score_samples(X) [source]

Apply transforms, and score_samples of the final estimator.  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorendarray of shape (n_samples,)

set_params(**kwargs) [source]

Set the parameters of this estimator. Valid parameter keys can be listed with get_params(). Note that you can directly set the parameters of the estimators contained in steps.  Returns
 self

property transform
Apply transforms, and transform with the final estimator This also works where final estimator is None: all prior transformations are applied.  Parameters

Xiterable

Data to transform. Must fulfill input requirements of first step of the pipeline.    Returns

Xtarray-like of shape (n_samples, n_transformed_features)

 Examples using sklearn.pipeline.Pipeline

  Feature agglomeration vs. univariate selection

  Poisson regression and non-normal loss

  Permutation Importance vs Random Forest Feature Importance (MDI)

  Scalable learning with polynomial kernel aproximation

  Explicit feature map approximation for RBF kernels

  Underfitting vs. Overfitting

  Sample pipeline for text feature extraction and evaluation

  Balance model complexity and cross-validated score

  Caching nearest neighbors

  Comparing Nearest Neighbors with and without Neighborhood Components Analysis

  Restricted Boltzmann Machine features for digit classification

  Concatenating multiple feature extraction methods

  Pipelining: chaining a PCA and a logistic regression

  Selecting dimensionality reduction with Pipeline and GridSearchCV

  Column Transformer with Mixed Types

  Column Transformer with Heterogeneous Data Sources

  Semi-supervised Classification on a Text Dataset

  SVM-Anova: SVM with univariate feature selection

  Classification of text documents using sparse features


decision_function(X) [source]

Apply transforms, and decision_function of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorearray-like of shape (n_samples, n_classes)


fit(X, y=None, **fit_params) [source]

Fit the model Fit all the transforms one after the other and transform the data, then fit the transformed data using the final estimator.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

selfPipeline

This estimator


fit_predict(X, y=None, **fit_params) [source]

Applies fit_predict of last step in pipeline after transforms. Applies fit_transforms of a pipeline to the data, followed by the fit_predict method of the final estimator in the pipeline. Valid only if the final estimator implements fit_predict.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

y_predarray-like


fit_transform(X, y=None, **fit_params) [source]

Fit the model and transform with the final estimator Fits all the transforms one after the other and transforms the data, then uses fit_transform on transformed data with the final estimator.  Parameters

Xiterable

Training data. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Training targets. Must fulfill label requirements for all steps of the pipeline.
**fit_paramsdict of string -> object

Parameters passed to the fit method of each step, where each parameter name is prefixed such that parameter p for step s has key s__p.    Returns

Xtarray-like of shape (n_samples, n_transformed_features)

Transformed samples


get_params(deep=True) [source]

Get parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the steps of the Pipeline.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsmapping of string to any

Parameter names mapped to their values.


property inverse_transform
Apply inverse transformations in reverse order All estimators in the pipeline must support inverse_transform.  Parameters

Xtarray-like of shape (n_samples, n_transformed_features)

Data samples, where n_samples is the number of samples and n_features is the number of features. Must fulfill input requirements of last step of pipeline’s inverse_transform method.    Returns

Xtarray-like of shape (n_samples, n_features)


predict(X, **predict_params) [source]

Apply transforms to the data, and predict with the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.
**predict_paramsdict of string -> object

Parameters to the predict called at the end of all transformations in the pipeline. Note that while this may be used to return uncertainties from some models with return_std or return_cov, uncertainties that are generated by the transformations in the pipeline are not propagated to the final estimator.  New in version 0.20.     Returns

y_predarray-like


predict_log_proba(X) [source]

Apply transforms, and predict_log_proba of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorearray-like of shape (n_samples, n_classes)


predict_proba(X) [source]

Apply transforms, and predict_proba of the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_probaarray-like of shape (n_samples, n_classes)


score(X, y=None, sample_weight=None) [source]

Apply transforms, and score with the final estimator  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.
yiterable, default=None

Targets used for scoring. Must fulfill label requirements for all steps of the pipeline.
sample_weightarray-like, default=None

If not None, this argument is passed as sample_weight keyword argument to the score method of the final estimator.    Returns

scorefloat


score_samples(X) [source]

Apply transforms, and score_samples of the final estimator.  Parameters

Xiterable

Data to predict on. Must fulfill input requirements of first step of the pipeline.    Returns

y_scorendarray of shape (n_samples,)


set_params(**kwargs) [source]

Set the parameters of this estimator. Valid parameter keys can be listed with get_params(). Note that you can directly set the parameters of the estimators contained in steps.  Returns
 self


property transform
Apply transforms, and transform with the final estimator This also works where final estimator is None: all prior transformations are applied.  Parameters

Xiterable

Data to transform. Must fulfill input requirements of first step of the pipeline.    Returns

Xtarray-like of shape (n_samples, n_transformed_features)


sklearn.preprocessing.add_dummy_feature(X, value=1.0) [source]

Augment dataset with an additional dummy feature. This is useful for fitting an intercept term with implementations which cannot otherwise fit it directly.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

Data.
valuefloat

Value to use for the dummy feature.    Returns

X{ndarray, sparse matrix} of shape (n_samples, n_features + 1)

Same data with dummy feature added as first column.     Examples >>> from sklearn.preprocessing import add_dummy_feature
>>> add_dummy_feature([[0, 1], [1, 0]])
array([[1., 0., 1.],
       [1., 1., 0.]])


sklearn.preprocessing.binarize(X, *, threshold=0.0, copy=True) [source]

Boolean thresholding of array-like or scipy.sparse matrix. Read more in the User Guide.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The data to binarize, element by element. scipy.sparse matrices should be in CSR or CSC format to avoid an un-necessary copy.
thresholdfloat, default=0.0

Feature values below or equal to this are replaced by 0, above it by 1. Threshold may not be less than 0 for operations on sparse matrices.
copybool, default=True

set to False to perform inplace binarization and avoid a copy (if the input is already a numpy array or a scipy.sparse CSR / CSC matrix and if axis is 1).    Returns

X_tr{ndarray, sparse matrix} of shape (n_samples, n_features)

The transformed data.      See also
Binarizer

Performs binarization using the Transformer API (e.g. as part of a preprocessing Pipeline).


class sklearn.preprocessing.Binarizer(*, threshold=0.0, copy=True) [source]

Binarize data (set feature values to 0 or 1) according to a threshold. Values greater than the threshold map to 1, while values less than or equal to the threshold map to 0. With the default threshold of 0, only positive values map to 1. Binarization is a common operation on text count data where the analyst can decide to only consider the presence or absence of a feature rather than a quantified number of occurrences for instance. It can also be used as a pre-processing step for estimators that consider boolean random variables (e.g. modelled using the Bernoulli distribution in a Bayesian setting). Read more in the User Guide.  Parameters

thresholdfloat, default=0.0

Feature values below or equal to this are replaced by 0, above it by 1. Threshold may not be less than 0 for operations on sparse matrices.
copybool, default=True

set to False to perform inplace binarization and avoid a copy (if the input is already a numpy array or a scipy.sparse CSR matrix).      See also
binarize

Equivalent function without the estimator API.    Notes If the input is a sparse matrix, only the non-zero values are subject to update by the Binarizer class. This estimator is stateless (besides constructor parameters), the fit method does nothing but is useful when used in a pipeline. Examples >>> from sklearn.preprocessing import Binarizer
>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]
>>> transformer = Binarizer().fit(X)  # fit does nothing.
>>> transformer
Binarizer()
>>> transformer.transform(X)
array([[1., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])
 Methods
fit(X[, y]) Do nothing and return the estimator unchanged.
fit_transform(X[, y]) Fit to data, then transform it.
get_params([deep]) Get parameters for this estimator.
set_params(**params) Set the parameters of this estimator.
transform(X[, copy]) Binarize each element of X.
fit(X, y=None) [source]

Do nothing and return the estimator unchanged. This method is just there to implement the usual API and hence work in pipelines.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The data.
yNone

Ignored.    Returns

selfobject

Fitted transformer.

fit_transform(X, y=None, **fit_params) [source]

Fit to data, then transform it. Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.  Parameters

Xarray-like of shape (n_samples, n_features)

Input samples.
yarray-like of shape (n_samples,) or (n_samples, n_outputs), default=None

Target values (None for unsupervised transformations).
**fit_paramsdict

Additional fit parameters.    Returns

X_newndarray array of shape (n_samples, n_features_new)

Transformed array.

get_params(deep=True) [source]

Get parameters for this estimator.  Parameters

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.    Returns

paramsdict

Parameter names mapped to their values.

set_params(**params) [source]

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

**paramsdict

Estimator parameters.    Returns

selfestimator instance

Estimator instance.

transform(X, copy=None) [source]

Binarize each element of X.  Parameters

X{array-like, sparse matrix} of shape (n_samples, n_features)

The data to binarize, element by element. scipy.sparse matrices should be in CSR format to avoid an un-necessary copy.
copybool

Copy the input X or not.    Returns

X_tr{ndarray, sparse matrix} of shape (n_samples, n_features)

Transformed array.