R Language
कारक
खोज…
वाक्य - विन्यास
- फ़ैक्टर (x = वर्ण (), स्तर, लेबल = स्तर, बाहर करना = NA, आदेशित = is.ordered (x), nmax = NA)
- भागो
?factorया प्रलेखन ऑनलाइन देखें ।
टिप्पणियों
वर्ग factor साथ एक वस्तु विशेषताओं के एक विशेष सेट के साथ एक वेक्टर है।
- इसे आंतरिक रूप से एक
integerवेक्टर के रूप में संग्रहीत किया जाता है। - यह उन
levelsबनाए रखता है, जो मूल्यों के चरित्र प्रतिनिधित्व को दर्शाते हैं। - इसका वर्ग
factorरूप में संग्रहीतfactor
उदाहरण के लिए, आइए हम रंगों के एक सेट से 1,000 टिप्पणियों का एक वेक्टर उत्पन्न करते हैं।
set.seed(1)
Color <- sample(x = c("Red", "Blue", "Green", "Yellow"),
size = 1000,
replace = TRUE)
Color <- factor(Color)
हम ऊपर सूचीबद्ध Color की प्रत्येक विशेषताओं का निरीक्षण कर सकते हैं:
#* 1. It is stored internally as an `integer` vector
typeof(Color)
[1] "integer"
#* 2. It maintains a `levels` attribute the shows the character representation of the values.
#* 3. Its class is stored as `factor`
attributes(Color)
$levels [1] "Blue" "Green" "Red" "Yellow" $class [1] "factor"
एक कारक वस्तु का प्राथमिक लाभ डेटा भंडारण में दक्षता है। एक पूर्णांक को वर्ण की तुलना में कम मेमोरी की आवश्यकता होती है। इस तरह की दक्षता अत्यधिक वांछनीय थी जब कई कंप्यूटरों में वर्तमान मशीनों की तुलना में बहुत अधिक सीमित संसाधन थे (कारकों का उपयोग करने के पीछे प्रेरणाओं के एक अधिक विस्तृत इतिहास के लिए, stringsAsFactors देखें) : एक अनधिकृत जीवनी )। मेमोरी उपयोग में अंतर हमारे Color ऑब्जेक्ट में भी देखा जा सकता है। जैसा कि आप देख सकते हैं, Color को एक चरित्र के रूप में संग्रहीत करने के लिए कारक वस्तु के रूप में लगभग 1.7 गुना अधिक मेमोरी की आवश्यकता होती है।
#* Amount of memory required to store Color as a factor.
object.size(Color)
4624 bytes
#* Amount of memory required to store Color as a character
object.size(as.character(Color))
8232 bytes
पूर्णांक को स्तर तक मैप करना
जबकि कारकों की आंतरिक गणना वस्तु को पूर्णांक के रूप में देखती है, मानव उपभोग के लिए वांछित प्रतिनिधित्व वर्ण स्तर है। उदाहरण के लिए,
head(Color)
[1] Blue Blue Green Yellow Red Yellow Levels: Blue Green Red Yellow
की तुलना में मानव समझ के लिए एक आसान है
head(as.numeric(Color))
[1] 1 1 2 4 3 4
आंतरिक पूर्णांक मान के चरित्र प्रतिनिधित्व के मिलान के बारे में आर कैसे जाता है, इसका एक अनुमानित चित्र इस प्रकार है:
head(levels(Color)[as.numeric(Color)])
[1] "Blue" "Blue" "Green" "Yellow" "Red" "Yellow"
इन परिणामों की तुलना करें
head(Color)
[1] Blue Blue Green Yellow Red Yellow Levels: Blue Green Red Yellow
कारकों का आधुनिक उपयोग
2007 में, R ने वर्ण वैक्टर (Ref: stringsAsFactors : एक अनधिकृत जीवनी ) की मेमोरी बोझ को कम करने के लिए वर्णों के लिए हैशिंग विधि पेश की। ध्यान दें कि जब हमने निर्धारित किया था कि वर्णों को कारकों की तुलना में 1.7 गुना अधिक भंडारण स्थान की आवश्यकता होती है, जो कि आर के हाल के संस्करण में गणना की गई थी, जिसका अर्थ है कि चरित्र वैक्टर का मेमोरी उपयोग 2007 से पहले भी अधिक कर था।
आधुनिक आर में हैशिंग विधि और आधुनिक कंप्यूटरों में अधिक से अधिक मेमोरी संसाधनों के कारण, चरित्र मूल्यों को संचय करने में स्मृति दक्षता का मुद्दा बहुत ही कम हो गया है। आर समुदाय में प्रचलित रवैया ज्यादातर स्थितियों में कारकों पर चरित्र वैक्टर के लिए एक प्राथमिकता है। कारकों से दूर शिफ्ट के लिए प्राथमिक कारण हैं
- असंरचित और / या शिथिल नियंत्रित चरित्र डेटा की वृद्धि
- जब उपयोगकर्ता यह भूल जाता है कि वह एक कारक के साथ काम कर रहा है और चरित्र नहीं, तो कारकों की प्रवृत्ति वांछित नहीं है
पहले मामले में, यह मुक्त पाठ या खुले प्रतिक्रिया क्षेत्रों को कारकों के रूप में संग्रहीत करने का कोई मतलब नहीं है, क्योंकि किसी भी पैटर्न की संभावना नहीं होगी जो प्रति स्तर एक से अधिक अवलोकन के लिए अनुमति देता है। वैकल्पिक रूप से, यदि डेटा संरचना को सावधानीपूर्वक नियंत्रित नहीं किया जाता है, तो कई स्तरों को प्राप्त करना संभव है जो एक ही श्रेणी (जैसे "ब्लू", "ब्लू" और "ब्लू") के अनुरूप हैं। ऐसे मामलों में, कई इन विसंगतियों को एक कारक में बदलने से पहले वर्ण के रूप में प्रबंधित करना पसंद करते हैं (यदि रूपांतरण बिल्कुल होता है)।
दूसरे मामले में, यदि उपयोगकर्ता को लगता है कि वह एक चरित्र वेक्टर के साथ काम कर रहा है, तो कुछ विधियाँ प्रत्याशित रूप से प्रतिक्रिया नहीं दे सकती हैं। स्क्रिप्ट और कोड को डीबग करते समय यह बुनियादी समझ भ्रम और निराशा पैदा कर सकती है। हालांकि, कड़ाई से बोलते हुए, इसे उपयोगकर्ता की गलती माना जा सकता है, अधिकांश उपयोगकर्ता कारकों का उपयोग करने और इन स्थितियों से पूरी तरह से बचने के लिए खुश हैं।
कारकों का मूल निर्माण
कारक आर में श्रेणीबद्ध चर का प्रतिनिधित्व करने का एक तरीका है। एक कारक आंतरिक रूप से पूर्णांक के वेक्टर के रूप में संग्रहीत किया जाता है। आपूर्ति किए गए वर्ण वेक्टर के अद्वितीय तत्वों को कारक के स्तर के रूप में जाना जाता है। डिफ़ॉल्ट रूप से, यदि उपयोगकर्ता द्वारा स्तरों की आपूर्ति नहीं की जाती है, तो R वेक्टर में अद्वितीय मानों का सेट उत्पन्न करेगा, इन मानों को अल्फ़ान्यूमेरिक रूप से क्रमबद्ध करेगा, और उन्हें स्तरों के रूप में उपयोग करेगा।
charvar <- rep(c("n", "c"), each = 3)
f <- factor(charvar)
f
levels(f)
> f
[1] n n n c c c
Levels: c n
> levels(f)
[1] "c" "n"
यदि आप स्तरों के क्रम को बदलना चाहते हैं, तो मैन्युअल रूप से स्तरों को निर्दिष्ट करने का एक विकल्प है:
levels(factor(charvar, levels = c("n","c")))
> levels(factor(charvar, levels = c("n","c")))
[1] "n" "c"
कारकों में कई गुण होते हैं। उदाहरण के लिए, स्तरों को लेबल दिया जा सकता है:
> f <- factor(charvar, levels=c("n", "c"), labels=c("Newt", "Capybara"))
> f
[1] Newt Newt Newt Capybara Capybara Capybara
Levels: Newt Capybara
एक और संपत्ति जिसे सौंपा जा सकता है, वह यह है कि क्या कारक का आदेश दिया गया है:
> Weekdays <- factor(c("Monday", "Wednesday", "Thursday", "Tuesday", "Friday", "Sunday", "Saturday"))
> Weekdays
[1] Monday Wednesday Thursday Tuesday Friday Sunday Saturday
Levels: Friday Monday Saturday Sunday Thursday Tuesday Wednesday
> Weekdays <- factor(Weekdays, levels=c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"), ordered=TRUE)
> Weekdays
[1] Monday Wednesday Thursday Tuesday Friday Sunday Saturday
Levels: Monday < Tuesday < Wednesday < Thursday < Friday < Saturday < Sunday
जब कारक का स्तर अब उपयोग नहीं किया जाता है, तो आप इसे droplevels() फ़ंक्शन का उपयोग करके छोड़ सकते हैं:
> Weekend <- subset(Weekdays, Weekdays == "Saturday" | Weekdays == "Sunday")
> Weekend
[1] Sunday Saturday
Levels: Monday < Tuesday < Wednesday < Thursday < Friday < Saturday < Sunday
> Weekend <- droplevels(Weekend)
> Weekend
[1] Sunday Saturday
Levels: Saturday < Sunday
एक सूची के साथ फैक्टर स्तर को समेकित करना
ऐसे समय होते हैं जिनमें कारक समूहों को कम समूहों में समेकित करना वांछनीय होता है, शायद इसलिए कि किसी एक श्रेणी में विरल डेटा। यह तब भी हो सकता है जब आपके पास श्रेणी नामों के अलग-अलग वर्तनी या कैपिटलाइज़ेशन हों। एक उदाहरण के रूप में कारक पर विचार करें
set.seed(1)
colorful <- sample(c("red", "Red", "RED", "blue", "Blue", "BLUE", "green", "gren"),
size = 20,
replace = TRUE)
colorful <- factor(colorful)
चूंकि R केस-संवेदी है, इसलिए इस वेक्टर की एक आवृत्ति तालिका नीचे की तरह दिखाई देगी।
table(colorful)
colorful blue Blue BLUE green gren red Red RED 3 1 4 2 4 1 3 2
हालाँकि, यह तालिका डेटा के सही वितरण का प्रतिनिधित्व नहीं करती है, और श्रेणियां प्रभावी रूप से तीन प्रकारों में कम हो सकती हैं: ब्लू, ग्रीन और रेड। तीन उदाहरण दिए गए हैं। पहला चित्रण जो एक स्पष्ट समाधान की तरह लगता है, लेकिन वास्तव में एक समाधान प्रदान नहीं करेगा। दूसरा एक कार्यशील समाधान देता है, लेकिन क्रियात्मक और कम्प्यूटेशनल रूप से महंगा है। तीसरा एक स्पष्ट समाधान नहीं है, लेकिन अपेक्षाकृत कॉम्पैक्ट और कम्प्यूटेशनल रूप से कुशल है।
factor ( factor_approach ) का उपयोग करके समेकन स्तर
factor(as.character(colorful),
levels = c("blue", "Blue", "BLUE", "green", "gren", "red", "Red", "RED"),
labels = c("Blue", "Blue", "Blue", "Green", "Green", "Red", "Red", "Red"))
[1] Green Blue Red Red Blue Red Red Red Blue Red Green Green Green Blue Red Green [17] Red Green Green Red Levels: Blue Blue Blue Green Green Red Red Red Warning message: In `levels<-`(`*tmp*`, value = if (nl == nL) as.character(labels) else paste0(labels, : duplicated levels in factors are deprecated
ध्यान दें कि डुप्लिकेट स्तर हैं। हमारे पास अभी भी "ब्लू" के लिए तीन श्रेणियां हैं, जो स्तरों को समेकित करने के हमारे कार्य को पूरा नहीं करती हैं। इसके अतिरिक्त, एक चेतावनी है कि डुप्लिकेट स्तर को हटा दिया जाता है, जिसका अर्थ है कि यह कोड भविष्य में त्रुटि उत्पन्न कर सकता है।
ifelse ( ifelse_approach ) का उपयोग करके स्तरों को समेकित करना
factor(ifelse(colorful %in% c("blue", "Blue", "BLUE"),
"Blue",
ifelse(colorful %in% c("green", "gren"),
"Green",
"Red")))
[1] Green Blue Red Red Blue Red Red Red Blue Red Green Green Green Blue Red Green [17] Red Green Green Red Levels: Blue Green Red
यह कोड वांछित परिणाम उत्पन्न करता है, लेकिन नेस्टेड ifelse स्टेटमेंट के उपयोग की आवश्यकता होती है। हालांकि इस दृष्टिकोण में कुछ भी गलत नहीं है, नेस्टेड ifelse स्टेटमेंट को प्रबंधित करना एक थकाऊ काम हो सकता है और इसे ध्यान से किया जाना चाहिए।
एक सूची ( list_approach ) के साथ कारकों को समेकित करना
स्तरों को समेकित करने का एक कम स्पष्ट तरीका एक सूची का उपयोग करना है जहां प्रत्येक तत्व का नाम वांछित श्रेणी का नाम है, और तत्व कारक का एक स्तर वेक्टर है जो वांछित श्रेणी में मैप होना चाहिए। इसमें नई वस्तुओं को असाइन किए बिना, कारक के levels विशेषता पर सीधे काम करने का अतिरिक्त लाभ है।
levels(colorful) <-
list("Blue" = c("blue", "Blue", "BLUE"),
"Green" = c("green", "gren"),
"Red" = c("red", "Red", "RED"))
[1] Green Blue Red Red Blue Red Red Red Blue Red Green Green Green Blue Red Green [17] Red Green Green Red Levels: Blue Green Red
प्रत्येक दृष्टिकोण को बेंचमार्क करना
इनमें से प्रत्येक दृष्टिकोण को निष्पादित करने के लिए आवश्यक समय नीचे संक्षेप में प्रस्तुत किया गया है। (अंतरिक्ष के लिए, इस सारांश को उत्पन्न करने के लिए कोड नहीं दिखाया गया है)
Unit: microseconds expr min lq mean median uq max neval cld factor 78.725 83.256 93.26023 87.5030 97.131 218.899 100 b ifelse 104.494 107.609 123.53793 113.4145 128.281 254.580 100 c list_approach 49.557 52.955 60.50756 54.9370 65.132 138.193 100 a
सूची दृष्टिकोण ifelse दृष्टिकोण के रूप में तेजी से दो बार के बारे में चलाता है। हालांकि, बहुत बड़ी मात्रा में डेटा को छोड़कर, निष्पादन समय के अंतर को संभवतः माइक्रोसेकंड या मिलीसेकंड में मापा जाएगा। ऐसे छोटे समय के अंतर के साथ, दक्षता को निर्णय लेने की आवश्यकता नहीं है कि किस दृष्टिकोण का उपयोग करना है। इसके बजाय, एक दृष्टिकोण का उपयोग करें जो परिचित और आरामदायक है, और जिसे आप और आपके सहयोगी भविष्य की समीक्षा पर समझेंगे।
कारक
कारकों को देखते हुए एक वेक्टर आर में स्पष्ट चर का प्रतिनिधित्व करने के लिए एक तरीका है x जिनके मान का उपयोग कर पात्रों में बदला जा सकता as.character() , के लिए डिफ़ॉल्ट तर्क factor() और as.factor() में से प्रत्येक के विशिष्ट तत्व के लिए एक पूर्णांक आवंटित वेक्टर और साथ ही एक स्तर विशेषता और एक लेबल विशेषता। स्तर वे मान हैं जिन्हें x संभवतः ले सकता है और लेबल या तो दिए गए तत्व हो सकते हैं या उपयोगकर्ता द्वारा निर्धारित किए जा सकते हैं।
उदाहरण के लिए कि हम किस तरह से काम करते हैं, हम डिफ़ॉल्ट विशेषताओं के साथ एक कारक बनाएंगे, फिर कस्टम स्तर और फिर कस्टम स्तर और लेबल।
# standard
factor(c(1,1,2,2,3,3))
[1] 1 1 2 2 3 3
Levels: 1 2 3
उदाहरण उत्पन्न हो सकते हैं जहां उपयोगकर्ता जानता है कि कारक जिन संभावित मूल्यों की संख्या ले सकते हैं, वे वेक्टर में वर्तमान मूल्यों से अधिक हैं। इसके लिए हम खुद को factor() में स्तरों को निर्दिष्ट करते हैं।
factor(c(1,1,2,2,3,3),
levels = c(1,2,3,4,5))
[1] 1 1 2 2 3 3
Levels: 1 2 3 4 5
शैली के प्रयोजनों के लिए उपयोगकर्ता प्रत्येक स्तर पर लेबल असाइन करना चाह सकता है। डिफ़ॉल्ट रूप से, लेबल स्तरों के चरित्र प्रतिनिधित्व हैं। यहां हम कारक में प्रत्येक संभावित स्तर के लिए लेबल प्रदान करते हैं।
factor(c(1,1,2,2,3,3),
levels = c(1,2,3,4,5),
labels = c("Fox","Dog","Cow","Brick","Dolphin"))
[1] Fox Fox Dog Dog Cow Cow
Levels: Fox Dog Cow Brick Dolphin
आम तौर पर, कारकों की तुलना केवल == और != का उपयोग करके की जा सकती है और यदि कारकों में समान स्तर होते हैं। कारकों की निम्नलिखित तुलना विफल हो जाती है भले ही वे समान दिखाई दें क्योंकि कारकों के अलग-अलग कारक स्तर होते हैं।
factor(c(1,1,2,2,3,3),levels = c(1,2,3)) == factor(c(1,1,2,2,3,3),levels = c(1,2,3,4,5))
Error in Ops.factor(factor(c(1, 1, 2, 2, 3, 3), levels = c(1, 2, 3)), :
level sets of factors are different
यह समझ में आता है क्योंकि आरएचएस में अतिरिक्त स्तर का मतलब है कि आर के पास प्रत्येक कारक के बारे में पर्याप्त जानकारी नहीं है ताकि उनकी तुलना सार्थक तरीके से की जा सके।
ऑपरेटर्स < , <= , > और >= केवल ऑर्डर किए गए कारकों के लिए उपयोग करने योग्य हैं। ये श्रेणीबद्ध मूल्यों का प्रतिनिधित्व कर सकते हैं जो अभी भी एक रैखिक आदेश हैं। एक आदेशित कारक को factor फ़ंक्शन को ordered = TRUE गए ordered = TRUE तर्क प्रदान करके या केवल ordered फ़ंक्शन का उपयोग करके बनाया जा सकता है।
x <- factor(1:3, labels = c('low', 'medium', 'high'), ordered = TRUE)
print(x)
[1] low medium high
Levels: low < medium < high
y <- ordered(3:1, labels = c('low', 'medium', 'high'))
print(y)
[1] high medium low
Levels: low < medium < high
x < y
[1] TRUE FALSE FALSE
अधिक जानकारी के लिए, फैक्टर प्रलेखन देखें।
कारकों को बदलना और पुन: व्यवस्थित करना
कारकों चूक के साथ बनाया जाता है, levels द्वारा बनाई हैं as.character आदानों के लिए आवेदन किया और वर्णानुक्रम कर रहे हैं।
charvar <- rep(c("W", "n", "c"), times=c(17,20,14))
f <- factor(charvar)
levels(f)
# [1] "c" "n" "W"
कुछ स्थितियों में levels के डिफॉल्ट ऑर्डर (अल्फाबेटिक / लेक्सिकल ऑर्डर) का उपचार स्वीकार्य होगा। उदाहरण के लिए, यदि कोई व्यक्ति आवृत्तियों को plot करना चाहता है, तो यह परिणाम होगा:
plot(f,col=1:length(levels(f)))
लेकिन अगर हम का एक अलग आदेश चाहते levels , हम में इस निर्दिष्ट करने की आवश्यकता levels या labels पैरामीटर (देखभाल कि "आदेश" का अर्थ यहां आदेश दिया कारकों से अलग है ले रही है, नीचे देखें)। स्थिति के आधार पर उस कार्य को पूरा करने के लिए कई विकल्प हैं।
1. कारक को फिर से परिभाषित करें
जब यह संभव होता है, तो हम जिस levels पैरामीटर का उपयोग करना चाहते हैं उस क्रम के साथ कारक को फिर से बना सकते हैं।
ff <- factor(charvar, levels = c("n", "W", "c"))
levels(ff)
# [1] "n" "W" "c"
gg <- factor(charvar, levels = c("W", "c", "n"))
levels(gg)
# [1] "W" "c" "n"
जब इनपुट स्तर वांछित आउटपुट स्तरों से अलग होते हैं, तो हम labels पैरामीटर का उपयोग करते labels जो स्वीकार्य इनपुट मानों के लिए "फ़िल्टर" बनने के लिए levels पैरामीटर का कारण बनता है, लेकिन कारक वेक्टर के लिए "स्तर" के अंतिम मानों को तर्क के रूप में छोड़ देता है। labels :
fm <- factor(as.numeric(f),levels = c(2,3,1),
labels = c("nn", "WW", "cc"))
levels(fm)
# [1] "nn" "WW" "cc"
fm <- factor(LETTERS[1:6], levels = LETTERS[1:4], # only 'A'-'D' as input
labels = letters[1:4]) # but assigned to 'a'-'d'
fm
#[1] a b c d <NA> <NA>
#Levels: a b c d
2. relevel समारोह का उपयोग करें
जब एक विशिष्ट level होता है, तो हमें पहले relevel उपयोग करने की relevel । यह, उदाहरण के लिए, सांख्यिकीय विश्लेषण के संदर्भ में होता है, जब परिकल्पना के परीक्षण के लिए base श्रेणी आवश्यक होती है।
g<-relevel(f, "n") # moves n to be the first level
levels(g)
# [1] "n" "c" "W"
जैसा कि सत्यापित किया जा सकता है f और g समान हैं
all.equal(f, g)
# [1] "Attributes: < Component “levels”: 2 string mismatches >"
all.equal(f, g, check.attributes = F)
# [1] TRUE
3. पुन: व्यवस्थित करने वाले कारक
ऐसे मामले हैं जब हमें किसी संख्या, एक आंशिक परिणाम, एक संकलित सांख्यिकी या पिछले गणना के आधार पर levels को reorder से reorder करने की आवश्यकता होती है। आइए levels की आवृत्तियों के आधार पर पुन: व्यवस्थित करें
table(g)
# g
# n c W
# 20 14 17
reorder फ़ंक्शन जेनेरिक है ( help(reorder) देखें help(reorder) देखें help(reorder) ), लेकिन इस संदर्भ में आवश्यकता है: x , इस मामले में कारक; X , के रूप में एक ही लंबाई के एक अंकीय मान x ; और FUN , X लागू होने वाला एक फ़ंक्शन और x स्तर से गणना की जाती है, जो डिफ़ॉल्ट रूप से बढ़ते हुए, levels क्रम को निर्धारित करता levels । परिणाम अपने स्तर को फिर से व्यवस्थित करने के साथ एक ही कारक है।
g.ord <- reorder(g,rep(1,length(g)), FUN=sum) #increasing
levels(g.ord)
# [1] "c" "W" "n"
घटते क्रम को प्राप्त करने के लिए हम नकारात्मक मूल्यों पर विचार करते हैं ( -1 )
g.ord.d <- reorder(g,rep(-1,length(g)), FUN=sum)
levels(g.ord.d)
# [1] "n" "W" "c"
फिर से कारक दूसरों के समान है।
data.frame(f,g,g.ord,g.ord.d)[seq(1,length(g),by=5),] #just same lines
# f g g.ord g.ord.d
# 1 W W W W
# 6 W W W W
# 11 W W W W
# 16 W W W W
# 21 n n n n
# 26 n n n n
# 31 n n n n
# 36 n n n n
# 41 c c c c
# 46 c c c c
# 51 c c c c
जब कारक चर से संबंधित मात्रात्मक चर होता है, तो हम levels को फिर से व्यवस्थित करने के लिए अन्य कार्यों का उपयोग कर सकते हैं। अपने माध्य Sepal.Width का उपयोग करके Species कारक को फिर से Sepal.Width करने के लिए iris डेटा (अधिक जानकारी के लिए help("iris") लेने की सुविधा देता है।
miris <- iris #help("iris") # copy the data
with(miris, tapply(Sepal.Width,Species,mean))
# setosa versicolor virginica
# 3.428 2.770 2.974
miris$Species.o<-with(miris,reorder(Species,-Sepal.Width))
levels(miris$Species.o)
# [1] "setosa" "virginica" "versicolor"
सामान्य boxplot (कहते हैं: with(miris, boxplot(Petal.Width~Species) ) इस क्रम में with(miris, boxplot(Petal.Width~Species) दिखाएगा: सेटोसा , वर्सीकोलर , और वर्जिनिका । लेकिन ऑर्डर किए गए फैक्टर का उपयोग करके हम प्रजातियों को इसके माध्य से Sepal.Width :
boxplot(Petal.Width~Species.o, data = miris,
xlab = "Species", ylab = "Petal Width",
main = "Iris Data, ordered by mean sepal width", varwidth = TRUE,
col = 2:4)
इसके अतिरिक्त, levels के नामों को बदलना, उन्हें समूहों में संयोजित करना या नए levels जोड़ना भी संभव levels । उसके लिए हम समान नाम levels के फ़ंक्शन का उपयोग करते levels ।
f1<-f
levels(f1)
# [1] "c" "n" "W"
levels(f1) <- c("upper","upper","CAP") #rename and grouping
levels(f1)
# [1] "upper" "CAP"
f2<-f1
levels(f2) <- c("upper","CAP", "Number") #add Number level, which is empty
levels(f2)
# [1] "upper" "CAP" "Number"
f2[length(f2):(length(f2)+5)]<-"Number" # add cases for the new level
table(f2)
# f2
# upper CAP Number
# 33 17 6
f3<-f1
levels(f3) <- list(G1 = "upper", G2 = "CAP", G3 = "Number") # The same using list
levels(f3)
# [1] "G1" "G2" "G3"
f3[length(f3):(length(f3)+6)]<-"G3" ## add cases for the new level
table(f3)
# f3
# G1 G2 G3
# 33 17 7
- ऑर्डर किए गए कारक
अंत में, हम जानते हैं कि ordered कारक कारकों से भिन्न होते factors , पहले एक का उपयोग क्रमिक डेटा का प्रतिनिधित्व करने के लिए किया जाता है, और दूसरा नाममात्र डेटा के साथ काम करने के लिए। पहले तो, ऑर्डर किए गए कारकों के लिए levels के क्रम को बदलने का कोई मतलब नहीं है, लेकिन हम इसके labels को बदल सकते हैं।
ordvar<-rep(c("Low", "Medium", "High"), times=c(7,2,4))
of<-ordered(ordvar,levels=c("Low", "Medium", "High"))
levels(of)
# [1] "Low" "Medium" "High"
of1<-of
levels(of1)<- c("LOW", "MEDIUM", "HIGH")
levels(of1)
# [1] "LOW" "MEDIUM" "HIGH"
is.ordered(of1)
# [1] TRUE
of1
# [1] LOW LOW LOW LOW LOW LOW LOW MEDIUM MEDIUM HIGH HIGH HIGH HIGH
# Levels: LOW < MEDIUM < HIGH
शून्य से पुनर्निर्माण कारक
मुसीबत
कारकों का उपयोग उन चर को दर्शाने के लिए किया जाता है जो श्रेणियों के एक सेट से मान लेते हैं, जिन्हें आर के स्तर के रूप में जाना जाता है। उदाहरण के लिए, कुछ प्रयोग बैटरी के ऊर्जा स्तर की विशेषता हो सकते हैं, चार स्तरों के साथ: खाली, निम्न, सामान्य और पूर्ण। फिर, 5 अलग-अलग सैंपलिंग साइटों के लिए, उन स्तरों की पहचान की जा सकती है, उन शब्दों में, इस प्रकार है:
पूर्ण , पूर्ण , सामान्य , खाली , कम
आमतौर पर, डेटाबेस या अन्य सूचना स्रोतों में, इन डेटा की हैंडलिंग श्रेणियों या स्तरों से जुड़े मनमाने ढंग से पूर्णांक सूचकांकों द्वारा होती है। यदि हम मानते हैं कि, दिए गए उदाहरण के लिए, हम संकेत देंगे, निम्नानुसार हैं: 1 = खाली, 2 = कम, 3 = सामान्य, 4 = पूर्ण, तो 5 नमूनों को कोडित किया जा सकता है:
4 , 4 , 3 , 1 , 2
ऐसा हो सकता है कि, आपकी जानकारी के स्रोत से, उदाहरण के लिए, एक डेटाबेस, आपके पास केवल पूर्णांकों की एन्कोडेड सूची है, और प्रत्येक स्तर-कीवर्ड के साथ प्रत्येक पूर्णांक को जोड़ने वाले कैटलॉग। उस जानकारी से R के एक कारक का पुनर्निर्माण कैसे किया जा सकता है?
समाधान
हम 20 पूर्णांक के एक वेक्टर का अनुकरण करेंगे जो नमूनों का प्रतिनिधित्व करता है, जिनमें से प्रत्येक में चार भिन्न मान हो सकते हैं:
set.seed(18)
ii <- sample(1:4, 20, replace=T)
ii
[१] ४ ३ ४ १ १ ३ २ २ २ १ ३ ४ १ २ ४ १ ३ १ ४ १
पहला चरण एक कारक बनाना है, पिछले अनुक्रम से, जिसमें स्तर या श्रेणियां 1 से 4 तक की संख्याएं हैं।
fii <- factor(ii, levels=1:4) # it is necessary to indicate the numeric levels
fii
[१] ४ ३ ४ १ १ ३ २ २ २ १ ३ ४ १ २ ४ १ ३ १ ४ १
स्तर: 1 2 3 4
अब बस, आपको सूचकांक टैग के साथ पहले से ही तैयार किए गए कारक को तैयार करना होगा:
levels(fii) <- c("empty", "low", "normal", "full")
fii
[१] पूर्ण सामान्य पूर्ण खाली खाली सामान्य कम सामान्य सामान्य खाली खाली
[११] सामान्य पूर्ण खाली कम पूर्ण खाली सामान्य खाली पूर्ण पूर्ण खाली
स्तर: खाली कम सामान्य पूर्ण