如何使用 LabelBinarizer 对正确的训练和测试进行一次热编码

Posted 2023-03-12

【中文标题】如何使用 LabelBinarizer 对正确的训练和测试进行一次热编码

【英文标题】：How to use LabelBinarizer to one hot encode both train and test correctly

【发布时间】：2020-04-28 12:03:16

【问题描述】：

假设我有这样的火车：

Name   | day
------------
First  |  0
Second |  1
Third  |  1
Forth  |  2

还有一个不包含所有这些名称或日期的测试集。像这样：

Name   | day
------------
First  |  2
Second |  1
Forth  |  0

我有以下代码来转换编码特征中的这些列：

features_to_encode = ['Name', 'day']
label_final = pd.DataFrame()

for feature in features_to_encode:
    label_campaign = LabelBinarizer()
    label_results = label_campaign.fit_transform(df[feature])
    label_results = pd.DataFrame(label_results, columns=label_campaign.classes_)
    label_final = pd.concat([label_final, label_results], axis=1)

df_encoded = label_final.join(df)

在火车上产生以下输出（效果很好）：

First  | Second  | Third  | Forth | 0 | 1 | 2 | 
-----------------------------------------------
  1    |    0    |   0    |   0   | 1 | 0 | 0 |
  0    |    1    |   0    |   0   | 0 | 1 | 0 |
  0    |    0    |   1    |   0   | 0 | 1 | 0 |
  0    |    0    |   0    |   1   | 0 | 0 | 1 |

但是，当我在测试数据（新数据）上运行此程序时，如果测试数据不包含与训练数据完全相同的名称和日期，我会得到不匹配的特征。所以如果我在这个测试样本上运行类似的代码，我会得到：

First  | Second  | Forth | 0 | 1 | 2 | 
--------------------------------------
  1    |    0    |   0   | 0 | 0 | 1 |
  0    |    1    |   0   | 0 | 1 | 0 |
  0    |    0    |   1   | 1 | 0 | 0 |

我可以做些什么来保留来自训练数据的相同转换并将其正确应用于测试数据，从而产生这个所需的输出：

First  | Second  | Third  | Forth | 0 | 1 | 2 | 
-----------------------------------------------
  1    |    0    |   0    |   0   | 0 | 0 | 1 |
  0    |    1    |   0    |   0   | 0 | 1 | 0 |
  0    |    0    |   0    |   1   | 1 | 0 | 0 |

我已经尝试添加一个 dict 来捕获 fit_transform 结果，但我不确定这是否有效或之后如何处理：

features_to_encode = ['Name', 'day']
label_final = pd.DataFrame()

labels = --------------------------------------------------------------------> TRIED THIS
for feature in features_to_encode:
    label_campaign = LabelBinarizer()
    label_results = label_campaign.fit_transform(df[feature])
    labels[feature] = label_results--------------------------------------------> WITH THIS
    label_results = pd.DataFrame(label_results, columns=label_campaign.classes_)
    label_final = pd.concat([label_final, label_results], axis=1)

df_encoded = label_final.join(df)

感谢任何帮助。谢谢=)

【问题讨论】：

训练和测试数据是在不同时间产生的吗？在这种情况下，您可以在拆分之前创建这些列。无论如何，在更真实的场景中，我通常会创建一个名为 normalize_X 的函数，在其中检查测试集中缺失的列并将它们添加为 0，并删除训练集中不存在的列。

是的，这应该在生产环境中运行，其中测试数据从不同的来源收集并以完全相同的原始格式出现。预处理应该是相同的，因为我训练了 XGBoost，并且必须在类似的数据集上进行预测。

【参考方案1】：

这样的事情应该可以工作。我通常使用数据框直到最后一次，因为它们更容易使用。 X 应该是您预测之前的测试数据框。 original_cols 应该是您的训练集列的列表。让我知道它是否适合您。

def normalize_X(X, original_cols):


    missing_cols= set(original_cols) - set(X.columns)
    extra_cols= set(X.columns) - set(original_cols)
    if len(missing_cols)>0:

        print(f'missing columns: ", ".join(missing_cols)')
        for col in (missing_cols):

            X[col] = 0
    if len(extra_cols)>0:

        print(f'Columns to drop: ", ".join(extra_cols) ',)
        X = X.drop(columns = extra_cols)
    X = X[original_cols]
    return X

【参考方案2】：

pd.CategoricalDtype 和 pd.get_dummies

names_cat = pd.CategoricalDtype(['First', 'Second', 'Third', 'Forth'])
days_cat = pd.CategoricalDtype([0, 1, 2, 3, 4])

dumb_names = pd.get_dummies(df.Name.astype(names_cat))
dumb_names.columns = dumb_names.columns.to_numpy()

dumb_days = pd.get_dummies(df.day.astype(days_cat))
dumb_days.columns = dumb_days.columns.to_numpy()

   First  Second  Third  Forth  0  1  2  3  4
0      1       0      0      0  0  0  1  0  0
1      0       1      0      0  0  1  0  0  0
2      0       0      0      1  1  0  0  0  0

---

LabelBinarizer.classes_

from sklearn.preprocessing import LabelBinarizer

lb_0 = LabelBinarizer()
lb_1 = LabelBinarizer()

lb_0.classes_ = ['First', 'Second', 'Third', 'Forth']
lb_1.classes_ = [0, 1, 2, 3, 4]

a = lb_0.transform(df.Name)
b = lb_1.transform(df.day)

data = np.column_stack([a, b])
idx = df.index
col = np.concatenate([lb_0.classes_, lb_1.classes_])

result = pd.DataFrame(data, idx, col)
result

   First  Second  Third  Forth  0  1  2  3  4
0      1       0      0      0  0  0  1  0  0
1      0       1      0      0  0  1  0  0  0
2      0       0      0      1  1  0  0  0  0

---

reindex

cols = ['First', 'Second', 'Third', 'Forth', 0, 1, 2]
result = pd.concat(map(pd.get_dummies, map(df.get, df)), axis=1)
result.reindex(columns=cols, fill_value=0)

   First  Second  Third  Forth  0  1  2
0      1       0      0      0  0  0  1
1      0       1      0      0  0  1  0
2      0       0      0      1  1  0  0

【讨论】：

LabelBinarizer.classes_解决方案暗示我已经在训练集上使用了fit_transform？

没有。 fit 方法是识别唯一标签的探索过程。这绕过了它并预先设置了标签。这确实假设您预先知道唯一标签。

可能是我不知道训练集的标签，但测试集始终是训练的一个子集。所以我可以做类似 df_train[feature].unique() 的事情来总是得到所有可能类的列表。对吗？

是的，你可以。如果您始终只想保留 train 拥有的列，您可以通过多种方式做到这一点。 test.reindex(columns=train.columns, fill_value=0) 可能是最简单的。

你也可以test.align(train, join='right', axis=1, fill_value=0)[0]

【参考方案3】：

另一种方法，可能更适合您在不同变量之间具有共同值的情况，并且如果您计划为多个列自动编码以进行编码：

df_train = pd.DataFrame('Name': ['First', 'Second', 'Third', 'Fourth'], 'Day': [2,1,1,2])
df_test = pd.DataFrame('Name': ['First', 'Second', 'Fourth'], 'Day': [2,1,0])
categories = []

cols_to_encode = ['Name', 'Day']
# Union of all values in both training and testing datasets:
for col in cols_to_encode:
    categories.append(list(set(df_train[col].unique().tolist() + df_test[col].unique().tolist())))

# Sorts the class names under each variable    
for cat in categories:
    cat.sort()

for col_name, cat in zip(cols_to_encode, categories):
    df_test[col_name] =  pd.Categorical(df_test[col_name], categories=cat)
df_test = pd.get_dummies(df_test, columns=cols_to_encode)

df_test

>>

    Name_First  Name_Second Name_Third  Name_Fourth Day_0   Day_1   Day_2   Day_3   Day_4
0   1           0           0           0           0       0       1       0    0 
1   0           1           0           0           0       1       0       0    0
2   0           0           0           1           1       0       0       0    0