复杂数据集拆分 - StratifiedGroupShuffleSplit
Posted
技术标签:
【中文标题】复杂数据集拆分 - StratifiedGroupShuffleSplit【英文标题】：Complex dataset split - StratifiedGroupShuffleSplit 【发布时间】：2019-11-14 07:03:14 【问题描述】：我有一个大约 2m 观察的数据集，我需要以 60:20:20 的比例将其拆分为训练、验证和测试集。我的数据集的简化摘录如下所示：
+---------+------------+-----------+-----------+
| note_id | subject_id | category | note |
+---------+------------+-----------+-----------+
| 1 | 1 | ECG | blah ... |
| 2 | 1 | Discharge | blah ... |
| 3 | 1 | Nursing | blah ... |
| 4 | 2 | Nursing | blah ... |
| 5 | 2 | Nursing | blah ... |
| 6 | 3 | ECG | blah ... |
+---------+------------+-----------+-----------+
有多个类别——它们并不均衡——所以我需要确保训练集、验证集和测试集都具有与原始数据集中相同的类别比例。这部分很好，我可以使用sklearn 库中的StratifiedShuffleSplit。
但是，我还需要确保每个受试者的观察结果不会分散到训练、验证和测试数据集中。来自给定主题的所有观察结果都需要放在同一个桶中，以确保我训练有素的模型在验证/测试之前从未见过该主题。例如。 subject_id 1 的每个观察值都应该在训练集中。
我想不出一种方法来确保按类别进行分层拆分，防止subject_id在数据集之间的污染（因为需要更好的词），确保60:20:20 拆分并确保数据集以某种方式被打乱。任何帮助，将不胜感激！
谢谢！
编辑：
我现在了解到，也可以通过sklearn 通过GroupShuffleSplit 函数来完成按类别分组并在数据集拆分中保持组在一起。所以本质上，我需要的是一个组合的分层和分组的随机拆分，即StratifiedGroupShuffleSplit，它不存在。 Github问题：https://github.com/scikit-learn/scikit-learn/issues/12076
【问题讨论】：
【参考方案1】：我认为在这种情况下，您必须构建自己的函数来拆分数据。 这是我的一个实现：
def split(df, based_on='subject_id', cv=5):
splits = []
based_on_uniq = df[based_on]#set(df[based_on].tolist())
based_on_uniq = np.array_split(based_on_uniq, cv)
for fold in based_on_uniq:
splits.append(df[df[based_on] == fold.tolist()[0]])
return splits
if __name__ == '__main__':
df = pd.DataFrame(['note_id': 1, 'subject_id': 1, 'category': 'test1', 'note': 'test1',
'note_id': 2, 'subject_id': 1, 'category': 'test2', 'note': 'test2',
'note_id': 3, 'subject_id': 2, 'category': 'test3', 'note': 'test3',
'note_id': 4, 'subject_id': 2, 'category': 'test4', 'note': 'test4',
'note_id': 5, 'subject_id': 3, 'category': 'test5', 'note': 'test5',
'note_id': 6, 'subject_id': 3, 'category': 'test6', 'note': 'test6',
'note_id': 7, 'subject_id': 4, 'category': 'test7', 'note': 'test7',
'note_id': 8, 'subject_id': 4, 'category': 'test8', 'note': 'test8',
'note_id': 9, 'subject_id': 5, 'category': 'test9', 'note': 'test9',
'note_id': 10, 'subject_id': 5, 'category': 'test10', 'note': 'test10',
])
print(split(df))
【讨论】：
我认为你可能是对的。感谢您提供用于返回分割点的起始代码。我想问题是通过使用库提供的函数可以简化多少。我会看看我能想出什么【参考方案2】：基本上我需要不存在的StratifiedGroupShuffleSplit (Github issue)。这是因为这样一个函数的行为是不清楚的，并且实现这一点来产生一个既分组又分层的数据集并不总是可能的（also discussed here）——尤其是对于像我这样的严重不平衡的数据集。就我而言，我希望严格进行分组，以确保在分层和 60:20:20 的数据集比例拆分时，分组不会有任何重叠，即尽可能地完成。
正如 Ghanem 提到的，我别无选择，只能自己构建一个函数来拆分数据集，我在下面做了：
def StratifiedGroupShuffleSplit(df_main):
df_main = df_main.reindex(np.random.permutation(df_main.index)) # shuffle dataset
# create empty train, val and test datasets
df_train = pd.DataFrame()
df_val = pd.DataFrame()
df_test = pd.DataFrame()
hparam_mse_wgt = 0.1 # must be between 0 and 1
assert(0 <= hparam_mse_wgt <= 1)
train_proportion = 0.6 # must be between 0 and 1
assert(0 <= train_proportion <= 1)
val_test_proportion = (1-train_proportion)/2
subject_grouped_df_main = df_main.groupby(['subject_id'], sort=False, as_index=False)
category_grouped_df_main = df_main.groupby('category').count()[['subject_id']]/len(df_main)*100
def calc_mse_loss(df):
grouped_df = df.groupby('category').count()[['subject_id']]/len(df)*100
df_temp = category_grouped_df_main.join(grouped_df, on = 'category', how = 'left', lsuffix = '_main')
df_temp.fillna(0, inplace=True)
df_temp['diff'] = (df_temp['subject_id_main'] - df_temp['subject_id'])**2
mse_loss = np.mean(df_temp['diff'])
return mse_loss
i = 0
for _, group in subject_grouped_df_main:
if (i < 3):
if (i == 0):
df_train = df_train.append(pd.DataFrame(group), ignore_index=True)
i += 1
continue
elif (i == 1):
df_val = df_val.append(pd.DataFrame(group), ignore_index=True)
i += 1
continue
else:
df_test = df_test.append(pd.DataFrame(group), ignore_index=True)
i += 1
continue
mse_loss_diff_train = calc_mse_loss(df_train) - calc_mse_loss(df_train.append(pd.DataFrame(group), ignore_index=True))
mse_loss_diff_val = calc_mse_loss(df_val) - calc_mse_loss(df_val.append(pd.DataFrame(group), ignore_index=True))
mse_loss_diff_test = calc_mse_loss(df_test) - calc_mse_loss(df_test.append(pd.DataFrame(group), ignore_index=True))
total_records = len(df_train) + len(df_val) + len(df_test)
len_diff_train = (train_proportion - (len(df_train)/total_records))
len_diff_val = (val_test_proportion - (len(df_val)/total_records))
len_diff_test = (val_test_proportion - (len(df_test)/total_records))
len_loss_diff_train = len_diff_train * abs(len_diff_train)
len_loss_diff_val = len_diff_val * abs(len_diff_val)
len_loss_diff_test = len_diff_test * abs(len_diff_test)
loss_train = (hparam_mse_wgt * mse_loss_diff_train) + ((1-hparam_mse_wgt) * len_loss_diff_train)
loss_val = (hparam_mse_wgt * mse_loss_diff_val) + ((1-hparam_mse_wgt) * len_loss_diff_val)
loss_test = (hparam_mse_wgt * mse_loss_diff_test) + ((1-hparam_mse_wgt) * len_loss_diff_test)
if (max(loss_train,loss_val,loss_test) == loss_train):
df_train = df_train.append(pd.DataFrame(group), ignore_index=True)
elif (max(loss_train,loss_val,loss_test) == loss_val):
df_val = df_val.append(pd.DataFrame(group), ignore_index=True)
else:
df_test = df_test.append(pd.DataFrame(group), ignore_index=True)
print ("Group " + str(i) + ". loss_train: " + str(loss_train) + " | " + "loss_val: " + str(loss_val) + " | " + "loss_test: " + str(loss_test) + " | ")
i += 1
return df_train, df_val, df_test
df_train, df_val, df_test = StratifiedGroupShuffleSplit(df_main)
我基于两件事创建了一些任意损失函数：
-
与整个数据集相比，每个类别的百分比表示的平均平方差
数据集的比例长度与根据所提供的比例 (60:20:20) 应有的长度之间的平方差
将这两个输入加权到损失函数是由静态超参数hparam_mse_wgt 完成的。对于我的特定数据集，0.1 的值效果很好，但如果你使用这个函数，我鼓励你尝试一下。将其设置为 0 将优先考虑仅保持拆分比率并忽略分层。将其设置为 1 则相反。
使用此损失函数，然后我遍历每个主题（组）并根据具有最高损失函数的那个将其附加到适当的数据集（训练、验证或测试）。
这并不是特别复杂，但它对我来说是可行的。它不一定适用于每个数据集，但它越大，机会就越大。希望其他人会发现它有用。
【讨论】：
【参考方案3】：这已经超过一年了，但我发现自己处于类似的情况，我有标签和组，并且由于组的性质，一组数据点可以仅用于测试或仅用于训练，我用 pandas 和 sklearn 写了一个小算法，希望对你有帮助
from sklearn.model_selection import GroupShuffleSplit
groups = df.groupby('label')
all_train = []
all_test = []
for group_id, group in groups:
# if a group is already taken in test or train it must stay there
group = group[~group['groups'].isin(all_train+all_test)]
# if group is empty
if group.shape[0] == 0:
continue
train_inds, test_inds = next(GroupShuffleSplit(
test_size=valid_size, n_splits=2, random_state=7).split(group, groups=group['groups']))
all_train += group.iloc[train_inds]['groups'].tolist()
all_test += group.iloc[test_inds]['groups'].tolist()
train= df[df['groups'].isin(all_train)]
test= df[df['groups'].isin(all_test)]
form_train = set(train['groups'].tolist())
form_test = set(test['groups'].tolist())
inter = form_train.intersection(form_test)
print(df.groupby('label').count())
print(train.groupby('label').count())
print(test.groupby('label').count())
print(inter) # this should be empty
【讨论】：
【参考方案4】：我只需要解决同样的问题。在我的文档处理用例中，我希望同一页面中的单词粘在一起（组），而文档类别应该均匀地分布在训练集和测试集上（分层）。对于我的问题，它认为对于一组的所有实例，我们具有相同的分层类别，即一页中的所有单词都属于同一类别。因此，我发现直接对组执行分层拆分然后使用拆分组来选择实例是最简单的。如果此假设不成立，则此解决方案不适用。
from typing import Tuple
import pandas as pd
from sklearn.model_selection import train_test_split
def stratified_group_train_test_split(
samples: pd.DataFrame, group: str, stratify_by: str, test_size: float
) -> Tuple[pd.DataFrame, pd.DataFrame]:
groups = samples[group].drop_duplicates()
stratify = samples.drop_duplicates(group)[stratify_by].to_numpy()
groups_train, groups_test = train_test_split(groups, stratify=stratify, test_size=test_size)
samples_train = samples.loc[lambda d: d[group].isin(groups_train)]
samples_test = samples.loc[lambda d: d[group].isin(groups_test)]
return samples_train, samples_test
【讨论】：
【参考方案5】：正如其他人之前评论的那样：StratifiedGroupShuffleSplit 不存在，因为您可能无法保证分组拆分将具有每个类的相似数量的实例。
但是，您可以选择一个愚蠢但非常简单的解决方案，最终将提供一个足够好的解决方案：
-
将
GroupShuffleSplit 与随机状态集一起使用（例如GroupShuffleSplit(n_splits=1, test_size=0.3, random_state=0)）
计算每个分组中类之间的平衡。
如果您不满意，只需将random_state 设置为另一个值再次运行即可。
继续直到拆分足够好。
这种方法显然最适合少量的分割和二进制标签。
【讨论】：
【参考方案6】：这在 scikit-learn 1.0 中通过StratifiedGroupKFold 解决了
在此示例中，您在洗牌后生成 3 个折叠，将组保持在一起并进行分层（尽可能）
import numpy as np
from sklearn.model_selection import StratifiedGroupKFold
X = np.ones((30, 2))
y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 1, 1, 1,])
groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5,
5, 5, 6, 6, 7, 8, 8, 9, 9, 9,
10, 11, 11, 12, 12, 12, 13, 13,
13, 13])
print("ORIGINAL POSITIVE RATIO:", y.mean())
cv = StratifiedGroupKFold(n_splits=3, shuffle=True)
for fold, (train_idxs, test_idxs) in enumerate(cv.split(X, y, groups)):
print("Fold :", fold)
print("TRAIN POSITIVE RATIO:", y[train_idxs].mean())
print("TEST POSITIVE RATIO :", y[test_idxs].mean())
print("TRAIN GROUPS :", set(groups[train_idxs]))
print("TEST GROUPS :", set(groups[test_idxs]))
在输出中，您可以看到折叠中阳性病例的比例保持接近原始阳性比例，并且同一组永远不会出现在两组中。当然，你拥有的群体越少/越大（即你的班级越不平衡），就越难以接近原始班级分布。
输出：
ORIGINAL POSITIVE RATIO: 0.5
Fold : 0
TRAIN POSITIVE RATIO: 0.4375
TEST POSITIVE RATIO : 0.5714285714285714
TRAIN GROUPS : 1, 3, 4, 5, 6, 7, 10, 11
TEST GROUPS : 2, 8, 9, 12, 13
Fold : 1
TRAIN POSITIVE RATIO: 0.5
TEST POSITIVE RATIO : 0.5
TRAIN GROUPS : 2, 4, 5, 7, 8, 9, 11, 12, 13
TEST GROUPS : 1, 10, 3, 6
Fold : 2
TRAIN POSITIVE RATIO: 0.5454545454545454
TEST POSITIVE RATIO : 0.375
TRAIN GROUPS : 1, 2, 3, 6, 8, 9, 10, 12, 13
TEST GROUPS : 11, 4, 5, 7
【讨论】：
以上是关于复杂数据集拆分 - StratifiedGroupShuffleSplit的主要内容，如果未能解决你的问题，请参考以下文章