并非所有类别都存在时的虚拟变量

Question

我有一组数据框，其中一个列包含一个分类变量。我想将其转换为几个虚拟变量，在这种情况下，我通常会使用get_dummies。

发生的情况是get_dummies 查看每个数据帧中可用的数据以找出有多少类别，从而创建适当数量的虚拟变量。但是，在我现在正在处理的问题中，我实际上提前知道可能的类别是什么。但是，当单独查看每个数据框时，不一定会出现所有类别。

我的问题是：有没有办法将类别的名称传递给get_dummies（或等效函数），这样，对于未出现在给定数据框中的类别，它只会创建一列 0？

可以做到这一点的东西：

categories = ['a', 'b', 'c']

   cat
1   a
2   b
3   a

变成这样：

  cat_a  cat_b  cat_c
1   1      0      0
2   0      1      0
3   1      0      0

Answer 1

TL;DR：

pd.get_dummies(cat.astype(pd.CategoricalDtype(categories=categories)))

• 大熊猫：pd.get_dummies(cat.astype('category', categories=categories))

有没有办法将类别的名称传递给 get_dummies（或等效函数），这样，对于未出现在给定数据框中的类别，它只会创建一列 0？

是的，有！ Pandas 有一个特殊类型的 Series 仅用于 categorical data。本系列的属性之一是get_dummies 考虑的可能类别。这是一个例子：

In [1]: import pandas as pd

In [2]: possible_categories = list('abc')

In [3]: cat = pd.Series(list('aba'))

In [4]: cat = cat.astype(pd.CategoricalDtype(categories=possible_categories))

In [5]: cat
Out[5]: 
0    a
1    b
2    a
dtype: category
Categories (3, object): [a, b, c]

那么，get_dummies 会做你想做的事！

In [6]: pd.get_dummies(cat)
Out[6]: 
   a  b  c
0  1  0  0
1  0  1  0
2  1  0  0

还有很多其他方法可以创建分类Series 或DataFrame，这只是我觉得最方便的一种。您可以在the pandas documentation 阅读所有这些内容。

编辑：

我没有遵循确切的版本控制，但至少在 0.17.0 版之前，pandas 如何处理稀疏矩阵有一个bug。版本 0.18.1（2016 年 5 月发布）已对其进行了更正。

对于 0.17.0 版，如果您尝试使用带有 DataFrame 的 sparse=True 选项执行此操作，则缺少的虚拟变量的零列将是 NaN 列，并且它将被转换到稠密。

看起来 pandas 0.21.0 添加了一个CategoricalDType，并且创建明确包含原始答案中的类别的分类已被弃用，我不太确定何时。

Answer 2

使用转置和重新索引

import pandas as pd

cats = ['a', 'b', 'c']
df = pd.DataFrame({'cat': ['a', 'b', 'a']})

dummies = pd.get_dummies(df, prefix='', prefix_sep='')
dummies = dummies.T.reindex(cats).T.fillna(0)

print dummies

    a    b    c
0  1.0  0.0  0.0
1  0.0  1.0  0.0
2  1.0  0.0  0.0

Answer 3

试试这个：

In[1]: import pandas as pd
       cats = ["a", "b", "c"]

In[2]: df = pd.DataFrame({"cat": ["a", "b", "a"]})

In[3]: pd.concat((pd.get_dummies(df.cat, columns=cats), pd.DataFrame(columns=cats))).fillna(0)
Out[3]: 
     a    b    c
0  1.0  0.0  0
1  0.0  1.0  0
2  1.0  0.0  0

Answer 4

我确实在 pandas github 上问过这个问题。事实证明，当您将列定义为 Categorical 并在其中定义所有可能的类别时，很容易绕过它。

df['col'] = pd.Categorical(df['col'], categories=['a', 'b', 'c', 'd'])

get_dummies() 将按预期完成剩下的工作。

Answer 5

我不认为get_dummies 提供了开箱即用的功能，它只允许创建一个额外的column 来突出NaN 值。

要自己添加缺少的columns，您可以使用pd.concat 和axis=0 垂直“堆叠”DataFrames（虚拟列加上DataFrameid）并自动创建任何缺少的列，用fillna(0)替换缺失值，再用.groupby('id')分隔各个DataFrame。

Answer 6

在测试集中添加缺失的类别：

# Get missing columns in the training test
missing_cols = set( train.columns ) - set( test.columns )
# Add a missing column in test set with default value equal to 0
for c in missing_cols:
    test[c] = 0
# Ensure the order of column in the test set is in the same order than in train set
test = test[train.columns]

请注意，此代码还删除了测试数据集中类别产生的列，但训练数据集中不存在

Answer 7

根据其他人的建议 - 将您的分类特征转换为“类别”数据类型应该可以使用“get_dummies”解决看不见的标签问题。

# Your Data frame(df)
from sklearn.model_selection import train_test_split
X = df.loc[:,df.columns !='label']
Y = df.loc[:,df.columns =='label']

# Split the data into 70% training and 30% test
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3) 

# Convert Categorical Columns in your data frame to type 'category'
for col in df.select_dtypes(include=[np.object]).columns:
    X_train[col] = X_train[col].astype('category', categories = df[col].unique())
    X_test[col] = X_test[col].astype('category', categories = df[col].unique())

# Now, use get_dummies on training, test data and we will get same set of columns
X_train = pd.get_dummies(X_train,columns = ["Categorical_Columns"])
X_test = pd.get_dummies(X_test,columns = ["Categorical_Columns"])

Answer 8

越短越好：

import pandas as pd

cats = pd.Index(['a', 'b', 'c'])
df = pd.DataFrame({'cat': ['a', 'b', 'a']})

pd.get_dummies(df, prefix='', prefix_sep='').reindex(columns = cats, fill_value=0)

结果：

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

注意事项：

• cats 需要是熊猫索引
• 需要设置prefix='' 和prefix_sep='' 才能使用您首先定义的猫类别。否则，get_dummies 将转换为：cats_a、cats_b 和 cats_c)。对我来说这更好，因为它是明确的。
• 使用fill_value=0 将NaN 从列c 转换。或者，您可以在句末使用fillna(0)。 （我不知道哪个更快）。

这是一个更短的版本（更改了索引值）：

import pandas as pd

cats = pd.Index(['cat_a', 'cat_b', 'cat_c'])
df = pd.DataFrame({'cat': ['a', 'b', 'a']})

pd.get_dummies(df).reindex(columns = cats, fill_value=0)

结果：

    cat_a   cat_b   cat_c
0   1         0     0
1   0         1     0
2   1         0     0

奖励曲目！

我想您之所以拥有这些类别，是因为您之前使用训练数据做了一个虚拟/热门。您可以保存原始编码（.columns），然后在生产期间应用：

cats = pd.Index(['cat_a', 'cat_b', 'cat_c']) # it might come from the original onehot encoding (df_ohe.columns)

import pickle

with open('cats.pickle', 'wb') as handle:
    pickle.dump(cats, handle, protocol=pickle.HIGHEST_PROTOCOL)


with open('cats.pickle', 'rb') as handle:
    saved_cats = pickle.load(handle)



df = pd.DataFrame({'cat': ['a', 'b', 'a']})

pd.get_dummies(df).reindex(columns = saved_cats, fill_value=0)

结果：

    cat_a   cat_b   cat_c
0   1         0     0
1   0         1     0
2   1         0     0

Answer 9

如果您知道您的类别，您可以按照您的建议先申请pd.get_dummies()，然后添加缺少的类别列。

这将使用缺少的cat_c 创建您的示例：

import pandas as pd

categories = ['a', 'b', 'c']
df = pd.DataFrame(list('aba'), columns=['cat'])
df = pd.get_dummies(df)

print(df)

   cat_a  cat_b
0      1      0
1      0      1
2      1      0

现在只需使用联合操作添加缺少的类别列（如suggested here）。

possible_categories = ['cat_' + cat for cat in categories]

df = df.reindex(df.columns.union(possible_categories, sort=False), axis=1, fill_value=0)

print(df)

   cat_a  cat_b  cat_c
0      1      0      0
1      0      1      0
2      1      0      0

Answer 10

我最近想解决同样的问题，但使用的是多列数据框和两个数据集（用于机器学习任务的训练集和测试集）。测试数据帧与训练数据帧具有相同的分类列，但其中一些列缺少训练数据帧中存在的类别。

我不想为每一列手动定义所有可能的类别。相反，我将训练和测试数据帧合并为一个，称为 get_dummies，然后将其拆分回两个。

# train_cat, test_cat are dataframes instantiated elsewhere

train_test_cat = pd.concat([train_cat, test_cat]
tran_test_cat = pd.get_dummies(train_test_cat, axis=0))

train_cat = train_test_cat.iloc[:train_cat.shape[0], :]
test_cat = train_test_cat.iloc[train_cat.shape[0]:, :]