Come dividere i dati in set di training / test usando la funzione sample

Ho appena iniziato a utilizzare R e non sono sicuro di come incorporare il mio set di dati con il seguente codice di esempio:

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

Ho un set di dati che devo inserire in un allenamento (75%) e un test (25%) impostato. Non sono sicuro di quali informazioni dovrei inserire nella x e nella dimensione? X è il file del set di dati e misura quanti campioni ho?

Esistono numerosi approcci per raggiungere il partizionamento dei dati. Per un approccio più completo dai un’occhiata alla funzione createDataPartition nel pacchetto caret .

Qui c’è un semplice esempio:

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

Può essere fatto facilmente da:

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

Utilizzando il pacchetto caTools :

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

Questo è quasi lo stesso codice, ma in un aspetto più gradevole

 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 

Vorrei usare dplyr per questo, lo rende super semplice. Richiede una variabile id nel set di dati, che è comunque una buona idea, non solo per creare set ma anche per tracciabilità durante il tuo progetto. Aggiungilo se non contiene già.

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

Dividerò ‘a’ in treno (70%) e 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,] 

fatto

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

La mia soluzione è sostanzialmente la stessa di dickoa ma un po ‘più semplice da interpretare:

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

Se si digita:

 ?sample 

Se verrà lanciato un menu di aiuto per spiegare cosa significano i parametri della funzione di esempio.

Non sono un esperto, ma ecco un codice che ho:

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

Questo ti darà il 75% di allenamento e il 25% di test.

La mia soluzione mischia le righe, quindi prende il primo 75% delle righe come treno e l’ultimo 25% come 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)),] 

Di seguito una funzione che crea un list di sottocampioni della stessa dimensione che non è esattamente quello che volevi, ma potrebbe rivelarsi utile per gli altri. Nel mio caso creare alberi di classificazione multipli su campioni più piccoli per testare l’overfitting:

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

Esempio :

 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 

Utilizzare il pacchetto caTools nel codice di esempio R sarà il seguente: –

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

Usa base R. La funzione runif genera valori distribuiti uniformsmente da 0 a 1. Con un valore di taglio variabile (train.size nell’esempio seguente), avrai sempre approssimativamente la stessa percentuale di record casuali al di sotto del valore di cutoff.

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

Solo un modo più breve e semplice usando la fantastica libreria 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 funzione sample.split() aggiungerà una colonna aggiuntiva ‘split1’ a dataframe e 2/3 delle righe avranno questo valore come TRUE e altri come FALSE.Ora le righe dove split1 è TRUE saranno copiate in treno e altre righe sarà copiato per testare il dataframe.

C’è un modo molto semplice per selezionare un numero di righe usando l’indice R per righe e colonne. Ciò ti consente di dividere CLEANLY il set di dati in base a un numero di righe, ad esempio il 1 ° 80% dei dati.

In R tutte le righe e le colonne sono indicizzate in modo che DataSetName [1,1] sia il valore assegnato alla prima colonna e alla prima riga di “DataSetName”. Posso selezionare le righe usando [x,] e colonne usando [, x]

Ad esempio: se ho un set di dati chiamato “dati” con 100 righe, posso visualizzare le prime 80 righe usando

Vista (dati [1:80,])

Allo stesso modo posso selezionare queste righe e suddividerle usando:

treno = dati [1:80,]

test = data [81: 100,]

Ora ho i miei dati divisi in due parti senza la possibilità di ricampionare. Facile e veloce.