Comment diviser les données en formation/ensembles de test échantillon à l'aide de la fonction

Il peut être fait facilement par:

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, ]

En utilisant caTools package:

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

Je voudrais utiliser dplyr pour cela, le rend super simple. Il nécessite une variable id de votre jeu de données, ce qui est une bonne idée de toute façon, non seulement pour créer des ensembles, mais aussi pour la traçabilité au cours de votre projet. Ajouter si elle ne contient pas déjà.

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

Je vais split 'a' en train(70%) et de test(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,]

fait

Juste un plus bref et de manière simple à l'aide génial dplyr bibliothèque:

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, ]

Après en regardant à travers toutes les différentes méthodes de posté ici, je n'ai vu personne utiliser TRUE/FALSE pour sélectionner et désélectionner des données. J'ai donc pensé que je voudrais partager une méthode utilisant cette technique.

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

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

Explication

Il y a plusieurs façons de sélectionner des données à partir de R, le plus souvent les gens utilisent positif/négatif indices pour sélectionner/désélectionner respectivement. Cependant, les mêmes fonctionnalités peuvent être obtenues en utilisant des TRUE/FALSE pour sélectionner/désélectionner.

Considérons l'exemple suivant.

# 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

scorecard paquet a une fonction utile pour qui, où vous pouvez spécifier le ratio et de graines

library(scorecard)

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

Le tester et former les données sont stockées dans une liste et peut être accessible en appelant dt_list$train et dt_list$test

Utilisation caTools paquet dans la R
exemple de code sera comme suit:-

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

Je peux suggérer à l'aide de la réchantillon package:

# 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)

En supposant df est votre bloc de données, et que vous souhaitez créer 75% train et 25% test

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

Puis de créer un train et test des trames de données

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

Méfiez-vous des sample pour partager si vous recherchez des résultats reproductibles. Si vos données changent, même légèrement, la scission aura varier, même si vous utilisez set.seed. Imaginez, par exemple, la liste triée des Identifiants de données vous est tous les nombres entre 1 et 10. Si vous venez de tomber une observation, dire 4, l'échantillonnage par emplacement donnerait un des résultats différents car maintenant 5 à 10 tous les déplacés des lieux.

Une méthode alternative consiste à utiliser une fonction de hachage pour les Id de mappage dans certains pseudo-aléatoire de nombres, et l'échantillon sur le mod de ces numéros. Cet échantillon est plus stable, car l'affectation est aujourd'hui déterminée par la valeur de hachage de chaque observation, et non pas par sa position relative.

Par exemple:

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

la taille de l'échantillon n'est pas exactement 5000 parce que l'affectation est probabiliste, mais il ne devrait pas être un problème dans des échantillons de grande taille grâce à la loi des grands nombres.

Voir aussi: http://blog.richardweiss.org/2016/12/25/hash-splits.html
et https://crypto.stackexchange.com/questions/20742/statistical-properties-of-hash-functions-when-calculating-modulo

Nous pouvons diviser les données d'un rapport ici, il est de 80% train et à 20% dans un ensemble de données de test.

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