如何将数据分成 3 组（训练、验证和测试）？
Posted
技术标签:
【中文标题】如何将数据分成 3 组（训练、验证和测试）？【英文标题】：How to split data into 3 sets (train, validation and test)? 【发布时间】：2017-01-04 10:11:22 【问题描述】：我有一个 pandas 数据框，我希望将它分成 3 个单独的集合。我知道使用sklearn.cross_validation 中的train_test_split，可以将数据分成两组（训练和测试）。但是，我找不到任何将数据分成三组的解决方案。最好，我想拥有原始数据的索引。
我知道一种解决方法是使用两次train_test_split 并以某种方式调整索引。但是有没有更标准/内置的方式将数据分成 3 组而不是 2 组？
【问题讨论】：
这不能回答你的具体问题，但我认为更标准的方法是分成两组，训练和测试，并在训练集上运行交叉验证，从而消除需要用于独立的“开发”集。 这个以前出现过，据我所知还没有内置的方法。 我建议 Hastie 等人的 The Elements of Statistical Learning 讨论为什么使用三组而不是两组（web.stanford.edu/~hastie/local.ftp/Springer/OLD/… 模型评估和选择章节） @David 在某些模型中，为了防止过度拟合，需要 3 组而不是 2 组。因为在您的设计选择中，您以某种方式调整参数以提高测试集的性能。为了防止这种情况，需要一个开发集。因此，使用交叉验证是不够的。 @ayhan，该书的更正 URL 是 statweb.stanford.edu/~tibs/ElemStatLearn/printings/…，第 7 章（第 219 页）。 【参考方案1】：Numpy 解决方案。我们将首先打乱整个数据集（df.sample(frac=1, random_state=42)），然后将我们的数据集拆分为以下部分：
In [305]: train, validate, test = \
np.split(df.sample(frac=1, random_state=42),
[int(.6*len(df)), int(.8*len(df))])
In [306]: train
Out[306]:
A B C D E
0 0.046919 0.792216 0.206294 0.440346 0.038960
2 0.301010 0.625697 0.604724 0.936968 0.870064
1 0.642237 0.690403 0.813658 0.525379 0.396053
9 0.488484 0.389640 0.599637 0.122919 0.106505
8 0.842717 0.793315 0.554084 0.100361 0.367465
7 0.185214 0.603661 0.217677 0.281780 0.938540
In [307]: validate
Out[307]:
A B C D E
5 0.806176 0.008896 0.362878 0.058903 0.026328
6 0.145777 0.485765 0.589272 0.806329 0.703479
In [308]: test
Out[308]:
A B C D E
4 0.521640 0.332210 0.370177 0.859169 0.401087
3 0.333348 0.964011 0.083498 0.670386 0.169619
[int(.6*len(df)), int(.8*len(df))] - 是indices_or_sections 的numpy.split() 数组。
这是np.split() 用法的小演示 - 让我们将 20 元素数组拆分为以下部分：80%、10%、10%：
In [45]: a = np.arange(1, 21)
In [46]: a
Out[46]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
In [47]: np.split(a, [int(.8 * len(a)), int(.9 * len(a))])
Out[47]:
[array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
array([17, 18]),
array([19, 20])]
【讨论】：
@root frac=1 参数到底在做什么？ @SpiderWasp42,frac=1 指示 sample() 函数返回所有（100% 或 fraction = 1.0）行
谢谢@MaxU。我想提两件事情来简化事情。首先，在分割线之前使用np.random.seed(any_number)，每次运行都获得相同的结果。其次，要使train:test:val::50:40:10这样的不等比使用[int(.5*len(dfn)), int(.9*len(dfn))]。这里第一个元素表示train (0.5%) 的大小，第二个元素表示val (1-0.9 = 0.1%) 的大小，两者之间的差异表示test(0.9-0.5 = 0.4%) 的大小。如果我错了，请纠正我:)
hrmm 当你说“这是一个关于 np.split() 用法的小演示 - 让我们将 20 元素数组拆分为以下部分：90%、10%、10%： " 我很确定你的意思是 80%、10%、10%
嘿，@MaxU 我有一个案例，有点类似。我想知道您是否可以帮我看看它是否存在并在那里帮助我。这是我的问题***.com/questions/54847668/…【参考方案2】：
注意：
函数是为处理随机集创建的播种而编写的。您不应该依赖不会随机化集合的集合拆分。
import numpy as np
import pandas as pd
def train_validate_test_split(df, train_percent=.6, validate_percent=.2, seed=None):
np.random.seed(seed)
perm = np.random.permutation(df.index)
m = len(df.index)
train_end = int(train_percent * m)
validate_end = int(validate_percent * m) + train_end
train = df.iloc[perm[:train_end]]
validate = df.iloc[perm[train_end:validate_end]]
test = df.iloc[perm[validate_end:]]
return train, validate, test
演示
np.random.seed([3,1415])
df = pd.DataFrame(np.random.rand(10, 5), columns=list('ABCDE'))
df
train, validate, test = train_validate_test_split(df)
train
validate
test
【讨论】：
我相信这个函数需要一个索引值从1到n的df。就我而言，我修改了函数以使用 df.loc，因为我的索引值不一定在此范围内。【参考方案3】：但是，将数据集划分为 train、test、cv 和 0.6、0.2、0.2 的一种方法是使用 train_test_split 方法两次。
from sklearn.model_selection import train_test_split
x, x_test, y, y_test = train_test_split(xtrain,labels,test_size=0.2,train_size=0.8)
x_train, x_cv, y_train, y_cv = train_test_split(x,y,test_size = 0.25,train_size =0.75)
【讨论】：
@MaksymGanenko 你能详细说明一下吗？ 使用np.split()，您可以拆分索引，因此您可以重新索引任何数据类型。如果您查看train_test_split()，您会发现它的作用完全相同：定义np.arange()，对其进行洗牌，然后重新索引原始数据。但是train_test_split()不能将数据分成三个数据集，所以它的使用是有限的。在答案的上下文中，它不是最理想的（== 错误）。
这种方法的另一个好处是您可以使用分层参数。
一个简单易行的方法！
@MaksymGanenko：谁在乎它的性能是否欠佳？通常，您只想执行一次训练/验证/测试拆分，因此您要确保它正确完成，而不仅仅是高效。对于训练/验证/测试拆分，您需要进行分层抽样，这是 Numpy split() 所不具备的；你必须自己实施分层。 sci-kit 学习功能使用 train_test_split() 为您完成所有这些工作。【参考方案4】：
这是一个 Python 函数，它通过分层抽样将 Pandas 数据帧拆分为训练、验证和测试数据帧。它通过调用 scikit-learn 的函数 train_test_split() 两次来执行这种拆分。
import pandas as pd
from sklearn.model_selection import train_test_split
def split_stratified_into_train_val_test(df_input, stratify_colname='y',
frac_train=0.6, frac_val=0.15, frac_test=0.25,
random_state=None):
'''
Splits a Pandas dataframe into three subsets (train, val, and test)
following fractional ratios provided by the user, where each subset is
stratified by the values in a specific column (that is, each subset has
the same relative frequency of the values in the column). It performs this
splitting by running train_test_split() twice.
Parameters
----------
df_input : Pandas dataframe
Input dataframe to be split.
stratify_colname : str
The name of the column that will be used for stratification. Usually
this column would be for the label.
frac_train : float
frac_val : float
frac_test : float
The ratios with which the dataframe will be split into train, val, and
test data. The values should be expressed as float fractions and should
sum to 1.0.
random_state : int, None, or RandomStateInstance
Value to be passed to train_test_split().
Returns
-------
df_train, df_val, df_test :
Dataframes containing the three splits.
'''
if frac_train + frac_val + frac_test != 1.0:
raise ValueError('fractions %f, %f, %f do not add up to 1.0' % \
(frac_train, frac_val, frac_test))
if stratify_colname not in df_input.columns:
raise ValueError('%s is not a column in the dataframe' % (stratify_colname))
X = df_input # Contains all columns.
y = df_input[[stratify_colname]] # Dataframe of just the column on which to stratify.
# Split original dataframe into train and temp dataframes.
df_train, df_temp, y_train, y_temp = train_test_split(X,
y,
stratify=y,
test_size=(1.0 - frac_train),
random_state=random_state)
# Split the temp dataframe into val and test dataframes.
relative_frac_test = frac_test / (frac_val + frac_test)
df_val, df_test, y_val, y_test = train_test_split(df_temp,
y_temp,
stratify=y_temp,
test_size=relative_frac_test,
random_state=random_state)
assert len(df_input) == len(df_train) + len(df_val) + len(df_test)
return df_train, df_val, df_test
下面是一个完整的工作示例。
考虑一个数据集，该数据集具有您要在其上执行分层的标签。这个标签在原始数据集中有自己的分布，比如 75% foo、15% bar 和 10% baz。现在让我们使用 60/20/20 的比率将数据集拆分为训练、验证和测试的子集，其中每个拆分都保留相同的标签分布。见下图：
这是示例数据集：
df = pd.DataFrame( 'A': list(range(0, 100)),
'B': list(range(100, 0, -1)),
'label': ['foo'] * 75 + ['bar'] * 15 + ['baz'] * 10 )
df.head()
# A B label
# 0 0 100 foo
# 1 1 99 foo
# 2 2 98 foo
# 3 3 97 foo
# 4 4 96 foo
df.shape
# (100, 3)
df.label.value_counts()
# foo 75
# bar 15
# baz 10
# Name: label, dtype: int64
现在，让我们从上面调用 split_stratified_into_train_val_test() 函数，以按照 60/20/20 的比率获取训练、验证和测试数据帧。
df_train, df_val, df_test = \
split_stratified_into_train_val_test(df, stratify_colname='label', frac_train=0.60, frac_val=0.20, frac_test=0.20)
df_train、df_val 和 df_test 三个数据框包含所有原始行，但它们的大小将遵循上述比例。
df_train.shape
#(60, 3)
df_val.shape
#(20, 3)
df_test.shape
#(20, 3)
此外，三个拆分中的每一个都将具有相同的标签分布，即 75% foo、15% bar 和 10% baz。
df_train.label.value_counts()
# foo 45
# bar 9
# baz 6
# Name: label, dtype: int64
df_val.label.value_counts()
# foo 15
# bar 3
# baz 2
# Name: label, dtype: int64
df_test.label.value_counts()
# foo 15
# bar 3
# baz 2
# Name: label, dtype: int64
【讨论】：
NameError: 名称“df”未定义。 split_stratified_into_train_val_test() 中的“df”应替换为“df_input”。 谢谢。我修好了它。问题出在代码的错误处理路径中。【参考方案5】：在监督学习的情况下，您可能希望同时拆分 X 和 y（其中 X 是您的输入，y 是基本事实输出）。 您只需要在拆分之前注意以相同的方式将 X 和 y 洗牌。
在这里，要么 X 和 y 在同一个数据帧中，所以我们将它们打乱，将它们分开并为每个应用拆分（就像在选择的答案中一样），或者 X 和 y 在两个不同的数据帧中，所以我们打乱 X , 重新排序 y 与洗牌后的 X 相同，并将拆分应用于每个。
# 1st case: df contains X and y (where y is the "target" column of df)
df_shuffled = df.sample(frac=1)
X_shuffled = df_shuffled.drop("target", axis = 1)
y_shuffled = df_shuffled["target"]
# 2nd case: X and y are two separated dataframes
X_shuffled = X.sample(frac=1)
y_shuffled = y[X_shuffled.index]
# We do the split as in the chosen answer
X_train, X_validation, X_test = np.split(X_shuffled, [int(0.6*len(X)),int(0.8*len(X))])
y_train, y_validation, y_test = np.split(y_shuffled, [int(0.6*len(X)),int(0.8*len(X))])
【讨论】：
【参考方案6】：使用train_test_split很方便，分割成几组后不用重新索引，不用写一些额外的代码。上面的最佳答案没有提到通过使用train_test_split 分隔两次而不更改分区大小不会给出最初预期的分区：
x_train, x_remain = train_test_split(x, test_size=(val_size + test_size))
那么x_remain中的验证集和测试集部分发生变化，可以算作
new_test_size = np.around(test_size / (val_size + test_size), 2)
# To preserve (new_test_size + new_val_size) = 1.0
new_val_size = 1.0 - new_test_size
x_val, x_test = train_test_split(x_remain, test_size=new_test_size)
在这种情况下，所有初始分区都被保存。
【讨论】：
【参考方案7】：def train_val_test_split(X, y, train_size, val_size, test_size):
X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size = test_size)
relative_train_size = train_size / (val_size + train_size)
X_train, X_val, y_train, y_val = train_test_split(X_train_val, y_train_val,
train_size = relative_train_size, test_size = 1-relative_train_size)
return X_train, X_val, X_test, y_train, y_val, y_test
这里我们用sklearn的train_test_split拆分数据2次
【讨论】：
【参考方案8】：考虑到 df 标识您的原始数据框：
1 - 首先在训练和测试之间拆分数据 (10%)：
my_test_size = 0.10
X_train_, X_test, y_train_, y_test = train_test_split(
df.index.values,
df.label.values,
test_size=my_test_size,
random_state=42,
stratify=df.label.values,
)
2 - 然后将训练集在训练和验证之间拆分 (20%)：
my_val_size = 0.20
X_train, X_val, y_train, y_val = train_test_split(
df.loc[X_train_].index.values,
df.loc[X_train_].label.values,
test_size=my_val_size,
random_state=42,
stratify=df.loc[X_train_].label.values,
)
3 - 然后，根据上述步骤中生成的索引对原始数据帧进行切片：
# data_type is not necessary.
df['data_type'] = ['not_set']*df.shape[0]
df.loc[X_train, 'data_type'] = 'train'
df.loc[X_val, 'data_type'] = 'val'
df.loc[X_test, 'data_type'] = 'test'
结果会是这样的：
注意：此解决方案使用问题中提到的解决方法。
【讨论】：
【参考方案9】：在训练和测试集中拆分数据集，就像在其他答案中一样，使用
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
然后，如果您适合您的模型，您可以添加validation_split 作为参数。那么您不需要提前创建验证集。例如：
from tensorflow.keras import Model
model = Model(input_layer, out)
[...]
history = model.fit(x=X_train, y=y_train, [...], validation_split = 0.3)
验证集旨在作为训练集训练期间的代表性运行测试集，完全取自训练集，通过 k 折交叉-验证（推荐）或validation_split；那么您不需要单独创建验证集，仍然可以将数据集拆分为您要求的三个集合。
【讨论】：
【参考方案10】：回答任意数量的子集：
def _separate_dataset(patches, label_patches, percentage, shuffle: bool = True):
"""
:param patches: data patches
:param label_patches: label patches
:param percentage: list of percentages for each value, example [0.9, 0.02, 0.08] to get 90% train, 2% val and 8% test.
:param shuffle: Shuffle dataset before split.
:return: tuple of two lists of size = len(percentage), one with data x and other with labels y.
"""
x_test = patches
y_test = label_patches
percentage = list(percentage) # need it to be mutable
assert sum(percentage) == 1., f"percentage must add to 1, but it adds to sumpercentage = sum(percentage)"
x = []
y = []
for i, per in enumerate(percentage[:-1]):
x_train, x_test, y_train, y_test = train_test_split(x_test, y_test, test_size=1-per, shuffle=shuffle)
percentage[i+1:] = [value / (1-percentage[i]) for value in percentage[i+1:]]
x.append(x_train)
y.append(y_train)
x.append(x_test)
y.append(y_test)
return x, y
这适用于任何大小的百分比。在你的情况下，你应该做percentage = [train_percentage, val_percentage, test_percentage]。
【讨论】：
以上是关于如何将数据分成 3 组（训练、验证和测试）？的主要内容，如果未能解决你的问题，请参考以下文章