Python 我可以使用numpy数组生成交叉验证的折叠吗？

我想使用numpy数组为k-folds交叉验证任务构建折叠。取出测试片很容易，但我不知道如何返回数组的其余部分，而忽略了测试片。有没有一种有效的方法可以做到这一点

examples = range(50)
classes = range(50)
data = np.array(zip(classes,examples))
test_slice = data[5:10]
train_on_remainder = ??

---

您可以这样设置：

test_slice, remainder = np.split(data.copy(), [test_size], axis=0)
# run test
remainder[:test_size], test_slice = test_slice, remainder[:test_size].copy()
# run test
remainder[test_size:2*test_size], test_slice = test_slice, remainder[test_size:2*test_size].copy()

# etc.

我不认为你可以少复制它

工作原理：

.      full set:            | 0 | 1 | 2 | 3 | 4 | 5 |
       split (full copy)       / \
       tst / rem         | 0 |     | 1 | 2 | 3 | 4 | 5 |
         run trial
                             | 1 | 2 | 3 | 4 | 5 |
       swap tst and           ^ |
       first segment:         | v
       (partial copy)        | 0 |

       tst / rem         | 1 |     | 0 | 2 | 3 | 4 | 5 |
         run trial
                             | 0 | 2 | 3 | 4 | 5 |
       swap tst and               ^ |
       second segment:            | v
       (partial copy)            | 1 |

       tst / rem         | 2 |     | 0 | 1 | 3 | 4 | 5 |
         run trial
                             | 0 | 1 | 3 | 4 | 5 |
       swap tst and                   ^ |
       third segment:                 | v
       (partial copy)                | 2 |

---

如你所见，它几乎是在移动褶皱。保存许多完整副本。

您可以这样设置：

test_slice, remainder = np.split(data.copy(), [test_size], axis=0)
# run test
remainder[:test_size], test_slice = test_slice, remainder[:test_size].copy()
# run test
remainder[test_size:2*test_size], test_slice = test_slice, remainder[test_size:2*test_size].copy()

# etc.

我不认为你可以少复制它

工作原理：

.      full set:            | 0 | 1 | 2 | 3 | 4 | 5 |
       split (full copy)       / \
       tst / rem         | 0 |     | 1 | 2 | 3 | 4 | 5 |
         run trial
                             | 1 | 2 | 3 | 4 | 5 |
       swap tst and           ^ |
       first segment:         | v
       (partial copy)        | 0 |

       tst / rem         | 1 |     | 0 | 2 | 3 | 4 | 5 |
         run trial
                             | 0 | 2 | 3 | 4 | 5 |
       swap tst and               ^ |
       second segment:            | v
       (partial copy)            | 1 |

       tst / rem         | 2 |     | 0 | 1 | 3 | 4 | 5 |
         run trial
                             | 0 | 1 | 3 | 4 | 5 |
       swap tst and                   ^ |
       third segment:                 | v
       (partial copy)                | 2 |

---

如你所见，它几乎是在移动褶皱。保存许多完整副本。

这是一个奇怪的问题，因为人们通常会使用sklearn的

train\u test\u split（）

编辑：另一种方法可能是

r = np.arange(len(data))
trainX = data[r < 5 | r > 10]

当然，如果有sklearn的
train\u test\u split（）
，你也可以问类似的问题。
如果有sklearn的
train\u test\u split（）

split = np.vsplit(data, np.array([5,10]))

'''This will give you a list with 3 elements'''

test_slice = split[1]
train_slice = np.vstack((split[0],split[2]))

编辑：另一种方法可能是

r = np.arange(len(data))
trainX = data[r < 5 | r > 10]

当然，如果有sklearn的
train\u test\u split（）

split = np.vsplit(data, np.array([5,10]))

'''This will give you a list with 3 elements'''

test_slice = split[1]
train_slice = np.vstack((split[0],split[2]))

[5 5][6][7][8][9]

[0 0][11][2 2][3][4][10][11][12
12]  [13 13]  [14 14]  [15 15]  [16 16]  [17 17]  [18 18]
…[47][48][49]]

[5 5][6][7][8][9]

[0 0][11][2 2][3][4][10][11][12
12]  [13 13]  [14 14]  [15 15]  [16 16]  [17 17]  [18 18]
…[47][48][49]]

在1d阵列上演示了两种方法：

In [64]: data = np.arange(20)
In [65]: test = data[5:10]
In [66]: rest = np.concatenate((data[:5],data[10:]),axis=0)
In [67]: rest
Out[67]: array([ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
In [68]: 
In [68]: mask = np.zeros(data.shape[0], dtype=bool)
In [69]: mask[5:10] = True
In [70]: test = data[mask]
In [71]: rest = data[~mask]
In [72]: rest
Out[72]: array([ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

有一个
np.delete
函数

In [75]: np.delete(data, np.arange(5,10))
Out[75]: array([ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

在内部，它使用我演示的两种方法之一。
在1d阵列上演示的两种方法：

In [64]: data = np.arange(20)
In [65]: test = data[5:10]
In [66]: rest = np.concatenate((data[:5],data[10:]),axis=0)
In [67]: rest
Out[67]: array([ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
In [68]: 
In [68]: mask = np.zeros(data.shape[0], dtype=bool)
In [69]: mask[5:10] = True
In [70]: test = data[mask]
In [71]: rest = data[~mask]
In [72]: rest
Out[72]: array([ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

有一个
np.delete
函数

In [75]: np.delete(data, np.arange(5,10))
Out[75]: array([ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

在内部，它使用了我演示的两种方法之一。
如果您必须手动实现任意数量拆分的k倍方法：我使用了以下解决方案（为交叉验证设置训练和验证）：

如果您必须为任意数量的拆分手动实施k-fold方法：我使用了以下解决方案（为交叉验证设置训练和验证）：

连接两边的切片；结果将是一个副本；结果将是一份副本。