标签：ram 相同 range 相等 不可 validator raise app ini
主要参数：
n_splits : int, default=3
在GroupKFold.split(X[, y, groups])中会调用下面的方法
def _iter_test_indices(self, X, y, groups):
if groups is None:
raise ValueError("The ‘groups‘ parameter should not be None.")
groups = check_array(groups, ensure_2d=False, dtype=None)
unique_groups, groups = np.unique(groups, return_inverse=True) # unique_groups[groups] 可以重建原来的groups
n_groups = len(unique_groups)
if self.n_splits > n_groups:
raise ValueError("Cannot have number of splits n_splits=%d greater"
" than the number of groups: %d."
% (self.n_splits, n_groups))
# Weight groups by their number of occurrences
n_samples_per_group = np.bincount(groups) # 每组中的样本数
# Distribute the most frequent groups first
indices = np.argsort(n_samples_per_group)[::-1] # 按从每组样本数由多到少的顺序排列每组的索引
n_samples_per_group = n_samples_per_group[indices] # 每组的样本数从大到小的排列，n_samples_per_group 的索引不再有意义而被 indices 代替
# Total weight of each fold
n_samples_per_fold = np.zeros(self.n_splits)
# Mapping from group index to fold index
group_to_fold = np.zeros(len(unique_groups))
# Distribute samples by adding the largest weight to the lightest fold
# largest weight 就是当前最大的一组样本数，lightest fold 就是所有fold中所含样本最少的那一折
for group_index, weight in enumerate(n_samples_per_group):
lightest_fold = np.argmin(n_samples_per_fold)
n_samples_per_fold[lightest_fold] += weight
group_to_fold[indices[group_index]] = lightest_fold # 这里就是组数要比折数多的原因，因为一组必须全部放到一折里面，一折可包含多组
indices = group_to_fold[groups]
for f in range(self.n_splits):
yield np.where(indices == f)[0] # 返回每一折的 test index总结：
GroupKFold是没有随机性参数的，也就是样本的groups确定后，每一折包含那些样本也是确定的。算法的文字描述如下：
使用时注意组数要大于折数，同一组的样本一定被分到同一折中。
主要参数：
n_splits : int (default 5) 划分样本训练集和测试集的次数，不同于折数
train_size/test_size : 训练集或测试集的样本比例或数目
random_state
在GroupShuffleSplit.split(X[, y, groups])方法中：
def _iter_indices(self, X, y, groups):
if groups is None:
raise ValueError("The ‘groups‘ parameter should not be None.")
groups = check_array(groups, ensure_2d=False, dtype=None)
classes, group_indices = np.unique(groups, return_inverse=True)
for group_train, group_test in super(
GroupShuffleSplit, self)._iter_indices(X=classes): # 对组进行ShuffleSplit，group_train包含了作为训练集的组号，group_test类同
# these are the indices of classes in the partition
# invert them into data indices
# np.in1d 返回group_indices中的元素是否在group_train中，True False的数组
# np.flatnonzero() 返回数组中不为0的元素的索引，实际就是选为train或者test的样本的index
train = np.flatnonzero(np.in1d(group_indices, group_train))
test = np.flatnonzero(np.in1d(group_indices, group_test))
yield train, test然后其中调用ShuffleSplit的同名方法：
# ShuffleSplit的方法
def _iter_indices(self, X, y=None, groups=None):
n_samples = _num_samples(X) # 返回 X 中样本数目
n_train, n_test = _validate_shuffle_split(n_samples, # 对传入参数做数据检查，返回训练集和测试集的样本数
self.test_size,
self.train_size)
rng = check_random_state(self.random_state) # 对random_state做数据检查，返回随机种子 np.random.RandomState()
for i in range(self.n_splits):
# random partition
permutation = rng.permutation(n_samples) # 随机打乱数据
ind_test = permutation[:n_test]
ind_train = permutation[n_test:(n_test + n_train)]
yield ind_train, ind_test # 返回每一折的训练集的index和测试集的index总结：
GroupShuffleSplit是有随机性参数random_state的，其随机性来自于其父类ShuffleSplit。该算法的核心就是对组编号做ShuffleSplit，这也是其继承该类的原因，然后所有落在train中的组的所有样本组成训练集，其他组成测试集。和GroupKFold类似，一组的数组要么只出现在train中，要么只出现test中，不可同时出现在二者之中。
注意：
参数shuffle的默认值是False，而我们一般要设置为True。当shuffle设置为True时，random_state才会被用到，这时，如果random_state如果不设置，每次结果会不一样，只有给每次设置random_state同一个值，shuffle的结果才是相同的。所以shuffle决定是否引入随机性，random_state只不过是让随机性可以重现。
def _iter_test_masks(self, X, y, groups):
if groups is None:
raise ValueError("The ‘groups‘ parameter should not be None.")
# We make a copy of groups to avoid side-effects during iteration
groups = check_array(groups, copy=True, ensure_2d=False, dtype=None)
unique_groups = np.unique(groups)
if len(unique_groups) <= 1:
raise ValueError(
"The groups parameter contains fewer than 2 unique groups "
"(%s). LeaveOneGroupOut expects at least 2." % unique_groups)
for i in unique_groups:
yield groups == i # 返回作为测试集的index总结：
一开始对留一法不是很清楚，其实留一法就是交叉验证方法的极端情形，当交叉验证的折数和数据集的个数相等时就是留一法。理解了留一法后上面的源码就是非常清晰简洁的。一句话概括该算法就是以组为单位做留一法。
理解前面的就很简单，就是留出P个Group做测试集。
def __init__(self, test_fold):
self.test_fold = np.array(test_fold, dtype=np.int)
self.test_fold = column_or_1d(self.test_fold) # 将shape是(n_samples,1)的数组拉成(n_samples,)的数组
self.unique_folds = np.unique(self.test_fold)
self.unique_folds = self.unique_folds[self.unique_folds != -1] # test_fold 中所有-1的样本要放到train中，也就是test_fold中不为-1的值的种类数就是split的数目。
def split(self, X=None, y=None, groups=None):
ind = np.arange(len(self.test_fold))
for test_index in self._iter_test_masks():
train_index = ind[np.logical_not(test_index)]
test_index = ind[test_index]
yield train_index, test_index
def _iter_test_masks(self):
"""Generates boolean masks corresponding to test sets."""
for f in self.unique_folds:
test_index = np.where(self.test_fold == f)[0]
test_mask = np.zeros(len(self.test_fold), dtype=np.bool)
test_mask[test_index] = True
yield test_mask上面的源码是清晰明了的，下面举例子说明：
PredefinedSplit需要的参数只有一个那就是test_fold, test_fold的size要和数据集的size相同，test_fold中元素的值为-1，表示这个样本要放到训练集中，test_fold中具有相同值的元素对应的样本要放到同一个test_set中。比如 test_fold = [1, 1, 1, -1, -1, -1, 2, 2, 2, 2]表示或做两个split，第一次split中第4（首个index是1）到第10个样本做train，第1个到第3个做test；第二次split中第1到第7个样本做train，第8个到第10个样本做test 。
用不同的随机化重复KFold若干次，内部代码在每次KFold时会把shuffle设置为True。
注意：
split(X, y, [groups])中y是必须的参数而不是可选的。
def __init__(self, n_splits=3, max_train_size=None):
super(TimeSeriesSplit, self).__init__(n_splits,
shuffle=False,
random_state=None)
self.max_train_size = max_train_size # 训练集的最大样本数
def split(self, X, y=None, groups=None):
X, y, groups = indexable(X, y, groups)
n_samples = _num_samples(X)
n_splits = self.n_splits
n_folds = n_splits + 1
if n_folds > n_samples: # 折数不能大于样本数，也即是参数n_splits不能大于样本数减1
raise ValueError(
("Cannot have number of folds ={0} greater"
" than the number of samples: {1}.").format(n_folds,
n_samples))
indices = np.arange(n_samples)
test_size = (n_samples // n_folds)
test_starts = range(test_size + n_samples % n_folds,
n_samples, test_size)
for test_start in test_starts:
if self.max_train_size and self.max_train_size < test_start:
yield (indices[test_start - self.max_train_size:test_start],
indices[test_start:test_start + test_size])
else:
yield (indices[:test_start],
indices[test_start:test_start + test_size])# template
spliter = Spliter(...)
for i, trn_idx,test_idx in enumerate(spliter.split(X,y)):
....sklearn.model_selection Part 1: Splitter Classes
标签：ram 相同 range 相等 不可 validator raise app ini
原文地址：https://www.cnblogs.com/ZeroTensor/p/10277119.html
