Comment diviser les données en ensembles de formation / test en utilisant la fonction échantillon

Je viens de commencer à utiliser R et je ne sais pas comment intégrer mon jeu de données avec l’exemple de code suivant:

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

J’ai un dataset que je dois mettre dans un ensemble de formation (75%) et de test (25%). Je ne suis pas sûr de quelle information je suis censé mettre dans le x et la taille? Est-ce que x est le fichier de jeu de données et la taille du nombre d’échantillons que j’ai?

Il existe de nombreuses approches pour réaliser le partitionnement des données. Pour une approche plus complète, consultez la fonction createDataPartition dans le package caret .

Voici un exemple simple:

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

Cela 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 le package caTools :

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

C’est presque le même code, mais dans un aspect plus agréable

 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 

J’utiliserais dplyr pour cela, le rend très simple. Il nécessite une variable d’identification dans votre dataset, ce qui est une bonne idée, non seulement pour créer des ensembles, mais aussi pour assurer la traçabilité pendant votre projet. Ajoutez-le s’il 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 diviser ‘a’ en train (70%) et 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,] 

terminé

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

Ma solution est fondamentalement la même que celle de Dickoa, mais un peu plus facile à interpréter:

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

Si vous tapez:

 ?sample 

Si lancer un menu d’aide pour expliquer ce que signifient les parameters de la fonction échantillon.

Je ne suis pas un expert, mais voici un code que j’ai:

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

Cela vous donnera 75% de train et 25% de test.

Ma solution mélange les lignes, puis prend le premier 75% des lignes comme train et le dernier 25% comme test. Super simples!

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

Au-dessous d’une fonction qui crée une list de sous-échantillons de la même taille, ce qui n’est pas exactement ce que vous vouliez, mais pourrait s’avérer utile pour d’autres. Dans mon cas, créer plusieurs arbres de classification sur des échantillons plus petits pour tester le sur-ajustement:

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

Exemple :

 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 

Utiliser le package caTools dans l’exemple de code R sera comme suit: –

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

Utiliser la base R. La fonction runif génère des valeurs uniformément dissortingbuées de 0 à 1. En modifiant la valeur de coupure (train.size dans l’exemple ci-dessous), vous aurez toujours approximativement le même pourcentage d’enregistrements aléatoires en dessous de la valeur de coupure.

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

Juste une manière plus brève et plus simple en utilisant la bibliothèque géniale de 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, ] 
 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) 

La fonction sample.split() appenda une colonne supplémentaire «split1» au dataframe et 2/3 des lignes aura cette valeur comme TRUE et d’autres comme FALSE. Maintenant, les lignes où split1 est TRUE seront copiées dans le train et les autres lignes sera copié pour tester le dataframe.

Il existe un moyen très simple de sélectionner un nombre de lignes à l’aide de l’index R pour les lignes et les colonnes. Cela vous permet de scinder en toute transparence le jeu de données en fonction du nombre de lignes – disons le premier 80% de vos données.

Dans R, toutes les lignes et toutes les colonnes sont indexées afin que DataSetName [1,1] soit la valeur affectée à la première colonne et à la première ligne de “DataSetName”. Je peux sélectionner des lignes en utilisant [x,] et les colonnes en utilisant [, x]

Par exemple: Si je dispose d’un dataset nommé «données» avec 100 lignes, je peux afficher les 80 premières lignes à l’aide de

Voir (données [1:80,])

De la même manière, je peux sélectionner ces lignes et les sous-ensembles en utilisant:

train = données [1:80,]

test = données [81: 100,]

Maintenant, mes données sont divisées en deux parties sans possibilité de rééchantillonnage. Rapide et facile.