Ik ben net begonnen met het gebruik van R en ik weet niet zeker hoe ik mijn gegevensset kan opnemen met de volgende voorbeeldcode:

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

Ik heb een dataset die ik nodig heb om in een training (75%) en test (25%) in te stellen.
Ik weet niet zeker welke informatie ik zou moeten doen in de X en de grootte?
Is x het datasetbestand en grootte hoeveel monsters ik heb?

Antwoord 1, Autoriteit 100%

Er zijn talloze benaderingen om data-partitionering te bereiken. Neem voor een completere aanpak een kijkje op de createDataPartitionFunctie in de caToolsPackage.

Hier is een eenvoudig voorbeeld:

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

Antwoord 2, Autoriteit 37%

het kan eenvoudig worden gedaan door:

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

Door Catools pakket:

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

Antwoord 3, Autoriteit 13%

Ik zou dplyrhiervoor gebruiken, maakt het super eenvoudig. Het vereist een ID-variabele in uw dataset, wat toch een goed idee is, niet alleen voor het maken van sets, maar ook voor traceerbaarheid tijdens uw project. Voeg het toe als dit niet al bevat.

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

Antwoord 4, Autoriteit 11%

Dit is bijna dezelfde code, maar in meer mooie uitstraling

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

Antwoord 5, Autoriteit 9%

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

Antwoord 6, Autoriteit 8%

Ik zal ‘A’ in de trein (70%) en 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,]

Gereed

Antwoord 7, Autoriteit 6%

Mijn oplossing is eigenlijk hetzelfde als Dickoa’s, maar een beetje gemakkelijker te interpreteren:

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

Antwoord 8, Autoriteit 4%

Ik kan u adviseren over het gebruik van de rsample pakket:

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

Antwoord 9, Autoriteit 3%

Just een meer korte en eenvoudige manier gebruik geweldig dplyr bibliotheek:

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

Antwoord 10, Autoriteit 2%

Als u typt:

?sample

Als u een help-menu op te roepen om uit te leggen wat de parameters van het voorbeeld van de functie gemiddelde.

Ik ben geen expert, maar hier is wat code die ik heb:

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

Dit zal u 75% trein en 25% test te geven.

Antwoord 11, Autoriteit 2%

Na het kijken door alle verschillende methoden die hier worden geplaatst, heb ik niet zien aan iemand gebruik maken van TRUE/FALSEte selecteren en deselecteren data. Dus ik dacht dat ik zou een methode met behulp van die techniek te delen.

n = nrow(dataset)
split = sample(c(TRUE, FALSE), n, replace=TRUE, prob=c(0.75, 0.25))
training = dataset[split, ]
testing = dataset[!split, ]

Uitleg

Er zijn meerdere manieren om gegevens uit R te selecteren, meestal gebruiken mensen positieve/negatieve indices om respectievelijk te selecteren/deselecteren. Dezelfde functionaliteiten kunnen echter worden bereikt door TRUE/FALSEte gebruiken om te selecteren/deselecteren.

Beschouw het volgende voorbeeld.

# 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

Antwoord 12

Mijn oplossing schudt de rijen, neemt dan de eerste 75% van de rijen als trein en de laatste 25% als test. Supersimpel!

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

Antwoord 13

Het

scorecard-pakket heeft daar een handige functie voor, waar je de verhouding en het zaad kunt specificeren

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

De test- en treingegevens worden opgeslagen in een lijst en zijn toegankelijk door dt_list$trainen dt_list$test

te bellen.

Antwoord 14

Hieronder een functie die een listvan sub-samples van dezelfde groottemaakt, wat niet precies is wat je wilde, maar misschien handig is voor anderen. In mijn geval om meerdere classificatiebomen te maken op kleinere steekproeven om overfitting te testen:

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

Voorbeeld:

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

Antwoord 15

Gebruik caTools-pakket in R
voorbeeldcode is als volgt:-

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

Antwoord 16

Gebruik basis R. Functie runifgenereert uniform verdeelde waarden van 0 tot 1. Door de cutoff-waarde te variëren (train.size in het onderstaande voorbeeld), heeft u altijd ongeveer hetzelfde percentage willekeurige records hieronder de afkapwaarde.

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

Antwoord 17

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)

De functie sample.split()voegt een extra kolom ‘split1’ toe aan het dataframe en 2/3 van de rijen heeft deze waarde als TRUE en andere als FALSE. Nu zijn de rijen waar split1 is TRUE wordt naar de trein gekopieerd en andere rijen worden naar het testdataframe gekopieerd.

Antwoord 18

Ervan uitgaande dat dfuw dataframe is en dat u 75% treinen 25% test

wilt maken

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

Vervolgens een trein maken en dataframes testen

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

Antwoord 19

We kunnen gegevens in een bepaalde verhouding verdelen, het is 80% trein en 20% in een testgegevensset.

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

Antwoord 20

Pas op voor samplevoor het splitsen als u op zoek bent naar reproduceerbare resultaten. Als je gegevens ook maar een klein beetje veranderen, zal de splitsing variëren, zelfs als je set.seedgebruikt. Stel je bijvoorbeeld voor dat de gesorteerde lijst met ID’s in je gegevens alle getallen tussen 1 en 10 zijn. Als je slechts één observatie zou laten vallen, zeg 4, zou steekproeven op locatie een ander resultaat opleveren, omdat nu 5 tot 10 alle verplaatste plaatsen zijn.

Een alternatieve methode is om een hash-functie te gebruiken om ID’s toe te wijzen aan pseudo-willekeurige getallen en vervolgens te samplen op de modificatie van deze getallen. Deze steekproef is stabieler omdat de toewijzing nu wordt bepaald door de hash van elke waarneming, en niet door de relatieve positie.

Bijvoorbeeld:

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

de steekproefomvang is niet precies 5000 omdat toewijzing waarschijnlijk is, maar het zou geen probleem moeten zijn in grote steekproeven dankzij de wet van de grote getallen.

Zie ook: http://blog.richardweiss.org/ 2016/12/25/hash-splits.html
en https://crypto.stackexchange.com/questions/20742 /statistische-eigenschappen-van-hash-functies-wanneer-berekenen-modulo

Antwoord 21

Ik kwam deze tegen, het kan ook helpen.

set.seed(12)
data = Sonar[sample(nrow(Sonar)),]#reshufles the data
bound = floor(0.7 * nrow(data))
df_train = data[1:bound,]
df_test = data[(bound+1):nrow(data),]

Antwoord 22

Maak een indexrij “rowid” en gebruik anti-join om uit te filteren met by = “rowid”. U kunt de rowid-kolom verwijderen door %>% select(-rowid) te gebruiken na de splitsing.

data <- tibble::rowid_to_column(data)

set.seed(11081995)

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

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

Antwoord 23

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

Antwoord 24

Ik denk dat dit het probleem zou oplossen:

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]

Antwoord 25

Ik gebruik liever dplyrom de waarden te mutate

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

Ik kan dplyr::filterblijven gebruiken met hulpfuncties zoals

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

Antwoord 26

Er is een heel eenvoudige manier om een aantal rijen te selecteren met behulp van de R-index voor rijen en kolommen. Hierdoor kunt u de dataset SCHOON splitsen op basis van een aantal rijen – zeg maar de eerste 80% van uw gegevens.

In R worden alle rijen en kolommen geïndexeerd, dus DataSetName[1,1] is de waarde die is toegewezen aan de eerste kolom en eerste rij van “DataSetName”. Ik kan rijen selecteren met [x,] en kolommen met [,x]

Bijvoorbeeld: als ik een dataset heb met de handige naam “data” met 100 rijen, kan ik de eerste 80 rijen bekijken met

Bekijken(gegevens[1:80,])

Op dezelfde manier kan ik deze rijen selecteren en ze subsetten met:

trein = data[1:80,]

test = gegevens[81:100,]

Nu heb ik mijn gegevens in twee delen gesplitst zonder de mogelijkheid om opnieuw te samplen. Snel en gemakkelijk.