R में Long से Wide डेटा

ऐसा समय आता है जब लोगों को long फॉर्मेट (इसे आप "लॉन्ग-फॉर्म" कहते हैं—इसका मतलब आगे स्पष्ट होगा) के डेटा को wide फॉर्मेट में और wide को long में बदलने की जरूरत पड़ती है। वास्तविक जीवन में डेटा अलग-अलग फॉर्मेट में आता है, लेकिन अधिकांश R फ़ंक्शन एक विशेष फॉर्म के लिए बनाए गए होते हैं।

उदाहरण के लिए, मिश्रित रैखिक मॉडलिंग के लिए lme4::lmer(), विज़ुअलाइज़ेशन के लिए ggplot2::ggplot() लॉन्ग-फॉर्म के लिए डिज़ाइन किए गए हैं। लेकिन कुछ अन्य फ़ंक्शन wide-फॉर्म के लिए बने हैं, जैसे mosaicplot()। इसका मतलब है कि विश्लेषण या विज़ुअलाइज़ेशन करने के लिए आपको फॉर्मेट बदलना पड़ेगा, जब तक कि डेटा पहले से प्रोसेस होकर सही फॉर्म में न हो।

R में फॉर्मेट कन्वर्ज़न के कई विकल्प हैं, लेकिन शुरुआत में यह काफी उलझाऊ लग सकता है।

यह ट्यूटोरियल आपको लॉन्ग-फॉर्म और वाइड-फॉर्म के बीच डेटा कन्वर्ट करने की बुनियादी प्रक्रिया समझाएगा। आप निम्नलिखित विषयों को एक्सप्लोर करेंगे:

• आप लॉन्ग फॉर्म के बारे में और जानेंगे।
• फिर, आप वाइड फॉर्म से परिचित होंगे।
• आप लॉन्ग और वाइड फॉर्मेट्स के बीच के अंतर को रिकैप करेंगे;
• इसके बाद आप देखेंगे कि एक फॉर्म से दूसरे में जाने के लिए किन स्टेप्स की जरूरत होती है।
• अंत में, आप R की मदद से इसे इम्प्लीमेंट करेंगे। आप melt() और dcast() फ़ंक्शंस के साथ long फॉर्मेट से wide फॉर्मेट में जाना सीखेंगे।

डेटा

यह तालिका एक छोटे स्थानीय क्षेत्र में शिशुओं की लंबाई दिखाती है। लंबाई 2011 से 2015 तक मापी गई। जैसा कि आप जानते होंगे, NA का मतलब ‘Not Available’ है। NA की पोज़िशंस से आप शिशुओं की उम्र का अंदाज़ा लगा सकते हैं, लेकिन किसी शिशु की सटीक उम्र तालिका से नहीं मिलती। तालिका सुव्यवस्थित दिखती है, लेकिन जो लोग शिशुओं की वृद्धि का अध्ययन करना चाहते हैं, उनके लिए एक समस्या है: महत्वपूर्ण जानकारी यह नहीं है कि कब (एब्सोल्यूट समय) मापा गया, बल्कि यह कि शिशु की उम्र कितनी थी जब माप लिया गया। क्या आप यह जानकारी तालिका में जोड़ सकते हैं? नीचे एक तरीका दिखाया गया है:

NA की संख्या बढ़ गई है। ## वाइड फॉर्म डेटा लेकिन यदि आप बताना चाहें कि शिशु कितने महीनों का था, तो आप क्या करेंगे? यह कुछ इस तरह दिखेगा:

ऊपर की तालिका में बहुत सारे NA हैं। यदि शिशुओं के सापेक्ष मापन समय अलग-अलग हों, तो वाइड फॉर्म बहुत जगह बर्बाद कर सकता है। एक और विकल्प यह है कि 2015 के साल में शिशुओं की उम्र शामिल की जाए, लेकिन यह तभी संभव है जब एब्सोल्यूट मापन समय सबके लिए एक जैसा हो। अगर शिशु महीनों के हिसाब से अलग-अलग समय पर मापे गए हों और आप उम्र महीनों में जानना चाहें, तो यह तरीका काम नहीं करता। तब यह उदाहरण ही एकमात्र तरीका लगता है। ऐसे में आप लॉन्ग-फॉर्म का उपयोग करने पर विचार कर सकते हैं। ## लॉन्ग फॉर्म में डेटा जहाँ वाइड-फॉर्म में एक शिशु के सारे मापन एक ही पंक्ति में दिखते हैं, वहीं लॉन्ग-फॉर्म में एक पंक्ति में एक ही माप दिखेगा। इसे पाने का सबसे सरल तरीका है: एक पंक्ति में बच्चे का नाम, मापन का समय, और मापन (लंबाई) दिखाना। यही इस तालिका में है:

यदि आप डेटा को नामों के अनुसार सॉर्ट कर दें, तो आपको नीचे जैसी तालिका मिलेगी। साफ है, यह तालिका ऊपर की तालिका 3 से कम जगह घेरती है!

लॉन्ग बनाम वाइड

ध्यान दें एक बार फिर कि वाइड-फॉर्म और लॉन्ग-फॉर्म के बीच बुनियादी फर्क क्या है: एक सरल अंतर यह है कि वाइड-फॉर्म में एक व्यक्ति के कई माप एक पंक्ति में दिखते हैं और कॉलम नाम बताते हैं कि वे माप क्या हैं।

यह तालिका Liam Brown की 2011-2015 की लंबाइयाँ एक पंक्ति में दिखाती है:

लॉन्ग-फॉर्म में Liam Brown की लंबाइयाँ एक कॉलम में दिखाई जाती हैं:

जैसा कि आप देख सकते हैं, आपको यह नहीं पता चलता कि ये माप किसके लिए हैं। यदि आप कॉलम नाम लिख दें, तो यह इस तरह दिखेगा:

लेकिन इसमें अपनी समस्या है। Sophia Johnson की लंबाई 2011-2014 में मापी ही नहीं गई। तो आप नीचे देख सकते हैं, कॉलम नाम आसानी से सेट नहीं किया जा सकता:

वाइड-फॉर्म से लॉन्ग-फॉर्म

वाइड-फॉर्म को लॉन्ग-फॉर्म में बदलना एक क्रमबद्ध प्रक्रिया की तरह समझा जा सकता है। एक पंक्ति के मापों को एक कॉलम में बदलने से पहले, आप तालिका को इस तरह बना सकते हैं कि हर पंक्ति में केवल एक ही माप हो। आइए इस तालिका के लिए यह करें:

परिणाम नीचे की तालिका जैसा है:

उन मापों को, जो कॉलमों में बिखरे हैं, एक कॉलम में इकट्ठा करने से पहले, आपको एक अतिरिक्त कॉलम बनाना होगा जो बताए कि ये माप क्या हैं, जैसे नीचे:

कॉलम का नाम आमतौर पर “measure” या “key” होता है। आप ऊपर की तालिका में देख सकते हैं कि “age0”, “age1”, “age2”, “age3”, “age4”, “age5” कॉलम नामों में भी हैं और एक कॉलम के अंदर भी। यदि आप कॉलम नामों को छोड़ दें, तो तालिका इस तरह होगी।

क्योंकि हर पंक्ति में केवल एक माप है, आप उन्हें एक कॉलम में इकट्ठा कर सकते हैं और परिणाम निम्न होगा:

आइए सभी मापों के लिए नए कॉलम का नाम बनाते हैं। आमतौर पर इसे "value" कहा जाता है:

ऊपर की तालिका देखें। क्या आप नोटिस करते हैं कि "age" दोहर रहा है? आप दोहराए जा रहे हिस्से को हटा सकते हैं, जिससे निम्न परिणाम मिलेगा:

Age, जो हर पंक्ति में दोहर रहा था, अब एक कॉलम नाम है। ऊपर की तालिका में value कॉलम नाम और अधिक विशिष्ट हो सकता है। आपने इसे height से बदल दिया है, जो ज्यादा स्पष्ट है। परिणाम नीचे की तालिका में देखें:

आइए तालिका 15 की तुलना तालिका 17 से करें। तालिका 15 का value कॉलम कुछ भी दर्शा सकता है, लेकिन तालिका 17 का height बहुत विशिष्ट है: यह केवल लंबाई को दर्शाता है, जबकि तालिका 15 का value किसी भी प्रकार का मान हो सकता था—जैसे लंबाई, वजन, गति या रंग। एक और तरीका नीचे जैसा हो सकता है:

उस स्थिति पर विचार करें जिसमें मापन विविध हों। यदि मापन लंबाई, वजन और BMI हों, तो यह नीचे की तालिका जैसा होगा। लेकिन इस स्थिति में value कॉलम में अलग-अलग स्केल के संख्यात्मक मान होंगे, जिससे पढ़ना भ्रमित कर सकता है। इस तालिका में लंबाई सेंटीमीटर में और वजन किलोग्राम में मापा गया है:

इसलिए वाइड-फॉर्म को लॉन्ग-फॉर्म में बदलते समय, आपको तय करना होता है कि किन मानों को एक कॉलम में इकट्ठा किया जाएगा। उसके बाद आप कॉलम का नाम तय कर सकते हैं।

अब तक कही बातों का सार: वाइड-फॉर्म को लॉन्ग-फॉर्म में बदलने के लिए, यह तय करना पड़ता है कि किन कॉलमों को मॉडिफाई करके एक कॉलम में लाया जाएगा। ऐसा करते समय, कई कॉलम एक कॉलम में संयोजित होते हैं। इसलिए उस कॉलम के लिए एक कॉलम नाम चाहिए, जैसा कि अगली तालिकाओं में दिखता है:

आइए ऊपर दी गई तालिका में कॉलम id1 और id2 को देखें। id2 किसी व्यक्ति को निर्दिष्ट नहीं करता बल्कि यह व्यक्ति का गुण (लिंग) बताता है। दूसरे शब्दों में, आप कह सकते हैं कि यह एक मापन है। इसलिए आप इसे लंबे-रूप में बदल सकते हैं। सबसे लंबे-रूप में तीन कॉलम होते हैं: id, key और value।

ऊपर की तालिका तालिका 25 से प्राप्त सबसे लंबे-रूप को दिखाती है। लेकिन अलग-अलग लोगों के नाम एक जैसे हो सकते हैं।

ऐसे में, लंबे-रूप से भ्रम हो सकता है क्योंकि id एक व्यक्ति को निर्दिष्ट नहीं कर पाता। आप नाम के पीछे एक संख्या लगाकर लोगों को अलग कर सकते हैं (उदाहरण के लिए, R फ़ंक्शन make.unique() का उपयोग करके), लेकिन आप उस नाम में अंतर नहीं कर पाएंगे जो बदला गया है और वह मूल नाम जिसमें संख्या पहले से शामिल है। सोचिए किसी व्यक्ति का वास्तविक नाम ही "John.2" हो!

इसका स्पष्ट समाधान यह है कि अलग-अलग व्यक्तियों को अलग-अलग संख्यात्मक ID आवंटित की जाए। इस स्थिति में, नाम भी एक अन्य मापन बन जाते हैं।

अगली तालिका दिखाती है कि नामों को भी मापन माना गया है। एक मायने में, यही वास्तविक सबसे लंबा-रूप है।

सबसे लंबा-रूप, चौड़े-रूप को बनाने के लिए सबसे आसान रूप है। यदि आप चौड़े-रूप को लंबे-रूप में बदलने की प्रक्रिया को उल्टा करें, जैसा कि तालिका 20 से 25 में दिखाया गया है, तो आप फिर से चौड़े-रूप पर पहुँच जाते हैं। नीचे की अगली तालिकाएँ यह प्रक्रिया दिखाती हैं:

चौड़े-रूप को लंबे-रूप में बदलते समय मुख्य बात यह तय करना है कि किन कॉलमों को एक कॉलम में समेटा जाएगा।

लेकिन यह केवल एक कॉलम तक सीमित नहीं है। यदि आवश्यक हो तो आप दो कॉलम भी इस्तेमाल कर सकते हैं, ठीक नीचे दी गई तालिका की तरह:

क्या आप इसे लंबे-रूप में बना सकते हैं?

कॉलम h2011, h2012, w2011, w2012 साल 2011 और 2012 में ऊँचाई और वज़न को दर्शाते हैं। height और weight अलग-अलग मात्रकों में मापे जाते हैं - सेमी, किलोग्राम। इसलिए आप ऊँचाई और वज़न दोनों के लिए एक ही कॉलम का उपयोग कर सकते हैं, या फिर दो अलग कॉलम भी रख सकते हैं, ठीक इस तालिका की तरह:

क्या यह लंबा-रूप है या चौड़ा-रूप?

R में लंबे से चौड़े डेटा तक

आइए R के साथ लंबे-रूप और चौड़े-रूप के बीच रूपांतरण करें। इस काम के लिए कई फ़ंक्शन और पैकेज उपलब्ध हैं।

यहाँ मैं reshape2 पैकेज के melt() और dcast() फ़ंक्शनों का उपयोग कैसे करें, यह समझाऊँगा। वजह यह है कि stack() और unstack() बुनियादी फ़ंक्शन हैं, इसलिए उनके परिणामों पर बाद में अतिरिक्त प्रोसेसिंग करनी पड़ती है। ध्यान दें कि gather() और spread() tidyr के फ़ंक्शन हैं जो काफी लोकप्रिय भी हैं, लेकिन इस ट्यूटोरियल में उन्हें शामिल नहीं किया गया है।

एक और फ़ंक्शन जिसे आप उपयोग कर सकते हैं, वह है reshape(), जो stats पैकेज के साथ आता है। दरअसल, इस फ़ंक्शन से भ्रमित न हों, क्योंकि एक पैकेज reshape नाम से भी है! यह पैकेज, reshape2 के साथ मिलकर, उन लोगों के लिए विकसित किया गया था जिन्हें reshape() से जूझना पड़ रहा था। इसके अलावा, reshape() फ़ंक्शन ऐसा प्रतीत होता है कि डेटा के अनुदैर्ध्य होने की धारणा रखता है, यानी समय के साथ मापन दोहराए जाते हैं।

आइए तालिका 35 के डेटा को लंबे-रूप में बदलें। मान लें कि नीचे दी गई तालिका में एक data.frame dat नाम से संग्रहीत है।

babies = data.frame(name= c("Jackson Smith", "Emma Williams", "Liam Brown", "Ava Wilson"), gender = c("M", "F", "M", "F"), year2011= c(74.69, NA, 88.24, 88.77), year2012=c(84.99, NA, NA, 96.45), year2013=c(91.73, 75.74, 101.83, NA)) babies

##            name gender year2011 year2012 year2013
## 1 Jackson Smith      M    74.69    84.99    91.73
## 2 Emma Williams      F       NA       NA    75.74
## 3    Liam Brown      M    88.24       NA   101.83
## 4    Ava Wilson      F    88.77    96.45       NA
संचालित द्वारा

वह सवाल जो आप पूछना चाहेंगे: "कौन-से कॉलमों को एक कॉलम में जोड़ा जाए?"

वे होंगे year2011, year2012, year2013। जब आप melt() फ़ंक्शन का उपयोग करते हैं, तो इन कॉलमों को measure.vars में सूचीबद्ध करना चाहिए:

melt(babies, measure.vars = c("year2011", "year2012", "year2013"))

##             name gender variable  value
## 1  Jackson Smith      M year2011  74.69
## 2  Emma Williams      F year2011     NA
## 3     Liam Brown      M year2011  88.24
## 4     Ava Wilson      F year2011  88.77
## 5  Jackson Smith      M year2012  84.99
## 6  Emma Williams      F year2012     NA
## 7     Liam Brown      M year2012     NA
## 8     Ava Wilson      F year2012  96.45
## 9  Jackson Smith      M year2013  91.73
## 10 Emma Williams      F year2013  75.74
## 11    Liam Brown      M year2013 101.83
## 12    Ava Wilson      F year2013     NA
संचालित द्वारा

year2011, year2012, year2013 क्रमशः 3रे, 4थे, 5वें कॉलम में हैं, इसलिए आप यह भी कर सकते हैं:

melt(babies, measure.vars = 3:5)

##             name gender variable  value
## 1  Jackson Smith      M year2011  74.69
## 2  Emma Williams      F year2011     NA
## 3     Liam Brown      M year2011  88.24
## 4     Ava Wilson      F year2011  88.77
## 5  Jackson Smith      M year2012  84.99
## 6  Emma Williams      F year2012     NA
## 7     Liam Brown      M year2012     NA
## 8     Ava Wilson      F year2012  96.45
## 9  Jackson Smith      M year2013  91.73
## 10 Emma Williams      F year2013  75.74
## 11    Liam Brown      M year2013 101.83
## 12    Ava Wilson      F year2013     NA
संचालित द्वारा

परिणाम ऊपर की तालिका में है। ध्यान दें कॉलम नाम variable और value। तालिका 23 और तालिका 24 ने दिखाया था कि नए कॉलम नामों की ज़रूरत पड़ती है। melt() फ़ंक्शन के पास नए कॉलमों के लिए डिफ़ॉल्ट नाम होते हैं - variable और value। आप इन्हें variable.name= और value.name= आर्ग्युमेंट से बदल सकते हैं। आइए नीचे ऐसा करते हैं:

melt(babies, measure.vars=3:5, variable.name="year", value.name="height")

##             name gender     year height
## 1  Jackson Smith      M year2011  74.69
## 2  Emma Williams      F year2011     NA
## 3     Liam Brown      M year2011  88.24
## 4     Ava Wilson      F year2011  88.77
## 5  Jackson Smith      M year2012  84.99
## 6  Emma Williams      F year2012     NA
## 7     Liam Brown      M year2012     NA
## 8     Ava Wilson      F year2012  96.45
## 9  Jackson Smith      M year2013  91.73
## 10 Emma Williams      F year2013  75.74
## 11    Liam Brown      M year2013 101.83
## 12    Ava Wilson      F year2013     NA
संचालित द्वारा

ऊपर के उदाहरणों में मापन सीधे बताए गए थे। जिन परिस्थितियों से आप निपट रहे हैं, उनमें Id अप्रत्यक्ष रूप से मापन का संकेत दे सकता है। इसलिए आप मापन के बजाय id के लिए कॉलम चुन सकते हैं।

नीचे दिए दोनों तरीकों के परिणाम समान हैं। पहला id के लिए कॉलम चुनता है, दूसरा समेटे जाने वाले कॉलम चुनता है:

melt(babies, id.vars=c("name","gender"))

melt(babies, measure.vars = c("year2011", "year2012", "year2013"))

##             name gender variable  value
## 1  Jackson Smith      M year2011  74.69
## 2  Emma Williams      F year2011     NA
## 3     Liam Brown      M year2011  88.24
## 4     Ava Wilson      F year2011  88.77
## 5  Jackson Smith      M year2012  84.99
## 6  Emma Williams      F year2012     NA
## 7     Liam Brown      M year2012     NA
## 8     Ava Wilson      F year2012  96.45
## 9  Jackson Smith      M year2013  91.73
## 10 Emma Williams      F year2013  75.74
## 11    Liam Brown      M year2013 101.83
## 12    Ava Wilson      F year2013     NA
संचालित द्वारा

यदि आप दोनों id.vars और measure.vars निर्दिष्ट करते हैं, तो जो कॉलम इनमें शामिल नहीं हैं वे परिणाम से बाहर हो जाते हैं। उदाहरण के लिए, नीचे के कोड अंश को देखें:

melt(babies, id.vars=c("name"), measure.vars=c("year2011", "year2012"))

##            name variable value
## 1 Jackson Smith year2011 74.69
## 2 Emma Williams year2011    NA
## 3    Liam Brown year2011 88.24
## 4    Ava Wilson year2011 88.77
## 5 Jackson Smith year2012 84.99
## 6 Emma Williams year2012    NA
## 7    Liam Brown year2012    NA
## 8    Ava Wilson year2012 96.45
संचालित द्वारा

इसके अलावा, na.rm=T NA मानों को हटा सकता है:

melt(babies, id.vars=c("name"), measure.vars=c("year2011", "year2012"), na.rm=T)

##            name variable value
## 1 Jackson Smith year2011 74.69
## 3    Liam Brown year2011 88.24
## 4    Ava Wilson year2011 88.77
## 5 Jackson Smith year2012 84.99
## 8    Ava Wilson year2012 96.45
संचालित द्वारा

dcast() फ़ंक्शन melt() का उल्टा काम करता है। id, variable, और value सबसे लंबे-रूप के कॉलम हैं। dcast(data, id ~ variable, value.var="value") सबसे लंबे-रूप को चौड़े-रूप में ले जाता है।

babiesLong <- melt(babies, id.vars=c("name"), measure.vars=c("year2011", "year2012"), na.rm=T)
babiesLong

##            name variable value
## 1 Jackson Smith year2011 74.69
## 3    Liam Brown year2011 88.24
## 4    Ava Wilson year2011 88.77
## 5 Jackson Smith year2012 84.99
## 8    Ava Wilson year2012 96.45
संचालित द्वारा

babiesLong में id के लिए name, variable के लिए variable, और value के लिए value है। इसलिए आप dcast() का उपयोग करके इसे चौड़े-रूप में बदल सकते हैं:

dcast(babiesLong, name ~ variable, value.var="value")

##            name year2011 year2012
## 1    Ava Wilson    88.77    96.45
## 2 Jackson Smith    74.69    84.99
## 3    Liam Brown    88.24       NA
संचालित द्वारा

निष्कर्ष

यही लगभग सब है। इस ट्यूटोरियल में, आपने डेटा को रेशेप करने के तर्क और प्रक्रिया को समझने पर ध्यान केंद्रित किया। आमतौर पर, विश्लेषण के लिए लंबे-रूप को प्राथमिकता दी जाती है, लेकिन अपवाद भी होते हैं। उपयुक्त स्थितियों में चौड़े-रूप में डेटा प्रस्तुत करना जगह बचा सकता है, पर जैसे-जैसे लापता मानों की संख्या बढ़ती है, आपको लंबे-रूप में बदल लेना चाहिए।

फ़ॉर्मेट रूपांतरण के लिए, आपको इस पर ध्यान देना होगा कि मापन क्या हैं। लंबे-रूप का सूत्र है: एक पंक्ति में एक मापन; और चौड़े-रूप में एक पंक्ति में कई मापन होते हैं। जब आप जिन कॉलमों में मापन फैले हैं उन्हें एक कॉलम में समेटते हैं, तो मूल कॉलम नामों को एक अतिरिक्त कॉलम में सुरक्षित रखना आवश्यक होता है। जब आप एक कॉलम में मौजूद मापों को अलग-अलग कॉलमों में फैलाते हैं, तो आपको variable कॉलम से तय करना होता है कि कॉलम नाम क्या होने चाहिए।

एक बार जब आप इस प्रक्रिया को समझ लेते हैं, तो dcast() और melt() जैसे फ़ंक्शनों का उपयोग बहुत आसान हो जाता है!