在R中随机化后将数据帧拆分为K倍

我有一个6行的数据框。我想把它分成5层，这样最终会有4个数据帧，每个数据帧有1个元素，最后一个数据帧应该有2个元素。我尝试了以下代码。但这没用。我是R公司的新员工，非常感谢您的帮助

a = matrix(1:12,6,2)
d <- split(a,rep(1:6,each=4))    
Warning message:
In split.default(a, rep(1:6, each = 4)) :
data length is not a multiple of split variable

a=矩阵（1:12,6,2）
d不确定“每个1个元素”的方面，这似乎与R版本的矩阵对象有关，但这里有一种方法可以将满足要求的12个元素的矩阵分解为元素：

split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf)))
$`1`
[1] 1 7

$`2`
[1] 2 3 8 9

$`3`
[1]  4 10

$`4`
[1]  5 11

$`5`
[1]  6 12

如果要将它们返回到两列矩阵中：

lapply( split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf))) ,
        matrix, ncol=2)
$`1`
     [,1] [,2]
[1,]    1    7

$`2`
     [,1] [,2]
[1,]    2    8

$`3`
     [,1] [,2]
[1,]    3    9

$`4`
     [,1] [,2]
[1,]    4   10
[2,]    5   11

$`5`
     [,1] [,2]
[1,]    6   12

不确定“每个1个元素”的方面，这似乎与R版本的矩阵对象有关，但这里有一种方法可以将12个元素的矩阵分解为满足要求的元素：

split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf)))
$`1`
[1] 1 7

$`2`
[1] 2 3 8 9

$`3`
[1]  4 10

$`4`
[1]  5 11

$`5`
[1]  6 12

如果要将它们返回到两列矩阵中：

lapply( split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf))) ,
        matrix, ncol=2)
$`1`
     [,1] [,2]
[1,]    1    7

$`2`
     [,1] [,2]
[1,]    2    8

$`3`
     [,1] [,2]
[1,]    3    9

$`4`
     [,1] [,2]
[1,]    4   10
[2,]    5   11

$`5`
     [,1] [,2]
[1,]    6   12

不确定“每个1个元素”的方面，这似乎与R版本的矩阵对象有关，但这里有一种方法可以将12个元素的矩阵分解为满足要求的元素：

split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf)))
$`1`
[1] 1 7

$`2`
[1] 2 3 8 9

$`3`
[1]  4 10

$`4`
[1]  5 11

$`5`
[1]  6 12

如果要将它们返回到两列矩阵中：

lapply( split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf))) ,
        matrix, ncol=2)
$`1`
     [,1] [,2]
[1,]    1    7

$`2`
     [,1] [,2]
[1,]    2    8

$`3`
     [,1] [,2]
[1,]    3    9

$`4`
     [,1] [,2]
[1,]    4   10
[2,]    5   11

$`5`
     [,1] [,2]
[1,]    6   12

不确定“每个1个元素”的方面，这似乎与R版本的矩阵对象有关，但这里有一种方法可以将12个元素的矩阵分解为满足要求的元素：

split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf)))
$`1`
[1] 1 7

$`2`
[1] 2 3 8 9

$`3`
[1]  4 10

$`4`
[1]  5 11

$`5`
[1]  6 12

如果要将它们返回到两列矩阵中：

lapply( split( matrix(1:12,ncol=2), findInterval(1:6, c(sort(sample(1:6,5)),Inf))) ,
        matrix, ncol=2)
$`1`
     [,1] [,2]
[1,]    1    7

$`2`
     [,1] [,2]
[1,]    2    8

$`3`
     [,1] [,2]
[1,]    3    9

$`4`
     [,1] [,2]
[1,]    4   10
[2,]    5   11

$`5`
     [,1] [,2]
[1,]    6   12

split
期望作为向量，组作为第二个参数。就你而言

ngroups <- 5
floor(seq(1, ngroups, length.out = nrow(a)))

编辑：根据@IShouldByABoat的建议，以下内容也适用于
矩阵
对象：

split.as.data.frame(a, floor(seq(1, ngroups, length.out = nrow(a))))

split
期望作为向量，组作为第二个参数。就你而言

ngroups <- 5
floor(seq(1, ngroups, length.out = nrow(a)))

编辑：根据@IShouldByABoat的建议，以下内容也适用于
矩阵
对象：

split.as.data.frame(a, floor(seq(1, ngroups, length.out = nrow(a))))

split
期望作为向量，组作为第二个参数。就你而言

ngroups <- 5
floor(seq(1, ngroups, length.out = nrow(a)))

编辑：根据@IShouldByABoat的建议，以下内容也适用于
矩阵
对象：

split.as.data.frame(a, floor(seq(1, ngroups, length.out = nrow(a))))

split
期望作为向量，组作为第二个参数。就你而言

ngroups <- 5
floor(seq(1, ngroups, length.out = nrow(a)))

编辑：根据@IShouldByABoat的建议，以下内容也适用于
矩阵
对象：

split.as.data.frame(a, floor(seq(1, ngroups, length.out = nrow(a))))

我在1:6序列上使用模运算符解决了类似的问题。对于您的示例，请尝试以下方法：

a = matrix(1:12, 6, 2)
d = split(as.data.frame(a), 1:6%%5)

很简单，它完成了任务

对于拆分为K个折叠，您可能会发现使用以下方法非常有用：

nfolds = 5
a = matrix(1:12, 6, 2)
folds = 1:nrow(a)%%nfolds  # or sample(1:nrow(a)%%nfolds) if you want to randomize
fold = 1  # which ever fold you want to test with
train = a[folds != fold,]
test = a[folds == fold,]

我在1:6序列上使用模运算符解决了类似的问题。对于您的示例，请尝试以下方法：

a = matrix(1:12, 6, 2)
d = split(as.data.frame(a), 1:6%%5)

很简单，它完成了任务

对于拆分为K个折叠，您可能会发现使用以下方法非常有用：

nfolds = 5
a = matrix(1:12, 6, 2)
folds = 1:nrow(a)%%nfolds  # or sample(1:nrow(a)%%nfolds) if you want to randomize
fold = 1  # which ever fold you want to test with
train = a[folds != fold,]
test = a[folds == fold,]

我在1:6序列上使用模运算符解决了类似的问题。对于您的示例，请尝试以下方法：

a = matrix(1:12, 6, 2)
d = split(as.data.frame(a), 1:6%%5)

很简单，它完成了任务

对于拆分为K个折叠，您可能会发现使用以下方法非常有用：

nfolds = 5
a = matrix(1:12, 6, 2)
folds = 1:nrow(a)%%nfolds  # or sample(1:nrow(a)%%nfolds) if you want to randomize
fold = 1  # which ever fold you want to test with
train = a[folds != fold,]
test = a[folds == fold,]

我在1:6序列上使用模运算符解决了类似的问题。对于您的示例，请尝试以下方法：

a = matrix(1:12, 6, 2)
d = split(as.data.frame(a), 1:6%%5)

很简单，它完成了任务

对于拆分为K个折叠，您可能会发现使用以下方法非常有用：

nfolds = 5
a = matrix(1:12, 6, 2)
folds = 1:nrow(a)%%nfolds  # or sample(1:nrow(a)%%nfolds) if you want to randomize
fold = 1  # which ever fold you want to test with
train = a[folds != fold,]
test = a[folds == fold,]

split
的帮助页面建议使用
split.data.frame
处理矩阵。（它是通用的。）@IShouldBuyABoat我在答案中添加了你的建议。谢谢.split（如.data.frame（a），floor（seq（1，ngroups，length.out=nrow（a）））正在工作，但我想在最后一次折叠中保留剩余的行，我的意思是，在这种情况下，第5组应该有2行。@pa1geek使用
天花板
而不是
地板
，
拆分
的帮助页面建议使用
拆分.data.frame
处理矩阵。（它是通用的。）@IShouldBuyABoat我在答案中添加了你的建议。谢谢.split（如.data.frame（a），floor（seq（1，ngroups，length.out=nrow（a）））正在工作，但我想在最后一次折叠中保留剩余的行，我的意思是，在这种情况下，第5组应该有2行。@pa1geek使用
天花板
而不是
地板
，
拆分
的帮助页面建议使用
拆分.data.frame
处理矩阵。（它是通用的。）@IShouldBuyABoat我在答案中添加了你的建议。谢谢.split（如.data.frame（a），floor（seq（1，ngroups，length.out=nrow（a）））正在工作，但我想在最后一次折叠中保留剩余的行，我的意思是，在这种情况下，第5组应该有2行。@pa1geek使用
天花板
而不是
地板
，
拆分
的帮助页面建议使用
拆分.data.frame
处理矩阵。（它是通用的。）@IShouldBuyABoat我在答案中添加了你的建议。谢谢.split（如.data.frame（a），floor（seq（1，ngroups，length.out=nrow（a）））正在工作，但我想在最后一次折叠中保留剩余的行，我的意思是在这种情况下，第五组应该有2行。@pa1geek使用
天花板
而不是
地板
第二组适合我，但是如何将2行矩阵从$
4
推到最后一行呢？将其设置为'my.matrix'，然后
my.matries[sappy（my.matries，length）]
第二个对我有效，但是如何将2行矩阵从$
4
推到最后一个？将其设置为'my.matrix'，然后
my.matries[sappy（my.matries，length）]
第二个对我有效，但是如何将2行矩阵从$
4
推到最后一个？将其设置为'my.matrix'，然后
my.matries[sappy（my.matries，length）]
第二个对我有效，但是如何将2行矩阵从$
4
推到最后一个？将其设置为'my.matrices'，然后
my.matrices[sappy（my.matrices，length）]