R Language
Lauflängencodierung
Suche…
Bemerkungen
Ein Lauf ist eine aufeinanderfolgende Folge wiederholter Werte oder Beobachtungen. Bei wiederholten Werten beschreibt die "Lauflängencodierung" von R einen Vektor präzise in Bezug auf seine Läufe. Erwägen:
dat <- c(1, 2, 2, 2, 3, 1, 4, 4, 1, 1)
Wir haben eine Länge von 1s; dann ein 3er-Lauf von 2s; dann ein Länge-Eins-Lauf von 3s; und so weiter. Die Lauflängencodierung von R erfasst alle Längen und Werte der Läufe eines Vektors.
Erweiterungen
Ein Lauf kann sich auch auf aufeinanderfolgende Beobachtungen in Tabellendaten beziehen. Obwohl R keine natürliche Art der Codierung dieser Codierungen hat, können sie mit rleid aus dem data.table-Paket (derzeit eine Sackgassenverbindung) behandelt werden .
Lauflängencodierung mit "rle"
Lauflängencodierung erfasst die Längen von Läufen aufeinanderfolgender Elemente in einem Vektor. Betrachten Sie einen Beispielvektor:
dat <- c(1, 2, 2, 2, 3, 1, 4, 4, 1, 1)
Die Funktion rle extrahiert jeden Lauf und seine Länge:
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
Die Werte für jeden Lauf werden in r$values erfasst:
r$values
# [1] 1 2 3 1 4 1
Dies zeigt, dass wir zuerst eine Reihe von Einsen gesehen haben, dann eine Reihe von Zweien, dann eine Reihe von Dreien, dann eine Reihe von Einsen und so weiter.
Die Längen jedes Laufs werden in r$lengths erfasst:
r$lengths
# [1] 1 3 1 1 2 2
Wir sehen, dass der anfängliche Lauf von 1er Länge von 1 war, der Lauf von 2en von Länge 3 und so weiter.
Identifizierung und Gruppierung nach Läufen in Basis R
Vielleicht möchten Sie ihre Daten nach den Läufen einer Variablen gruppieren und eine Art Analyse durchführen. Betrachten Sie das folgende einfache Dataset:
(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
Die Variable x hat drei Läufe: einen Lauf der Länge 2 mit dem Wert 1, einen Lauf der Länge 3 mit dem Wert 2 und einen Lauf der Länge 1 mit dem Wert 1. Wir möchten vielleicht den Mittelwert der Variablen y in jedem der berechnen Läufe der Variablen x (diese Mittelwerte sind 1,5, 4 und 6).
In Basis R würden wir zuerst die Lauflängencodierung der x Variablen mit rle :
(r <- rle(dat$x))
# Run Length Encoding
# lengths: int [1:3] 2 3 1
# values : num [1:3] 1 2 1
Der nächste Schritt besteht darin, die Laufnummer jeder Zeile unseres Datensatzes zu berechnen. Wir wissen, dass die Gesamtzahl der Läufe length(r$lengths) und die Länge jedes Laufs r$lengths , sodass wir die Laufnummer jedes unserer Läufe mit rep berechnen können:
(run.id <- rep(seq_along(r$lengths), r$lengths))
# [1] 1 1 2 2 2 3
Jetzt können wir tapply , um den mittleren y Wert für jeden Lauf zu berechnen, tapply wir die Lauf-ID zusammenfassen:
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
Identifizieren und Gruppieren nach Läufen in data.table
Das Paket data.table bietet eine bequeme Möglichkeit zum Gruppieren von Läufen in Daten. Betrachten Sie die folgenden Beispieldaten:
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
Die Variable x hat drei Läufe: einen Lauf der Länge 2 mit dem Wert 1, einen Lauf der Länge 3 mit dem Wert 2 und einen Lauf der Länge 1 mit dem Wert 1. Wir möchten vielleicht den Mittelwert der Variablen y in jedem der berechnen Läufe der Variablen x (diese Mittelwerte sind 1,5, 4 und 6).
Die Funktion data.table rleid stellt eine ID bereit, die die Lauf-ID jedes Elements eines Vektors angibt:
rleid(DT$x)
# [1] 1 1 2 2 2 3
Man kann dann leicht diese Lauf-ID gruppieren und die y Daten zusammenfassen:
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
Lauflängencodierung zum Komprimieren und Dekomprimieren von Vektoren
Lange Vektoren mit langen Läufen mit demselben Wert können erheblich komprimiert werden, indem sie in ihrer Lauflängencodierung gespeichert werden (der Wert jedes Laufs und die Anzahl der Wiederholungen des Werts). Als Beispiel betrachten wir einen Vektor der Länge 10 Millionen mit einer großen Anzahl von Einsen und nur einer kleinen Anzahl von Nullen:
set.seed(144)
dat <- sample(rep(0:1, c(1, 1e5)), 1e7, replace=TRUE)
table(dat)
# 0 1
# 103 9999897
Das Speichern von 10 Millionen Einträgen erfordert viel Speicherplatz. Stattdessen können Sie einen Datenrahmen mit der Lauflängencodierung dieses Vektors erstellen:
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
Bei der Lauflängencodierung sehen wir, dass die ersten 52.818 Werte in dem Vektor Einsen sind, gefolgt von einer einzelnen 0, gefolgt von 219.329 aufeinanderfolgenden Einsen, gefolgt von einer 0 usw. Die Lauflängencodierung hat nur 207 Einträge, so dass wir nur 414 Werte statt 10 Millionen Werte speichern müssen. Da rle.df ein rle.df ist, kann er mit Standardfunktionen wie write.csv gespeichert werden.
Das Dekomprimieren eines Vektors bei der Lauflängencodierung kann auf zwei Arten erfolgen. Die erste Methode ist einfach zu nennen rep , das vorbeiziehenden values Element der Lauflängencodierung als erstes Argument und die lengths Element der Lauflängencodierung als zweites Argument:
decompressed <- rep(rle.df$values, rle.df$lengths)
Wir können bestätigen, dass unsere dekomprimierten Daten mit unseren ursprünglichen Daten identisch sind:
identical(decompressed, dat)
# [1] TRUE
Die zweite Methode besteht darin, die eingebaute inverse.rle Funktion von R für das rle Objekt zu verwenden, zum Beispiel:
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
Wir können erneut bestätigen, dass dies genau die ursprünglichen dat :
identical(dat.inv, dat)
# [1] TRUE