Scikit-learn学习系列 | 2. sklearn数据预处理的相关方法
如有错误，恳请指出。
以下内容整理自专栏：博主“文火冰糖的硅基工坊”的专栏——机器学习与scikit-learn，对部分的文章的简化与整理。
文章目录
- 1. 数据预处理介绍
- 2. 缺失数据na的预处理
- 2.1 直接丢弃：dropna
- 2.2 用常数填充：fillna
- 2.3 用平均值mean填充: SimpleImputer（strategy='mean'）
- 2.4 用频率最高值most_frequent填充：SimpleImputer（strategy='most_frequent'）
- 2.5 用中位数median填充：SimpleImputer（strategy='median'）
- 3. 数据的无量纲处理
- 3.1 preprocessing.MinMaxScaler
- 3.2 preprocessing.MaxAbsScaler
- 3.3 preprocessing.RobustScaler
- 4. 数据的非线性处理
- 4.1 标准化StandardScaler
- 4.2 正则化Normalizer
- 4.3 多项式升维PolynomialFeatures
- 5. 数据的二值化与分段
- 5.1 二值化Binarizer
- 5.2 分段KBinsDiscretizer
- 5.3 分段函数pd.cut处理
- 6. 数据的特征编码处理
- 6.1 LabelEncoder编码处理
- 6.2 OrdinalEncoder编码处理
- 6.3 OneHotEncoder 编码处理
1. 数据预处理介绍
数据挖掘的五大流程：
（1）获取数据（原始数据）：获取用于模型训练的原始样本数据。
（2）数据预处理 （数据合法性检查与初步处理）：数据预处理是从数据中检测，纠正或删除损坏，不准确或不适用于模型的记录的过程。
（3）特征工程（特征的有效性选择）：特征工程是将预处理后的数据转换为更能代表预测模型的潜在问题的特征的过程，可以通过挑选最相关的特征，提取特征以及创造特征来实现。特征工程是理解难度较大的一部分，它涉及到利用一定的数学原理来从众多特征中选择部分有意义的特征。
（4）算法与模型训练：建模、训练模型、测试模型并预测出结果。
（5）上线，验证模型效果为什么需要数据预处理这个过程？
（1）缺失：缺少、丢失
（2）错误：噪声、异常、错误
（3）不平衡：过大、过小、偏离
（4）重复：重复
（5）数据类型不匹配（格式）
（6）数值相差较大
（7）不符合特定模型训练的要求
数据预处理的目的：
消除原始数据中的异常，让数据适应模型、匹配模型的需求。sklearn中的数据预处理Preprocessing模块提供了大量数据预处理的函数和类，几乎包含数据预处理的所有内容。另外还有一个Impute模块，填补缺失值专用。其中有类接口与函数接口，前者是大写后者是小写（推荐使用类接口）。
数据预处理的常见方法：
缺失值的处理
（1）缺失值插补：impute.SimpleImputer数据无量纲转换
（1）归一化：preprocessing.MinMaxScaler
（2）特征的标准化：preprocessing.StandardScaler
（3）数据的正则化：sklearn.preprocessing.scale创造新的特征
（1）非线性转换
（2）生成多项式特征连续型特征的二值化与分段
（1）特征的二值化：sklearn.preprocessing.Binarizer
（2）特征的分段：preprocessing.KBinsDiscretizer分类型特征的编码，将文字型数据转换为数值型
（1）preprocessing.LabelEncoder：标签专用，能够将分类转换为分类数值
（2）preprocessing.OrdinalEncoder：特征专用，能够将分类特征转换为分类数值
（3）preprocessing.OneHotEncoder：独热编码，创建哑变量
下面就对上面提及的数据预处理方法依次介绍。
2. 缺失数据na的预处理
真实世界中的许多数据集都包含缺失数据，这类数据经常被编码成空格、NaN，或者是其他的占位符。但是这样的数据集并不能和scikit-learn学习算法兼容。使用不完整的数据集的一个最简单的策略就是：舍弃掉整行或整列包含缺失值的数据。但是这样就付出了舍弃可能有价值数据（即使是不完整的 ）的代价，常常会有重要的字段缺失值很多，但又不能舍弃字段的情况。因此，数据预处理中非常重要的一项就是处理缺失值。
策略：
（1）平均值mean：其他样本对应特征值的平均值替代缺失值
（2）频率最高值most_frequent：其他样本对应特征值的最高值替代缺失值
（3）中位数median：其他样本对应特征值的中位数替代缺失值
（4）常数constant：用某个常数来替代缺失值使用接口：
sklearn.impute.SimpleImputer ( missing_values=nan, strategy=’mean’, fill_value=None, verbose=0, copy=True)
代码展示：
2.1 直接丢弃：dropna
# .dropna(axis=0)删除所有有缺失值的行，.dropna(axis=1)删除所有有缺失值的列
# 参数inplace，为True表示在原数据集上进行修改，为False表示生成一个复制对象，不修改原数据，默认False
data_raw.dropna(axis=0, inplace=True)
2.2 用常数填充：fillna
# data.fillna 在DataFrame里面直接进行填补
data_fill = data_raw.fillna(0) # 这里设置用0来填补
2.3 用平均值mean填充: SimpleImputer（strategy=‘mean’）
from sklearn.impute import SimpleImputer# 策略有 mean,most_frequent,median
# 设定缺失值填补策略
imp = SimpleImputer(missing_values=np.nan, strategy='mean')
# 更具每一列的平均值训练，计算出数据集X每一列的均值来填充缺失值
imp.fit(X)
X = imp.transform(X) # 用训练出的数据填充缺失值
Y = imp.transform(Y) # 用在X数据集训练出来的填充缺失值来用在Y处
2.4 用频率最高值most_frequent填充：SimpleImputer（strategy=‘most_frequent’）
from sklearn.impute import SimpleImputer# 策略有 mean,most_frequent,median
# 设定缺失值填补策略：missing_values就是选择徐亚填充的数值
imp = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
# 更具每一列的平均值训练，计算出数据集X每一列的使用次数最多的来填充缺失值
imp.fit(X)
X = imp.transform(X) # 用训练出的数据填充缺失值
Y = imp.transform(Y) # 用在X数据集训练出来的填充缺失值来用在Y处
2.5 用中位数median填充：SimpleImputer（strategy=‘median’）
from sklearn.impute import SimpleImputer# 策略有 mean,most_frequent,median
# 设定缺失值填补策略：missing_values就是选择徐亚填充的数值
imp = SimpleImputer(missing_values=np.nan, strategy='median')
# 更具每一列的平均值训练，计算出数据集X每一列的中位数来填充缺失值
imp.fit(X)
X = imp.transform(X) # 用训练出的数据填充缺失值
Y = imp.transform(Y) # 用在X数据集训练出来的填充缺失值来用在Y处
3. 数据的无量纲处理
数据的无量纲处理介绍：
在机器学习算法实践中，我们往往有着将不同规格的数据转换到同一规格，或不同分布的数据转换到某个特定分布的需求，这种需求统称为将数据“无量纲化”。无量纲化一般可以加快求解的速度，在距离类模型，譬如K近邻，K-Means聚类中，无量纲化可以帮我们提升模型精度，避免某一个取值范围特别大的特征对距离计算造成影响。（一个特例是决策树和树的集成算法们，对决策树我们不需要无量纲化，决策树可以把任意数据都处理得很好。）
常用的办法是中心化处理与缩放处理：
1）中心化：本质是让所有记录减去一个固定值，即让数据样本数据平移到某个位置。
2）缩放：本质是通过除以一个固定值，将数据固定在某个范围之中，取对数也算是一种缩放处理。
- 代码展示：
3.1 preprocessing.MinMaxScaler
把区间范围[min, max]缩放至[0,1]之间，是把最小值转为0，最大值转为1，其它值在[0,1]之间等比例放缩。也可以指定范围feature_range.
from sklearn import preprocessing# 注意这里的对每列数据进行处理的，也就是针对每个特征的数据
data = np.linspace(1, 10, 10).reshape(-1, 1)
# 定义缩放对象，feature_range参数可以指定缩放范围
scaler = preprocessing.MinMaxScaler(feature_range=(0, 2), copy=True)
# 可以选进行训练fit，再进行转换transform，也可以像如下这样直接一步处理
postdata = scaler.fit_transform(data)
# 分两步，这样可以使用data训练出来的模型来作用在其他的特征数据上
# scaler.fit(data)
# postdata = scaler.transform(data)
3.2 preprocessing.MaxAbsScaler
把区间范围缩放至[-1,1]之间，无偏移
from sklearn import preprocessing# 注意这里的对每列数据进行处理的，也就是针对每个特征的数据
data = np.linspace(-10, 10, 10).reshape(-1, 1)
# 定义缩放对象
scaler = preprocessing.MaxAbsScaler()
# 先训练再转换
scaler.fit(data)
postdata = scaler.transform(data)
3.3 preprocessing.RobustScaler
如果数据中，有异常数据，如绝对值特别大的数据，如果把他们作为正常数据，会导致其他数据放缩后，非常非常的小，接近于0。这种情况，就不能以按照正常数据处理，把他们放缩到指定的区间，而应该亦然把他们作为异常数据处理，只需要把正常数据映射到指定区间即可，异常数据正常数据的放缩比例来进行等比例放缩，放缩后，它们依然是异常数据。
from sklearn import preprocessing
import numpy as np# 随机选择一个变异索引
np.random.seed(42)
id = np.random.choice(data.flatten().astype(int))
# 对data的对于数据进行变异，称为异常数据
data = np.linspace(1, 10, 10)
data[id] *= 100
# 转换为列特征
data = data.reshape(-1, 1)
print(data.flatten()) # 展平后输出# 参数说明：
# with_centering : 布尔值，默认为True。若为True，则在缩放之前将数据居中。若使用稀疏矩阵时，此转换将引发异常，因为将其居中需要建立一个密集的矩阵，在通常情况下，该矩阵可能太大而无法容纳在内存中。
# with_scaling : 布尔值，默认为True。若为True，则将数据缩放到四分位数范围。
# quantile_range : tuple (q_min, q_max)。默认值：（25.0，75.0）=（第一分位数，第三分位数）
# copy : 布尔值，是否拷贝一份数据以避免在原数据上进行操作，默认为True
scaler = preprocessing.RobustScaler(with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)
scaler.fit(data)
postdata = scaler.transform(data)# 如果为 True，则始终使用定点表示法打印浮点数。False：则科学计数法
np.set_printoptions(suppress=True, linewidth=200)
print(postdata.round(3).flatten()) # 展平后输出# 输出结果：
# [ 1. 2. 3. 4. 5. 6. 7. 800. 9. 10.]
# [ -0.857 -0.667 -0.476 -0.286 -0.095 0.095 0.286 151.333 0.667 0.857]
4. 数据的非线性处理
4.1 标准化StandardScaler
标准化后的数据并非全部在[0,1]之间，数据在空间中的分布服从标准正态分布，大部分数据落在标准差1以内，还有大量的数据分布在1之外。
import numpy as np
from sklearn import datasets
from sklearn import preprocessing# 导入数据集
boston = datasets.load_boston()
scaler = preprocessing.StandardScaler()
# 训练并拟合
postdata = scaler.fit_transform(boston.data)
# 显示图像
df = pd.DataFrame(data = postdata, columns = list(boston.feature_names))
df.plot()
显示标准后后的数据的参考代码：
# StandardScaler缩放
# 1. 定义一个放缩数据的对象
standard_scaler = preprocessing.StandardScaler()# 2. 把该对象绑定到特定的数据集上
standard_scaler.fit(df.values)# 3. 对源数据进行放缩
data = standard_scaler.transform(df.values)# 4. 构建可显示对象
dfscaled = pd.DataFrame(data,columns = list(boston.feature_names))# 5. 显示数据
dfscaled.plot(legend = True)########### 与MinMaxScaler的比较 ###########
# MinMax缩放
# 1. 定义一个放缩数据的对象
minmaxscaler = preprocessing.MinMaxScaler(feature_range = (0,1))# 2. 把该对象绑定到特定的数据集上
minmaxscaler.fit(df.values)# 3. 对源数据进行放缩
data = minmaxscaler.transform(df.values)# 4. 构建可显示对象
dfscaled = pd.DataFrame(data,columns = list(boston.feature_names))# 5. 显示数据
dfscaled.plot(legend = True)
4.2 正则化Normalizer
正则化是把样本数据看成一个向量序列，然后使用一定的规则对序列中的所有样本数据进行缩放，这个规则就是“范数”。“范数”常常被用来度量某个向量空间（或矩阵）中的每个向量的长度或大小的方法。
范数：就是按照某种算法，获得向量的长度值。
1）1范数：把向量分量绝对值的和作为长度，称为1范数
2）2范数：把向量分量绝对值的平方和，再开方，就是2范数
3）p范数：把向量分量绝对值的p次方和，再开p次方，就是p范数
4）无穷范数：当p无穷大时，范数的值接近于绝对值最大的分量
from sklearn import preprocessing# 待转换数据
X = [[ 1., -1., 2.],[ 2., 0., 0.],[ 0., 1., -1.]]# 按照1范数的方式正则化
normalizer = preprocessing.Normalizer(norm = 'l1')
normalizer.fit(X)
normalizer.transform(X)
# 输出:
# array([[ 0.25, -0.25, 0.5 ],
# [ 1. , 0. , 0. ],
# [ 0. , 0.5 , -0.5 ]])# 按照2范数的方式正则化
# 1）方法1：可以使用Normalizer类
normalizer = preprocessing.Normalizer(norm = 'l2')
normalizer.fit(X)
normalizer.transform(X)
# 输出:
# array([[ 0.40824829, -0.40824829, 0.81649658],
# [ 1. , 0. , 0. ],
# [ 0. , 0.70710678, -0.70710678]])# 2）方法2：可以使用Normalizer类
normalizer = preprocessing.Normalizer(norm = 'l2')
normalizer.fit_transform(X)
# 输出:
# array([[ 0.40824829, -0.40824829, 0.81649658],
# [ 1. , 0. , 0. ],
# [ 0. , 0.70710678, -0.70710678]])# 3）方法3：使用normalize函数
preprocessing.normalize(X, norm='l2')
# 输出:
# array([[ 0.40824829, -0.40824829, 0.81649658],
# [ 1. , 0. , 0. ],
# [ 0. , 0.70710678, -0.70710678]])
ps:
- 对于1范数：每一行向量的各个分量的绝对值和为1.
- 对于2范数：每一行向量的各个分量的二范数为1
4.3 多项式升维PolynomialFeatures
在现有的数据的基础之上，通过增加一些现有输入数据对应的非线性特征数据来增加模型的复杂度通常是有效的。一个简单通用的办法是使用多项式特征，这可以获得现有特征的更高次数和互相间关系的项。
比如：[a, b] -> [1, a, b, a^2, ab, b^2]
以下是官方的示例代码：
| >>> 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.]])| >>> poly = PolynomialFeatures(interaction_only=True)| >>> poly.fit_transform(X)| array([[ 1., 0., 1., 0.],| [ 1., 2., 3., 6.],| [ 1., 4., 5., 20.]])
5. 数据的二值化与分段
概述：
- 特征的二值化：把原始数据转换成0和1.
- 特征的分段化：把原始数据转换成多分段
5.1 二值化Binarizer
特征二值化是将数值特征值用阈值过滤，得到布尔值的过程。根据阈值将数据二值化（将特征值设置为0或1），用于处理连续型变量。大于阈值的值映射为1，而小于或等于阈值的值映射为0。默认阈值为0时，特征中所有的正值都映射到1。映射后，所有的数据，变成了0或1
二值化是对文本计数数据的常见操作，分析人员可以决定仅考虑某种现象的存在与否。它还可以用作考虑布尔随机变量的估计器的预处理步骤（例如，使用贝叶斯设置中的伯努利分布建模）。
from sklearn import preprocessing# 随机输入数据（范围是-2~2之间的一个3x3的矩阵）
np.random.seed(42)
X = np.random.randint(-2, 2, 9).reshape(3, 3)
print(X)
# 输出：
# [[ 0 1 -2]
# [ 0 0 1]
# [-2 -2 0]]# 构建二值化对象：threshold可以设置阈值
binarizer = preprocessing.Binarizer(threshold=0)
binarizer.fit(X)
binarizer.transform(X)
# 输出：
# array([[0, 1, 0],
# [0, 0, 1],
# [0, 0, 0]])
5.2 分段KBinsDiscretizer
除了可以进行0和1的二分隔，还可以进行分段，把将连续型变量划分为分类变量的类，能够将连续型变量排序后按顺序分段编码。分段的规则：在最大值和最小值间，按照等分的原则，把所有数据分为指定的等分数。常见与分数段的评级等等情况。
from sklearn import preprocessing# 随机输入数据: 从范围为50~100中随机选择30个数
np.random.seed(42)
X = np.random.randint(50, 100, 30).reshape(-1, 5)
print(X)
# 输出：
# [[88 78 64 92 57]
# [70 88 68 72 60]
# [60 73 85 89 73]
# [52 71 51 73 93]
# [79 87 51 70 82]
# [61 71 93 74 98]]# 构建二值化对象：threshold可以设置阈值
# 这里是为每个特征进行一个自动合适的分段
# 说明：n_bins=5表示设置5个分段，使用整数编码
binarizer = preprocessing.KBinsDiscretizer(n_bins=5, encode='ordinal', strategy='uniform')
binarizer.fit(X)
binarizer.transform(X)
# 输出：
# array([[4., 2., 1., 4., 0.],
# [2., 4., 2., 0., 0.],
# [1., 0., 4., 4., 1.],
# [0., 0., 0., 0., 4.],
# [3., 4., 0., 0., 3.],
# [1., 0., 4., 0., 4.]])
5.3 分段函数pd.cut处理
如果是想要自己定义一个分段的范围，比如50-75评分为D，95-100评分为A的这种情况，无法使用这个函数处理，需要另行处理。可以使用pd.cut来设置分段与每个分段对于的标签值。
- 分段方法1：
# 随机输入数据: 从范围为50~100中随机选择30个数
np.random.seed(42)
X = np.random.randint(50, 100, 30).reshape(-1, 5)
df = pd.DataFrame(data=X, columns=[['math', 'chinese', 'english', 'physics', 'biology']])
print(df.values)
# 输出：
# [[88 78 64 92 57]
# [70 88 68 72 60]
# [60 73 85 89 73]
# [52 71 51 73 93]
# [79 87 51 70 82]
# [61 71 93 74 98]]# 对分数进行一个分段的设置；
# 50-60：E -> 0
# 61-75：D -> 1
# 76-85：C -> 2
# 86-95：B -> 3
# 96-100：A-> 4
df[df > 95] = 4
df[df > 85] = 3
df[df > 75] = 2
df[df > 60] = 1
df[df > 50] = 0
df
表格的输出如下：
- 分段方法2：
import numpy as np
import pandas as pd# 随机输入数据: 从范围为50~100中随机选择30个数
np.random.seed(42)
X = np.random.randint(50, 100, 30).reshape(-1, 5)
df = pd.DataFrame(data=X, columns=[['math', 'chinese', 'english', 'physics', 'biology']])
print(df.values)
# 输出：
# [[88 78 64 92 57]
# [70 88 68 72 60]
# [60 73 85 89 73]
# [52 71 51 73 93]
# [79 87 51 70 82]
# [61 71 93 74 98]]# 对分数进行一个分段的设置；
# 50-60：E -> 0
# 61-75：D -> 1
# 76-85：C -> 2
# 86-95：B -> 3
# 96-100：A-> 4
# 利用cut进行分段处理，其中.codes是将其转化为array的numpy格式
postdata = pd.cut(df.values.reshape(-1), [50, 60, 75, 85, 95, 100], labels=[0, 1, 2, 3, 4]).codes.reshape(-1, 5)
# 构建DataFrame格式输出
pd.DataFrame(data=postdata, columns=df.columns)
labels=[0, 1, 2, 3, 4]格式输出：
labels=[‘E’,‘D’,‘C’,‘B’,‘A’]格式输出：
postdata = pd.cut(df.values.reshape(-1), bins=[50, 60, 75, 85, 95, 100], labels=['E','D','C','B','A']).to_numpy().reshape(-1, 5)
pd.DataFrame(data=postdata, columns=df.columns)
6. 数据的特征编码处理
许多标签和特征在数据收集完毕的时候，都不是以数字来表现的。比如说，学历的取值可以是[“小学”，“初中”，“高中”，“大学”]，付费方式可能包含[“支付宝”，“现金”，“微信”]等等。在这种情况下，为了让数据适应算法和库，我们必须将数据进行编码，即是说，将文字型数据转换为数值型。
通常使用"one-hot"方式编码后会增加数据的维度和稀疏性。个人来说喜欢使用数值行的编码处理。
sklearn支持的方法：
- preprocessing.LabelEncoder：标签专用，能够将分类标签转换为分类数值
- preprocessing.OrdinalEncoder：特征专用，能够将分类特征转换为分类数值
- preprocessing.OneHotEncoder：独热编码
6.1 LabelEncoder编码处理
from sklearn import preprocessing# 构建一个随机的特征数据
feature = ['A', 'B', 'C', 'D']
np.random.seed(42)
index = np.random.randint(0, 4, 10) # 随机输出0-4的随机值最为索引
X = [feature[i] for i in index] # 根据索引构建特征数据
# ['C', 'D', 'A', 'C', 'C', 'D', 'A', 'A', 'C', 'B']
X = np.array(X).reshape(-1, 1)
# 输出：
# array([['C'],
# ['D'],
# ['A'],
# ['C'],
# ['C'],
# ['D'],
# ['A'],
# ['A'],
# ['C'],
# ['B']], dtype='<U1')# 构建编码器
encoder = preprocessing.LabelEncoder()
encoder.fit_transform(X)
# 输出： array([2, 3, 0, 2, 2, 3, 0, 0, 2, 1])# 对应关系如下所示：
# ['C', 'D', 'A', 'C', 'C', 'D', 'A', 'A', 'C', 'B']
# [2, 3, 0, 2, 2, 3, 0, 0, 2, 1]# 根据隐射关系构建键值对与反键值对
mapping = {key: index for index, key in enumerate(encoder.classes_)}
rmapping = {index: key for index, key in enumerate(encoder.classes_)}
print("mapping", mapping)
print("rmapping", rmapping)
# 输出：
# mapping {'A': 0, 'B': 1, 'C': 2, 'D': 3}
# rmapping {0: 'A', 1: 'B', 2: 'C', 3: 'D'}
6.2 OrdinalEncoder编码处理
from sklearn import preprocessing# 构建一个随机的特征数据
feature = ['A', 'B', 'C', 'D']
np.random.seed(42)
index = np.random.randint(0, 4, 20) # 随机输出0-4的随机值最为索引
X = [feature[i] for i in index] # 根据索引构建特征数据
X = np.array(X).reshape(-1, 4)
print(X)
# 输出：
# [['C' 'D' 'A' 'C']
# ['C' 'D' 'A' 'A']
# ['C' 'B' 'C' 'C']
# ['C' 'C' 'D' 'A']
# ['D' 'D' 'D' 'C']]# 把每一行当作一个样本，每一列当作一个特征
# 第1列：2个特征值：C,D， 0,1
# 第2列：3个特征值：B,C,D， 0,1,2
# 第3列：3个特征值：A,C,D， 0,1,2
# 第4列：2个特征值：A,C， 0,1# 构建编码器
encoder = preprocessing.OrdinalEncoder()
encoder.fit_transform(X)
# 编码结果：
# array([[0., 2., 0., 1.],
# [0., 2., 0., 0.],
# [0., 0., 1., 1.],
# [0., 1., 2., 0.],
# [1., 2., 2., 1.]])# 映射关系
encoder.categories_
# 输出：
# [array(['C', 'D'], dtype='<U1'),
# array(['B', 'C', 'D'], dtype='<U1'),
# array(['A', 'C', 'D'], dtype='<U1'),
# array(['A', 'C'], dtype='<U1')]# 对每个特征一一构建起数值的编码对于关系
feature_mapping = {} # 存储最后结构的字典
for index, encoding in enumerate(encoder.categories_):# 获取每个特征的编码关系mapping = {key: index for index, key in enumerate(encoding)}feature_name = "feature" + str(index)feature_mapping[feature_name] = mapping
feature_mapping
# 输出：
# {'feature0': {'C': 0, 'D': 1},
# 'feature1': {'B': 0, 'C': 1, 'D': 2},
# 'feature2': {'A': 0, 'C': 1, 'D': 2},
# 'feature3': {'A': 0, 'C': 1}}
6.3 OneHotEncoder 编码处理
from sklearn import preprocessing# 构建一个随机的特征数据
feature = ['A', 'B', 'C']
np.random.seed(42)
index = np.random.randint(0, 3, 8) # 随机输出0-4的随机值最为索引
X = [feature[i] for i in index] # 根据索引构建特征数据
X = np.array(X).reshape(-1, 2)
print(X)
# 输出：
# [['C' 'A']
# ['C' 'C']
# ['A' 'A']
# ['C' 'B']]#把每一行当作一个样本，每一列当作一个特征
#第1列：2个特征值：A，C
#第2列：3个特征值：A， B， C# 构建编码器
encoder = preprocessing.OneHotEncoder()
# .toarray()将将稀疏矩阵转化为普通矩阵
encoder.fit_transform(X).toarray()
# 输出：
# array([[0., 1., 1., 0., 0.],
# [0., 1., 0., 0., 1.],
# [1., 0., 1., 0., 0.],
# [0., 1., 0., 1., 0.]])# 映射关系
encoder.categories_
# 输出：[array(['A', 'C'], dtype='<U1'), array(['A', 'B', 'C'], dtype='<U1')]
参考资料：
1. Pandas：按范围对列值进行分类
2. 专栏：机器学习与scikit-learn
Scikit-learn学习系列 | 2. sklearn数据预处理的相关方法相关推荐
- Caffe学习系列(13)：数据可视化环境（python接口)配置
原文有更新: Caffe学习系列(13):数据可视化环境(python接口)配置 - denny402 - 博客园 http://www.cnblogs.com/denny402/p/5088399. ...
- 机器学习与Scikit Learn学习库
摘要: 本文介绍机器学习相关的学习库Scikit Learn,包含其安装及具体识别手写体数字案例,适合机器学习初学者入门Scikit Learn. 在我科研的时候,机器学习(ML)是计算机科学领域中最 ...
- sklearn数据预处理－scale
对数据按列属性进行scale处理后,每列的数据均值变成0,标准差变为1.可通过下面的例子加深理解: from sklearn import preprocessing import numpy as ...
- sklearn数据预处理
@Author : By Runsen 文章目录 预处理数据 映射到统一分布 标准化,或平均删除和方差缩放 数据的正则化(正则化有时也叫归一化) 特征的二值化 怎么设置阈值 分类特征编码 有丢失的分类 ...
- Scikit-learn学习系列 | 1. sklearn的简要使用介绍与数据集获取
如有错误,恳请指出. 以下内容整理自专栏:博主"文火冰糖的硅基工坊"的专栏--机器学习与scikit-learn,对部分的文章的简化与整理. 文章目录 1. scikit-lear ...
- Sklearn 数据预处理与特征工程 preprocessingimpute
数据预处理:目的是为了提高数据质量,使数据挖掘的过程更加有效,更加容易,同时也提高挖掘结果的质量.数据预处理的对象主要是清理其中的噪声数据.空缺数据和不一致数据. 特征工程:降低计算成本.提升模型上限 ...
- Caffe学习系列(2)：数据层及参数
要运行caffe,需要先创建一个模型(model),如比较常用的Lenet,Alex等, 而一个模型由多个屋(layer)构成,每一屋又由许多参数组成.所有的参数都定义在caffe.proto这个文件 ...
- [机器学习-sklearn]数据预处理要点总结
数据预处理要点总结 1. 为什么要数据预处理 2. 数据中存在缺失值 2.1 查看数据的完整性(missingno) 2.2 简单删除法 2.3 人工填写(filling manually) 2.4 ...
- R语言学习（三）— 数据预处理
第四章-数据预处理 4.1数据清洗 1.缺失值处理 2.异常值处理 4.2数据集成 1.实体识别 2.冗余属性识别 4.3 数据变换 1.简单函数变换 2.规范化 3.连续属性离散化 4.属性构造 4 ...
最新文章
- workerman的基本用法
- （转载）大数据实战：站在JMP分析平台上的FIT足迹识别技术
- 函数atof,atoi，atol，strtod，strtol，strtoul 描述
- 【手写系列】理解数据库连接池底层原理之手写实现
- Android逆向工程 初篇
- 自我分析colly的robots源码
- excel表格中添加combobox_excel高阶打印技巧：批量为表格添加logo，学会它老板都夸你厉害...
- 1.通俗解释分布式系统
- php recordarray,php5.5新数组函数array-column使用实例
- sprk sql自定义UDF函数
- MyBatis 基础知识
- 在线卡密销售系统之JAVA WEB学习之路
- php开发的在线客服系统，全开源无加密，支持微信客服对接
- TI毫米波雷达开发中软件版本的说明
- 解析android多语言与自定义字体
- CUDA软件架构—网格（Grid）、线程块（Block）和线程（Thread）的组织关系以及线程索引的计算公式
- 2023年全国最新二级建造师精选真题及答案
- 曲率发动机和反重力装置原理
- （转载）毕业论文反侦测抄袭的攻略（精简浓缩版）
- 北京汽车转型背后：“大北汽”棋局中的变与不变