# Authors: The scikit-learn developers

# SPDX-License-Identifier: BSD-3-Clause

import warnings

from numbers import Integral, Real

import numpy as np

from scipy import sparse, stats

from scipy.special import boxcox, inv_boxcox

from sklearn.base import (

BaseEstimator,

ClassNamePrefixFeaturesOutMixin,

OneToOneFeatureMixin,

TransformerMixin,

_fit_context,

)

from sklearn.callback import CallbackSupportMixin

from sklearn.preprocessing._encoders import OneHotEncoder

from sklearn.utils import _array_api, check_array, metadata_routing, resample

from sklearn.utils._array_api import (

_find_matching_floating_dtype,

_max_precision_float_dtype,

_modify_in_place_if_numpy,

device,

get_namespace,

get_namespace_and_device,

size,

supported_float_dtypes,

)

from sklearn.utils._param_validation import (

Interval,

Options,

StrOptions,

validate_params,

)

from sklearn.utils._sparse import _align_api_if_sparse

from sklearn.utils.extmath import _incremental_mean_and_var, row_norms

from sklearn.utils.sparsefuncs import (

incr_mean_variance_axis,

inplace_column_scale,

mean_variance_axis,

min_max_axis,

)

from sklearn.utils.sparsefuncs_fast import (

inplace_csr_row_normalize_l1,

inplace_csr_row_normalize_l2,

)

from sklearn.utils.validation import (

FLOAT_DTYPES,

_check_sample_weight,

check_is_fitted,

check_random_state,

validate_data,

)

BOUNDS_THRESHOLD = 1e-7

__all__ = [

"Binarizer",

"KernelCenterer",

"MaxAbsScaler",

"MinMaxScaler",

"Normalizer",

"OneHotEncoder",

"PowerTransformer",

"QuantileTransformer",

"RobustScaler",

"StandardScaler",

"add_dummy_feature",

"binarize",

"maxabs_scale",

"minmax_scale",

"normalize",

"power_transform",

"quantile_transform",

"robust_scale",

"scale",

]

def _is_constant_feature(var, mean, n_samples):

"""Detect if a feature is indistinguishable from a constant feature.

The detection is based on its computed variance and on the theoretical

error bounds of the '2 pass algorithm' for variance computation.

See "Algorithms for computing the sample variance: analysis and

recommendations", by Chan, Golub, and LeVeque.

"""

# In scikit-learn, variance is always computed using float64 accumulators.

xp, _, device_ = get_namespace_and_device(var, mean)

max_float_dtype = _max_precision_float_dtype(xp=xp, device=device_)

eps = xp.finfo(max_float_dtype).eps

upper_bound = n_samples * eps * var + (n_samples * mean * eps) ** 2

return var <= upper_bound

def _handle_zeros_in_scale(scale, copy=True, constant_mask=None):

"""Set scales of near constant features to 1.

The goal is to avoid division by very small or zero values.

Near constant features are detected automatically by identifying

scales close to machine precision unless they are precomputed by

the caller and passed with the `constant_mask` kwarg.

Typically for standard scaling, the scales are the standard

deviation while near constant features are better detected on the

computed variances which are closer to machine precision by

construction.

"""

# if we are fitting on 1D arrays, scale might be a scalar

if np.isscalar(scale):

if scale == 0.0:

scale = 1.0

return scale

# scale is an array

else:

xp, _ = get_namespace(scale)

if constant_mask is None:

# Detect near constant values to avoid dividing by a very small

# value that could lead to surprising results and numerical

# stability issues.

constant_mask = scale < 10 * xp.finfo(scale.dtype).eps

if copy:

# New array to avoid side-effects

scale = xp.asarray(scale, copy=True)

scale[constant_mask] = 1.0

return scale

@validate_params(

{

"X": ["array-like", "sparse matrix"],

"axis": [Options(Integral, {0, 1})],

"with_mean": ["boolean"],

"with_std": ["boolean"],

"copy": ["boolean"],

},

prefer_skip_nested_validation=True,

)

def scale(X, *, axis=0, with_mean=True, with_std=True, copy=True):

"""Standardize a dataset along any axis.

Center to the mean and component wise scale to unit variance.

Read more in the :ref:`User Guide <preprocessing_scaler>`.

Parameters

----------

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

The data to center and scale.

axis : {0, 1}, default=0

Axis used to compute the means and standard deviations along. If 0,

independently standardize each feature, otherwise (if 1) standardize

each sample.

with_mean : bool, default=True

If True, center the data before scaling.

with_std : bool, default=True

If True, scale the data to unit variance (or equivalently,

unit standard deviation).

copy : bool, default=True

If False, try to avoid a copy and scale in place.

This is not guaranteed to always work in place; e.g. if the data is

a numpy array with an int dtype, a copy will be returned even with

copy=False.

Returns

-------

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

The transformed data.

See Also

--------

StandardScaler : Performs scaling to unit variance using the Transformer

API (e.g. as part of a preprocessing

:class:`~sklearn.pipeline.Pipeline`).

Notes

-----

This implementation will refuse to center scipy.sparse matrices

since it would make them non-sparse and would potentially crash the

program with memory exhaustion problems.

Instead the caller is expected to either set explicitly

`with_mean=False` (in that case, only variance scaling will be

performed on the features of the CSC matrix) or to call `X.toarray()`

if he/she expects the materialized dense array to fit in memory.

To avoid memory copy the caller should pass a CSC matrix.

NaNs are treated as missing values: disregarded to compute the statistics,

and maintained during the data transformation.

We use a biased estimator for the standard deviation, equivalent to

`numpy.std(x, ddof=0)`. Note that the choice of `ddof` is unlikely to

affect model performance.

For a comparison of the different scalers, transformers, and normalizers,

see: :ref:`sphx_glr_auto_examples_preprocessing_plot_all_scaling.py`.

.. warning:: Risk of data leak

Do not use :func:`~sklearn.preprocessing.scale` unless you know

what you are doing. A common mistake is to apply it to the entire data

*before* splitting into training and test sets. This will bias the

model evaluation because information would have leaked from the test

set to the training set.

In general, we recommend using

:class:`~sklearn.preprocessing.StandardScaler` within a

:ref:`Pipeline <pipeline>` in order to prevent most risks of data

leaking: `pipe = make_pipeline(StandardScaler(), LogisticRegression())`.

Examples

--------

>>> from sklearn.preprocessing import scale

>>> X = [[-2, 1, 2], [-1, 0, 1]]

>>> scale(X, axis=0) # scaling each column independently

array([[-1., 1., 1.],

[ 1., -1., -1.]])

>>> scale(X, axis=1) # scaling each row independently

array([[-1.37, 0.39, 0.98],

[-1.22, 0. , 1.22]])

"""

X = check_array(

X,

accept_sparse="csc",

copy=copy,

ensure_2d=False,

estimator="the scale function",

dtype=FLOAT_DTYPES,

ensure_all_finite="allow-nan",

input_name="X",

)

if sparse.issparse(X):

if with_mean:

raise ValueError(

"Cannot center sparse matrices: pass `with_mean=False` instead"

" See docstring for motivation and alternatives."

)

if axis != 0:

raise ValueError(

"Can only scale sparse matrix on axis=0, got axis=%d" % axis

)

if with_std:

_, var = mean_variance_axis(X, axis=0)

var = _handle_zeros_in_scale(var, copy=False)

inplace_column_scale(X, 1 / np.sqrt(var))

else:

X = np.asarray(X)

if with_mean:

mean_ = np.nanmean(X, axis)

if with_std:

scale_ = np.nanstd(X, axis)

# Xr is a view on the original array that enables easy use of

# broadcasting on the axis in which we are interested in

Xr = np.rollaxis(X, axis)

if with_mean:

Xr -= mean_

mean_1 = np.nanmean(Xr, axis=0)

# Verify that mean_1 is 'close to zero'. If X contains very

# large values, mean_1 can also be very large, due to a lack of

# precision of mean_. In this case, a pre-scaling of the

# concerned feature is efficient, for instance by its mean or

# maximum.

if not np.allclose(mean_1, 0):

warnings.warn(

"Numerical issues were encountered "

"when centering the data "

"and might not be solved. Dataset may "

"contain too large values. You may need "

"to prescale your features."

)

Xr -= mean_1

if with_std:

scale_ = _handle_zeros_in_scale(scale_, copy=False)

Xr /= scale_

if with_mean:

mean_2 = np.nanmean(Xr, axis=0)

# If mean_2 is not 'close to zero', it comes from the fact that

# scale_ is very small so that mean_2 = mean_1/scale_ > 0, even

# if mean_1 was close to zero. The problem is thus essentially

# due to the lack of precision of mean_. A solution is then to

# subtract the mean again:

if not np.allclose(mean_2, 0):

warnings.warn(

"Numerical issues were encountered "

"when scaling the data "

"and might not be solved. The standard "

"deviation of the data is probably "

"very close to 0. "

)

Xr -= mean_2

return X

class MinMaxScaler(OneToOneFeatureMixin, TransformerMixin, BaseEstimator):

"""Transform features by scaling each feature to a given range.

This estimator scales and translates each feature individually such

that it is in the given range on the training set, e.g. between

zero and one.

The transformation is given by::

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

where min, max = feature_range.

This transformation is often used as an alternative to zero mean,

unit variance scaling.

`MinMaxScaler` doesn't reduce the effect of outliers, but it linearly

scales them down into a fixed range, where the largest occurring data point

corresponds to the maximum value and the smallest one corresponds to the

minimum value. For an example visualization, refer to :ref:`Compare

MinMaxScaler with other scalers <plot_all_scaling_minmax_scaler_section>`.

Read more in the :ref:`User Guide <preprocessing_scaler>`.

Parameters

----------

feature_range : tuple (min, max), default=(0, 1)

Desired range of transformed data.

copy : bool, default=True

Set to False to perform inplace row normalization and avoid a

copy (if the input is already a numpy array).

clip : bool, default=False

Set to True to clip transformed values of held-out data to

provided `feature_range`.

Since this parameter will clip values, `inverse_transform` may not

be able to restore the original data.

.. note::

Setting `clip=True` does not prevent feature drift (a distribution

shift between training and test data). The transformed values are clipped

to the `feature_range`, which helps avoid unintended behavior in models

sensitive to out-of-range inputs (e.g. linear models). Use with care,

as clipping can distort the distribution of test data.

.. versionadded:: 0.24

Attributes

----------

min_ : ndarray of shape (n_features,)

Per feature adjustment for minimum. Equivalent to

``min - X.min(axis=0) * self.scale_``

scale_ : ndarray of shape (n_features,)

Per feature relative scaling of the data. Equivalent to

``(max - min) / (X.max(axis=0) - X.min(axis=0))``

.. versionadded:: 0.17

*scale_* attribute.

data_min_ : ndarray of shape (n_features,)

Per feature minimum seen in the data

.. versionadded:: 0.17

*data_min_*

data_max_ : ndarray of shape (n_features,)

Per feature maximum seen in the data

.. versionadded:: 0.17

*data_max_*

data_range_ : ndarray of shape (n_features,)

Per feature range ``(data_max_ - data_min_)`` seen in the data

.. versionadded:: 0.17

*data_range_*

n_features_in_ : int

Number of features seen during :term:`fit`.

.. versionadded:: 0.24

n_samples_seen_ : int

The number of samples processed by the estimator.

It will be reset on new calls to fit, but increments across

``partial_fit`` calls.

feature_names_in_ : ndarray of shape (`n_features_in_`,)

Names of features seen during :term:`fit`. Defined only when `X`

has feature names that are all strings.

.. versionadded:: 1.0

See Also

--------

minmax_scale : Equivalent function without the estimator API.

Notes

-----

NaNs are treated as missing values: disregarded in fit, and maintained in

transform.

Examples

--------

>>> from sklearn.preprocessing import MinMaxScaler

>>> data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]

>>> scaler = MinMaxScaler()

>>> print(scaler.fit(data))

MinMaxScaler()

>>> print(scaler.data_max_)

[ 1. 18.]

>>> print(scaler.transform(data))

[[0. 0. ]

[0.25 0.25]

[0.5 0.5 ]

[1. 1. ]]

>>> print(scaler.transform([[2, 2]]))

[[1.5 0. ]]

"""

_parameter_constraints: dict = {

"feature_range": [tuple],

"copy": ["boolean"],

"clip": ["boolean"],

}

def __init__(self, feature_range=(0, 1), *, copy=True, clip=False):

self.feature_range = feature_range

self.copy = copy

self.clip = clip

def _reset(self):

"""Reset internal data-dependent state of the scaler, if necessary.

__init__ parameters are not touched.

"""

# Checking one attribute is enough, because they are all set together

# in partial_fit

if hasattr(self, "scale_"):

del self.scale_

del self.min_

del self.n_samples_seen_

del self.data_min_

del self.data_max_

del self.data_range_

def fit(self, X, y=None):

"""Compute the minimum and maximum to be used for later scaling.

Parameters

----------

X : array-like of shape (n_samples, n_features)

The data used to compute the per-feature minimum and maximum

used for later scaling along the features axis.

y : None

Ignored.

Returns

-------

self : object

Fitted scaler.

"""

# Reset internal state before fitting

self._reset()

return self.partial_fit(X, y)

@_fit_context(prefer_skip_nested_validation=True)

def partial_fit(self, X, y=None):

"""Online computation of min and max on X for later scaling.

All of X is processed as a single batch. This is intended for cases

when :meth:`fit` is not feasible due to very large number of

`n_samples` or because X is read from a continuous stream.

Parameters

----------

X : array-like of shape (n_samples, n_features)

The data used to compute the mean and standard deviation

used for later scaling along the features axis.

y : None

Ignored.

Returns

-------

self : object

Fitted scaler.

"""

feature_range = self.feature_range

if feature_range[0] >= feature_range[1]:

raise ValueError(

"Minimum of desired feature range must be smaller than maximum. Got %s."

% str(feature_range)

)

if sparse.issparse(X):

raise TypeError(

"MinMaxScaler does not support sparse input. "

"Consider using MaxAbsScaler instead."

)

xp, _ = get_namespace(X)

first_pass = not hasattr(self, "n_samples_seen_")

X = validate_data(

self,

X,

reset=first_pass,

dtype=_array_api.supported_float_dtypes(xp, device=device(X)),

ensure_all_finite="allow-nan",

)

device_ = device(X)

feature_range = (

xp.asarray(feature_range[0], dtype=X.dtype, device=device_),

xp.asarray(feature_range[1], dtype=X.dtype, device=device_),

)

data_min = _array_api._nanmin(X, axis=0, xp=xp)

data_max = _array_api._nanmax(X, axis=0, xp=xp)

if first_pass:

self.n_samples_seen_ = X.shape[0]

else:

data_min = xp.minimum(self.data_min_, data_min)

data_max = xp.maximum(self.data_max_, data_max)

self.n_samples_seen_ += X.shape[0]

data_range = data_max - data_min

self.scale_ = (feature_range[1] - feature_range[0]) / _handle_zeros_in_scale(

data_range, copy=True

)

self.min_ = feature_range[0] - data_min * self.scale_

self.data_min_ = data_min

self.data_max_ = data_max

self.data_range_ = data_range

return self

def transform(self, X):

"""Scale features of X according to feature_range.

Parameters

----------

X : array-like of shape (n_samples, n_features)

Input data that will be transformed.

Returns

-------

Xt : ndarray of shape (n_samples, n_features)

Transformed data.

"""

check_is_fitted(self)

xp, _ = get_namespace(X)

X = validate_data(

self,

X,

copy=self.copy,

dtype=_array_api.supported_float_dtypes(xp, device=device(X)),

force_writeable=True,

ensure_all_finite="allow-nan",

reset=False,

)

X *= self.scale_

X += self.min_

if self.clip:

device_ = device(X)

X = _modify_in_place_if_numpy(

xp,

xp.clip,

X,

xp.asarray(self.feature_range[0], dtype=X.dtype, device=device_),

xp.asarray(self.feature_range[1], dtype=X.dtype, device=device_),

out=X,

)

return X

def inverse_transform(self, X):

"""Undo the scaling of X according to feature_range.

Parameters

----------

X : array-like of shape (n_samples, n_features)

Input data that will be transformed. It cannot be sparse.

Returns

-------

X_original : ndarray of shape (n_samples, n_features)

Transformed data.

"""

check_is_fitted(self)

xp, _ = get_namespace(X)

X = check_array(

X,

copy=self.copy,

dtype=_array_api.supported_float_dtypes(xp, device=device(X)),

force_writeable=True,

ensure_all_finite="allow-nan",

)

X -= self.min_

X /= self.scale_

return X

def __sklearn_tags__(self):

tags = super().__sklearn_tags__()

tags.input_tags.allow_nan = True

tags.array_api_support = True

return tags

@validate_params(

{

"X": ["array-like"],

"axis": [Options(Integral, {0, 1})],

},

prefer_skip_nested_validation=False,

)

def minmax_scale(X, feature_range=(0, 1), *, axis=0, copy=True):

"""Transform features by scaling each feature to a given range.

This estimator scales and translates each feature individually such

that it is in the given range on the training set, i.e. between

zero and one.

The transformation is given by (when ``axis=0``)::

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

where min, max = feature_range.

The transformation is calculated as (when ``axis=0``)::

X_scaled = scale * X + min - X.min(axis=0) * scale

where scale = (max - min) / (X.max(axis=0) - X.min(axis=0))

This transformation is often used as an alternative to zero mean,

unit variance scaling.

Read more in the :ref:`User Guide <preprocessing_scaler>`.

.. versionadded:: 0.17

*minmax_scale* function interface

to :class:`~sklearn.preprocessing.MinMaxScaler`.

Parameters

----------

X : array-like of shape (n_samples, n_features)

The data.

feature_range : tuple (min, max), default=(0, 1)

Desired range of transformed data.

axis : {0, 1}, default=0

Axis used to scale along. If 0, independently scale each feature,

otherwise (if 1) scale each sample.

copy : bool, default=True

If False, try to avoid a copy and scale in place.

This is not guaranteed to always work in place; e.g. if the data is

a numpy array with an int dtype, a copy will be returned even with

copy=False.

Returns

-------

X_tr : ndarray of shape (n_samples, n_features)

The transformed data.

.. warning:: Risk of data leak

Do not use :func:`~sklearn.preprocessing.minmax_scale` unless you know

what you are doing. A common mistake is to apply it to the entire data

*before* splitting into training and test sets. This will bias the

model evaluation because information would have leaked from the test

set to the training set.

In general, we recommend using

:class:`~sklearn.preprocessing.MinMaxScaler` within a

:ref:`Pipeline <pipeline>` in order to prevent most risks of data

leaking: `pipe = make_pipeline(MinMaxScaler(), LogisticRegression())`.

See Also

--------

MinMaxScaler : Performs scaling to a given range using the Transformer

API (e.g. as part of a preprocessing

:class:`~sklearn.pipeline.Pipeline`).

Notes

-----

For a comparison of the different scalers, transformers, and normalizers,

see: :ref:`sphx_glr_auto_examples_preprocessing_plot_all_scaling.py`.

Examples

--------

>>> from sklearn.preprocessing import minmax_scale

>>> X = [[-2, 1, 2], [-1, 0, 1]]

>>> minmax_scale(X, axis=0) # scale each column independently

array([[0., 1., 1.],

[1., 0., 0.]])

>>> minmax_scale(X, axis=1) # scale each row independently

array([[0. , 0.75, 1. ],

[0. , 0.5 , 1. ]])

"""

# Unlike the scaler object, this function allows 1d input.

# If copy is required, it will be done inside the scaler object.

X = check_array(

X,

copy=False,

ensure_2d=False,

dtype=FLOAT_DTYPES,

ensure_all_finite="allow-nan",

)

original_ndim = X.ndim

if original_ndim == 1:

X = X.reshape(X.shape[0], 1)

s = MinMaxScaler(feature_range=feature_range, copy=copy)

if axis == 0:

X = s.fit_transform(X)

else:

X = s.fit_transform(X.T).T

if original_ndim == 1:

X = X.ravel()

return X

class StandardScaler(

CallbackSupportMixin, OneToOneFeatureMixin, TransformerMixin, BaseEstimator

):

"""Standardize features by removing the mean and scaling to unit variance.

The standard score of a sample `x` is calculated as:

.. code-block:: text

z = (x - u) / s

where `u` is the mean of the training samples or zero if `with_mean=False`,

and `s` is the standard deviation of the training samples or one if

`with_std=False`.

Centering and scaling happen independently on each feature by computing

the relevant statistics on the samples in the training set. Mean and

standard deviation are then stored to be used on later data using

:meth:`transform`.

Standardization of a dataset is a common requirement for many

machine learning estimators: they might behave badly if the

individual features do not more or less look like standard normally

distributed data (e.g. Gaussian with 0 mean and unit variance).

For instance many elements used in the objective function of

a learning algorithm (such as the RBF kernel of Support Vector

Machines or the L1 and L2 regularizers of linear models) assume that

all features are centered around 0 and have variance in the same

order. If a feature has a variance that is orders of magnitude larger

than others, it might dominate the objective function and make the

estimator unable to learn from other features correctly as expected.

`StandardScaler` is sensitive to outliers, and the features may scale

differently from each other in the presence of outliers. For an example

visualization, refer to :ref:`Compare StandardScaler with other scalers

<plot_all_scaling_standard_scaler_section>`.

This scaler can also be applied to sparse CSR or CSC matrices by passing

`with_mean=False` to avoid breaking the sparsity structure of the data.

Read more in the :ref:`User Guide <preprocessing_scaler>`.

Parameters

----------

copy : bool, default=True

If False, try to avoid a copy and do inplace scaling instead.

This is not guaranteed to always work inplace; e.g. if the data is

not a NumPy array or scipy.sparse CSR matrix, a copy may still be

returned.

with_mean : bool, default=True

If True, center the data before scaling.

This does not work (and will raise an exception) when attempted on

sparse matrices, because centering them entails building a dense

matrix which in common use cases is likely to be too large to fit in

memory.

with_std : bool, default=True

If True, scale the data to unit variance (or equivalently,

unit standard deviation).

Attributes

----------

scale_ : ndarray of shape (n_features,) or None

Per feature relative scaling of the data to achieve zero mean and unit

variance. Generally this is calculated using `np.sqrt(var_)`. If a

variance is zero, we can't achieve unit variance, and the data is left

as-is, giving a scaling factor of 1. `scale_` is equal to `None`

when `with_std=False`.

.. versionadded:: 0.17

*scale_*

mean_ : ndarray of shape (n_features,) or None

The mean value for each feature in the training set.

Equal to ``None`` when ``with_mean=False`` and ``with_std=False``.

var_ : ndarray of shape (n_features,) or None

The variance for each feature in the training set. Used to compute

`scale_`. Equal to ``None`` when ``with_mean=False`` and

``with_std=False``.

n_features_in_ : int

Number of features seen during :term:`fit`.

.. versionadded:: 0.24

feature_names_in_ : ndarray of shape (`n_features_in_`,)

Names of features seen during :term:`fit`. Defined only when `X`

has feature names that are all strings.

.. versionadded:: 1.0

n_samples_seen_ : int or ndarray of shape (n_features,)

The number of samples processed by the estimator for each feature.

If there are no missing samples, the ``n_samples_seen`` will be an

integer, otherwise it will be an array of dtype int. If

`sample_weights` are used it will be a float (if no missing data)

or an array of dtype float that sums the weights seen so far.

Will be reset on new calls to fit, but increments across

``partial_fit`` calls.

See Also

--------

scale : Equivalent function without the estimator API.

:class:`~sklearn.decomposition.PCA` : Further removes the linear

correlation across features with 'whiten=True'.

Notes

-----

NaNs are treated as missing values: disregarded in fit, and maintained in

transform.

We use a biased estimator for the standard deviation, equivalent to

`numpy.std(x, ddof=0)`. Note that the choice of `ddof` is unlikely to

affect model performance.

Examples

--------

>>> from sklearn.preprocessing import StandardScaler

>>> data = [[0, 0], [0, 0], [1, 1], [1, 1]]

>>> scaler = StandardScaler()

>>> print(scaler.fit(data))

StandardScaler()

>>> print(scaler.mean_)

[0.5 0.5]

>>> print(scaler.transform(data))

[[-1. -1.]

[-1. -1.]

[ 1. 1.]

[ 1. 1.]]

>>> print(scaler.transform([[2, 2]]))

[[3. 3.]]

"""

_parameter_constraints: dict = {

"copy": ["boolean"],

"with_mean": ["boolean"],

"with_std": ["boolean"],

}

def __init__(self, *, copy=True, with_mean=True, with_std=True):

self.with_mean = with_mean

self.with_std = with_std

self.copy = copy

def _reset(self):

"""Reset internal data-dependent state of the scaler, if necessary.

__init__ parameters are not touched.

"""

# Checking one attribute is enough, because they are all set together

# in partial_fit

if hasattr(self, "scale_"):

del self.scale_

del self.n_samples_seen_

del self.mean_

del self.var_

def fit(self, X, y=None, sample_weight=None):

"""Compute the mean and std to be used for later scaling.

Parameters

----------

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

The data used to compute the mean and standard deviation

used for later scaling along the features axis.

y : None

Ignored.

sample_weight : array-like of shape (n_samples,), default=None

Individual weights for each sample.

.. versionadded:: 0.24

parameter *sample_weight* support to StandardScaler.

Returns

-------

self : object

Fitted scaler.

"""

# Reset internal state before fitting

self._reset()

return self.partial_fit(X, y, sample_weight)

@_fit_context(prefer_skip_nested_validation=True)

def partial_fit(self, X, y=None, sample_weight=None):

"""Online computation of mean and std on X for later scaling.

All of X is processed as a single batch. This is intended for cases

when :meth:`fit` is not feasible due to very large number of

`n_samples` or because X is read from a continuous stream.

The algorithm for incremental mean and std is given in Equation 1.5a,b

in Chan, Tony F., Gene H. Golub, and Randall J. LeVeque. "Algorithms

for computing the sample variance: Analysis and recommendations."

The American Statistician 37.3 (1983): 242-247:

Parameters

----------

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

The data used to compute the mean and standard deviation

used for later scaling along the features axis.

y : None

Ignored.

sample_weight : array-like of shape (n_samples,), default=None

Individual weights for each sample.

.. versionadded:: 0.24

parameter *sample_weight* support to StandardScaler.

Returns

-------

self : object

Fitted scaler.

"""

xp, _, X_device = get_namespace_and_device(X)

first_call = not hasattr(self, "n_samples_seen_")

X = validate_data(

self,

X,

accept_sparse=("csr", "csc"),

dtype=supported_float_dtypes(xp, X_device),

ensure_all_finite="allow-nan",

reset=first_call,

)

n_features = X.shape[1]

callback_ctx = self._init_callback_context()

callback_ctx.call_on_fit_task_begin(

estimator=self, X=X, y=y, metadata={"sample_weight": sample_weight}

)

if sample_weight is not None:

sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype)

# Even in the case of `with_mean=False`, we update the mean anyway

# This is needed for the incremental computation of the var

# See incr_mean_variance_axis and _incremental_mean_variance_axis

# if n_samples_seen_ is an integer (i.e. no missing values), we need to

# transform it to an array of shape (n_features,) required by

# incr_mean_variance_axis and _incremental_variance_axis

dtype = xp.int64 if sample_weight is None else X.dtype

if first_call:

self.n_samples_seen_ = xp.zeros(n_features, dtype=dtype, device=X_device)

elif size(self.n_samples_seen_) == 1:

self.n_samples_seen_ = xp.repeat(self.n_samples_seen_, X.shape[1])

self.n_samples_seen_ = xp.astype(self.n_samples_seen_, dtype, copy=False)

if sparse.issparse(X):

if self.with_mean:

raise ValueError(

"Cannot center sparse matrices: pass `with_mean=False` "