2

为了离散化分类特征,我使用了 LabelEncoder 和 OneHotEncoder。我知道 LabelEncoder 按字母顺序映射数据,但是 OneHotEncoder 是如何映射数据的呢?

我有一个 pandas 数据框,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,5dataFeatY.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.
4

1 回答 1

8

一种热编码意味着您创建一和零的向量。所以顺序无关紧要。在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  

这是完全一样的!

于 2016-08-17T05:09:00.460 回答