机器学习之离散值处理

前面我们学习了分类决策树，下面我们以周志华的机器学习书上的西瓜数据作为训练集练习以下，数据集如下。

X = [
    ['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑'],
    ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑'],
    ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑'],
    ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑'],
    ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑'],
    ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘'],
    ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘'],
    ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑'],
    ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑'],
    ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘'],
    ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑'],
    ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘'],
    ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑'],
    ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑'],
    ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘'],
    ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑'],
    ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑']
]
Y = ['是', '是', '是', '是', '是', '是', '是', '是', '否', '否', '否', '否', '否', '否', '否', '否', '否']

如果你直接将这个数据集传入决策树，则会运行出错，错误信息如下。

ValueError: could not convert string to float: '青绿'

为什么会出现这样的错误呢？这是因为决策树在训练中，会把数据转换为np.float32类型，但你的输入数据是string类型，还是中文，无法进行转换，所以出错。在sklearn中提供了独热编码（One-Hot Encoding）来解决这样的问题。

下面我们来了解下什么是独热编码，它又是如何将离散的数据进行编码的。独热编码就是用M个寄存器来标识M个状态，每一个状态对应指定的寄存器。下面举个例子。

比如人的性别属性可以取值为{"male","female"，"others"}，即人的性别有三种状态，我们可以使用三个寄存器来唯一标识。比如"male"可以编码100，"female"编码为010，"others"编码为001。再比如人的肤色属性可以取值为{"yellow","white","black"}，则"yellow"编码为100，"white"编码为010，"black"编码为001。

对于有多个属性怎么编码呢？就是将每个属性的单独编码拼接起来就可以。比如有个人的性别为"male"，肤色为"black"，则他的编码为100001。

了解了独热编码是怎么编码的，我们就想直接把西瓜数据集进行独热编码，但很抱歉还是会出错。为什么呢，查看One-Hot Encoding的使用方法后发现输入数据只能是int类型。什么意思呢，下面举个例子。

还是以人的性别属性可以取值为{"male","female"，"others"}为例，我们不能直接传入One-Hot Encoding，而是先将{"male","female"，"others"}标识为{0,1,2}再传入One-Hot Encoding中，这样就得到了独热编码。这里可能有的人就问了：“为什么不直接把{0,1,2}作为编码直接传入决策树，这是因为如果直接传入，决策树是把它当作连续值处理的，也就认为属性的值是有序的，但我们知道性别是离散属性，属性值是无序的。

from sklearn import preprocessing
enc = preprocessing.OneHotEncoder()
print(enc.fit_transform([[0],[1],[2]]).toarray())

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

所以我们第一步要做的就是先将属性用数字标识，好在sklearn提供了LabelBinarizer类。比如西瓜数据集的第一列属性会被标识成[2 0 0 2 1 2 0 0 0 2 1 1 2 1 0 1 2]。将西瓜数据集的所有属性利用LabelBinarizer类标识的代码如下。

Xdf = pd.DataFrame(X)
le = preprocessing.LabelEncoder()
for col in Xdf.columns:
    f = le.fit_transform(Xdf[col])
    Xdf[col] = f
print(Xdf)

    0  1  2  3  4  5
0   2  2  1  1  0  0
1   0  2  0  1  0  0
2   0  2  1  1  0  0
3   2  2  0  1  0  0
4   1  2  1  1  0  0
5   2  1  1  1  2  1
6   0  1  1  2  2  1
7   0  1  1  1  2  0
8   0  1  0  2  2  0
9   2  0  2  1  1  1
10  1  0  2  0  1  0
11  1  2  1  0  1  1
12  2  1  1  2  0  0
13  1  1  0  2  0  0
14  0  1  1  1  2  1
15  1  2  1  0  1  0
16  2  2  0  2  2  0

再将标识好的数据集One-Hot Encoding进行独热编码。代码如下。

enc = preprocessing.OneHotEncoder()
Xdf_enc = enc.fit_transform(Xdf).toarray()
print(Xdf_enc)

[[0. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0.]
 [1. 0. 0. 0. 0. 1. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0.]
 [1. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0.]
 [0. 0. 1. 0. 0. 1. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0.]
 [0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0.]
 [0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1.]
 [1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 1.]
 [1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0.]
 [1. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0. 1. 0. 0. 1. 1. 0.]
 [0. 0. 1. 1. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 1.]
 [0. 1. 0. 1. 0. 0. 0. 0. 1. 1. 0. 0. 0. 1. 0. 1. 0.]
 [0. 1. 0. 0. 0. 1. 0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1.]
 [0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 1. 0.]
 [0. 1. 0. 0. 1. 0. 1. 0. 0. 0. 0. 1. 1. 0. 0. 1. 0.]
 [1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1.]
 [0. 1. 0. 0. 0. 1. 0. 1. 0. 1. 0. 0. 0. 1. 0. 1. 0.]
 [0. 0. 1. 0. 0. 1. 1. 0. 0. 0. 0. 1. 0. 0. 1. 1. 0.]]

最后就可以传入决策树进行训练了，代码如下。

clf = tree.DecisionTreeClassifier()
clf.fit(Xdf_enc,Y)

这样决策树就构建了，如果你要对一个数据样本进行预测，你就要先对这个样本进行LabelBinarizer和独热编码了，再传入决策树进行预测。我们在原始数据集进行预测。

print(clf.predict(Xdf_enc))

['是' '是' '是' '是' '是' '是' '是' '是' '否' '否' '否' '否' '否' '否' '否' '否' '否']

到此，我们就知道了离散属性如何处理了。