说明

Question

我刚开始使用R而我不知道如何将我的数据集与以下示例代码合并：

sample(x, size, replace = FALSE, prob = NULL)

我有一个数据集，我需要进行培训（75％）和测试（25％）设置。我不确定我应该把什么信息放入x和大小？ x是数据集文件，并确定了我有多少个样本？

Answer 1

有许多方法可以实现数据分区。有关更完整的方法，请查看createDataPartition包中的caret函数。

这是一个简单的例子：

data(mtcars)

## 75% of the sample size
smp_size <- floor(0.75 * nrow(mtcars))

## set the seed to make your partition reproducible
set.seed(123)
train_ind <- sample(seq_len(nrow(mtcars)), size = smp_size)

train <- mtcars[train_ind, ]
test <- mtcars[-train_ind, ]

Answer 2

可以通过以下方式轻松完成：

set.seed(101) # Set Seed so that same sample can be reproduced in future also
# Now Selecting 75% of data as sample from total 'n' rows of the data  
sample <- sample.int(n = nrow(data), size = floor(.75*nrow(data)), replace = F)
train <- data[sample, ]
test  <- data[-sample, ]

使用caTools包：

require(caTools)
set.seed(101) 
sample = sample.split(data$anycolumn, SplitRatio = .75)
train = subset(data, sample == TRUE)
test  = subset(data, sample == FALSE)

Answer 3

这几乎是相同的代码，但看起来更漂亮

bound <- floor((nrow(df)/4)*3)         #define % of training and test set

df <- df[sample(nrow(df)), ]           #sample rows 
df.train <- df[1:bound, ]              #get training set
df.test <- df[(bound+1):nrow(df), ]    #get test set

Answer 4

我会使用dplyr来使它变得非常简单。它确实需要在您的数据集中使用id变量，这无论如何都是一个好主意，不仅用于创建集合，还用于项目期间的可跟踪性。如果不包含，请添加。

mtcars$id <- 1:nrow(mtcars)
train <- mtcars %>% dplyr::sample_frac(.75)
test  <- dplyr::anti_join(mtcars, train, by = 'id')

Answer 5

我将分开＆＃39; a＆＃39;进入火车（70％）和考试（30％）

    a # original data frame
    library(dplyr)
    train<-sample_frac(a, 0.7)
    sid<-as.numeric(rownames(train)) # because rownames() returns character
    test<-a[-sid,]

完成

Answer 6

library(caret)
intrain<-createDataPartition(y=sub_train$classe,p=0.7,list=FALSE)
training<-m_train[intrain,]
testing<-m_train[-intrain,]

Answer 7

我的解决方案与dickoa基本相同，但更容易理解：

data(mtcars)
n = nrow(mtcars)
trainIndex = sample(1:n, size = round(0.7*n), replace=FALSE)
train = mtcars[trainIndex ,]
test = mtcars[-trainIndex ,]

Answer 8

使用真棒 dplyr 库只是一种更简单明了的方式：

library(dplyr)
set.seed(275) #to get repeatable data

data.train <- sample_frac(Default, 0.7)

train_index <- as.numeric(rownames(data.train))
data.test <- Default[-train_index, ]

Answer 9

如果输入：

?sample

如果要启动帮助菜单来解释样本函数的参数含义。

我不是专家，但这里有一些代码：

data <- data.frame(matrix(rnorm(400), nrow=100))
splitdata <- split(data[1:nrow(data),],sample(rep(1:4,as.integer(nrow(data)/4))))
test <- splitdata[[1]]
train <- rbind(splitdata[[1]],splitdata[[2]],splitdata[[3]])

这将为您提供75％的火车和25％的测试。

Answer 10

我的解决方案对行进行洗牌，然后将前75％的行作为列，将最后25％作为测试。超级简单！

row_count <- nrow(orders_pivotted)
shuffled_rows <- sample(row_count)
train <- orders_pivotted[head(shuffled_rows,floor(row_count*0.75)),]
test <- orders_pivotted[tail(shuffled_rows,floor(row_count*0.25)),]

Answer 11

使用基数R.函数data(mtcars) set.seed(123) #desired proportion of records in training set train.size<-.7 #true/false vector of values above/below the cutoff above train.ind<-runif(nrow(mtcars))<train.size #train train.df<-mtcars[train.ind,] #test test.df<-mtcars[!train.ind,]生成从0到1的均匀分布值。通过变化的截止值（下面的示例中的train.size），您将始终在截止值以下具有大致相同的随机记录百分比

namespace AppBundle\Listener;


use Doctrine\ORM\EntityManager;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Http\Event\InteractiveLoginEvent;

class LoginListener
{

    private $session;
    private $tokenstorageInterface;
    private $em;
    private $container;

    public function __construct(TokenStorageInterface $tokenStorageInterface)
    {
        $this->tokenstorageInterface = $tokenStorageInterface;
    }


    public function onLogin(InteractiveLoginEvent $event)
    {
        //toDo onLogin
    }

}

Answer 12

在R中使用caTools包示例代码如下： -

data
split = sample.split(data$DependentcoloumnName, SplitRatio = 0.6)
training_set = subset(data, split == TRUE)
test_set = subset(data, split == FALSE)

Answer 13

在创建 list相同大小的子样本的函数下面，这不是您想要的，但可能对其他人有用。在我的例子中，在较小的样本上创建多个分类树来测试过度拟合：

df_split <- function (df, number){
  sizedf      <- length(df[,1])
  bound       <- sizedf/number
  list        <- list() 
  for (i in 1:number){
    list[i] <- list(df[((i*bound+1)-bound):(i*bound),])
  }
  return(list)
}

示例：

x <- matrix(c(1:10), ncol=1)
x
# [,1]
# [1,]    1
# [2,]    2
# [3,]    3
# [4,]    4
# [5,]    5
# [6,]    6
# [7,]    7
# [8,]    8
# [9,]    9
#[10,]   10

x.split <- df_split(x,5)
x.split
# [[1]]
# [1] 1 2

# [[2]]
# [1] 3 4

# [[3]]
# [1] 5 6

# [[4]]
# [1] 7 8

# [[5]]
# [1] 9 10

Answer 14

scorecard软件包为此提供了有用的功能，您可以在其中指定比例和种子

library(scorecard)

dt_list <- split_df(mtcars, ratio = 0.75, seed = 66)

测试和训练数据存储在列表中，可以通过调用dt_list$train和dt_list$test

进行访问

Answer 15

require(caTools)

set.seed(101)            #This is used to create same samples everytime

split1=sample.split(data$anycol,SplitRatio=2/3)

train=subset(data,split1==TRUE)

test=subset(data,split1==FALSE)

sample.split()功能会添加一个额外的列＆＃39; split1＆＃39;数据帧和2/3的行将此值设置为TRUE，其他行的值为FALSE。现在，split1为TRUE的行将被复制到train中，其他行将被复制到测试数据帧。

Answer 16

我建议使用rsample软件包：

# choosing 75% of the data to be the training data
data_split <- initial_split(data, prop = .75)
# extracting training data and test data as two seperate dataframes
data_train <- training(data_split)
data_test  <- testing(data_split)

Answer 17

假设 df 是您的数据框，并且您要创建 75％训练和 25％测试

all <- 1:nrow(df)
train_i <- sort(sample(all, round(nrow(df)*0.75,digits = 0),replace=FALSE))
test_i <- all[-train_i]

然后创建火车并测试数据框

df_train <- df[train_i,]
df_test <- df[test_i,]

Answer 18

查看了此处发布的所有不同方法之后，我看不到有人利用TRUE/FALSE来选择和取消选择数据。所以我想我会分享一种利用该技术的方法。

n = nrow(dataset)
split = sample(c(TRUE, FALSE), n, replace=TRUE, prob=c(0.75, 0.25))

training = dataset[split, ]
testing = dataset[!split, ]

说明

有多种方法可以从R中选择数据，最常见的是人们分别使用正/负索引来选择/取消选择。但是，使用TRUE/FALSE选择/取消选择可以实现相同的功能。

请考虑以下示例。

# let's explore ways to select every other element
data = c(1, 2, 3, 4, 5)


# using positive indices to select wanted elements
data[c(1, 3, 5)]
[1] 1 3 5

# using negative indices to remove unwanted elements
data[c(-2, -4)]
[1] 1 3 5

# using booleans to select wanted elements
data[c(TRUE, FALSE, TRUE, FALSE, TRUE)]
[1] 1 3 5

# R recycles the TRUE/FALSE vector if it is not the correct dimension
data[c(TRUE, FALSE)]
[1] 1 3 5

Answer 19

创建一个索引行“rowid”并使用反连接过滤掉使用by =“rowid”。您可以在拆分后使用 %>% select(-rowid) 删除 rowid 列。

<块引用>

数据 <- tibble::rowid_to_column(data)

set.seed(11081995)

testdata <- data %>% slice_sample(prop = 0.2)

traindata <- anti_join(data, testdata, by = "rowid")

Answer 20

当您寻找可重复的结果时，请注意sample进行拆分。如果您的数据变化很小，即使您使用set.seed，拆分也会有所不同。例如，假设您数据中ID的排序列表是1到10之间的所有数字。如果您只删除了一个观测值（例如4），则按位置采样将产生不同的结果，因为现在所有移动的位置都有5到10个。

另一种方法是使用哈希函数将ID映射到一些伪随机数，然后对这些数字的mod进行采样。该示例更加稳定，因为赋值现在由每个观察值的哈希值决定，而不是由其相对位置决定。

例如：

require(openssl)  # for md5
require(data.table)  # for the demo data

set.seed(1)  # this won't help `sample`

population <- as.character(1e5:(1e6-1))  # some made up ID names

N <- 1e4  # sample size

sample1 <- data.table(id = sort(sample(population, N)))  # randomly sample N ids
sample2 <- sample1[-sample(N, 1)]  # randomly drop one observation from sample1

# samples are all but identical
sample1
sample2
nrow(merge(sample1, sample2))

[1] 9999

# row splitting yields very different test sets, even though we've set the seed
test <- sample(N-1, N/2, replace = F)

test1 <- sample1[test, .(id)]
test2 <- sample2[test, .(id)]
nrow(test1)

[1] 5000

nrow(merge(test1, test2))

[1] 2653

# to fix that, we can use some hash function to sample on the last digit

md5_bit_mod <- function(x, m = 2L) {
  # Inputs: 
  #  x: a character vector of ids
  #  m: the modulo divisor (modify for split proportions other than 50:50)
  # Output: remainders from dividing the first digit of the md5 hash of x by m
  as.integer(as.hexmode(substr(openssl::md5(x), 1, 1)) %% m)
}

# hash splitting preserves the similarity, because the assignment of test/train 
# is determined by the hash of each obs., and not by its relative location in the data
# which may change 
test1a <- sample1[md5_bit_mod(id) == 0L, .(id)]
test2a <- sample2[md5_bit_mod(id) == 0L, .(id)]
nrow(merge(test1a, test2a))

[1] 5057

nrow(test1a)

[1] 5057

由于分配是概率性的，因此样本大小不完全是5000，但是由于大数定律，在大样本中这不是问题。

另请参阅：http://blog.richardweiss.org/2016/12/25/hash-splits.html 和https://crypto.stackexchange.com/questions/20742/statistical-properties-of-hash-functions-when-calculating-modulo

Answer 21

set.seed(123)
llwork<-sample(1:length(mydata),round(0.75*length(mydata),digits=0)) 
wmydata<-mydata[llwork, ]
tmydata<-mydata[-llwork, ]

Answer 22

我碰到了这个，它也有帮助。

DepartmentViewModel

Answer 23

我们可以将数据划分为特定比例，在测试数据集中，该比例为80％的训练和20％。

ind <- sample(2, nrow(dataName), replace = T, prob = c(0.8,0.2))
train <- dataName[ind==1, ]
test <- dataName[ind==2, ]

Answer 24

我认为这可以解决问题：

df = data.frame(read.csv("data.csv"))
# Split the dataset into 80-20
numberOfRows = nrow(df)
bound = as.integer(numberOfRows *0.8)
train=df[1:bound ,2]
test1= df[(bound+1):numberOfRows ,2]

Answer 25

我更喜欢使用 dplyr 来 mutate 的值

set.seed(1)
mutate(x, train = runif(1) < 0.75)

我可以继续将 dplyr::filter 与辅助函数一起使用，例如

data.split <- function(is_train = TRUE) {
    set.seed(1)
    mutate(x, train = runif(1) < 0.75) %>%
    filter(train == is_train)
}

Answer 26

有一种非常简单的方法可以使用R索引选择行和列的行数。这使您可以根据给定的行数清晰地拆分数据集-例如，数据的前80％。

在R中，所有行和列都已索引，因此DataSetName [1,1]是分配给“ DataSetName”的第一列和第一行的值。我可以使用[x，]选择行，并使用[，x]

选择列

例如：如果我有一个方便地命名为“ data”的数据集，其中包含100行，则可以使用

查看前80行

查看（数据[1:80，]）

以相同的方式，我可以选择这些行并使用：

火车=数据[1:80，]

test =数据[81：100，]

现在，我将数据分为两部分，无法重新采样。快速简便。

如何使用样本函数将数据拆分为训练/测试集

26 个答案:

说明