设定一个阈值（threshold），对于每个输入值，如果该值大于或等于阈值，则输出 1；否则输出 0

from sklearn.preprocessing import Binarizer# 创建 Binarizer 对象，并设定阈值
binarizer = Binarizer(threshold=0.5)# 输入数据
data = [[0.1, 0.8], [0.4, 0.6], [0.7, 0.2]]# 进行二值化处理
binary_data = binarizer.transform(data)print(binary_data)
[[0. 1.][0. 1.][1. 0.]]

将一个自定义的函数应用于数据的转换过程

from sklearn.preprocessing import FunctionTransformer
import numpy as np# 定义一个简单的函数
def log_transform(x):return np.log1p(x)# 创建 FunctionTransformer 对象
transformer = FunctionTransformer(log_transform)# 应用转换
data = np.array([[1, 2], [3, 4]])
transformed_data = transformer.transform(data)
print(transformed_data)
[[0.69314718 1.09861229][1.38629436 1.60943791]]

它可以将任何可调用的函数包装成一个转换器，使其能够与流水线（pipeline）和网格搜索（grid search）无缝集成

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import Binarizer# 创建 Binarizer 对象，并设定阈值
# binarizer = Binarizer(threshold=0.5)# 创建一个流水线，将自定义转换器与标准化器结合
pipeline = Pipeline([('log_transform', FunctionTransformer(log_transform)),('scaler', Binarizer(threshold=0.8))
])# 应用流水线
data = np.array([[1, 2], [3, 4]])
transformed_data = pipeline.fit_transform(data)
print(transformed_data)
[[0. 1.][1. 1.]]

将连续数据分箱（即离散化）
将连续特征值分成离散的区间（bins），从而将连续变量转换为离散变量

class sklearn.preprocessing.KBinsDiscretizer(n_bins=5, *, encode='onehot', strategy='quantile', dtype=None, subsample=200000, random_state=None)

• n_bins：指定每个特征要分成的箱子的数量
• encode：指定编码方式
  • ‘onehot’：独热编码
  • 'onehot-dense’密集独热编码
  • ‘ordinal’：使用序数编码（即每个箱用一个整数表示）
• strategy：指定分箱策略
  • ‘uniform’：将数据均匀分箱
  • ‘quantile’：根据分位数分箱
  • ‘kmeans’：使用 K-Means 聚类分箱

from sklearn.preprocessing import KBinsDiscretizer
import numpy as np# 创建示例数据
X = np.array([[1, 2, 6],[4, 5, 8],[7, 8, 10]])# 初始化 KBinsDiscretizer
kbins = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')# 拟合并转换数据
X_binned = kbins.fit_transform(X)print(X_binned)
[[0. 0. 0.][1. 1. 1.][2. 2. 2.]]

在上述示例中，KBinsDiscretizer 将每个特征列分成 3 个箱，并使用均匀分箱策略，具体分箱情况如下：

• 第一列：对于数据范围 [1, 7]，每个箱的宽度为 (7 - 1) / 3 = 2
  • 第一个箱子：[1, 3)对应编号为0
  • 第二个箱子：[3, 5)对应编号为1
  • 第二个箱子：[5, 7)对应编号为2
    所以第一列特征的[1, 4, 7]变换为[0, 1, 2]，同理第二列特征的[2, 5, 8]变换为[0, 1, 2]，第二列特征的[6, 8, 10]变换为[0, 1, 2]

再看另外一个例子

from sklearn.preprocessing import KBinsDiscretizer
import numpy as np# 创建示例数据
X = np.array([[1, 2, 6],[2, 5, 8],[7, 8, 10]])# 初始化 KBinsDiscretizer
#n_bins参数如果是列表形式，则其长度须等于特征数，即列数
kbins = KBinsDiscretizer(n_bins=[3, 2, 2], encode='ordinal', strategy='uniform')# 拟合并转换数据
X_binned = kbins.fit_transform(X)print(X_binned)
[[0. 0. 0.][0. 1. 1.][2. 1. 1.]]

在上述示例中，KBinsDiscretizer 将第一列分成 3 个箱、第二列分成2个箱、第三列分成2个箱，并使用均匀分箱策略，具体分箱情况如下：

• 第一列：对于数据范围 [1, 7]，每个箱的宽度为 (7 - 1) / 3 = 2
  • 第一个箱子：[1, 3)对应编号为0
  • 第二个箱子：[3, 5)对应编号为1
  • 第二个箱子：[5, 7)对应编号为2
• 第二列：对于数据范围 [2, 8]，每个箱的宽度为 (8 - 2) / 2 = 3
  • 第一个箱子：[2, 5)对应编号为0
  • 第二个箱子：[5, 8]对应编号为1
• 第三列：对于数据范围 [6, 10]，每个箱的宽度为 (10 - 6) / 2 = 2
  • 第一个箱子：[6, 8)对应编号为0
  • 第二个箱子：[8, 10]对应编号为1
    所以第一列特征的[1, 4, 7]变换为[0, 1, 2]，同理第二列特征的[2, 5, 8变换为[0, 1, 1]，第二列特征的[6, 8, 10]变换为[0, 1, 1]

用于中心化核矩阵的工具，通常用于核方法（如支持向量机和核主成分分析）中，以确保核矩阵的中心化，从而提高算法的性能
调整核矩阵使其行和列的均值为零，目的是消除数据的偏移，使得算法能够更好地捕捉数据的结构特征

具体计算方式参见机器学习数据预处理preprocessing之KernelCenterer

将多类标签转换为一组二进制值，使得每个类都用一个独立的二进制特征表示

from sklearn.preprocessing import LabelBinarizer# 创建 LabelBinarizer 对象
lb = LabelBinarizer()# 拟合并转换标签
labels = ['猫', '狗', '兔子', '猫', '狗']
binary_labels = lb.fit_transform(labels)print(binary_labels)
[[0 0 1][0 1 0][1 0 0][0 0 1][0 1 0]]
# 查看标签
print(lb.classes_)
# 输出：
# ['兔子' '狗' '猫']

将每个类别值映射到一个从 0 到 n_classes-1 的整数，其中 n_classes 是类别的数量

from sklearn.preprocessing import LabelEncoder# 创建一个 LabelEncoder 实例
label_encoder = LabelEncoder()# 假设我们有一个包含类别数据的列表
categories = ['猫', '狗', '猫', '鸟']# 使用 LabelEncoder 将类别数据转换为数值数据
encoded_labels = label_encoder.fit_transform(categories)print(encoded_labels)
# 输出: [0 1 0 2]# 如果需要将数值数据转换回类别数据，可以使用 inverse_transform 方法
decoded_labels = label_encoder.inverse_transform(encoded_labels)
print(decoded_labels)
# 输出: ['猫' '狗' '猫' '鸟']

通过将每个特征值除以该特征的最大绝对值，将特征值缩放到 [-1, 1] 范围内
MaxAbsScaler 不会改变数据的稀疏性（即不会破坏稀疏矩阵的结构），适合处理稀疏数据

$$X_{scaled}=\frac{X}{max(|X|)}$$

1. 初始化 MaxAbsScaler 对象
2. 使用 fit 方法计算训练数据的最大绝对值
3. 使用 transform 方法将训练数据缩放到 [-1, 1] 范围内
4. 对测试数据重复第 3 步的缩放操作

from sklearn.preprocessing import MaxAbsScaler
X = [[ 1., -1.,  2.],[ 2.,  0.,  0.],[ 0.,  1., -1.]]
transformer = MaxAbsScaler().fit(X)
transformer.transform(X)
array([[ 0.5, -1. ,  1. ],[ 1. ,  0. ,  0. ],[ 0. ,  1. , -0.5]])

class sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1), *, copy=True, clip=False)

将特征缩放到给定的最小值和最大值之间，通常是0和1之间

$$X_{scaled}=\frac{X-X_{min}}{X_{max}-X_{min}}$$

from sklearn.preprocessing import MinMaxScaler
data =	[[-1.   2.  ][-0.5 6][0  10 ][1.   18.  ]]
scaler = MinMaxScaler()
scaler.fit(data)
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. ]]

将多标签数据转换为二进制格式。它可以将一组标签集合转换为一个二进制矩阵，其中每一列代表一个可能的标签，每一行代表一个样本。如果样本包含某个标签，则相应位置为1，否则为0。

from sklearn.preprocessing import MultiLabelBinarizer# 假设我们有以下多标签数据
y = [['apple', 'banana'],['banana', 'orange'],['apple'],['banana', 'orange', 'apple']]# 创建 MultiLabelBinarizer 对象
mlb = MultiLabelBinarizer()# 拟合并转换数据
y_bin = mlb.fit_transform(y)
print(y_bin)
# 输出：
# [[1 1 0]
#  [0 1 1]
#  [1 0 0]
#  [1 1 1]]# 查看标签
print(mlb.classes_)
# 输出：
# ['apple' 'banana' 'orange']

对特征向量进行归一化处理，将每个样本缩放到单位范数（即每个样本的向量长度为1）

class sklearn.preprocessing.Normalizer(norm='l2', *, copy=True)

Normalizer 类的主要参数是 norm，它指定了归一化的方式。常用的选项包括:

• l1: 使用L1范数进行归一化。
• l2: 使用L2范数进行归一化（默认值）。
• max: 使用最大值范数进行归一化。

from sklearn.preprocessing import Normalizer
import numpy as np# 创建示例数据
X = np.array([[4, 1, 2, 2],[1, 3, 9, 3],[5, 7, 5, 1]])# 初始化 Normalizer
normalizer = Normalizer(norm='l1')
# 对数据进行归一化处理
X_normalized = normalizer.fit_transform(X)
X_normalized
array([[0.8, 0.2, 0.4, 0.4],[0.1, 0.3, 0.9, 0.3],[0.5, 0.7, 0.5, 0.1]])

向量[4, 1, 2, 2]的$L2$范数为：
$$\begin{gathered} ||x_1|{|}_2=\sqrt{4^2+1^2+2^2+2^2}=5 \\ {x}_{11}=4/5=0.8,x_{12}=1/5=0.2,x_{13}=2/5=0.4,x_{14}=2/5=0.4 \end{gathered}$$

将分类（类别）特征转换为可以用于机器学习算法的独热编码（one-hot encoding）
OneHotEncoder转换的是数据端的特征向量，而LabelBinarizer转换的是类别端的标签

class sklearn.preprocessing.OneHotEncoder(*, categories='auto', drop=None, sparse_output=True, dtype=<class 'numpy.float64'>, handle_unknown='error', min_frequency=None, max_categories=None, feature_name_combiner='concat')

主要参数:

• categories: 指定每个特征的类别。如果是 ‘auto’，则类别会从数据中自动推断。
• drop: 指定要删除的类别，以避免多重共线性。可以是 ‘first’ 或 ‘if_binary’。
• sparse_output: 如果为 True，则返回稀疏矩阵。默认值是 True。
• dtype: 输出数据的类型。默认是 np.float64。
• handle_unknown: 指定如何处理未知类别。可以是 ‘error’（默认）或 ‘ignore’。
  主要方法:
• fit(X): 拟合模型，根据输入数据 X 学习类别。
• transform(X): 将输入数据 X 转换为独热编码。
• fit_transform(X): 结合 fit 和 transform，对输入数据 X 进行拟合并转换。
• inverse_transform(X): 将独热编码的数据转换回原始类别值。

from sklearn.preprocessing import OneHotEncoder
enc = OneHotEncoder(handle_unknown='ignore')
X = [['Male', 1], ['Female', 3], ['Female', 2]]
enc.fit(X)
enc.categories_
[array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)]
enc.transform([['Female', 1], ['Male', 0]]).toarray()
array([[1., 0., 1., 0., 0.],[0., 1., 0., 0., 0.]])

每个样本有两维特征：第一维特征是array([‘Female’, ‘Male’]，第二维特征是array([1, 2, 3]，共有5个值，新样本转换后是一个5维仅包含0和1的特征向量，对于待转换样本：

• 如果第一维特征中有’Female’，则转换后对应[1, 0, …，如果有’Male’，则转换后对应[0, 1, …，否则对应[0, 0, …
• 同理， 如果第二维特征中分别有1， 2， 3，则分别对应…, 1, 0, 0]，…, 0, 1, 0]，…, 0, 0, 1]，否则对应…, 0, 0, 0]

因此，[‘Female’, 1]转换后对应[1, 0, 1, 0, 0]，[‘Male’, 0]转换后对应[0, 1, 0, 0, 0]

将分类（类别）数据转换为整数编码，适用于将类别特征转换为机器学习算法可以处理的数值特征
OrdinalEncoder与OneHotEncoder相似的地方：转换的是数据端的特征向量
OrdinalEncoder与OneHotEncoder差异的地方：OrdinalEncoder只能转换categories_包含的值，否则会报错
OrdinalEncoder与OneHotEncoder差异的地方：categories_包含的值，从0开始编码对应
OrdinalEncoder与OneHotEncoder差异的地方：OrdinalEncoder转换后长度与原特征向量一致

class sklearn.preprocessing.OrdinalEncoder(*, categories='auto', dtype=<class 'numpy.float64'>, handle_unknown='error', unknown_value=None, encoded_missing_value=nan, min_frequency=None, max_categories=None)

from sklearn.preprocessing import OrdinalEncoder
enc = OrdinalEncoder()
X = [['Male', 1], ['Female', 3], ['Female', 2]]
enc.fit(X)
enc.categories_
[array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)]
enc.transform([['Female', 3], ['Male', 1]])
array([[0., 2.],[1., 0.]])
enc.transform([['Female', 2], ['Male', 3]])
array([[0., 1.],[1., 2.]])

每个样本有两维特征：第一维特征是array([‘Female’, ‘Male’]，对应编码为0和1；第二维特征是array([1, 2, 3]，对应编码为0， 1 和2，对于待转换样本：

• 如果第一维特征中是’Female’，则转换后对应0，如果是’Male’，则转换后对应1，否则报错
• 如果第二维特征中是1，则转换后对应0，如果是 2，则转换后对应1， 如果是3，则转换后对应2，否则报错

因此，[‘Female’, 3]转换后对应[0， 2]，[‘Male’, 1]转换后对应[1, 0]，[‘Female’, 2]转换后对应[0， 1], [‘Male’, 3]转换后对应[1， 2]

将输入数据转换为多项式特征，从而扩展特征空间，使得线性模型能够拟合非线性数据

class sklearn.preprocessing.PolynomialFeatures(degree=2, *, interaction_only=False, include_bias=True, order='C')

主要参数:

• degree: 多项式的最高次数, 默认值为 2。
• interaction_only: 布尔值，如果为 True，则仅包括交互项，而不包括各个特征的幂次项。默认值为 False。
• include_bias: 布尔值，如果为 True，则包括偏置（即截距）列。默认值为 True。
• order: 字符串，指定输出特征的顺序。可以是 “C”（行优先）或 “F”（列优先）。默认值为 “C”。

from sklearn.preprocessing import PolynomialFeatures
import numpy as np
# 创建示例数据
X = np.array([[2, 3], [3, 4], [4, 5]])
# 初始化 PolynomialFeatures 对象
poly = PolynomialFeatures(degree=2, include_bias=False)
# 生成多项式特征
X_poly = poly.fit_transform(X)
X_poly
array([[ 2.,  3.,  4.,  6.,  9.],[ 3.,  4.,  9., 12., 16.],[ 4.,  5., 16., 20., 25.]])
poly = PolynomialFeatures(degree=2, include_bias=True)
# 生成多项式特征
X_poly = poly.fit_transform(X)
X_poly
array([[ 1.,  2.,  3.,  4.,  6.,  9.],[ 1.,  3.,  4.,  9., 12., 16.],[ 1.,  4.,  5., 16., 20., 25.]])
poly = PolynomialFeatures(degree=2, include_bias=True, interaction_only=True)
# 生成多项式特征
X_poly = poly.fit_transform(X)
X_poly
array([[ 1.,  2.,  3.,  6.],[ 1.,  3.,  4., 12.],[ 1.,  4.,  5., 20.]])

对数据进行幂变换（power transformation），旨在通过应用幂函数来稳定方差、使数据更接近正态分布，从而提高模型的性能

class sklearn.preprocessing.PowerTransformer(method='yeo-johnson', *, standardize=True, copy=True)

主要参数:

• method: 选择变换方法，‘yeo-johnson’ 适用于正负值数据或 'box-cox’仅适用于正值数据。
• standardize: 布尔值，表示是否在变换后将数据标准化为均值为0，方差为1。默认为 True。
• copy: 布尔值，表示是否在变换时复制输入数据。默认为 True。

对于method='box-cox'：
$$y(\lambda )=\{\begin{array}{ll}\frac{y^{\lambda }-1}{\lambda },& \\ log(y),& \end{array}$$