如何将数据分成 3 组(训练、验证和测试)?
Posted
技术标签:
【中文标题】如何将数据分成 3 组(训练、验证和测试)?【英文标题】:How to split data into 3 sets (train, validation and test)? 【发布时间】:2018-12-05 05:50:32 【问题描述】:我有一个 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 组(训练、验证和测试)?的主要内容,如果未能解决你的问题,请参考以下文章