R Language
रन-लंबाई एन्कोडिंग

टिप्पणियों

dat <- c(1, 2, 2, 2, 3, 1, 4, 4, 1, 1)

रन-लंबाई एनकोडिंग `rle` के साथ

रन-लंबाई एन्कोडिंग एक वेक्टर में लगातार तत्वों के रन की लंबाई कैप्चर करता है। एक उदाहरण वेक्टर पर विचार करें:

dat <- c(1, 2, 2, 2, 3, 1, 4, 4, 1, 1)

rle फ़ंक्शन प्रत्येक रन और उसकी लंबाई को निकालता है:

r <- rle(dat)
r
# Run Length Encoding
#   lengths: int [1:6] 1 3 1 1 2 2
#   values : num [1:6] 1 2 3 1 4 1

प्रत्येक रन के r$values को r$values में कैप्चर किया गया है:

r$values
# [1] 1 2 3 1 4 1

यह कैप्चर करता है कि हमने पहले 1 का रन देखा, फिर 2 का रन, फिर 3 का रन, फिर 1 का रन, और इसी तरह।

प्रत्येक रन की लंबाई r$lengths में कैप्चर की गई है:

r$lengths
# [1] 1 3 1 1 2 2

हम देखते हैं कि 1 का प्रारंभिक रन 1 की लंबाई का था, 2 का रन जो 3 की लंबाई का था, और इसी तरह आगे भी।

बेस आर में रन द्वारा पहचान और समूहन

एक चर के रन से अपने डेटा को समूहीकृत करना और किसी प्रकार का विश्लेषण करना चाह सकते हैं। निम्नलिखित सरल डेटासेट पर विचार करें:

(dat <- data.frame(x = c(1, 1, 2, 2, 2, 1), y = 1:6))
#   x y
# 1 1 1
# 2 1 2
# 3 2 3
# 4 2 4
# 5 2 5
# 6 1 6

चर x में तीन रन हैं: मान 1 के साथ लंबाई 2 का एक रन, मान 2 के साथ लंबाई 3 का एक रन, और मान 1 के साथ लंबाई 1 का रन। हम प्रत्येक में चर y के माध्य मान की गणना करना चाहते हैं। चर x रन (ये माध्य मान 1.5, 4 और 6 हैं)।

बेस आर में, हम पहले rle का उपयोग करके x वेरिएबल के रन-लेंथ एन्कोडिंग की गणना करेंगे:

(r <- rle(dat$x))
# Run Length Encoding
#   lengths: int [1:3] 2 3 1
#   values : num [1:3] 1 2 1

अगला कदम हमारे डेटासेट की प्रत्येक पंक्ति की रन संख्या की गणना करना है। हम जानते हैं कि रन की कुल संख्या है length(r$lengths) , और प्रत्येक रन की लंबाई है r$lengths , तो हम साथ हमारे रन में से प्रत्येक की रन संख्या की गणना कर सकता rep :

(run.id <- rep(seq_along(r$lengths), r$lengths))
# [1] 1 1 2 2 2 3

अब हम रन आईडी पर समूहीकरण करके प्रत्येक रन के लिए औसत y मान की गणना करने के लिए tapply का उपयोग कर सकते हैं:

data.frame(x=r$values, meanY=tapply(dat$y, run.id, mean))
#   x meanY
# 1 1   1.5
# 2 2   4.0
# 3 1   6.0

Data.table में रन से पहचानना और समूहीकरण करना

Data.table पैकेज डेटा में रन के आधार पर समूह को एक सुविधाजनक तरीका प्रदान करता है। निम्नलिखित उदाहरण के आंकड़ों पर विचार करें:

library(data.table)
(DT <- data.table(x = c(1, 1, 2, 2, 2, 1), y = 1:6))
#    x y
# 1: 1 1
# 2: 1 2
# 3: 2 3
# 4: 2 4
# 5: 2 5
# 6: 1 6

चर x में तीन रन हैं: मान 1 के साथ लंबाई 2 का एक रन, मान 2 के साथ लंबाई 3 का एक रन, और मान 1 के साथ लंबाई 1 का रन। हम प्रत्येक में चर y के औसत मूल्य की गणना करना चाहते हैं। चर x के रन (ये माध्य मान 1.5, 4 और 6 हैं)।

डेटाटेबल rleid फ़ंक्शन एक वेक्टर के प्रत्येक तत्व की रन आईडी को इंगित करता है:

rleid(DT$x)
# [1] 1 1 2 2 2 3

फिर आसानी से इस रन आईडी पर समूह बना सकते हैं और y डेटा को सारांशित कर सकते हैं:

DT[,mean(y),by=.(x, rleid(x))]
#    x rleid  V1
# 1: 1     1 1.5
# 2: 2     2 4.0
# 3: 1     3 6.0

वैक्टर को संपीड़ित और विघटित करने के लिए रन-लंबाई एन्कोडिंग

एक ही मूल्य के लंबे रन वाले लंबे वैक्टर को उनके रन-लेंथ एन्कोडिंग (प्रत्येक रन का मान और बार-बार उस मूल्य को दोहराया जाता है) में संग्रहीत करके महत्वपूर्ण रूप से संकुचित किया जा सकता है। एक उदाहरण के रूप में, 1 की विशाल संख्या के साथ 10 मिलियन लंबाई के वेक्टर पर विचार करें और केवल 0 की एक छोटी संख्या:

set.seed(144)
dat <- sample(rep(0:1, c(1, 1e5)), 1e7, replace=TRUE)
table(dat)
#       0       1 
#     103 9999897 

10 मिलियन प्रविष्टियों को संग्रहीत करने के लिए महत्वपूर्ण स्थान की आवश्यकता होगी, लेकिन हम इस वेक्टर की रन-लेंथ एन्कोडिंग के साथ एक डेटा फ्रेम बना सकते हैं:

rle.df <- with(rle(dat), data.frame(values, lengths))
dim(rle.df)
# [1] 207   2
head(rle.df)
#   values lengths
# 1      1   52818
# 2      0       1
# 3      1  219329
# 4      0       1
# 5      1  318306
# 6      0       1

रन-लंबाई एन्कोडिंग से, हम देखते हैं कि वेक्टर में पहले 52,818 मान 1 के हैं, इसके बाद एक 0 है, इसके बाद 219,329 लगातार 1 है, इसके बाद 0 है, और इसी तरह। रन-लंबाई एन्कोडिंग में केवल 207 प्रविष्टियां हैं, जिससे हमें 10 मिलियन मानों के बजाय केवल 414 मान संग्रहीत करने की आवश्यकता होती है। जैसा कि rle.df एक डेटा फ़्रेम है, इसे write.csv जैसे मानक फ़ंक्शंस का उपयोग करके संग्रहीत किया जा सकता है।

एक वेक्टर को रन-लंबाई एन्कोडिंग में दो तरीकों से पूरा किया जा सकता है। पहली विधि केवल कॉल को rep , रन-लेंथ एन्कोडिंग के values तत्व को पहले तर्क के रूप में और दूसरे तर्क के रूप में रन-लंबाई एन्कोडिंग के lengths तत्व को पास करना:

decompressed <- rep(rle.df$values, rle.df$lengths)

हम पुष्टि कर सकते हैं कि हमारा विघटित डेटा हमारे मूल डेटा के समान है:

identical(decompressed, dat)
# [1] TRUE

दूसरी विधि का प्रयोग है आर के अंतर्निहित inverse.rle पर समारोह rle वस्तु, उदाहरण के लिए:

rle.obj <- rle(dat)                            # create a rle object here
class(rle.obj)
# [1] "rle"

dat.inv <- inverse.rle(rle.obj)               # apply the inverse.rle on the rle object

हम फिर से पुष्टि कर सकते हैं कि यह वास्तव में मूल dat उत्पादन करता है:

identical(dat.inv, dat)
# [1] TRUE