要离散分类功能,我正在使用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,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.
答案 0 :(得分:6)
一个热编码意味着您创建一个和零的向量。所以顺序无关紧要。
在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
正如您在映射期间所看到的,为每个分类要素创建了一个向量。向量的元素在分类特征的位置处是一个元素,在其他位置处是零。以下是该系列中只有两个分类要素的示例:
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',''' c']等分类数据编码为整数[1,2,3](例如使用LableEncoder),除了编码您的分类数据外,您还可以给它们一些权重,如1< 2<这种编码方式适用于像RandomForest这样的机器学习技术。但是许多机器学习技术会假设在这种情况下' a' < ' B' < ' C'如果你分别用1,2,3编码它们。为避免此问题,您可以为数据中的每个唯一分类变量创建一列。换句话说,您为每个分类变量创建了一个新功能(这里有一列用于'一个用于' b'一个用于' c')。如果变量位于该索引中,则这些新列中的值设置为1,而其他位置则设置为零。
对于示例中的数组,一个热编码器将是:
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 vector设置为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'因为它是数组的最后一个元素(index = 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
完全一样!