R में निम्नलिखित डमी-चर उत्पन्न करने में मुझे परेशानी होती है:
मैं वार्षिक समय श्रृंखला डेटा (समय अवधि 1948-2009) का विश्लेषण कर रहा हूं। मेरे दो सवाल हैं:
मैं वर्ष 1957 (मान = 1 1957 और शून्य अन्यथा) के अवलोकन के लिए एक डमी चर कैसे उत्पन्न करूं?
मैं एक डमी चर कैसे उत्पन्न करता हूं जो 1957 से पहले शून्य है और 1957 से 1 और 2009 के बाद का मूल्य 1 लेता है।
जवाबों:
एक और विकल्प जो आपके कई चर है factorऔर बेहतर हो सकता है model.matrix।
> year.f = factor(year)
> dummies = model.matrix(~year.f)
इसमें आपके डेटा सेट में प्रत्येक को छोड़कर एक इंटरसेप्ट कॉलम (सभी वाले) और एक कॉलम शामिल होगा, जो "डिफ़ॉल्ट" या इंटरसेप्ट वैल्यू होगा।
आप यह बदल सकते हैं कि किस तरह से गड़बड़ करके "डिफ़ॉल्ट" चुना गया contrasts.argहै model.matrix।
इसके अलावा, यदि आप अवरोधन को छोड़ना चाहते हैं, तो आप पहले कॉलम को छोड़ सकते हैं या +0सूत्र के अंत में जोड़ सकते हैं ।
आशा है कि यह उपयोगी है।
+ 0 या तो निकाल सकते हैं - 1। तो model.matrix(~ year.f + 0)एक संदर्भ स्तर के बिना एक डमी चर दे देंगे।
इन डमी चर का उत्पादन करने का सबसे सरल तरीका कुछ इस प्रकार है:
> print(year)
[1] 1956 1957 1957 1958 1958 1959
> dummy <- as.numeric(year == 1957)
> print(dummy)
[1] 0 1 1 0 0 0
> dummy2 <- as.numeric(year >= 1957)
> print(dummy2)
[1] 0 1 1 1 1 1
आमतौर पर, आप ifelseएक शर्त के आधार पर दो मूल्यों के बीच चयन करने के लिए उपयोग कर सकते हैं। इसलिए यदि आप 0-1 डमी वैरिएबल के बजाय किसी कारण से, 4 और 7 का उपयोग करना चाहते हैं, तो आप उपयोग कर सकते हैं ifelse(year == 1957, 4, 7)।
पैकेज mlrमें createDummyFeaturesइस उद्देश्य के लिए शामिल हैं :
library(mlr)
df <- data.frame(var = sample(c("A", "B", "C"), 10, replace = TRUE))
df
# var
# 1 B
# 2 A
# 3 C
# 4 B
# 5 C
# 6 A
# 7 C
# 8 A
# 9 B
# 10 C
createDummyFeatures(df, cols = "var")
# var.A var.B var.C
# 1 0 1 0
# 2 1 0 0
# 3 0 0 1
# 4 0 1 0
# 5 0 0 1
# 6 1 0 0
# 7 0 0 1
# 8 1 0 0
# 9 0 1 0
# 10 0 0 1
createDummyFeatures मूल चर बूँदें।
https://www.rdocumentation.org/packages/mlr/versions/2.9/topics/createDummyFeatures
.....
इस कार्य को पूरा करने के लिए यहां अन्य उत्तर सीधे मार्ग प्रदान करते हैं - एक जो कई मॉडल (जैसे lm) आंतरिक रूप से आपके लिए वैसे भी करेंगे। बहरहाल, यहां मैक्स कुह्न के लोकप्रिय caretऔर recipesपैकेज के साथ डमी वैरिएबल बनाने के तरीके दिए गए हैं। जबकि कुछ हद तक अधिक क्रियात्मक, वे दोनों अधिक जटिल परिस्थितियों में आसानी से बड़े पैमाने पर होते हैं, और बड़े करीने से अपने संबंधित ढांचे में फिट होते हैं।
caret::dummyVarsसाथ caret, प्रासंगिक कार्य है dummyVars, एक है जो predictएक डेटा फ्रेम पर यह लागू करने का तरीका:
df <- data.frame(letter = rep(c('a', 'b', 'c'), each = 2),
y = 1:6)
library(caret)
dummy <- dummyVars(~ ., data = df, fullRank = TRUE)
dummy
#> Dummy Variable Object
#>
#> Formula: ~.
#> 2 variables, 1 factors
#> Variables and levels will be separated by '.'
#> A full rank encoding is used
predict(dummy, df)
#> letter.b letter.c y
#> 1 0 0 1
#> 2 0 0 2
#> 3 1 0 3
#> 4 1 0 4
#> 5 0 1 5
#> 6 0 1 6
recipes::step_dummyसाथ recipes, प्रासंगिक कार्य है step_dummy:
library(recipes)
dummy_recipe <- recipe(y ~ letter, df) %>%
step_dummy(letter)
dummy_recipe
#> Data Recipe
#>
#> Inputs:
#>
#> role #variables
#> outcome 1
#> predictor 1
#>
#> Steps:
#>
#> Dummy variables from letter
संदर्भ के आधार पर, डेटा को या prepतो bakeऔर juice:
# Prep and bake on new data...
dummy_recipe %>%
prep() %>%
bake(df)
#> # A tibble: 6 x 3
#> y letter_b letter_c
#> <int> <dbl> <dbl>
#> 1 1 0 0
#> 2 2 0 0
#> 3 3 1 0
#> 4 4 1 0
#> 5 5 0 1
#> 6 6 0 1
# ...or use `retain = TRUE` and `juice` to extract training data
dummy_recipe %>%
prep(retain = TRUE) %>%
juice()
#> # A tibble: 6 x 3
#> y letter_b letter_c
#> <int> <dbl> <dbl>
#> 1 1 0 0
#> 2 2 0 0
#> 3 3 1 0
#> 4 4 1 0
#> 5 5 0 1
#> 6 6 0 1
Usecase के लिए जैसा कि प्रश्न में प्रस्तुत किया गया है, आप केवल तार्किक स्थिति को 1(या शायद इससे भी बेहतर, इसके साथ 1L) गुणा कर सकते हैं :
# example data
df1 <- data.frame(yr = 1951:1960)
# create the dummies
df1$is.1957 <- 1L * (df1$yr == 1957)
df1$after.1957 <- 1L * (df1$yr >= 1957)
जो देता है:
> df1
yr is.1957 after.1957
1 1951 0 0
2 1952 0 0
3 1953 0 0
4 1954 0 0
5 1955 0 0
6 1956 0 0
7 1957 1 1
8 1958 0 1
9 1959 0 1
10 1960 0 1
उदाहरण के लिए @ zx8754 और @Sosos के उदाहरण के रूप में प्रस्तुत किए गए usecases के लिए, अभी भी कुछ अन्य विकल्प हैं, जिन्हें अभी तक कवर नहीं किया गया है।
1) अपने अनुकूल बनाएं make_dummiesसमारोह
# example data
df2 <- data.frame(id = 1:5, year = c(1991:1994,1992))
# create a function
make_dummies <- function(v, prefix = '') {
s <- sort(unique(v))
d <- outer(v, s, function(v, s) 1L * (v == s))
colnames(d) <- paste0(prefix, s)
d
}
# bind the dummies to the original dataframe
cbind(df2, make_dummies(df2$year, prefix = 'y'))
जो देता है:
id year y1991 y1992 y1993 y1994
1 1 1991 1 0 0 0
2 2 1992 0 1 0 0
3 3 1993 0 0 1 0
4 4 1994 0 0 0 1
5 5 1992 0 1 0 0
2) का उपयोग करें dcast या तो से -function काविवरण सारणी या reshape2
dcast(df2, id + year ~ year, fun.aggregate = length)
जो देता है:
id year 1991 1992 1993 1994
1 1 1991 1 0 0 0
2 2 1992 0 1 0 0
3 3 1993 0 0 1 0
4 4 1994 0 0 0 1
5 5 1992 0 1 0 0
हालाँकि, यह तब काम नहीं करेगा जब कॉलम में डुप्लिकेट मान हों, जिसके लिए डमी बनाना होगा। मामले में एक विशिष्ट एकत्रीकरण समारोह की आवश्यकता है dcastऔर dcastमूल में वापस विलय की आवश्यकता का परिणाम है :
# example data
df3 <- data.frame(var = c("B", "C", "A", "B", "C"))
# aggregation function to get dummy values
f <- function(x) as.integer(length(x) > 0)
# reshape to wide with the cumstom aggregation function and merge back to the original
merge(df3, dcast(df3, var ~ var, fun.aggregate = f), by = 'var', all.x = TRUE)
जो देता है (ध्यान दें कि byकॉलम के अनुसार परिणाम का आदेश दिया गया है ):
var A B C
1 A 1 0 0
2 B 0 1 0
3 B 0 1 0
4 C 0 0 1
5 C 0 0 1
3) का उपयोग करें spread से -function काtidyr (साथ में mutate सेdplyr)
library(dplyr)
library(tidyr)
df2 %>%
mutate(v = 1, yr = year) %>%
spread(yr, v, fill = 0)
जो देता है:
id year 1991 1992 1993 1994
1 1 1991 1 0 0 0
2 2 1992 0 1 0 0
3 3 1993 0 0 1 0
4 4 1994 0 0 0 1
5 5 1992 0 1 0 0
मैं इस तरह के डमी चर के साथ काम करने के लिए सामान्य रूप से क्या करता हूं:
(१) मैं १ ९ ५ value यानी १ ९ ५) के मूल्य (१ = १ ९ और शून्य) के लिए अवलोकन संख्या १० के लिए एक डमी चर कैसे उत्पन्न करूँ?
data$factor_year_1 <- factor ( with ( data, ifelse ( ( year == 1957 ), 1 , 0 ) ) )
(२) मैं एक डमी-चर कैसे उत्पन्न करता हूं जो १ ९ ५ takes से पहले शून्य है और १ ९ ५ and से १ और बाद में २०० ९ तक मान लेता है।
data$factor_year_2 <- factor ( with ( data, ifelse ( ( year < 1957 ), 0 , 1 ) ) )
फिर, मैं इस कारक को अपने मॉडलों में एक डमी चर के रूप में पेश कर सकता हूं। उदाहरण के लिए, यह देखने के लिए कि क्या परिवर्तनीय में दीर्घकालिक प्रवृत्ति है y :
summary ( lm ( y ~ t, data = data ) )
उम्मीद है की यह मदद करेगा!
यदि आप K-1 के बजाय K डमी चर प्राप्त करना चाहते हैं, तो प्रयास करें:
dummies = table(1:length(year),as.factor(year))
श्रेष्ठ,
as.data.frame.matrix(dummies)इसे एक में अनुवाद करने के लिए उपयोग करें
मैंने इसे कागल फोरम पर पढ़ा:
#Generate example dataframe with character column
example <- as.data.frame(c("A", "A", "B", "F", "C", "G", "C", "D", "E", "F"))
names(example) <- "strcol"
#For every unique value in the string column, create a new 1/0 column
#This is what Factors do "under-the-hood" automatically when passed to function requiring numeric data
for(level in unique(example$strcol)){
example[paste("dummy", level, sep = "_")] <- ifelse(example$strcol == level, 1, 0)
}
ifelseसमारोह इस तरह सरल तर्क के लिए सबसे अच्छा है।
> x <- seq(1950, 1960, 1)
ifelse(x == 1957, 1, 0)
ifelse(x <= 1957, 1, 0)
> [1] 0 0 0 0 0 0 0 1 0 0 0
> [1] 1 1 1 1 1 1 1 1 0 0 0
इसके अलावा, यदि आप चाहते हैं कि यह चरित्र डेटा वापस करे तो आप ऐसा कर सकते हैं।
> x <- seq(1950, 1960, 1)
ifelse(x == 1957, "foo", "bar")
ifelse(x <= 1957, "foo", "bar")
> [1] "bar" "bar" "bar" "bar" "bar" "bar" "bar" "foo" "bar" "bar" "bar"
> [1] "foo" "foo" "foo" "foo" "foo" "foo" "foo" "foo" "bar" "bar" "bar"
घोंसले के शिकार के साथ श्रेणीबद्ध चर ...
> x <- seq(1950, 1960, 1)
ifelse(x == 1957, "foo", ifelse(x == 1958, "bar","baz"))
> [1] "baz" "baz" "baz" "baz" "baz" "baz" "baz" "foo" "bar" "baz" "baz"
यह सबसे सीधा विकल्प है।
अपने डेटा को डेटाटेबल में बदलें। संदर्भ और पंक्ति फ़िल्टरिंग द्वारा सेट का उपयोग करें
library(data.table)
dt <- as.data.table(your.dataframe.or.whatever)
dt[, is.1957 := 0]
dt[year == 1957, is.1957 := 1]
प्रूफ ऑफ कॉन्सेप्ट टॉय उदाहरण:
library(data.table)
dt <- as.data.table(cbind(c(1, 1, 1), c(2, 2, 3)))
dt[, is.3 := 0]
dt[V2 == 3, is.3 := 1]
बेस आर में यह एक लाइनर
model.matrix( ~ iris$Species - 1)
देता है
iris$Speciessetosa iris$Speciesversicolor iris$Speciesvirginica
1 1 0 0
2 1 0 0
3 1 0 0
4 1 0 0
5 1 0 0
6 1 0 0
7 1 0 0
8 1 0 0
9 1 0 0
10 1 0 0
11 1 0 0
12 1 0 0
13 1 0 0
14 1 0 0
15 1 0 0
16 1 0 0
17 1 0 0
18 1 0 0
19 1 0 0
20 1 0 0
21 1 0 0
22 1 0 0
23 1 0 0
24 1 0 0
25 1 0 0
26 1 0 0
27 1 0 0
28 1 0 0
29 1 0 0
30 1 0 0
31 1 0 0
32 1 0 0
33 1 0 0
34 1 0 0
35 1 0 0
36 1 0 0
37 1 0 0
38 1 0 0
39 1 0 0
40 1 0 0
41 1 0 0
42 1 0 0
43 1 0 0
44 1 0 0
45 1 0 0
46 1 0 0
47 1 0 0
48 1 0 0
49 1 0 0
50 1 0 0
51 0 1 0
52 0 1 0
53 0 1 0
54 0 1 0
55 0 1 0
56 0 1 0
57 0 1 0
58 0 1 0
59 0 1 0
60 0 1 0
61 0 1 0
62 0 1 0
63 0 1 0
64 0 1 0
65 0 1 0
66 0 1 0
67 0 1 0
68 0 1 0
69 0 1 0
70 0 1 0
71 0 1 0
72 0 1 0
73 0 1 0
74 0 1 0
75 0 1 0
76 0 1 0
77 0 1 0
78 0 1 0
79 0 1 0
80 0 1 0
81 0 1 0
82 0 1 0
83 0 1 0
84 0 1 0
85 0 1 0
86 0 1 0
87 0 1 0
88 0 1 0
89 0 1 0
90 0 1 0
91 0 1 0
92 0 1 0
93 0 1 0
94 0 1 0
95 0 1 0
96 0 1 0
97 0 1 0
98 0 1 0
99 0 1 0
100 0 1 0
101 0 0 1
102 0 0 1
103 0 0 1
104 0 0 1
105 0 0 1
106 0 0 1
107 0 0 1
108 0 0 1
109 0 0 1
110 0 0 1
111 0 0 1
112 0 0 1
113 0 0 1
114 0 0 1
115 0 0 1
116 0 0 1
117 0 0 1
118 0 0 1
119 0 0 1
120 0 0 1
121 0 0 1
122 0 0 1
123 0 0 1
124 0 0 1
125 0 0 1
126 0 0 1
127 0 0 1
128 0 0 1
129 0 0 1
130 0 0 1
131 0 0 1
132 0 0 1
133 0 0 1
134 0 0 1
135 0 0 1
136 0 0 1
137 0 0 1
138 0 0 1
139 0 0 1
140 0 0 1
141 0 0 1
142 0 0 1
143 0 0 1
144 0 0 1
145 0 0 1
146 0 0 1
147 0 0 1
148 0 0 1
149 0 0 1
150 0 0 1
मैं इस तरह के एक फ़ंक्शन का उपयोग करता हूं (data.table के लिए):
# Ta funkcja dla obiektu data.table i zmiennej var.name typu factor tworzy dummy variables o nazwach "var.name: (level1)"
factorToDummy <- function(dtable, var.name){
stopifnot(is.data.table(dtable))
stopifnot(var.name %in% names(dtable))
stopifnot(is.factor(dtable[, get(var.name)]))
dtable[, paste0(var.name,": ",levels(get(var.name)))] -> new.names
dtable[, (new.names) := transpose(lapply(get(var.name), FUN = function(x){x == levels(get(var.name))})) ]
cat(paste("\nDodano zmienne dummy: ", paste0(new.names, collapse = ", ")))
}
उपयोग:
data <- data.table(data)
data[, x:= droplevels(x)]
factorToDummy(data, "x")
हाय, मैंने एक डमी वैरिएबल जेनरेट करने के लिए यह सामान्य फंक्शन लिखा था, जो स्टैटा में रिप्लेस फंक्शन की अनिवार्य रूप से प्रतिकृति करता है।
यदि x है डेटा फ्रेम एक्स है और मैं एक डमी चर कहा चाहते हैं aजो मूल्य ले जाएगा 1जब x$bमूल्य लेता हैc
introducedummy<-function(x,a,b,c){
g<-c(a,b,c)
n<-nrow(x)
newcol<-g[1]
p<-colnames(x)
p2<-c(p,newcol)
new1<-numeric(n)
state<-x[,g[2]]
interest<-g[3]
for(i in 1:n){
if(state[i]==interest){
new1[i]=1
}
else{
new1[i]=0
}
}
x$added<-new1
colnames(x)<-p2
x
}
हम cSplit_eसे भी उपयोग कर सकते हैं splitstackshape। @ Zx8754 के डेटा का उपयोग करना
df1 <- data.frame(id = 1:4, year = 1991:1994)
splitstackshape::cSplit_e(df1, "year", fill = 0)
# id year year_1 year_2 year_3 year_4
#1 1 1991 1 0 0 0
#2 2 1992 0 1 0 0
#3 3 1993 0 0 1 0
#4 4 1994 0 0 0 1
संख्यात्मक के अलावा डेटा के लिए यह काम करने के लिए हमें स्पष्ट typeरूप से निर्दिष्ट करने की आवश्यकता है"character"
df1 <- data.frame(id = 1:4, let = LETTERS[1:4])
splitstackshape::cSplit_e(df1, "let", fill = 0, type = "character")
# id let let_A let_B let_C let_D
#1 1 A 1 0 0 0
#2 2 B 0 1 0 0
#3 3 C 0 0 1 0
#4 4 D 0 0 0 1