机器学习数据预处理preprocessing

设定一个阈值（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']