并非所有类别都存在时的虚拟变量
Dummy variables when not all categories are present
我有一组数据框，其中一列包含一个分类变量。我想将它转换为几个虚拟变量，在这种情况下我通常会使用 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
我不认为 get_dummies 提供了开箱即用的功能，它只允许创建一个额外的 column 来突出显示 NaN 值。
要自己添加缺失的 columns，您可以沿 axis=0 使用 pd.concat 垂直 'stack' DataFrames（虚拟列加上 DataFrame id) 并自动创建任何缺失的列，使用 fillna(0) 替换缺失值，然后使用 .groupby('id') 再次分隔各个 DataFrame。
试试这个：
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
使用转置和重新索引
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
TL;DR:
pd.get_dummies(cat.astype(pd.CategoricalDtype(categories=categories)))
- 年长 pandas：
pd.get_dummies(cat.astype('category', categories=categories))
is there a way to pass to get_dummies (or an equivalent function) the names of the categories, so that, for the categories that don't appear in a given dataframe, it'd just create a column of 0s?
是的，有！ 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.
中阅读所有这些内容
编辑：
我没有遵循确切的版本控制，但是在 pandas 如何处理稀疏矩阵方面有一个 bug，至少在版本 0.17.0 之前是这样。它已在 0.18.1 版（2016 年 5 月发布）中得到纠正。
对于版本 0.17.0，如果您尝试使用带有 DataFrame 的 sparse=True 选项来执行此操作，则缺少的虚拟变量的零列将是 NaN, 会转成dense.
看起来 pandas 0.21.0 添加了一个 CategoricalDType，并且创建明确包含原始答案中的类别的分类已被弃用，我不太确定何时。
在测试集中添加缺失的类别：
# 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]
请注意，此代码还会删除由测试数据集中的类别产生但不存在于训练数据集中的列
我确实在 pandas github 上问过这个问题。事实证明，当您将列定义为 Categorical 并在其中定义所有可能的类别时，绕过它真的很容易。
df['col'] = pd.Categorical(df['col'], categories=['a', 'b', 'c', 'd'])
get_dummies() 将按预期完成剩下的工作。
正如其他人所建议的那样 - 将您的分类特征转换为 'category' 数据类型应该可以使用“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"])
越短越好：
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 需要成为 pandas 索引 prefix='' 和 prefix_sep='' 才能使用您首先定义的猫类别。否则，get_dummies 转换为：cats_a、cats_b 和 cats_c)。对我来说这更好，因为它是明确的。 - 使用 fill_value=0 从列
c 转换 NaN。或者，您可以在句子末尾使用 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
奖金曲目！
我想你有这些类别，因为你以前 dummy/one 热使用训练数据。您可以保存原始编码（.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
我最近想解决同样的问题，但使用的是多列数据框和两个数据集（用于机器学习任务的训练集和测试集）。测试数据帧具有与训练数据帧相同的分类列，但其中一些列缺少训练数据帧中存在的类别。
我不想为每一列手动定义所有可能的类别。相反，我将训练和测试数据帧合并为一个，称为 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]:, :]
如果您知道自己的类别，可以先按照您的建议应用 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
现在只需使用联合操作添加缺失的类别列（如）。
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
我有一组数据框，其中一列包含一个分类变量。我想将它转换为几个虚拟变量，在这种情况下我通常会使用 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
我不认为 get_dummies 提供了开箱即用的功能，它只允许创建一个额外的 column 来突出显示 NaN 值。
要自己添加缺失的 columns，您可以沿 axis=0 使用 pd.concat 垂直 'stack' DataFrames（虚拟列加上 DataFrame id) 并自动创建任何缺失的列，使用 fillna(0) 替换缺失值，然后使用 .groupby('id') 再次分隔各个 DataFrame。
试试这个：
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
使用转置和重新索引
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
TL;DR:
pd.get_dummies(cat.astype(pd.CategoricalDtype(categories=categories)))
- 年长 pandas：
pd.get_dummies(cat.astype('category', categories=categories))
is there a way to pass to get_dummies (or an equivalent function) the names of the categories, so that, for the categories that don't appear in a given dataframe, it'd just create a column of 0s?
是的，有！ 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.
编辑：
我没有遵循确切的版本控制，但是在 pandas 如何处理稀疏矩阵方面有一个 bug，至少在版本 0.17.0 之前是这样。它已在 0.18.1 版（2016 年 5 月发布）中得到纠正。
对于版本 0.17.0，如果您尝试使用带有 DataFrame 的 sparse=True 选项来执行此操作，则缺少的虚拟变量的零列将是 NaN, 会转成dense.
看起来 pandas 0.21.0 添加了一个 CategoricalDType，并且创建明确包含原始答案中的类别的分类已被弃用，我不太确定何时。
在测试集中添加缺失的类别：
# 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]
请注意，此代码还会删除由测试数据集中的类别产生但不存在于训练数据集中的列
我确实在 pandas github 上问过这个问题。事实证明，当您将列定义为 Categorical 并在其中定义所有可能的类别时，绕过它真的很容易。
df['col'] = pd.Categorical(df['col'], categories=['a', 'b', 'c', 'd'])
get_dummies() 将按预期完成剩下的工作。
正如其他人所建议的那样 - 将您的分类特征转换为 'category' 数据类型应该可以使用“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"])
越短越好：
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需要成为 pandas 索引
需要设置 prefix=''和prefix_sep=''才能使用您首先定义的猫类别。否则，get_dummies转换为：cats_a、cats_b和cats_c)。对我来说这更好，因为它是明确的。- 使用 fill_value=0 从列
c转换NaN。或者，您可以在句子末尾使用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
奖金曲目！
我想你有这些类别，因为你以前 dummy/one 热使用训练数据。您可以保存原始编码（.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
我最近想解决同样的问题，但使用的是多列数据框和两个数据集（用于机器学习任务的训练集和测试集）。测试数据帧具有与训练数据帧相同的分类列，但其中一些列缺少训练数据帧中存在的类别。
我不想为每一列手动定义所有可能的类别。相反，我将训练和测试数据帧合并为一个，称为 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]:, :]
如果您知道自己的类别，可以先按照您的建议应用 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
现在只需使用联合操作添加缺失的类别列（如
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