wake-up-neo.com

So teilen Sie Daten mithilfe der Musterfunktion in Trainings-/Testsets auf

Ich habe gerade mit R angefangen und bin mir nicht sicher, wie ich mein Dataset mit dem folgenden Beispielcode integrieren kann: 

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

Ich habe einen Datensatz, den ich in ein Trainings- (75%) und Test-Set (25%) legen muss .. Ich bin nicht sicher, welche Informationen ich in das X und die Größe stecken soll x die Datensatzdatei und wie viele Proben habe ich? 

124
Susie Humby

Es gibt zahlreiche Ansätze zur Datenpartitionierung. Um einen umfassenderen Ansatz zu erhalten, werfen Sie einen Blick auf die Funktion createDataPartition im Paket caret.

Hier ist ein einfaches Beispiel:

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

Es kann leicht gemacht werden durch:

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

Verwenden Sie caTools package:

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

Dies ist fast derselbe Code, aber in mehr nettem Look

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
26

Ich würde dplyr dafür verwenden, macht es super einfach. Es erfordert eine id-Variable in Ihrem Datensatz, was ohnehin eine gute Idee ist, nicht nur zum Erstellen von Sets, sondern auch zur Rückverfolgbarkeit während Ihres Projekts. Fügen Sie es hinzu, wenn es nicht bereits enthält.

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

Ich werde 'a' in train (70%) und testen (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,]

erledigt

18
hyunwoo jeong
library(caret)
intrain<-createDataPartition(y=sub_train$classe,p=0.7,list=FALSE)
training<-m_train[intrain,]
testing<-m_train[-intrain,]
17
pradnya chavan

Meine Lösung ist im Grunde dieselbe wie die von Dickoa, aber etwas einfacher zu interpretieren:

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

Nur eine kurzere und einfachere Möglichkeit, awesome dplyr library zu verwenden:

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, ]
5
SHi ON

Wenn Sie Folgendes eingeben: 

?sample

Wenn ein Hilfemenü geöffnet wird, wird erläutert, was die Parameter der Beispielfunktion bedeuten. 

Ich bin kein Experte, aber hier ist ein Code, den ich habe:

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

Dies gibt Ihnen 75% Training und 25% Test.

5
user2502836

Meine Lösung mischt die Reihen, nimmt dann die ersten 75% der Reihen als Zug und die letzten 25% als Test. Super einfach!

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)),]
3
Johnny V

Darunter eine Funktion, die einelist von Sub-Samples gleicher Größe erstellt die nicht genau das ist, was Sie wollten, aber für andere nützlich sein könnte. In meinem Fall erstellen Sie mehrere Klassifizierungsbäume auf kleineren Stichproben, um die Überanpassung zu 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)
}

Beispiel:

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
2
Yohan Obadia

Verwenden Sie das caTools-Paket in R Beispielcode lautet wie folgt: -

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

Basis R verwenden. Die Funktion runif erzeugt gleichmäßig verteilte Werte von 0 bis 1. Durch variierenden Cutoff-Wert (train.size im Beispiel unten) haben Sie immer ungefähr denselben Prozentsatz an Zufallsdatensätzen unter dem Cutoff-Wert.

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

Ich bin auf dieses gestoßen, es kann auch helfen.

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

scorecard package hat dafür eine nützliche Funktion, bei der Sie das Verhältnis und den Startwert angeben können

library(scorecard)

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

Die Test- und Zugdaten werden in einer Liste gespeichert und können durch Aufrufen von dt_list$train und dt_list$test abgerufen werden.

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

Die Funktion sample.split() fügt dem Datenrahmen eine zusätzliche Spalte 'split1' hinzu, und 2/3 der Zeilen haben diesen Wert als TRUE und andere als FALSE. Jetzt werden die Zeilen, in denen split1 TRUE ist, in den Zug kopiert und die anderen Zeilen werden kopiert Testdatenrahmen.

1
Abhishek

Ich kann vorschlagen, das Paket rsample zu verwenden:

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

Angenommen, df ist Ihr Datenrahmen, und Sie möchten 75% train und 25% test erstellen.

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

Dann erstellen Sie einen Zug und testen Datenrahmen

df_train <- df[train_i,]
df_test <- df[test_i,]
1
Corentin
set.seed(123)
llwork<-sample(1:length(mydata),round(0.75*length(mydata),digits=0)) 
wmydata<-mydata[llwork, ]
tmydata<-mydata[-llwork, ]
0
Xavier Jiménez

Nachdem ich alle hier veröffentlichten Methoden durchgesehen hatte, sah ich niemanden, der TRUE/FALSE zum Auswählen und Deaktivieren von Daten verwendete. Also dachte ich, ich würde eine Methode teilen, die diese Technik anwendet.

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

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

Erläuterung

Es gibt mehrere Möglichkeiten, Daten aus R auszuwählen. Meistens verwenden Leute positive/negative Indizes, um sie auszuwählen bzw. die Auswahl aufzuheben. Dieselben Funktionalitäten können jedoch erreicht werden, indem Sie TRUE/FALSE zum Auswählen/Deaktivieren auswählen.

Betrachten Sie das folgende Beispiel.

# 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
0
Joe

Hüten Sie sich vor sample beim Spalten, wenn Sie nach reproduzierbaren Ergebnissen suchen. Wenn sich Ihre Daten sogar geringfügig ändern, variiert die Aufteilung, auch wenn Sie set.seed verwenden. Stellen Sie sich zum Beispiel vor, die sortierte Liste der IDs in Ihren Daten besteht aus allen Zahlen zwischen 1 und 10. Wenn Sie nur eine Beobachtung, z. B. 4, fallen gelassen haben, führt das Abtasten nach Standort zu unterschiedlichen Ergebnissen, da jetzt 5 bis 10 alle bewegten Stellen angezeigt werden. 

Eine alternative Methode besteht darin, eine Hash-Funktion zu verwenden, um IDs in einige Pseudo-Zufallszahlen abzubilden und dann die Mod dieser Zahlen abzutasten. Dieses Beispiel ist stabiler, da die Zuweisung jetzt vom Hash jeder Beobachtung und nicht von ihrer relativen Position bestimmt wird.

Zum Beispiel:

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

die Stichprobengröße ist nicht genau 5000, da die Zuweisung wahrscheinlich ist, aber bei großen Stichproben sollte dies aufgrund des Gesetzes großer Zahlen kein Problem sein.

Siehe auch: http://blog.richardweiss.org/2016/12/25/hash-splits.html Und https://crypto.stackexchange.com/questions/20742/statistical- Eigenschaften-von-Hash-Funktionen-Wenn-Berechnen-Modulo

0
dzeltzer