独热编码映射

Question

独热编码映射

3

为了将分类特征数字化，我使用了LabelEncoder和OneHotEncoder。我知道LabelEncoder按字母表顺序映射数据，但是OneHotEncoder如何映射数据呢？

我有一个pandas dataframe，dataFeat具有5个不同的列和4个可能的标签，就像上面一样。 dataFeat = data[['Feat1', 'Feat2', 'Feat3', 'Feat4', 'Feat5']]

Feat1  Feat2  Feat3  Feat4  Feat5
  A      B      A      A      A
  B      B      C      C      C
  D      D      A       A     B
  C      C      A       A     A

我会像这样使用labelencoder，

le = preprocessing.LabelEncoder()

intIndexed = dataFeat.apply(le.fit_transform)

这是LabelEncoder对标签进行编码的方式。

Label   LabelEncoded
 A         0
 B         1
 C         2
 D         3

我接着像这样应用 OneHotEncoder

enc = OneHotEncoder(sparse = False)

encModel = enc.fit(intIndexed)

dataFeatY = encModel.transform(intIndexed)

intIndexed.shape = 94,5 和 dataFeatY.shape=94,20。

我对dataFeatY的形状有点困惑 - 它不应该也是95,5吗？

按照下面MhFarahani的回答，我已经这样做了，以查看标签是如何映射的。

import numpy as np

S = np.array(['A', 'B','C','D'])
le = LabelEncoder()
S = le.fit_transform(S)
print(S)

[0 1 2 3]

ohe = OneHotEncoder()
one_hot = ohe.fit_transform(S.reshape(-1,1)).toarray()
print(one_hot.T)

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

这是否意味着标签是像这样映射的，还是每个列都不同？（这可能解释了94,20的形状）

Label   LabelEncoded    OneHotEncoded
 A         0               1.  0.  0.  0
 B         1               0.  1.  0.  0.
 C         2               0.  0.  1.  0.
 D         3               0.  0.  0.  1.

- gbhrea

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- MhFarahani · Accepted Answer

独热编码意味着您创建由一和零构成的向量。因此，顺序并不重要。在sklearn中，首先需要将分类数据编码为数字数据，然后将它们馈送给OneHotEncoder。例如：

from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder

S = np.array(['b','a','c'])
le = LabelEncoder()
S = le.fit_transform(S)
print(S)
ohe = OneHotEncoder()
one_hot = ohe.fit_transform(S.reshape(-1,1)).toarray()
print(one_hot)

这将导致：

[1 0 2]

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

但是，pandas 可以直接转换分类数据：

import pandas as pd
S = pd.Series( {'A': ['b', 'a', 'c']})
print(S)
one_hot = pd.get_dummies(S['A'])
print(one_hot)

输出结果为：

A    [b, a, c]
dtype: object

   a  b  c
0  0  1  0
1  1  0  0
2  0  0  1

从映射结果可以看出，对于每个分类特征都会创建一个向量。向量的元素在分类特征的位置上为1，在其他位置上为0。以下是一个示例，当系列中只有两个分类特征时：

S = pd.Series( {'A': ['a', 'a', 'c']})
print(S)
one_hot = pd.get_dummies(S['A'])
print(one_hot)

导致结果如下：

A    [a, a, c]
dtype: object

   a  c
0  1  0
1  1  0
2  0  1

回答新问题的编辑

让我们从这个问题开始：为什么要进行一次热编码？如果你将类别数据如 ['a'，'b'，'c'] 编码为整数 [1,2,3]（例如使用 LableEncoder），除了编码分类数据外，还会给它们赋予一些权重，如 1 < 2 < 3。这种编码方式对于某些机器学习技术（如 RandomForest）是可以的。但许多机器学习技术会假设在这种情况下，如果你用 1、2、3 对它们进行编码，则 'a' < 'b' < 'c'。为了避免这个问题，你可以为数据中每个唯一的分类变量创建一列。换句话说，你为每个分类变量创建一个新特征（这里为 'a'、'b' 和 'c' 分别创建一列）。这些新列中的值在该索引处设置为一，其他位置为零。

对于你的示例数组，热编码器将是：

features ->  A   B   C   D 

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

您有4个分类变量“A”，“B”，“C”，“D”。因此，OneHotEncoder将填充您的（4，）数组以使其变为（4，4），以便为每个分类变量（即您的新特征）创建一个向量（或列）。由于“A”是您数组的0元素，因此第一列的索引0设置为1，其余设置为0。类似地，第二个向量（列）属于特征“B”，并且由于“B”在您的数组的索引1中，因此“B”向量的索引1设置为1，其余设置为零。对于其他功能也是如此。

让我更改您的数组。也许这可以帮助您更好地理解标签编码器的工作原理：

S = np.array(['D', 'B','C','A'])
S = le.fit_transform(S)
enc = OneHotEncoder()
encModel = enc.fit_transform(S.reshape(-1,1)).toarray()
print(encModel)

现在的结果如下。这里的第一列是'A'，由于它是你的数组的最后一个元素（索引=3），因此第一列的最后一个元素将是1。

features ->  A   B   C   D
          [[ 0.  0.  0.  1.]
           [ 0.  1.  0.  0.]
           [ 0.  0.  1.  0.]
           [ 1.  0.  0.  0.]]

关于您的pandas数据框，dataFeat，您在关于LableEncoder如何工作的第一步上就错了。当您应用LableEncoder时，它会逐列拟合并编码; 然后，它进入下一列并对该列进行新的拟合。这是您应该得到的结果：

from sklearn.preprocessing import LabelEncoder
df =  pd.DataFrame({'Feat1': ['A','B','D','C'],'Feat2':['B','B','D','C'],'Feat3':['A','C','A','A'],
                    'Feat4':['A','C','A','A'],'Feat5':['A','C','B','A']})
print('my data frame:')
print(df)

le = LabelEncoder()
intIndexed = df.apply(le.fit_transform)
print('Encoded data frame')
print(intIndexed)

结果：

my data frame:
  Feat1 Feat2 Feat3 Feat4 Feat5
0     A     B     A     A     A
1     B     B     C     C     C
2     D     D     A     A     B
3     C     C     A     A     A

Encoded data frame
   Feat1  Feat2  Feat3  Feat4  Feat5
0      0      0      0      0      0
1      1      0      1      1      2
2      3      2      0      0      1
3      2      1      0      0      0

请注意，在第一列Feat1中，'A'被编码为0，但在第二列Feat2中，'B'元素为0。这是因为LableEncoder逐列拟合并单独转换每列。请注意，在您的第二列中，('B'、'C'、'D')中的变量'B'按字母顺序优先。

最后，以下是使用sklearn所需的内容:

from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder()
label_encoder = LabelEncoder()
data_lable_encoded = df.apply(label_encoder.fit_transform).as_matrix()
data_feature_onehot = encoder.fit_transform(data_lable_encoded).toarray()
print(data_feature_onehot)

这将给你：

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

如果您使用 pandas，您可以比较结果，并希望这能让您更加直观：

encoded = pd.get_dummies(df)
print(encoded)

结果：

     Feat1_A  Feat1_B  Feat1_C  Feat1_D  Feat2_B  Feat2_C  Feat2_D  Feat3_A  \
0        1        0        0        0        1        0        0        1   
1        0        1        0        0        1        0        0        0   
2        0        0        0        1        0        0        1        1   
3        0        0        1        0        0        1        0        1   

     Feat3_C  Feat4_A  Feat4_C  Feat5_A  Feat5_B  Feat5_C  
0        0        1        0        1        0        0  
1        1        0        1        0        0        1  
2        0        1        0        0        1        0  
3        0        1        0        1        0        0

这完全相同！