Gruppierungsfunktionen (tapply, by, aggregate) und die * apply-Familie

In der Randnotiz ist hier, wie die verschiedenen plyr - Funktionen den Basisfunktionen *apply entsprechen (vom Intro bis zum Plyr-Dokument von der Plyr-Webseite http://had.co.nz)/plyr / )

Base function   Input   Output   plyr function 
---------------------------------------
aggregate        d       d       ddply + colwise 
apply            a       a/l     aaply / alply 
by               d       l       dlply 
lapply           l       l       llply  
mapply           a       a/l     maply / mlply 
replicate        r       a/l     raply / rlply 
sapply           l       a       laply 

Eines der Ziele von plyr ist es, für jede der Funktionen einheitliche Namenskonventionen bereitzustellen und die Eingabe- und Ausgabedatentypen im Funktionsnamen zu kodieren. Es sorgt auch für Konsistenz bei der Ausgabe, da die Ausgabe von dlply() leicht an ldply() übergeben werden kann, um eine nützliche Ausgabe usw. zu erzeugen.

Konzeptionell ist das Lernen von plyr nicht schwieriger als das Verstehen der Basisfunktionen *apply.

plyr und reshape Funktionen haben fast alle diese Funktionen in meinem täglichen Gebrauch ersetzt. Aber auch aus dem Intro to Plyr-Dokument:

Verwandte Funktionen tapply und sweep haben in plyr keine entsprechende Funktion und sind weiterhin nützlich. merge ist nützlich, um Zusammenfassungen mit den Originaldaten zu kombinieren.

Aus Folie 21 von http://www.slideshare.net/hadley/plyr-one-data-analytic-strategy :

(Es ist hoffentlich klar, dass apply @ Hadleys aaply und aggregate @ Hadleys ddply entspricht.) Wenn Sie nicht sehen, wird dies durch Folie 20 derselben Diashow verdeutlicht es von diesem Bild.)

(links ist die Eingabe, oben ist die Ausgabe)

Beginnen Sie zuerst mit Jorans ausgezeichnete Antwort - zweifelhaft, dass irgendetwas das verbessern kann.

Dann können die folgenden Mnemoniken helfen, sich an die Unterschiede zwischen den beiden zu erinnern. Während einige offensichtlich sind, mögen andere weniger offensichtlich sein - dafür finden Sie Rechtfertigung in Jorans Diskussionen.

Mnemonics

• lapply ist eine Liste , die auf eine Liste oder einen Vektor wirkt und eine Liste zurückgibt.
• sapply ist ein einfaches lapply (Funktion liefert standardmäßig einen Vektor oder eine Matrix, wenn möglich)
• vapply ist eine verifizierte Anwendung (ermöglicht die Vorgabe des Rückgabeobjekttyps)
• rapply ist eine rekursive Anwendung für verschachtelte Listen, d. H. Listen innerhalb von Listen
• tapply ist eine getaggte Anwendung, bei der die Tags die Teilmengen identifizieren
• apply ist generisch : Wendet eine Funktion auf die Zeilen oder Spalten einer Matrix an (oder allgemeiner auf die Dimensionen eines Arrays).

Den richtigen Hintergrund erstellen

Wenn sich die Verwendung der apply -Familie für Sie noch etwas fremd anfühlt, fehlt möglicherweise eine wichtige Sichtweise.

Diese beiden Artikel können helfen. Sie liefern den notwendigen Hintergrund, um die funktionalen Programmiertechniken zu motivieren, die von der apply -Familie von Funktionen bereitgestellt werden.

Benutzer von LISP werden das Paradigma sofort erkennen. Wenn Sie nicht mit LISP vertraut sind, haben Sie, sobald Sie sich mit FP vertraut gemacht haben, eine mächtige Sichtweise für die Verwendung in R - erlangt, und apply macht viel mehr Sinn.

• Advanced R: Functional Programming , von Hadley Wickham
• Simple Functional Programming in R , von Michael Barton

Es gibt viele gute Antworten, die Unterschiede in den Anwendungsfällen für jede Funktion diskutieren. In keiner der Antworten werden die Leistungsunterschiede erörtert. Dies ist vernünftig, da verschiedene Funktionen verschiedene Eingaben erwarten und verschiedene Ausgaben erzeugen, aber die meisten von ihnen haben ein allgemeines gemeinsames Ziel, nach Serien/Gruppen zu bewerten. Meine Antwort wird sich auf die Leistung konzentrieren. Aufgrund der obigen Tatsache, dass die Eingabeerstellung aus den Vektoren im Timing enthalten ist, wird auch die Funktion apply nicht gemessen.

Ich habe zwei verschiedene Funktionen sum und length gleichzeitig getestet. Das getestete Volumen beträgt 50 MB am Eingang und 50 KB am Ausgang. Ich habe auch zwei derzeit beliebte Pakete beigefügt, die zu der Zeit, als die Frage gestellt wurde, nicht weit verbreitet waren, data.table und dplyr. Beides ist auf jeden Fall einen Blick wert, wenn Sie eine gute Leistung anstreben.

library(dplyr)
library(data.table)
set.seed(123)
n = 5e7
k = 5e5
x = runif(n)
grp = sample(k, n, TRUE)

timing = list()

# sapply
timing[["sapply"]] = system.time({
    lt = split(x, grp)
    r.sapply = sapply(lt, function(x) list(sum(x), length(x)), simplify = FALSE)
})

# lapply
timing[["lapply"]] = system.time({
    lt = split(x, grp)
    r.lapply = lapply(lt, function(x) list(sum(x), length(x)))
})

# tapply
timing[["tapply"]] = system.time(
    r.tapply <- tapply(x, list(grp), function(x) list(sum(x), length(x)))
)

# by
timing[["by"]] = system.time(
    r.by <- by(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# aggregate
timing[["aggregate"]] = system.time(
    r.aggregate <- aggregate(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# dplyr
timing[["dplyr"]] = system.time({
    df = data_frame(x, grp)
    r.dplyr = summarise(group_by(df, grp), sum(x), n())
})

# data.table
timing[["data.table"]] = system.time({
    dt = setnames(setDT(list(x, grp)), c("x","grp"))
    r.data.table = dt[, .(sum(x), .N), grp]
})

# all output size match to group count
sapply(list(sapply=r.sapply, lapply=r.lapply, tapply=r.tapply, by=r.by, aggregate=r.aggregate, dplyr=r.dplyr, data.table=r.data.table), 
       function(x) (if(is.data.frame(x)) nrow else length)(x)==k)
#    sapply     lapply     tapply         by  aggregate      dplyr data.table 
#      TRUE       TRUE       TRUE       TRUE       TRUE       TRUE       TRUE 

# print timings
as.data.table(sapply(timing, `[[`, "elapsed"), keep.rownames = TRUE
              )[,.(fun = V1, elapsed = V2)
                ][order(-elapsed)]
#          fun elapsed
#1:  aggregate 109.139
#2:         by  25.738
#3:      dplyr  18.978
#4:     tapply  17.006
#5:     lapply  11.524
#6:     sapply  11.326
#7: data.table   2.686

Trotz all der tollen Antworten gibt es hier noch zwei weitere Grundfunktionen, die erwähnenswert sind: die nützliche Funktion outer und die obskure Funktion eapply

äußere

outer ist eine sehr nützliche Funktion, die eher banal versteckt ist. Wenn Sie die Hilfe zu outer lesen, lautet die Beschreibung:

The outer product of the arrays X and Y is the array A with dimension  
c(dim(X), dim(Y)) where element A[c(arrayindex.x, arrayindex.y)] =   
FUN(X[arrayindex.x], Y[arrayindex.y], ...).

was den Anschein erweckt, dass dies nur für Dinge vom Typ der linearen Algebra nützlich ist. Es kann jedoch ähnlich wie mapply verwendet werden, um eine Funktion auf zwei Vektoren von Eingaben anzuwenden. Der Unterschied besteht darin, dass mapply die Funktion auf die ersten beiden Elemente und dann auf die zweiten beiden usw. anwendet, während outer die Funktion auf jede Kombination eines Elements aus dem ersten Vektor und eines aus dem zweiten Vektor anwendet . Zum Beispiel:

 A<-c(1,3,5,7,9)
 B<-c(0,3,6,9,12)

mapply(FUN=pmax, A, B)

> mapply(FUN=pmax, A, B)
[1]  1  3  6  9 12

outer(A,B, pmax)

 > outer(A,B, pmax)
      [,1] [,2] [,3] [,4] [,5]
 [1,]    1    3    6    9   12
 [2,]    3    3    6    9   12
 [3,]    5    5    6    9   12
 [4,]    7    7    7    9   12
 [5,]    9    9    9    9   12

Ich persönlich habe dies verwendet, wenn ich einen Vektor von Werten und einen Vektor von Bedingungen habe und sehen möchte, welche Werte welche Bedingungen erfüllen.

eapply

eapply ist wie lapply, außer dass eine Funktion nicht auf jedes Element in einer Liste angewendet wird, sondern auf jedes Element in einer Umgebung. Wenn Sie beispielsweise eine Liste benutzerdefinierter Funktionen in der globalen Umgebung suchen möchten:

A<-c(1,3,5,7,9)
B<-c(0,3,6,9,12)
C<-list(x=1, y=2)
D<-function(x){x+1}

> eapply(.GlobalEnv, is.function)
$A
[1] FALSE

$B
[1] FALSE

$C
[1] FALSE

$D
[1] TRUE 

Ehrlich gesagt benutze ich das nicht sehr oft, aber wenn Sie viele Pakete erstellen oder viele Umgebungen erstellen, kann es nützlich sein.

Es ist vielleicht erwähnenswert, ave. ave ist der freundliche Cousin von tapply. Es gibt Ergebnisse in einer Form zurück, die Sie direkt wieder in Ihren Datenrahmen einfügen können.

dfr <- data.frame(a=1:20, f=rep(LETTERS[1:5], each=4))
means <- tapply(dfr$a, dfr$f, mean)
##  A    B    C    D    E 
## 2.5  6.5 10.5 14.5 18.5 

## great, but putting it back in the data frame is another line:

dfr$m <- means[dfr$f]

dfr$m2 <- ave(dfr$a, dfr$f, FUN=mean) # NB argument name FUN is needed!
dfr
##   a f    m   m2
##   1 A  2.5  2.5
##   2 A  2.5  2.5
##   3 A  2.5  2.5
##   4 A  2.5  2.5
##   5 B  6.5  6.5
##   6 B  6.5  6.5
##   7 B  6.5  6.5
##   ...

Das Basispaket enthält nichts, was für ganze Datenrahmen wie ave funktioniert (da by wie tapply für Datenrahmen ist). Aber Sie können es fudgen:

dfr$foo <- ave(1:nrow(dfr), dfr$f, FUN=function(x) {
    x <- dfr[x,]
    sum(x$m*x$m2)
})
dfr
##     a f    m   m2    foo
## 1   1 A  2.5  2.5    25
## 2   2 A  2.5  2.5    25
## 3   3 A  2.5  2.5    25
## ...

Ich habe kürzlich die ziemlich nützliche Funktion sweep entdeckt und der Vollständigkeit halber hier hinzugefügt:

Sweep

Die Grundidee ist, sweep zeilen- oder spaltenweise durch ein Array zu gehen und ein modifiziertes Array zurückzugeben. Ein Beispiel wird dies verdeutlichen (Quelle: Datencamp ):

Angenommen, Sie haben eine Matrix und möchten standardisieren sie spaltenweise:

dataPoints <- matrix(4:15, nrow = 4)

# Find means per column with `apply()`
dataPoints_means <- apply(dataPoints, 2, mean)

# Find standard deviation with `apply()`
dataPoints_sdev <- apply(dataPoints, 2, sd)

# Center the points 
dataPoints_Trans1 <- sweep(dataPoints, 2, dataPoints_means,"-")
print(dataPoints_Trans1)
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Return the result
dataPoints_Trans1
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Normalize
dataPoints_Trans2 <- sweep(dataPoints_Trans1, 2, dataPoints_sdev, "/")

# Return the result
dataPoints_Trans2
##            [,1]       [,2]       [,3]
## [1,] -1.1618950 -1.1618950 -1.1618950
## [2,] -0.3872983 -0.3872983 -0.3872983
## [3,]  0.3872983  0.3872983  0.3872983
## [4,]  1.1618950  1.1618950  1.1618950

NB: Für dieses einfache Beispiel kann das gleiche Ergebnis natürlich leichter erreicht werden durch
apply(dataPoints, 2, scale)