6.3. Preprocessing data#
6.3. 预处理数据#

6.3.1.1. Scaling features to a range#
6.3.1.1. 将 Feature 缩放到某个范围#

An alternative standardization is scaling features to lie between a given minimum and maximum value, often between zero and one, or so that the maximum absolute value of each feature is scaled to unit size. This can be achieved using MinMaxScaler or MaxAbsScaler, respectively.
另一种标准化方法是将特征缩放到给定的最小值和最大值之间，通常介于 0 和 1 之间，或者将每个特征的最大绝对值缩放为单位大小。这可以分别使用 或 来实现。

The motivation to use this scaling include robustness to very small standard deviations of features and preserving zero entries in sparse data.
使用这种缩放的动机包括对非常小的特征标准差的鲁棒性，以及在稀疏数据中保留零条目。

Here is an example to scale a toy data matrix to the [0, 1] range:
下面是将玩具数据矩阵缩放到范围的示例：

>>> X_train = np.array([[ 1., -1.,  2.],
...                     [ 2.,  0.,  0.],
...                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

The same instance of the transformer can then be applied to some new test data unseen during the fit call: the same scaling and shifting operations will be applied to be consistent with the transformation performed on the train data:
然后，可以将 transformer 的相同实例应用于 fit 调用期间看不到的一些新测试数据：将应用相同的缩放和移位操作，以与对 train 数据执行的转换保持一致：

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

It is possible to introspect the scaler attributes to find about the exact nature of the transformation learned on the training data:
可以内省 scaler 属性，以找出在训练数据上学习的转换的确切性质：

>>> min_max_scaler.scale_
array([0.5       , 0.5       , 0.33...])

>>> min_max_scaler.min_
array([0.        , 0.5       , 0.33...])

If MinMaxScaler is given an explicit feature_range=(min, max) the full formula is:
如果给定一个显式，则完整公式为：

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

X_scaled = X_std * (max - min) + min

MaxAbsScaler works in a very similar fashion, but scales in a way that the training data lies within the range [-1, 1] by dividing through the largest maximum value in each feature. It is meant for data that is already centered at zero or sparse data.
其工作方式非常相似，但通过除以每个特征中的最大最大值，以训练数据位于该范围内的方式进行扩展。它适用于已经以零数据或稀疏数据为中心的数据。

Here is how to use the toy data from the previous example with this scaler:
以下是如何将上一个示例中的玩具数据与此缩放器一起使用：

>>> X_train = np.array([[ 1., -1.,  2.],
...                     [ 2.,  0.,  0.],
...                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

6.3.1.2. Scaling sparse data#
6.3.1.2. 缩放稀疏数据#

Centering sparse data would destroy the sparseness structure in the data, and thus rarely is a sensible thing to do. However, it can make sense to scale sparse inputs, especially if features are on different scales.
将稀疏数据居中会破坏数据中的稀疏结构，因此很少是明智的做法。但是，缩放稀疏输入是有意义的，尤其是在要素处于不同比例时。

MaxAbsScaler was specifically designed for scaling sparse data, and is the recommended way to go about this. However, StandardScaler can accept scipy.sparse matrices as input, as long as with_mean=False is explicitly passed to the constructor. Otherwise a ValueError will be raised as silently centering would break the sparsity and would often crash the execution by allocating excessive amounts of memory unintentionally. RobustScaler cannot be fitted to sparse inputs, but you can use the transform method on sparse inputs.
专为扩展稀疏数据而设计，是实现此目的的推荐方法。但是，可以接受矩阵作为输入，只要显式传递给构造函数即可。否则将引发 a，因为静默居中会破坏稀疏性，并且经常会因无意中分配过多的内存而使执行崩溃。 不能拟合到稀疏 inputs，但你可以在稀疏 inputs上使用该方法。

Note that the scalers accept both Compressed Sparse Rows and Compressed Sparse Columns format (see scipy.sparse.csr_matrix and scipy.sparse.csc_matrix). Any other sparse input will be converted to the Compressed Sparse Rows representation. To avoid unnecessary memory copies, it is recommended to choose the CSR or CSC representation upstream.
请注意，缩放器接受 Compressed Sparse Rows 和 Compressed Sparse Columns 格式（请参阅 和 ）。任何其他稀疏输入都将转换为 Compressed Sparse Rows 表示。为避免不必要的内存副本，建议选择上游的 CSR 或 CSC 表示形式。

Finally, if the centered data is expected to be small enough, explicitly converting the input to an array using the toarray method of sparse matrices is another option.
最后，如果预期居中数据足够小，则使用稀疏矩阵方法将输入显式转换为数组是另一种选择。

6.3.1.3. Scaling data with outliers#
6.3.1.3. 使用异常值缩放数据#

If your data contains many outliers, scaling using the mean and variance of the data is likely to not work very well. In these cases, you can use RobustScaler as a drop-in replacement instead. It uses more robust estimates for the center and range of your data.
如果您的数据包含许多异常值，则使用数据的均值和方差进行缩放可能效果不佳。在这些情况下，您可以改用 drop-in replacement 代替。它对数据的中心和范围使用更可靠的估计值。

6.3.1.4. Centering kernel matrices#
6.3.1.4. 将核矩阵居中#

If you have a kernel matrix of a kernel $K$ that computes a dot product in a feature space (possibly implicitly) defined by a function $\varphi (\cdot )$, a KernelCenterer can transform the kernel matrix so that it contains inner products in the feature space defined by $\varphi$ followed by the removal of the mean in that space. In other words, KernelCenterer computes the centered Gram matrix associated to a positive semidefinite kernel $K$.
如果您有一个内核的内核矩阵，该内核 $K$ 计算由 function $\varphi (\cdot )$ 定义的特征空间（可能隐式）中的点积，则 a 可以转换内核矩阵，使其包含定义的特征空间中的内部积， $\varphi$ 然后删除该空间中的平均值。换句话说，计算与正半定核 $K$ 关联的居中 Gram 矩阵。

6.3.2.1. Mapping to a Uniform distribution#
6.3.2.1. 映射到 Uniform 发行版#

QuantileTransformer provides a non-parametric transformation to map the data to a uniform distribution with values between 0 and 1:
提供非参数变换，以将数据映射到值介于 0 和 1 之间的均匀分布：

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

This feature corresponds to the sepal length in cm. Once the quantile transformation applied, those landmarks approach closely the percentiles previously defined:
这个特征对应于以 cm 为单位的萼片长度。应用分位数转换后，这些地标将接近之前定义的百分位数：

>>> np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100])
... 
array([ 0.00... ,  0.24...,  0.49...,  0.73...,  0.99... ])

This can be confirmed on a independent testing set with similar remarks:
这可以通过类似的评论在独立的测试集中得到确认：

>>> np.percentile(X_test[:, 0], [0, 25, 50, 75, 100])
... 
array([ 4.4  ,  5.125,  5.75 ,  6.175,  7.3  ])
>>> np.percentile(X_test_trans[:, 0], [0, 25, 50, 75, 100])
... 
array([ 0.01...,  0.25...,  0.46...,  0.60... ,  0.94...])

6.3.2.2. Mapping to a Gaussian distribution#
6.3.2.2. 映射到高斯分布#

In many modeling scenarios, normality of the features in a dataset is desirable. Power transforms are a family of parametric, monotonic transformations that aim to map data from any distribution to as close to a Gaussian distribution as possible in order to stabilize variance and minimize skewness.
在许多建模场景中，数据集中特征的正态性是可取的。幂变换是一系列参数化的单调变换，旨在将数据从任何分布映射到尽可能接近高斯分布，以稳定方差并最小化偏度。

PowerTransformer currently provides two such power transformations, the Yeo-Johnson transform and the Box-Cox transform.
目前提供两种这样的幂变换，即 Yeo-Johnson 变换和 Box-Cox 变换。

>>> pt = preprocessing.PowerTransformer(method='box-cox', standardize=False)
>>> X_lognormal = np.random.RandomState(616).lognormal(size=(3, 3))
>>> X_lognormal
array([[1.28..., 1.18..., 0.84...],
      [0.94..., 1.60..., 0.38...],
      [1.35..., 0.21..., 1.09...]])
>>> pt.fit_transform(X_lognormal)
array([[ 0.49...,  0.17..., -0.15...],
      [-0.05...,  0.58..., -0.57...],
      [ 0.69..., -0.84...,  0.10...]])

Below are examples of Box-Cox and Yeo-Johnson applied to various probability distributions. Note that when applied to certain distributions, the power transforms achieve very Gaussian-like results, but with others, they are ineffective. This highlights the importance of visualizing the data before and after transformation.
以下是应用于各种概率分布的 Box-Cox 和 Yeo-Johnson 的示例。请注意，当应用于某些分布时，幂变换会获得非常类似于高斯的结果，但对于其他分布，它们无效。这凸显了在转换前后可视化数据的重要性。

It is also possible to map data to a normal distribution using QuantileTransformer by setting output_distribution='normal'. Using the earlier example with the iris dataset:
也可以通过设置 将数据映射到正态分布。将前面的示例与 iris 数据集一起使用：

>>> quantile_transformer = preprocessing.QuantileTransformer(
...     output_distribution='normal', random_state=0)
>>> X_trans = quantile_transformer.fit_transform(X)
>>> quantile_transformer.quantiles_
array([[4.3, 2. , 1. , 0.1],
       [4.4, 2.2, 1.1, 0.1],
       [4.4, 2.2, 1.2, 0.1],
       ...,
       [7.7, 4.1, 6.7, 2.5],
       [7.7, 4.2, 6.7, 2.5],
       [7.9, 4.4, 6.9, 2.5]])

Thus the median of the input becomes the mean of the output, centered at 0. The normal output is clipped so that the input’s minimum and maximum — corresponding to the 1e-7 and 1 - 1e-7 quantiles respectively — do not become infinite under the transformation.
因此，输入的中位数成为输出的平均值，以 0 为中心。正常输出被裁剪，以便输入的最小值和最大值（分别对应于 1e-7 和 1 - 1e-7 分位数）在转换下不会变为无限。

6.3.4.1. Infrequent categories#
6.3.4.1. 不常见的分类#

OneHotEncoder and OrdinalEncoder support aggregating infrequent categories into a single output for each feature. The parameters to enable the gathering of infrequent categories are min_frequency and max_categories.
并支持将不频繁的类别聚合到每个特征的单个输出中。用于收集不常见类别的参数是 和 。

1. min_frequency is either an integer greater or equal to 1, or a float in the interval (0.0, 1.0). If min_frequency is an integer, categories with a cardinality smaller than min_frequency will be considered infrequent. If min_frequency is a float, categories with a cardinality smaller than this fraction of the total number of samples will be considered infrequent. The default value is 1, which means every category is encoded separately.
   是大于或等于 1 的整数，或者是区间 中的浮点数。如果是整数，则基数小于 的类别将被视为不常见。如果 是浮点数，则基数小于样本总数的此分数的类别将被视为不常见。默认值为 1，这意味着每个类别都单独编码。

2. max_categories is either None or any integer greater than 1. This parameter sets an upper limit to the number of output features for each input feature. max_categories includes the feature that combines infrequent categories.
   是 or 任何大于 1 的整数。此参数为每个输入要素的输出要素数量设置上限。 包括组合不频繁类别的功能。

In the following example with OrdinalEncoder, the categories 'dog' and 'snake' are considered infrequent:
在以下示例中，使用 ，这些类别被视为不常见：

>>> X = np.array([['dog'] * 5 + ['cat'] * 20 + ['rabbit'] * 10 +
...               ['snake'] * 3], dtype=object).T
>>> enc = preprocessing.OrdinalEncoder(min_frequency=6).fit(X)
>>> enc.infrequent_categories_
[array(['dog', 'snake'], dtype=object)]
>>> enc.transform(np.array([['dog'], ['cat'], ['rabbit'], ['snake']]))
array([[2.],
       [0.],
       [1.],
       [2.]])

OrdinalEncoder’s max_categories do not take into account missing or unknown categories. Setting unknown_value or encoded_missing_value to an integer will increase the number of unique integer codes by one each. This can result in up to max_categories + 2 integer codes. In the following example, “a” and “d” are considered infrequent and grouped together into a single category, “b” and “c” are their own categories, unknown values are encoded as 3 and missing values are encoded as 4.
不考虑缺失或未知的类别。将 or 设置为整数将使唯一整数代码的数量每个增加 1。这可能导致最多为整数的代码。在以下示例中，“a” 和 “d” 被视为不常见，并一起分组到一个类别中，“b” 和 “c” 是它们自己的类别，未知值编码为 3，缺失值编码为 4。

>>> X_train = np.array(
...     [["a"] * 5 + ["b"] * 20 + ["c"] * 10 + ["d"] * 3 + [np.nan]],
...     dtype=object).T
>>> enc = preprocessing.OrdinalEncoder(
...     handle_unknown="use_encoded_value", unknown_value=3,
...     max_categories=3, encoded_missing_value=4)
>>> _ = enc.fit(X_train)
>>> X_test = np.array([["a"], ["b"], ["c"], ["d"], ["e"], [np.nan]], dtype=object)
>>> enc.transform(X_test)
array([[2.],
       [0.],
       [1.],
       [2.],
       [3.],
       [4.]])

Similarity, OneHotEncoder can be configured to group together infrequent categories:
相似性，可以配置为将不常见的类别组合在一起：

>>> enc = preprocessing.OneHotEncoder(min_frequency=6, sparse_output=False).fit(X)
>>> enc.infrequent_categories_
[array(['dog', 'snake'], dtype=object)]
>>> enc.transform(np.array([['dog'], ['cat'], ['rabbit'], ['snake']]))
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

By setting handle_unknown to 'infrequent_if_exist', unknown categories will be considered infrequent:
通过将 handle_unknown 设置为 ，未知类别将被视为不常见：

>>> enc = preprocessing.OneHotEncoder(
...    handle_unknown='infrequent_if_exist', sparse_output=False, min_frequency=6)
>>> enc = enc.fit(X)
>>> enc.transform(np.array([['dragon']]))
array([[0., 0., 1.]])

OneHotEncoder.get_feature_names_out uses ‘infrequent’ as the infrequent feature name:
使用 'infrequent' 作为 Infrequently Feature Name：

>>> enc.get_feature_names_out()
array(['x0_cat', 'x0_rabbit', 'x0_infrequent_sklearn'], dtype=object)

When 'handle_unknown' is set to 'infrequent_if_exist' and an unknown category is encountered in transform:
当设置为 且在 transform 中遇到未知类别时：

1. If infrequent category support was not configured or there was no infrequent category during training, the resulting one-hot encoded columns for this feature will be all zeros. In the inverse transform, an unknown category will be denoted as None.
   如果未配置 infrequent category 支持，或者在训练期间没有 infrequent 类别，则此功能生成的 one-hot 编码列将全部为零。在逆变换中，未知类别将表示为 。

2. If there is an infrequent category during training, the unknown category will be considered infrequent. In the inverse transform, ‘infrequent_sklearn’ will be used to represent the infrequent category.
   如果在训练期间存在不频繁的类别，则未知类别将被视为不频繁。在逆变换中，'infrequent_sklearn' 将用于表示不频繁的类别。

Infrequent categories can also be configured using max_categories. In the following example, we set max_categories=2 to limit the number of features in the output. This will result in all but the 'cat' category to be considered infrequent, leading to two features, one for 'cat' and one for infrequent categories - which are all the others:
不频繁的类别也可以使用 进行配置。在以下示例中，我们设置为限制输出中的特征数。这将导致除 category 之外的所有 cookie 都被视为不频繁，从而导致两个功能，一个用于 infrequent categories - 即所有其他 cookie：

>>> enc = preprocessing.OneHotEncoder(max_categories=2, sparse_output=False)
>>> enc = enc.fit(X)
>>> enc.transform([['dog'], ['cat'], ['rabbit'], ['snake']])
array([[0., 1.],
       [1., 0.],
       [0., 1.],
       [0., 1.]])

If both max_categories and min_frequency are non-default values, then categories are selected based on min_frequency first and max_categories categories are kept. In the following example, min_frequency=4 considers only snake to be infrequent, but max_categories=3, forces dog to also be infrequent:
如果 和 都是非默认值，则根据 first 选择类别并保留类别。在以下示例中，仅认为不频繁，但 强制也为不频繁：

>>> enc = preprocessing.OneHotEncoder(min_frequency=4, max_categories=3, sparse_output=False)
>>> enc = enc.fit(X)
>>> enc.transform([['dog'], ['cat'], ['rabbit'], ['snake']])
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

If there are infrequent categories with the same cardinality at the cutoff of max_categories, then then the first max_categories are taken based on lexicon ordering. In the following example, “b”, “c”, and “d”, have the same cardinality and with max_categories=2, “b” and “c” are infrequent because they have a higher lexicon order.
如果在 的截止处存在具有相同基数的不常见类别，则根据词典排序采用第一个类别。在以下示例中，“b”、“c” 和 “d” 具有相同的基数，而 、 “b” 和 “c” 很少见，因为它们具有较高的词典顺序。

>>> X = np.asarray([["a"] * 20 + ["b"] * 10 + ["c"] * 10 + ["d"] * 10], dtype=object).T
>>> enc = preprocessing.OneHotEncoder(max_categories=3).fit(X)
>>> enc.infrequent_categories_
[array(['b', 'c'], dtype=object)]

6.3.4.2. Target Encoder#
6.3.4.2. 目标编码器#

The TargetEncoder uses the target mean conditioned on the categorical feature for encoding unordered categories, i.e. nominal categories [PAR] [MIC]. This encoding scheme is useful with categorical features with high cardinality, where one-hot encoding would inflate the feature space making it more expensive for a downstream model to process. A classical example of high cardinality categories are location based such as zip code or region.
它使用以分类特征为条件的目标均值来编码无序类别，即名义类别 [PAR][MIC]。此编码方案对于具有高基数的分类特征非常有用，其中独热编码会膨胀特征空间，使下游模型的处理成本更高。高基数类别的一个典型示例是基于位置，例如邮政编码或区域。

fit_transform internally relies on a cross fitting scheme to prevent target information from leaking into the train-time representation, especially for non-informative high-cardinality categorical variables, and help prevent the downstream model from overfitting spurious correlations. Note that as a result, fit(X, y).transform(X) does not equal fit_transform(X, y). In fit_transform, the training data is split into k folds (determined by the cv parameter) and each fold is encoded using the encodings learnt using the other k-1 folds. The following diagram shows the cross fitting scheme in fit_transform with the default cv=5:
内部依赖于交叉拟合方案来防止目标信息泄漏到训练时间表示中，特别是对于非信息性高基数分类变量，并有助于防止下游模型过度拟合虚假相关性。请注意，因此， 不等于 。在 中，训练数据被分成 k 个折叠（由参数确定），每个折叠都使用使用其他 k-1 个折叠学习的编码进行编码。下图显示了默认的交叉拟合方案：

fit_transform also learns a ‘full data’ encoding using the whole training set. This is never used in fit_transform but is saved to the attribute encodings_, for use when transform is called. Note that the encodings learned for each fold during the cross fitting scheme are not saved to an attribute.
此外，还使用整个训练集学习 'full data' 编码。这永远不会在 中使用，而是保存到属性 中，以便在调用时使用。请注意，在交叉拟合方案期间为每个折叠学习的编码不会保存到属性中。

The fit method does not use any cross fitting schemes and learns one encoding on the entire training set, which is used to encode categories in transform. This encoding is the same as the ‘full data’ encoding learned in fit_transform.
该方法不使用任何交叉拟合方案，而是在整个训练集上学习一种编码，该编码用于对 中的类别进行编码。此编码与 中学习的“完整数据”编码相同。

Examples 例子

• Comparing Target Encoder with Other Encoders
  将 Target 编码器与其他编码器进行比较

• Target Encoder’s Internal Cross fitting
  Target 编码器的内部十字接头

References 引用

6.3.5.1. K-bins discretization#
6.3.5.1. K bins离散化#

KBinsDiscretizer discretizes features into k bins:
将特征离散到 bin 中：

>>> X = np.array([[ -3., 5., 15 ],
...               [  0., 6., 14 ],
...               [  6., 3., 11 ]])
>>> est = preprocessing.KBinsDiscretizer(n_bins=[3, 2, 2], encode='ordinal').fit(X)

By default the output is one-hot encoded into a sparse matrix (See Encoding categorical features) and this can be configured with the encode parameter. For each feature, the bin edges are computed during fit and together with the number of bins, they will define the intervals. Therefore, for the current example, these intervals are defined as:
默认情况下，输出是 one-hot 编码为稀疏矩阵（请参阅 编码分类特征），这可以使用参数进行配置。对于每个要素，将在 bin 数量期间计算 bin 边缘，并与 bin 数量一起定义间隔。因此，对于当前示例，这些间隔定义为：

• feature 1: $[-\mathrm{\infty },-1),[-1,2),[2,\mathrm{\infty })$ 特点 1： $[-\mathrm{\infty },-1),[-1,2),[2,\mathrm{\infty })$

• feature 2: $[-\mathrm{\infty },5),[5,\mathrm{\infty })$ 特点 2： $[-\mathrm{\infty },5),[5,\mathrm{\infty })$

• feature 3: $[-\mathrm{\infty },14),[14,\mathrm{\infty })$ 特点 3： $[-\mathrm{\infty },14),[14,\mathrm{\infty })$

Based on these bin intervals, X is transformed as follows:
根据这些分箱间隔，将按如下方式进行转换：

>>> est.transform(X)                      
array([[ 0., 1., 1.],
       [ 1., 1., 1.],
       [ 2., 0., 0.]])

The resulting dataset contains ordinal attributes which can be further used in a Pipeline.
生成的数据集包含序号属性，这些属性可以在 .

Discretization is similar to constructing histograms for continuous data. However, histograms focus on counting features which fall into particular bins, whereas discretization focuses on assigning feature values to these bins.
离散化类似于为连续数据构建直方图。但是，直方图侧重于对落入特定 bin 的特征进行计数，而离散化侧重于为这些 bin 分配特征值。

KBinsDiscretizer implements different binning strategies, which can be selected with the strategy parameter. The ‘uniform’ strategy uses constant-width bins. The ‘quantile’ strategy uses the quantiles values to have equally populated bins in each feature. The ‘kmeans’ strategy defines bins based on a k-means clustering procedure performed on each feature independently.
实现不同的分箱策略，可以使用 parameter 进行选择。'uniform' 策略使用恒定宽度的 bin。'分位数' 策略使用分位数值在每个特征中具有相等填充的 bin。'kmeans' 策略根据对每个特征独立执行的 k-means 聚类过程来定义分箱。

Be aware that one can specify custom bins by passing a callable defining the discretization strategy to FunctionTransformer. For instance, we can use the Pandas function pandas.cut:
请注意，可以通过将定义离散化策略的可调用对象传递给 来指定自定义 bin。例如，我们可以使用 Pandas 函数：

>>> import pandas as pd
>>> import numpy as np
>>> from sklearn import preprocessing
>>>
>>> bins = [0, 1, 13, 20, 60, np.inf]
>>> labels = ['infant', 'kid', 'teen', 'adult', 'senior citizen']
>>> transformer = preprocessing.FunctionTransformer(
...     pd.cut, kw_args={'bins': bins, 'labels': labels, 'retbins': False}
... )
>>> X = np.array([0.2, 2, 15, 25, 97])
>>> transformer.fit_transform(X)
['infant', 'kid', 'teen', 'adult', 'senior citizen']
Categories (5, object): ['infant' < 'kid' < 'teen' < 'adult' < 'senior citizen']

Examples 例子

• Using KBinsDiscretizer to discretize continuous features
  使用 KBinsDiscretizer 离散化连续特征

• Feature discretization 特征离散化

• Demonstrating the different strategies of KBinsDiscretizer
  演示 KBinsDiscretizer 的不同策略

6.3.5.2. Feature binarization#
6.3.5.2. 特性二值化#

Feature binarization is the process of thresholding numerical features to get boolean values. This can be useful for downstream probabilistic estimators that make assumption that the input data is distributed according to a multi-variate Bernoulli distribution. For instance, this is the case for the BernoulliRBM.
特征二值化是对数值特征进行阈值处理以获得布尔值的过程。这对于假设输入数据根据多变量伯努利分布分布的下游概率估计器非常有用。例如，.

It is also common among the text processing community to use binary feature values (probably to simplify the probabilistic reasoning) even if normalized counts (a.k.a. term frequencies) or TF-IDF valued features often perform slightly better in practice.
在文本处理社区中，使用二进制特征值（可能是为了简化概率推理）也很常见，即使归一化计数（又名词频率）或 TF-IDF 值特征在实践中通常表现得稍微好一些。

As for the Normalizer, the utility class Binarizer is meant to be used in the early stages of Pipeline. The fit method does nothing as each sample is treated independently of others:
至于 ，实用程序类旨在用于 的早期阶段。该方法不执行任何操作，因为每个样本都独立于其他样本进行处理：

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

>>> binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
>>> binarizer
Binarizer()

>>> binarizer.transform(X)
array([[1., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])

It is possible to adjust the threshold of the binarizer:
可以调整 binarizer 的阈值：

>>> binarizer = preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 0., 0.]])

As for the Normalizer class, the preprocessing module provides a companion function binarize to be used when the transformer API is not necessary.
至于类，预处理模块提供了一个配套函数，当不需要 transformer API 时使用。

Note that the Binarizer is similar to the KBinsDiscretizer when k = 2, and when the bin edge is at the value threshold.
请注意，这类似于 when ，并且当 bin 边缘位于值 .

6.3.7.1. Polynomial features#

A simple and common method to use is polynomial features, which can get features’ high-order and interaction terms. It is implemented in PolynomialFeatures:

>>> import numpy as np
>>> from sklearn.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])

The features of X have been transformed from $(X_1,X_2)$ to $(1,X_1,X_2,X_1^2,X_1{X}_2,X_2^2)$.

In some cases, only interaction terms among features are required, and it can be gotten with the setting interaction_only=True:

>>> X = np.arange(9).reshape(3, 3)
>>> X
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> poly = PolynomialFeatures(degree=3, interaction_only=True)
>>> poly.fit_transform(X)
array([[  1.,   0.,   1.,   2.,   0.,   0.,   2.,   0.],
       [  1.,   3.,   4.,   5.,  12.,  15.,  20.,  60.],
       [  1.,   6.,   7.,   8.,  42.,  48.,  56., 336.]])

The features of X have been transformed from $(X_1,X_2,X_3)$ to $(1,X_1,X_2,X_3,X_1{X}_2,X_1{X}_3,X_2{X}_3,X_1{X}_2{X}_3)$.

Note that polynomial features are used implicitly in kernel methods (e.g., SVC, KernelPCA) when using polynomial Kernel functions.

See Polynomial and Spline interpolation for Ridge regression using created polynomial features.

6.3.7.2. Spline transformer#

Another way to add nonlinear terms instead of pure polynomials of features is to generate spline basis functions for each feature with the SplineTransformer. Splines are piecewise polynomials, parametrized by their polynomial degree and the positions of the knots. The SplineTransformer implements a B-spline basis, cf. the references below.

Some of the advantages of splines over polynomials are:

• B-splines are very flexible and robust if you keep a fixed low degree, usually 3, and parsimoniously adapt the number of knots. Polynomials would need a higher degree, which leads to the next point.

• B-splines do not have oscillatory behaviour at the boundaries as have polynomials (the higher the degree, the worse). This is known as Runge’s phenomenon.

• B-splines provide good options for extrapolation beyond the boundaries, i.e. beyond the range of fitted values. Have a look at the option extrapolation.

• B-splines generate a feature matrix with a banded structure. For a single feature, every row contains only degree + 1 non-zero elements, which occur consecutively and are even positive. This results in a matrix with good numerical properties, e.g. a low condition number, in sharp contrast to a matrix of polynomials, which goes under the name Vandermonde matrix. A low condition number is important for stable algorithms of linear models.

The following code snippet shows splines in action:

>>> import numpy as np
>>> from sklearn.preprocessing import SplineTransformer
>>> X = np.arange(5).reshape(5, 1)
>>> X
array([[0],
       [1],
       [2],
       [3],
       [4]])
>>> spline = SplineTransformer(degree=2, n_knots=3)
>>> spline.fit_transform(X)
array([[0.5  , 0.5  , 0.   , 0.   ],
       [0.125, 0.75 , 0.125, 0.   ],
       [0.   , 0.5  , 0.5  , 0.   ],
       [0.   , 0.125, 0.75 , 0.125],
       [0.   , 0.   , 0.5  , 0.5  ]])

As the X is sorted, one can easily see the banded matrix output. Only the three middle diagonals are non-zero for degree=2. The higher the degree, the more overlapping of the splines.

Interestingly, a SplineTransformer of degree=0 is the same as KBinsDiscretizer with encode='onehot-dense' and n_bins = n_knots - 1 if knots = strategy.

Examples

• Polynomial and Spline interpolation

• Time-related feature engineering