R: row-wise dplyr::mutieren mit Funktion, der einen Daten-frame Reihe und gibt eine Ganzzahl zurück

Ich versuche, mit Rohr mutieren-Anweisung mit einer benutzerdefinierten Funktion. Ich sah diesem wenig ähnlich SO ein post aber vergeblich.
Sagen, ich habe einen Daten-frame wie folgt aus (wobei blob ist einige variable, die nicht mit der spezifischen Aufgabe, sondern ist Teil der gesamten Daten) :

df <- 
  data.frame(exclude=c('B','B','D'), 
             B=c(1,0,0), 
             C=c(3,4,9), 
             D=c(1,1,0), 
             blob=c('fd', 'fs', 'sa'), 
             stringsAsFactors = F)

Habe ich eine Funktion verwendet, die die Variablennamen so wählen Sie basierend auf dem Wert in der exclude Spalte und z.B. berechnet eine Summe, die auf die Variablen, die nicht in exclude (das ist immer ein einzelnes Zeichen).

FUN <- function(df){
  sum(df[c('B', 'C', 'D')] [!names(df[c('B', 'C', 'D')]) %in% df['exclude']] )
}

Wenn ich gibt eine einzelne Zeile (Zeile 1) FUN bekomme ich die erwartete Summe der C und D (diejenigen, die nicht erwähnt exclude), nämlich 4:

FUN(df[1,])

Wie mache ich ähnlich wie in einem Rohr mit mutieren (addieren das Ergebnis zu einer variable s). Diese zwei versuche funktionieren nicht:

df %>% mutate(s=FUN(.))
df %>% group_by(1:n()) %>% mutate(s=FUN(.))

UPDATE
Das ja auch nicht so funktionieren wie Sie sollen:

df %>% rowwise(.) %>% mutate(s=FUN(.))

Diese Werke von Ursache aber nicht in dplyr ' s mutieren (und die Rohre):

df$s <- sapply(1:nrow(df), function(x) FUN(df[x,]))
  • Könnten Sie ein Beispiel geben? Funktioniert nicht: df %>% rowwise(.) %>% mutate(s=FUN(.)). Die Antwort von @konvas scheint etwas clumpsy (siehe mein Kommentar zu @konvas s Vorschlag)
  • Sorry, habe ich missverstanden.Sie tun kann df %>% rowwise(.) %>% mutate(s=FUN(data.frame(exclude = exclude, B = B, C = C, D = D))) oder df %>% rowwise() %>% nest(exclude:D) %>% mutate(s = map_dbl(data, FUN)) %>% unnest(). Das Problem ist, dass dplyr nicht natürlich funktionieren auf sub-Daten.frames, sondern in Spalten (D. H. Vektoren). So einige zusätzliche Tricks nötig.
  • Dies ist mehr, was ich nach ! (Für das Protokoll: es ist tidyr::nest() und purrr::map_dbl() ).
InformationsquelleAutor user3375672 | 2017-05-30
  1. 8

    Wenn Sie verwenden möchten dplyr können Sie dies mit Hilfe rowwise und Ihre Funktion FUN.

    df %>% 
    rowwise %>% 
    do({
        result = as_data_frame(.)
        result$s = FUN(result)
        result
    })

    Das gleiche kann erreicht werden durch group_by statt rowwise (wie Sie bereits versucht), aber mit do statt mutate 

    df %>% 
    group_by(1:n()) %>% 
    do({
        result = as_data_frame(.)
        result$s = FUN(result)
        result
    })

    Den Grund mutate funktioniert nicht in diesem Fall, ist, dass Sie übergeben die ganze tibble, so dass es wie ein Aufruf FUN(df).

    Einer viel effizienteren Weise zu tun, die gleiche Sache ist zwar nur eine matrix-Spalten enthalten, und verwenden Sie dann rowSums.

    cols <- c('B', 'C', 'D')
include_mat <- outer(function(x, y) x != y, X = df$exclude, Y = cols)
# or outer(`!=`, X = df$exclude, Y = cols) if it's more readable to you
df$s <- rowSums(df[cols] * include_mat)
    • Ja danke, aber mein Beispiel oben (Summe -) war nur ein Beispiel Spielzeug. Mein Ziel ist es, zu verstehen, wie eine(ny) benutzerdefinierte Funktion mit dplyr::mutieren innerhalb des dplyr-Rohr (%>%). Der Vorschlag in eine do () - Anweisung scheint sehr (wie du sagst) ineffizient und zustandsbehaftete - es da noch eine einfachere Möglichkeit. Ich könnte mir auch getan haben, sehr viel effizienter (aber dann ist dies nicht mit dplyr mutieren und Rohre): df$s <- sapply(1:nrow(df), function(x) FUN(df[x,])) .
    InformationsquelleAutor konvas
  2. 6

    purrr Ansatz

    Wir können eine Kombination von nest und map_dbl für diese:

    library(tidyverse)
df %>% 
  rowwise %>% 
  nest(-blob) %>% 
  mutate(s = map_dbl(data, FUN)) %>% 
  unnest

    Lassen Sie uns brechen, dass unten ein wenig. Zuerst rowwise ermöglicht es uns, gelten die jeweils nachfolgende Funktion zur Unterstützung von beliebig komplexen Operationen, die angewendet werden müssen, um jede Zeile.

    Weiter nest wird eine neue Spalte erstellen, die eine Liste mit unseren Daten gefüttert werden in FUN (die Schönheit der tibbles vs Daten.frames!). Da wir die Anwendung dieser rowwise jede Zeile enthält eine einzelne Zeile von tibble exclude:D.

    Schließlich verwenden wir map_dbl Zuordnung unserer FUN zu jedem dieser tibbles. map_dbl über die Familie der anderen map_* Funktionen, da unsere geplante Ergebnis numerisch ist (also das doppelte).

    unnest gibt unsere tibble, in der mehr standard-Struktur.

    purrrlyr Ansatz

    Während purrrlyr vielleicht nicht so "beliebt" wie seine Eltern dplyr und purrr seine by_row Funktion hat einige Dienstprogramm hier.

    In deinem obigen Beispiel würden wir nutzen Ihre Daten im Rahmen df - und Benutzer-definierte Funktion FUN in der folgenden Weise:

    df %>% 
  by_row(..f = FUN, .to = "s", .collate = "cols")

    Das ist es! Geben Sie: 

    # tibble [3 x 6]
  exclude     B     C     D  blob     s
    <chr> <dbl> <dbl> <dbl> <chr> <dbl>
1       B     1     3     1    fd     4
2       B     0     4     1    fs     5
3       D     0     9     0    sa     9

    Zugegeben, die syntax ist ein wenig seltsam, aber hier ist, wie es bricht:

    • ..f = die Funktion für jede Zeile
    • .to = der name der Ausgabespalte, in diesem Fall s
    • .collate = die Art und Weise sollen die Ergebnisse zusammengefaßt werden, indem die Liste, Zeile oder Spalte. Da FUN hat nur einen einzigen Ausgang, würden wir in Ordnung sein, um entweder "cols" oder "rows"

    Sehen hier für weitere Informationen über die Verwendung purrrlyr...

    Leistung

    Vorwarnung, während ich mag die Funktionalität der by_row es ist nicht immer der beste Ansatz für die Leistung! purrr ist mehr intuitiv, sondern auch bei einer ziemlich großen speed Verlust. Finden Sie unter den folgenden microbenchmark test:

    library(microbenchmark)
mbm <- microbenchmark(
  purrr.test = df %>% rowwise %>% nest(-blob) %>% 
    mutate(s = map_dbl(data, FUN)) %>% unnest,
  purrrlyr.test = df %>% by_row(..f = FUN, .to = "s", .collate = "cols"),
  rowwise.test = df %>% 
    rowwise %>% 
    do({
      result = as_tibble(.)
      result$s = FUN(result)
      result
    }),
  group_by.test = df %>% 
    group_by(1:n()) %>% 
    do({
      result = as_tibble(.)
      result$s = FUN(result)
      result
    }),
  sapply.test = {df$s <- sapply(1:nrow(df), function(x) FUN(df[x,]))}, 
  times = 1000
)
autoplot(mbm)

    R: row-wise dplyr::mutieren mit Funktion, der einen Daten-frame Reihe und gibt eine Ganzzahl zurück

    Können Sie sehen, dass die purrrlyr Ansatz ist schneller als der Ansatz, eine Kombination von do mit rowwise oder group_by(1:n()) (siehe @konvas Antwort), und eher auf Augenhöhe mit den sapply Ansatz. Aber das Paket ist zwar nicht die intuitive. Die standard - purrr Ansatz scheint der langsamste, sondern vielleicht auch einfacher, mit zu arbeiten. Verschiedene user-definierte Funktionen können die Geschwindigkeit ändern, um.

    InformationsquelleAutor Dave Gruenewald
Schreibe einen Kommentar