Unsupervised learner for implementing neighbor searches.
Read more in the User Guide.
New in version 0.9.
Number of neighbors to use by default for kneighbors queries.
Range of parameter space to use by default for radius_neighbors queries.
Algorithm used to compute the nearest neighbors:
Note: fitting on sparse input will override the setting of this parameter, using brute force.
Leaf size passed to BallTree or KDTree. This can affect the speed of the construction and query, as well as the memory required to store the tree. The optimal value depends on the nature of the problem.
the distance metric to use for the tree. The default metric is minkowski, and with p=2 is equivalent to the standard Euclidean metric. See the documentation of DistanceMetric for a list of available metrics. If metric is “precomputed”, X is assumed to be a distance matrix and must be square during fit. X may be a sparse graph, in which case only “nonzero” elements may be considered neighbors.
Parameter for the Minkowski metric from sklearn.metrics.pairwise.pairwise_distances. When p = 1, this is equivalent to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
Additional keyword arguments for the metric function.
The number of parallel jobs to run for neighbors search. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.
Metric used to compute distances to neighbors.
Parameters for the metric used to compute distances to neighbors.
Number of samples in the fitted data.
See also
See Nearest Neighbors in the online documentation for a discussion of the choice of algorithm and leaf_size.
https://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm
fit(X[, y])
Fit the nearest neighbors estimator from the training dataset.
get_params([deep])
Get parameters for this estimator.
kneighbors([X, n_neighbors, return_distance])
Finds the K-neighbors of a point.
kneighbors_graph([X, n_neighbors, mode])
Computes the (weighted) graph of k-Neighbors for points in X
radius_neighbors([X, radius, …])
Finds the neighbors within a given radius of a point or points.
radius_neighbors_graph([X, radius, mode, …])
Computes the (weighted) graph of Neighbors for points in X
set_params(**params)
Set the parameters of this estimator.
Fit the nearest neighbors estimator from the training dataset.
Training data.
Not used, present for API consistency by convention.
The fitted nearest neighbors estimator.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Finds the K-neighbors of a point.
Returns indices of and distances to the neighbors of each point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Number of neighbors required for each sample. The default is the value passed to the constructor.
Whether or not to return the distances.
Array representing the lengths to points, only present if return_distance=True
Indices of the nearest points in the population matrix.
In the following example, we construct a NearestNeighbors class from an array representing our data set and ask who’s the closest point to [1,1,1]
As you can see, it returns [[0.5]], and [[2]], which means that the element is at distance 0.5 and is the third element of samples (indexes start at 0). You can also query for multiple points:
Computes the (weighted) graph of k-Neighbors for points in X
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor. For metric='precomputed' the shape should be (n_queries, n_indexed). Otherwise the shape should be (n_queries, n_features).
Number of neighbors for each sample. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix is of CSR format.
See also
Finds the neighbors within a given radius of a point or points.
Return the indices and distances of each point from the dataset lying in a ball with size radius around the points of the query array. Points lying on the boundary are included in the results.
The result points are not necessarily sorted by distance to their query point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Limiting distance of neighbors to return. The default is the value passed to the constructor.
Whether or not to return the distances.
If True, the distances and indices will be sorted by increasing distances before being returned. If False, the results may not be sorted. If return_distance=False, setting sort_results=True will result in an error.
New in version 0.22.
Array representing the distances to each point, only present if return_distance=True. The distance values are computed according to the metric constructor parameter.
An array of arrays of indices of the approximate nearest points from the population matrix that lie within a ball of size radius around the query points.
Because the number of neighbors of each point is not necessarily equal, the results for multiple query points cannot be fit in a standard data array. For efficiency, radius_neighbors returns arrays of objects, where each object is a 1D array of indices or distances.
In the following example, we construct a NeighborsClassifier class from an array representing our data set and ask who’s the closest point to [1, 1, 1]:
The first array returned contains the distances to all points which are closer than 1.6, while the second array returned contains their indices. In general, multiple points can be queried at the same time.
Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Radius of neighborhoods. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
If True, in each row of the result, the non-zero entries will be sorted by increasing distances. If False, the non-zero entries may not be sorted. Only used with mode=’distance’.
New in version 0.22.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix if of format CSR.
See also
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.
Estimator parameters.
Estimator instance.


Fit the nearest neighbors estimator from the training dataset.
Training data.
Not used, present for API consistency by convention.
The fitted nearest neighbors estimator.


Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.


Finds the K-neighbors of a point.
Returns indices of and distances to the neighbors of each point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Number of neighbors required for each sample. The default is the value passed to the constructor.
Whether or not to return the distances.
Array representing the lengths to points, only present if return_distance=True
Indices of the nearest points in the population matrix.
In the following example, we construct a NearestNeighbors class from an array representing our data set and ask who’s the closest point to [1,1,1]
As you can see, it returns [[0.5]], and [[2]], which means that the element is at distance 0.5 and is the third element of samples (indexes start at 0). You can also query for multiple points:


Computes the (weighted) graph of k-Neighbors for points in X
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor. For metric='precomputed' the shape should be (n_queries, n_indexed). Otherwise the shape should be (n_queries, n_features).
Number of neighbors for each sample. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix is of CSR format.
See also


Finds the neighbors within a given radius of a point or points.
Return the indices and distances of each point from the dataset lying in a ball with size radius around the points of the query array. Points lying on the boundary are included in the results.
The result points are not necessarily sorted by distance to their query point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Limiting distance of neighbors to return. The default is the value passed to the constructor.
Whether or not to return the distances.
If True, the distances and indices will be sorted by increasing distances before being returned. If False, the results may not be sorted. If return_distance=False, setting sort_results=True will result in an error.
New in version 0.22.
Array representing the distances to each point, only present if return_distance=True. The distance values are computed according to the metric constructor parameter.
An array of arrays of indices of the approximate nearest points from the population matrix that lie within a ball of size radius around the query points.
Because the number of neighbors of each point is not necessarily equal, the results for multiple query points cannot be fit in a standard data array. For efficiency, radius_neighbors returns arrays of objects, where each object is a 1D array of indices or distances.
In the following example, we construct a NeighborsClassifier class from an array representing our data set and ask who’s the closest point to [1, 1, 1]:
The first array returned contains the distances to all points which are closer than 1.6, while the second array returned contains their indices. In general, multiple points can be queried at the same time.


Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Radius of neighborhoods. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
If True, in each row of the result, the non-zero entries will be sorted by increasing distances. If False, the non-zero entries may not be sorted. Only used with mode=’distance’.
New in version 0.22.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix if of format CSR.
See also


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.
Estimator parameters.
Estimator instance.


Neighborhood Components Analysis
Neighborhood Component Analysis (NCA) is a machine learning algorithm for metric learning. It learns a linear transformation in a supervised fashion to improve the classification accuracy of a stochastic nearest neighbors rule in the transformed space.
Read more in the User Guide.
Preferred dimensionality of the projected space. If None it will be set to n_features.
Initialization of the linear transformation. Possible options are ‘auto’, ‘pca’, ‘lda’, ‘identity’, ‘random’, and a numpy array of shape (n_features_a, n_features_b).
Depending on n_components, the most reasonable initialization will be chosen. If n_components <= n_classes we use ‘lda’, as it uses labels information. If not, but n_components < min(n_features, n_samples), we use ‘pca’, as it projects data in meaningful directions (those of higher variance). Otherwise, we just use ‘identity’.
n_components principal components of the inputs passed to fit will be used to initialize the transformation. (See PCA)
min(n_components, n_classes) most discriminative components of the inputs passed to fit will be used to initialize the transformation. (If n_components > n_classes, the rest of the components will be zero.) (See LinearDiscriminantAnalysis)
If n_components is strictly smaller than the dimensionality of the inputs passed to fit, the identity matrix will be truncated to the first n_components rows.
The initial transformation will be a random array of shape (n_components, n_features). Each value is sampled from the standard normal distribution.
n_features_b must match the dimensionality of the inputs passed to fit and n_features_a must be less than or equal to that. If n_components is not None, n_features_a must match it.
If True and fit has been called before, the solution of the previous call to fit is used as the initial linear transformation (n_components and init will be ignored).
Maximum number of iterations in the optimization.
Convergence tolerance for the optimization.
If not None, this function is called after every iteration of the optimizer, taking as arguments the current solution (flattened transformation matrix) and the number of iterations. This might be useful in case one wants to examine or store the transformation found after each iteration.
If 0, no progress messages will be printed. If 1, progress messages will be printed to stdout. If > 1, progress messages will be printed and the disp parameter of scipy.optimize.minimize will be set to verbose - 2.
A pseudo random number generator object or a seed for it if int. If init='random', random_state is used to initialize the random transformation. If init='pca', random_state is passed as an argument to PCA when initializing the transformation. Pass an int for reproducible results across multiple function calls. See :term: Glossary <random_state>.
The linear transformation learned during fitting.
Counts the number of iterations performed by the optimizer.
Pseudo random number generator object used during initialization.
J. Goldberger, G. Hinton, S. Roweis, R. Salakhutdinov. “Neighbourhood Components Analysis”. Advances in Neural Information Processing Systems. 17, 513-520, 2005. http://www.cs.nyu.edu/~roweis/papers/ncanips.pdf
Wikipedia entry on Neighborhood Components Analysis https://en.wikipedia.org/wiki/Neighbourhood_components_analysis
fit(X, y)
Fit the model according to the given training data.
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)
Applies the learned transformation to the given data.
Fit the model according to the given training data.
The training samples.
The corresponding training labels.
returns a trained NeighborhoodComponentsAnalysis model.
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Input samples.
Target values (None for unsupervised transformations).
Additional fit parameters.
Transformed array.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
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.
Estimator parameters.
Estimator instance.
Applies the learned transformation to the given data.
Data samples.
The data samples transformed.
If fit has not been called before.


Neighborhood Components Analysis
Neighborhood Component Analysis (NCA) is a machine learning algorithm for metric learning. It learns a linear transformation in a supervised fashion to improve the classification accuracy of a stochastic nearest neighbors rule in the transformed space.
Read more in the User Guide.
Preferred dimensionality of the projected space. If None it will be set to n_features.
Initialization of the linear transformation. Possible options are ‘auto’, ‘pca’, ‘lda’, ‘identity’, ‘random’, and a numpy array of shape (n_features_a, n_features_b).
Depending on n_components, the most reasonable initialization will be chosen. If n_components <= n_classes we use ‘lda’, as it uses labels information. If not, but n_components < min(n_features, n_samples), we use ‘pca’, as it projects data in meaningful directions (those of higher variance). Otherwise, we just use ‘identity’.
n_components principal components of the inputs passed to fit will be used to initialize the transformation. (See PCA)
min(n_components, n_classes) most discriminative components of the inputs passed to fit will be used to initialize the transformation. (If n_components > n_classes, the rest of the components will be zero.) (See LinearDiscriminantAnalysis)
If n_components is strictly smaller than the dimensionality of the inputs passed to fit, the identity matrix will be truncated to the first n_components rows.
The initial transformation will be a random array of shape (n_components, n_features). Each value is sampled from the standard normal distribution.
n_features_b must match the dimensionality of the inputs passed to fit and n_features_a must be less than or equal to that. If n_components is not None, n_features_a must match it.
If True and fit has been called before, the solution of the previous call to fit is used as the initial linear transformation (n_components and init will be ignored).
Maximum number of iterations in the optimization.
Convergence tolerance for the optimization.
If not None, this function is called after every iteration of the optimizer, taking as arguments the current solution (flattened transformation matrix) and the number of iterations. This might be useful in case one wants to examine or store the transformation found after each iteration.
If 0, no progress messages will be printed. If 1, progress messages will be printed to stdout. If > 1, progress messages will be printed and the disp parameter of scipy.optimize.minimize will be set to verbose - 2.
A pseudo random number generator object or a seed for it if int. If init='random', random_state is used to initialize the random transformation. If init='pca', random_state is passed as an argument to PCA when initializing the transformation. Pass an int for reproducible results across multiple function calls. See :term: Glossary <random_state>.
The linear transformation learned during fitting.
Counts the number of iterations performed by the optimizer.
Pseudo random number generator object used during initialization.
J. Goldberger, G. Hinton, S. Roweis, R. Salakhutdinov. “Neighbourhood Components Analysis”. Advances in Neural Information Processing Systems. 17, 513-520, 2005. http://www.cs.nyu.edu/~roweis/papers/ncanips.pdf
Wikipedia entry on Neighborhood Components Analysis https://en.wikipedia.org/wiki/Neighbourhood_components_analysis
fit(X, y)
Fit the model according to the given training data.
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)
Applies the learned transformation to the given data.
Fit the model according to the given training data.
The training samples.
The corresponding training labels.
returns a trained NeighborhoodComponentsAnalysis model.
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Input samples.
Target values (None for unsupervised transformations).
Additional fit parameters.
Transformed array.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
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.
Estimator parameters.
Estimator instance.
Applies the learned transformation to the given data.
Data samples.
The data samples transformed.
If fit has not been called before.
Manifold learning on handwritten digits: Locally Linear Embedding, Isomap…
Neighborhood Components Analysis Illustration
Comparing Nearest Neighbors with and without Neighborhood Components Analysis
Dimensionality Reduction with Neighborhood Components Analysis


Fit the model according to the given training data.
The training samples.
The corresponding training labels.
returns a trained NeighborhoodComponentsAnalysis model.


Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Input samples.
Target values (None for unsupervised transformations).
Additional fit parameters.
Transformed array.


Applies the learned transformation to the given data.
Data samples.
The data samples transformed.
If fit has not been called before.


Classifier implementing a vote among neighbors within a given radius
Read more in the User Guide.
Range of parameter space to use by default for radius_neighbors queries.
weight function used in prediction. Possible values:
Uniform weights are used by default.
Algorithm used to compute the nearest neighbors:
Note: fitting on sparse input will override the setting of this parameter, using brute force.
Leaf size passed to BallTree or KDTree. This can affect the speed of the construction and query, as well as the memory required to store the tree. The optimal value depends on the nature of the problem.
Power parameter for the Minkowski metric. When p = 1, this is equivalent to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
the distance metric to use for the tree. The default metric is minkowski, and with p=2 is equivalent to the standard Euclidean metric. See the documentation of DistanceMetric for a list of available metrics. If metric is “precomputed”, X is assumed to be a distance matrix and must be square during fit. X may be a sparse graph, in which case only “nonzero” elements may be considered neighbors.
label for outlier samples (samples with no neighbors in given radius).
Additional keyword arguments for the metric function.
The number of parallel jobs to run for neighbors search. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.
Class labels known to the classifier.
The distance metric used. It will be same as the metric parameter or a synonym of it, e.g. ‘euclidean’ if the metric parameter set to ‘minkowski’ and p parameter set to 2.
Additional keyword arguments for the metric function. For most metrics will be same with metric_params parameter, but may also contain the p parameter value if the effective_metric_ attribute is set to ‘minkowski’.
Number of samples in the fitted data.
Label which is given for outlier samples (samples with no neighbors on given radius).
False when y’s shape is (n_samples, ) or (n_samples, 1) during fit otherwise True.
See also
See Nearest Neighbors in the online documentation for a discussion of the choice of algorithm and leaf_size.
https://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm
fit(X, y)
Fit the radius neighbors classifier from the training dataset.
get_params([deep])
Get parameters for this estimator.
predict(X)
Predict the class labels for the provided data.
predict_proba(X)
Return probability estimates for the test data X.
radius_neighbors([X, radius, …])
Finds the neighbors within a given radius of a point or points.
radius_neighbors_graph([X, radius, mode, …])
Computes the (weighted) graph of Neighbors for points in X
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 the radius neighbors classifier from the training dataset.
Training data.
Target values.
The fitted radius neighbors classifier.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Predict the class labels for the provided data.
Test samples.
Class labels for each data sample.
Return probability estimates for the test data X.
Test samples.
of such arrays if n_outputs > 1. The class probabilities of the input samples. Classes are ordered by lexicographic order.
Finds the neighbors within a given radius of a point or points.
Return the indices and distances of each point from the dataset lying in a ball with size radius around the points of the query array. Points lying on the boundary are included in the results.
The result points are not necessarily sorted by distance to their query point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Limiting distance of neighbors to return. The default is the value passed to the constructor.
Whether or not to return the distances.
If True, the distances and indices will be sorted by increasing distances before being returned. If False, the results may not be sorted. If return_distance=False, setting sort_results=True will result in an error.
New in version 0.22.
Array representing the distances to each point, only present if return_distance=True. The distance values are computed according to the metric constructor parameter.
An array of arrays of indices of the approximate nearest points from the population matrix that lie within a ball of size radius around the query points.
Because the number of neighbors of each point is not necessarily equal, the results for multiple query points cannot be fit in a standard data array. For efficiency, radius_neighbors returns arrays of objects, where each object is a 1D array of indices or distances.
In the following example, we construct a NeighborsClassifier class from an array representing our data set and ask who’s the closest point to [1, 1, 1]:
The first array returned contains the distances to all points which are closer than 1.6, while the second array returned contains their indices. In general, multiple points can be queried at the same time.
Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Radius of neighborhoods. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
If True, in each row of the result, the non-zero entries will be sorted by increasing distances. If False, the non-zero entries may not be sorted. Only used with mode=’distance’.
New in version 0.22.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix if of format CSR.
See also
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.
Test samples.
True labels for X.
Sample weights.
Mean accuracy of self.predict(X) wrt. y.
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.
Estimator parameters.
Estimator instance.


Fit the radius neighbors classifier from the training dataset.
Training data.
Target values.
The fitted radius neighbors classifier.


Predict the class labels for the provided data.
Test samples.
Class labels for each data sample.


Return probability estimates for the test data X.
Test samples.
of such arrays if n_outputs > 1. The class probabilities of the input samples. Classes are ordered by lexicographic order.


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.
Test samples.
True labels for X.
Sample weights.
Mean accuracy of self.predict(X) wrt. y.


Regression based on neighbors within a fixed radius.
The target is predicted by local interpolation of the targets associated of the nearest neighbors in the training set.
Read more in the User Guide.
New in version 0.9.
Range of parameter space to use by default for radius_neighbors queries.
weight function used in prediction. Possible values:
Uniform weights are used by default.
Algorithm used to compute the nearest neighbors:
Note: fitting on sparse input will override the setting of this parameter, using brute force.
Leaf size passed to BallTree or KDTree. This can affect the speed of the construction and query, as well as the memory required to store the tree. The optimal value depends on the nature of the problem.
Power parameter for the Minkowski metric. When p = 1, this is equivalent to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
the distance metric to use for the tree. The default metric is minkowski, and with p=2 is equivalent to the standard Euclidean metric. See the documentation of DistanceMetric for a list of available metrics. If metric is “precomputed”, X is assumed to be a distance matrix and must be square during fit. X may be a sparse graph, in which case only “nonzero” elements may be considered neighbors.
Additional keyword arguments for the metric function.
The number of parallel jobs to run for neighbors search. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.
The distance metric to use. It will be same as the metric parameter or a synonym of it, e.g. ‘euclidean’ if the metric parameter set to ‘minkowski’ and p parameter set to 2.
Additional keyword arguments for the metric function. For most metrics will be same with metric_params parameter, but may also contain the p parameter value if the effective_metric_ attribute is set to ‘minkowski’.
Number of samples in the fitted data.
See also
See Nearest Neighbors in the online documentation for a discussion of the choice of algorithm and leaf_size.
https://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm
fit(X, y)
Fit the radius neighbors regressor from the training dataset.
get_params([deep])
Get parameters for this estimator.
predict(X)
Predict the target for the provided data
radius_neighbors([X, radius, …])
Finds the neighbors within a given radius of a point or points.
radius_neighbors_graph([X, radius, mode, …])
Computes the (weighted) graph of Neighbors for points in X
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 the radius neighbors regressor from the training dataset.
Training data.
Target values.
The fitted radius neighbors regressor.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Predict the target for the provided data
Test samples.
Target values.
Finds the neighbors within a given radius of a point or points.
Return the indices and distances of each point from the dataset lying in a ball with size radius around the points of the query array. Points lying on the boundary are included in the results.
The result points are not necessarily sorted by distance to their query point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Limiting distance of neighbors to return. The default is the value passed to the constructor.
Whether or not to return the distances.
If True, the distances and indices will be sorted by increasing distances before being returned. If False, the results may not be sorted. If return_distance=False, setting sort_results=True will result in an error.
New in version 0.22.
Array representing the distances to each point, only present if return_distance=True. The distance values are computed according to the metric constructor parameter.
An array of arrays of indices of the approximate nearest points from the population matrix that lie within a ball of size radius around the query points.
Because the number of neighbors of each point is not necessarily equal, the results for multiple query points cannot be fit in a standard data array. For efficiency, radius_neighbors returns arrays of objects, where each object is a 1D array of indices or distances.
In the following example, we construct a NeighborsClassifier class from an array representing our data set and ask who’s the closest point to [1, 1, 1]:
The first array returned contains the distances to all points which are closer than 1.6, while the second array returned contains their indices. In general, multiple points can be queried at the same time.
Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Radius of neighborhoods. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
If True, in each row of the result, the non-zero entries will be sorted by increasing distances. If False, the non-zero entries may not be sorted. Only used with mode=’distance’.
New in version 0.22.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix if of format CSR.
See also
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.
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.
True values for X.
Sample weights.
\(R^2\) of self.predict(X) wrt. y.
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 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.
Estimator parameters.
Estimator instance.


Fit the radius neighbors regressor from the training dataset.
Training data.
Target values.
The fitted radius neighbors regressor.


Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.


Predict the target for the provided data
Test samples.
Target values.


Finds the neighbors within a given radius of a point or points.
Return the indices and distances of each point from the dataset lying in a ball with size radius around the points of the query array. Points lying on the boundary are included in the results.
The result points are not necessarily sorted by distance to their query point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Limiting distance of neighbors to return. The default is the value passed to the constructor.
Whether or not to return the distances.
If True, the distances and indices will be sorted by increasing distances before being returned. If False, the results may not be sorted. If return_distance=False, setting sort_results=True will result in an error.
New in version 0.22.
Array representing the distances to each point, only present if return_distance=True. The distance values are computed according to the metric constructor parameter.
An array of arrays of indices of the approximate nearest points from the population matrix that lie within a ball of size radius around the query points.
Because the number of neighbors of each point is not necessarily equal, the results for multiple query points cannot be fit in a standard data array. For efficiency, radius_neighbors returns arrays of objects, where each object is a 1D array of indices or distances.
In the following example, we construct a NeighborsClassifier class from an array representing our data set and ask who’s the closest point to [1, 1, 1]:
The first array returned contains the distances to all points which are closer than 1.6, while the second array returned contains their indices. In general, multiple points can be queried at the same time.


Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Radius of neighborhoods. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
If True, in each row of the result, the non-zero entries will be sorted by increasing distances. If False, the non-zero entries may not be sorted. Only used with mode=’distance’.
New in version 0.22.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix if of format CSR.
See also


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.
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.
True values for X.
Sample weights.
\(R^2\) of self.predict(X) wrt. y.
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 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.
Estimator parameters.
Estimator instance.


Transform X into a (weighted) graph of neighbors nearer than a radius
The transformed data is a sparse graph as returned by radius_neighbors_graph.
Read more in the User Guide.
New in version 0.22.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, and ‘distance’ will return the distances between neighbors according to the given metric.
Radius of neighborhood in the transformed sparse graph.
Algorithm used to compute the nearest neighbors:
Note: fitting on sparse input will override the setting of this parameter, using brute force.
Leaf size passed to BallTree or KDTree. This can affect the speed of the construction and query, as well as the memory required to store the tree. The optimal value depends on the nature of the problem.
metric to use for distance computation. Any metric from scikit-learn or scipy.spatial.distance can be used.
If metric is a callable function, it is called on each pair of instances (rows) and the resulting value recorded. The callable should take two arrays as input and return one value indicating the distance between them. This works for Scipy’s metrics, but is less efficient than passing the metric name as a string.
Distance matrices are not supported.
Valid values for metric are:
See the documentation for scipy.spatial.distance for details on these metrics.
Parameter for the Minkowski metric from sklearn.metrics.pairwise.pairwise_distances. When p = 1, this is equivalent to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
Additional keyword arguments for the metric function.
The number of parallel jobs to run for neighbors search. If -1, then the number of jobs is set to the number of CPU cores.
The distance metric used. It will be same as the metric parameter or a synonym of it, e.g. ‘euclidean’ if the metric parameter set to ‘minkowski’ and p parameter set to 2.
Additional keyword arguments for the metric function. For most metrics will be same with metric_params parameter, but may also contain the p parameter value if the effective_metric_ attribute is set to ‘minkowski’.
Number of samples in the fitted data.
fit(X[, y])
Fit the radius neighbors transformer from the training dataset.
fit_transform(X[, y])
Fit to data, then transform it.
get_params([deep])
Get parameters for this estimator.
radius_neighbors([X, radius, …])
Finds the neighbors within a given radius of a point or points.
radius_neighbors_graph([X, radius, mode, …])
Computes the (weighted) graph of Neighbors for points in X
set_params(**params)
Set the parameters of this estimator.
transform(X)
Computes the (weighted) graph of Neighbors for points in X
Fit the radius neighbors transformer from the training dataset.
Training data.
The fitted radius neighbors transformer.
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Training set.
Xt[i, j] is assigned the weight of edge that connects i to j. Only the neighbors have an explicit value. The diagonal is always explicit. The matrix is of CSR format.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Finds the neighbors within a given radius of a point or points.
Return the indices and distances of each point from the dataset lying in a ball with size radius around the points of the query array. Points lying on the boundary are included in the results.
The result points are not necessarily sorted by distance to their query point.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Limiting distance of neighbors to return. The default is the value passed to the constructor.
Whether or not to return the distances.
If True, the distances and indices will be sorted by increasing distances before being returned. If False, the results may not be sorted. If return_distance=False, setting sort_results=True will result in an error.
New in version 0.22.
Array representing the distances to each point, only present if return_distance=True. The distance values are computed according to the metric constructor parameter.
An array of arrays of indices of the approximate nearest points from the population matrix that lie within a ball of size radius around the query points.
Because the number of neighbors of each point is not necessarily equal, the results for multiple query points cannot be fit in a standard data array. For efficiency, radius_neighbors returns arrays of objects, where each object is a 1D array of indices or distances.
In the following example, we construct a NeighborsClassifier class from an array representing our data set and ask who’s the closest point to [1, 1, 1]:
The first array returned contains the distances to all points which are closer than 1.6, while the second array returned contains their indices. In general, multiple points can be queried at the same time.
Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
The query point or points. If not provided, neighbors of each indexed point are returned. In this case, the query point is not considered its own neighbor.
Radius of neighborhoods. The default is the value passed to the constructor.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, in ‘distance’ the edges are Euclidean distance between points.
If True, in each row of the result, the non-zero entries will be sorted by increasing distances. If False, the non-zero entries may not be sorted. Only used with mode=’distance’.
New in version 0.22.
n_samples_fit is the number of samples in the fitted data A[i, j] is assigned the weight of edge that connects i to j. The matrix if of format CSR.
See also
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.
Estimator parameters.
Estimator instance.
Computes the (weighted) graph of Neighbors for points in X
Sample data
Xt[i, j] is assigned the weight of edge that connects i to j. Only the neighbors have an explicit value. The diagonal is always explicit. The matrix is of CSR format.


Fit the radius neighbors transformer from the training dataset.
Training data.
The fitted radius neighbors transformer.


Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Training set.
Xt[i, j] is assigned the weight of edge that connects i to j. Only the neighbors have an explicit value. The diagonal is always explicit. The matrix is of CSR format.


Computes the (weighted) graph of Neighbors for points in X
Sample data
Xt[i, j] is assigned the weight of edge that connects i to j. Only the neighbors have an explicit value. The diagonal is always explicit. The matrix is of CSR format.


Computes the (weighted) graph of Neighbors for points in X
Neighborhoods are restricted the points at a distance lower than radius.
Read more in the User Guide.
Sample data, in the form of a numpy array or a precomputed BallTree.
Radius of neighborhoods.
Type of returned matrix: ‘connectivity’ will return the connectivity matrix with ones and zeros, and ‘distance’ will return the distances between neighbors according to the given metric.
The distance metric used to calculate the neighbors within a given radius for each sample point. The DistanceMetric class gives a list of available metrics. The default distance is ‘euclidean’ (‘minkowski’ metric with the param equal to 2.)
Power parameter for the Minkowski metric. When p = 1, this is equivalent to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
additional keyword arguments for the metric function.
Whether or not to mark each sample as the first nearest neighbor to itself. If ‘auto’, then True is used for mode=’connectivity’ and False for mode=’distance’.
The number of parallel jobs to run for neighbors search. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.
Graph where A[i, j] is assigned the weight of edge that connects i to j. The matrix is of CSR format.
See also


Bernoulli Restricted Boltzmann Machine (RBM).
A Restricted Boltzmann Machine with binary visible units and binary hidden units. Parameters are estimated using Stochastic Maximum Likelihood (SML), also known as Persistent Contrastive Divergence (PCD) [2].
The time complexity of this implementation is O(d ** 2) assuming d ~ n_features ~ n_components.
Read more in the User Guide.
Number of binary hidden units.
The learning rate for weight updates. It is highly recommended to tune this hyper-parameter. Reasonable values are in the 10**[0., -3.] range.
Number of examples per minibatch.
Number of iterations/sweeps over the training dataset to perform during training.
The verbosity level. The default, zero, means silent mode.
Determines random number generation for:
Pass an int for reproducible results across multiple function calls. See Glossary.
Biases of the hidden units.
Biases of the visible units.
Weight matrix, where n_features in the number of visible units and n_components is the number of hidden units.
Hidden Activation sampled from the model distribution, where batch_size in the number of examples per minibatch and n_components is the number of hidden units.
deep belief nets. Neural Computation 18, pp 1527-1554. https://www.cs.toronto.edu/~hinton/absps/fastnc.pdf
Approximations to the Likelihood Gradient. International Conference on Machine Learning (ICML) 2008
fit(X[, y])
Fit the model to the data X.
fit_transform(X[, y])
Fit to data, then transform it.
get_params([deep])
Get parameters for this estimator.
gibbs(v)
Perform one Gibbs sampling step.
partial_fit(X[, y])
Fit the model to the data X which should contain a partial segment of the data.
score_samples(X)
Compute the pseudo-likelihood of X.
set_params(**params)
Set the parameters of this estimator.
transform(X)
Compute the hidden layer activation probabilities, P(h=1|v=X).
Fit the model to the data X.
Training data.
The fitted model.
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Input samples.
Target values (None for unsupervised transformations).
Additional fit parameters.
Transformed array.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Perform one Gibbs sampling step.
Values of the visible layer to start from.
Values of the visible layer after one Gibbs step.
Fit the model to the data X which should contain a partial segment of the data.
Training data.
The fitted model.
Compute the pseudo-likelihood of X.
Values of the visible layer. Must be all-boolean (not checked).
Value of the pseudo-likelihood (proxy for likelihood).
This method is not deterministic: it computes a quantity called the free energy on X, then on a randomly corrupted version of X, and returns the log of the logistic function of the difference.
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.
Estimator parameters.
Estimator instance.
Compute the hidden layer activation probabilities, P(h=1|v=X).
The data to be transformed.
Latent representations of the data.


Bernoulli Restricted Boltzmann Machine (RBM).
A Restricted Boltzmann Machine with binary visible units and binary hidden units. Parameters are estimated using Stochastic Maximum Likelihood (SML), also known as Persistent Contrastive Divergence (PCD) [2].
The time complexity of this implementation is O(d ** 2) assuming d ~ n_features ~ n_components.
Read more in the User Guide.
Number of binary hidden units.
The learning rate for weight updates. It is highly recommended to tune this hyper-parameter. Reasonable values are in the 10**[0., -3.] range.
Number of examples per minibatch.
Number of iterations/sweeps over the training dataset to perform during training.
The verbosity level. The default, zero, means silent mode.
Determines random number generation for:
Pass an int for reproducible results across multiple function calls. See Glossary.
Biases of the hidden units.
Biases of the visible units.
Weight matrix, where n_features in the number of visible units and n_components is the number of hidden units.
Hidden Activation sampled from the model distribution, where batch_size in the number of examples per minibatch and n_components is the number of hidden units.
deep belief nets. Neural Computation 18, pp 1527-1554. https://www.cs.toronto.edu/~hinton/absps/fastnc.pdf
Approximations to the Likelihood Gradient. International Conference on Machine Learning (ICML) 2008
fit(X[, y])
Fit the model to the data X.
fit_transform(X[, y])
Fit to data, then transform it.
get_params([deep])
Get parameters for this estimator.
gibbs(v)
Perform one Gibbs sampling step.
partial_fit(X[, y])
Fit the model to the data X which should contain a partial segment of the data.
score_samples(X)
Compute the pseudo-likelihood of X.
set_params(**params)
Set the parameters of this estimator.
transform(X)
Compute the hidden layer activation probabilities, P(h=1|v=X).
Fit the model to the data X.
Training data.
The fitted model.
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Input samples.
Target values (None for unsupervised transformations).
Additional fit parameters.
Transformed array.
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Perform one Gibbs sampling step.
Values of the visible layer to start from.
Values of the visible layer after one Gibbs step.
Fit the model to the data X which should contain a partial segment of the data.
Training data.
The fitted model.
Compute the pseudo-likelihood of X.
Values of the visible layer. Must be all-boolean (not checked).
Value of the pseudo-likelihood (proxy for likelihood).
This method is not deterministic: it computes a quantity called the free energy on X, then on a randomly corrupted version of X, and returns the log of the logistic function of the difference.
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.
Estimator parameters.
Estimator instance.
Compute the hidden layer activation probabilities, P(h=1|v=X).
The data to be transformed.
Latent representations of the data.
Restricted Boltzmann Machine features for digit classification


Fit the model to the data X.
Training data.
The fitted model.


Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
Input samples.
Target values (None for unsupervised transformations).
Additional fit parameters.
Transformed array.


Perform one Gibbs sampling step.
Values of the visible layer to start from.
Values of the visible layer after one Gibbs step.


Fit the model to the data X which should contain a partial segment of the data.
Training data.
The fitted model.


Compute the pseudo-likelihood of X.
Values of the visible layer. Must be all-boolean (not checked).
Value of the pseudo-likelihood (proxy for likelihood).
This method is not deterministic: it computes a quantity called the free energy on X, then on a randomly corrupted version of X, and returns the log of the logistic function of the difference.


Compute the hidden layer activation probabilities, P(h=1|v=X).
The data to be transformed.
Latent representations of the data.


Multi-layer Perceptron classifier.
This model optimizes the log-loss function using LBFGS or stochastic gradient descent.
New in version 0.18.
The ith element represents the number of neurons in the ith hidden layer.
Activation function for the hidden layer.
The solver for weight optimization.
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.
L2 penalty (regularization term) parameter.
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 schedule for weight updates.
Only used when solver='sgd'.
The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
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’.
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.
Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
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.
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.
Whether to print progress messages to stdout.
When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
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’
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
Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Value for numerical stability in adam. Only used when solver=’adam’
Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’
New in version 0.20.
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.
Class labels for each output.
The current loss computed with the loss function.
The minimum loss reached by the solver throughout fitting.
The ith element in the list represents the loss at the ith iteration.
The number of training samples seen by the solver during fitting.
The ith element in the list represents the weight matrix corresponding to layer i.
The ith element in the list represents the bias vector corresponding to layer i + 1.
The number of iterations the solver has ran.
Number of layers.
Number of outputs.
Name of the output activation function.
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.
“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.
training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.
performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).
optimization.” arXiv preprint arXiv:1412.6980 (2014).
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 the model to data matrix X and target(s) y.
The input data.
The target values (class labels in classification, real numbers in regression).
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Update the model with a single iteration over the given data.
The input data.
The target values.
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.
Predict using the multi-layer perceptron classifier
The input data.
The predicted classes.
Return the log of probability estimates.
The input data.
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))
Probability estimates.
The input data.
The predicted probability of the sample for each class in the model, where classes are ordered as they are in self.classes_.
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.
Test samples.
True labels for X.
Sample weights.
Mean accuracy of self.predict(X) wrt. y.
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.
Estimator parameters.
Estimator instance.


Multi-layer Perceptron classifier.
This model optimizes the log-loss function using LBFGS or stochastic gradient descent.
New in version 0.18.
The ith element represents the number of neurons in the ith hidden layer.
Activation function for the hidden layer.
The solver for weight optimization.
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.
L2 penalty (regularization term) parameter.
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 schedule for weight updates.
Only used when solver='sgd'.
The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
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’.
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.
Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
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.
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.
Whether to print progress messages to stdout.
When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
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’
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
Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Value for numerical stability in adam. Only used when solver=’adam’
Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’
New in version 0.20.
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.
Class labels for each output.
The current loss computed with the loss function.
The minimum loss reached by the solver throughout fitting.
The ith element in the list represents the loss at the ith iteration.
The number of training samples seen by the solver during fitting.
The ith element in the list represents the weight matrix corresponding to layer i.
The ith element in the list represents the bias vector corresponding to layer i + 1.
The number of iterations the solver has ran.
Number of layers.
Number of outputs.
Name of the output activation function.
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.
“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.
training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.
performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).
optimization.” arXiv preprint arXiv:1412.6980 (2014).
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 the model to data matrix X and target(s) y.
The input data.
The target values (class labels in classification, real numbers in regression).
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Update the model with a single iteration over the given data.
The input data.
The target values.
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.
Predict using the multi-layer perceptron classifier
The input data.
The predicted classes.
Return the log of probability estimates.
The input data.
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))
Probability estimates.
The input data.
The predicted probability of the sample for each class in the model, where classes are ordered as they are in self.classes_.
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.
Test samples.
True labels for X.
Sample weights.
Mean accuracy of self.predict(X) wrt. y.
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.
Estimator parameters.
Estimator instance.
Classifier comparison
Visualization of MLP weights on MNIST
Compare Stochastic learning strategies for MLPClassifier
Varying regularization in Multi-layer Perceptron


Fit the model to data matrix X and target(s) y.
The input data.
The target values (class labels in classification, real numbers in regression).


Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.


Update the model with a single iteration over the given data.
The input data.
The target values.
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.


Predict using the multi-layer perceptron classifier
The input data.
The predicted classes.


Return the log of probability estimates.
The input data.
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))


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


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.
Test samples.
True labels for X.
Sample weights.
Mean accuracy of self.predict(X) wrt. y.


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.
Estimator parameters.
Estimator instance.


Multi-layer Perceptron regressor.
This model optimizes the squared-loss using LBFGS or stochastic gradient descent.
New in version 0.18.
The ith element represents the number of neurons in the ith hidden layer.
Activation function for the hidden layer.
The solver for weight optimization.
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.
L2 penalty (regularization term) parameter.
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 schedule for weight updates.
Only used when solver=’sgd’.
The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
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’.
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.
Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
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.
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.
Whether to print progress messages to stdout.
When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
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’
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
Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Value for numerical stability in adam. Only used when solver=’adam’
Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’
New in version 0.20.
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.
The current loss computed with the loss function.
The minimum loss reached by the solver throughout fitting.
The ith element in the list represents the loss at the ith iteration.
The number of training samples seen by the solver during fitting.
The ith element in the list represents the weight matrix corresponding to layer i.
The ith element in the list represents the bias vector corresponding to layer i + 1.
The number of iterations the solver has ran.
Number of layers.
Number of outputs.
Name of the output activation function.
Loss value evaluated at the end of each training step.
Mathematically equals n_iters * X.shape[0], it means time_step and it is used by optimizer’s learning rate scheduler.
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.
“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.
training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.
performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).
optimization.” arXiv preprint arXiv:1412.6980 (2014).
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 the model to data matrix X and target(s) y.
The input data.
The target values (class labels in classification, real numbers in regression).
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Update the model with a single iteration over the given data.
The input data.
The target values.
Predict using the multi-layer perceptron model.
The input data.
The predicted values.
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.
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.
True values for X.
Sample weights.
\(R^2\) of self.predict(X) wrt. y.
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 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.
Estimator parameters.
Estimator instance.


Multi-layer Perceptron regressor.
This model optimizes the squared-loss using LBFGS or stochastic gradient descent.
New in version 0.18.
The ith element represents the number of neurons in the ith hidden layer.
Activation function for the hidden layer.
The solver for weight optimization.
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.
L2 penalty (regularization term) parameter.
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 schedule for weight updates.
Only used when solver=’sgd’.
The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.
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’.
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.
Whether to shuffle samples in each iteration. Only used when solver=’sgd’ or ‘adam’.
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.
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.
Whether to print progress messages to stdout.
When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See the Glossary.
Momentum for gradient descent update. Should be between 0 and 1. Only used when solver=’sgd’.
Whether to use Nesterov’s momentum. Only used when solver=’sgd’ and momentum > 0.
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’
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
Exponential decay rate for estimates of first moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Exponential decay rate for estimates of second moment vector in adam, should be in [0, 1). Only used when solver=’adam’
Value for numerical stability in adam. Only used when solver=’adam’
Maximum number of epochs to not meet tol improvement. Only effective when solver=’sgd’ or ‘adam’
New in version 0.20.
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.
The current loss computed with the loss function.
The minimum loss reached by the solver throughout fitting.
The ith element in the list represents the loss at the ith iteration.
The number of training samples seen by the solver during fitting.
The ith element in the list represents the weight matrix corresponding to layer i.
The ith element in the list represents the bias vector corresponding to layer i + 1.
The number of iterations the solver has ran.
Number of layers.
Number of outputs.
Name of the output activation function.
Loss value evaluated at the end of each training step.
Mathematically equals n_iters * X.shape[0], it means time_step and it is used by optimizer’s learning rate scheduler.
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.
“Connectionist learning procedures.” Artificial intelligence 40.1 (1989): 185-234.
training deep feedforward neural networks.” International Conference on Artificial Intelligence and Statistics. 2010.
performance on imagenet classification.” arXiv preprint arXiv:1502.01852 (2015).
optimization.” arXiv preprint arXiv:1412.6980 (2014).
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 the model to data matrix X and target(s) y.
The input data.
The target values (class labels in classification, real numbers in regression).
Get parameters for this estimator.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
Update the model with a single iteration over the given data.
The input data.
The target values.
Predict using the multi-layer perceptron model.
The input data.
The predicted values.
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.
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.
True values for X.
Sample weights.
\(R^2\) of self.predict(X) wrt. y.
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 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.
Estimator parameters.
Estimator instance.
Partial Dependence and Individual Conditional Expectation Plots
Advanced Plotting With Partial Dependence


Update the model with a single iteration over the given data.
The input data.
The target values.


Predict using the multi-layer perceptron model.
The input data.
The predicted values.


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.
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.
True values for X.
Sample weights.
\(R^2\) of self.predict(X) wrt. y.
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).


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.
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’.
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
Multiplicative weights for features per transformer. Keys are transformer names, values the weights. Raises ValueError if key not present in transformer_list.
If True, the time elapsed while fitting each transformer will be printed as it is completed.
See also
Convenience function for simplified feature union construction.
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 all transformers using X.
Input data, used to fit transformers.
Targets for supervised learning.
This estimator
Fit all transformers, transform the data and concatenate results.
Input data to be transformed.
Targets for supervised learning.
hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.
Get feature names from all transformers.
Names of the features produced by transform.
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.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
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.
Transform X separately by each transformer, concatenate results.
Input data to be transformed.
hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.


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.
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’.
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
Multiplicative weights for features per transformer. Keys are transformer names, values the weights. Raises ValueError if key not present in transformer_list.
If True, the time elapsed while fitting each transformer will be printed as it is completed.
See also
Convenience function for simplified feature union construction.
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 all transformers using X.
Input data, used to fit transformers.
Targets for supervised learning.
This estimator
Fit all transformers, transform the data and concatenate results.
Input data to be transformed.
Targets for supervised learning.
hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.
Get feature names from all transformers.
Names of the features produced by transform.
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.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.
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.
Transform X separately by each transformer, concatenate results.
Input data to be transformed.
hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.
Concatenating multiple feature extraction methods


Fit all transformers using X.
Input data, used to fit transformers.
Targets for supervised learning.
This estimator


Fit all transformers, transform the data and concatenate results.
Input data to be transformed.
Targets for supervised learning.
hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.


Get feature names from all transformers.
Names of the features produced by transform.


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.
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Parameter names mapped to their values.


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.


Transform X separately by each transformer, concatenate results.
Input data to be transformed.
hstack of results of transformers. sum_n_components is the sum of n_components (output dimension) over transformers.


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.
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.
If True, the time elapsed while fitting each step will be printed as it is completed.
See also
Class for creating a pipeline of transforms with a final estimator.


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.
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
If True, the time elapsed while fitting each transformer will be printed as it is completed.
See also
Class for concatenating the results of multiple transformer objects.