Podczas pracy plyrczęsto uważałem, że przydatne jest użycie adplyfunkcji skalarnych, które muszę zastosować do każdego wiersza.

na przykład

data(iris)
library(plyr)
head(
     adply(iris, 1, transform , Max.Len= max(Sepal.Length,Petal.Length))
    )
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species Max.Len
1          5.1         3.5          1.4         0.2  setosa     5.1
2          4.9         3.0          1.4         0.2  setosa     4.9
3          4.7         3.2          1.3         0.2  setosa     4.7
4          4.6         3.1          1.5         0.2  setosa     4.6
5          5.0         3.6          1.4         0.2  setosa     5.0
6          5.4         3.9          1.7         0.4  setosa     5.4

Teraz używam dplyrwięcej, zastanawiam się, czy istnieje uporządkowany / naturalny sposób na zrobienie tego? Ponieważ NIE tego chcę:

library(dplyr)
head(
     mutate(iris, Max.Len= max(Sepal.Length,Petal.Length))
    )
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species Max.Len
1          5.1         3.5          1.4         0.2  setosa     7.9
2          4.9         3.0          1.4         0.2  setosa     7.9
3          4.7         3.2          1.3         0.2  setosa     7.9
4          4.6         3.1          1.5         0.2  setosa     7.9
5          5.0         3.6          1.4         0.2  setosa     7.9
6          5.4         3.9          1.7         0.4  setosa     7.9

Od dplyr 0.2 (myślę) rowwise()jest zaimplementowany, więc odpowiedź na ten problem brzmi:

iris %>% 
  rowwise() %>% 
  mutate(Max.Len= max(Sepal.Length,Petal.Length))

Brak rowwisealternatywy

Pięć lat (!) Później ta odpowiedź jest nadal bardzo ruchliwa. Odkąd została podana, rowwisecoraz częściej nie jest zalecana, chociaż wiele osób wydaje się uważać ją za intuicyjną. Zrób sobie przysługę i przejdź przez przepływy pracy Jenny Bryan zorientowane na Row w R z uporządkowanym materiałem, aby dobrze zrozumieć ten temat.

Najprostszy sposób, jaki znalazłem, oparty jest na jednym z przykładów Hadleya z użyciem pmap:

iris %>% 
  mutate(Max.Len= purrr::pmap_dbl(list(Sepal.Length, Petal.Length), max))

Korzystając z tego podejścia, możesz podać dowolną liczbę argumentów funkcji ( .f) wewnątrz pmap.

pmap jest dobrym podejściem koncepcyjnym, ponieważ odzwierciedla fakt, że wykonując operacje na wierszach, w rzeczywistości pracujesz z krotkami z listy wektorów (kolumnami w ramce danych).

Idiomatycznym podejściem będzie stworzenie odpowiednio wektoryzowanej funkcji.

Rzapewnia, pmaxktóry jest tutaj odpowiedni, ale zapewnia również Vectorizejako opakowanie mapplyumożliwiające utworzenie wektoryzowanej dowolnej wersji dowolnej funkcji.

library(dplyr)
# use base R pmax (vectorized in C)
iris %>% mutate(max.len = pmax(Sepal.Length, Petal.Length))
# use vectorize to create your own function
# for example, a horribly inefficient get first non-Na value function
# a version that is not vectorized
coalesce <- function(a,b) {r <- c(a[1],b[1]); r[!is.na(r)][1]}
# a vectorized version
Coalesce <- Vectorize(coalesce, vectorize.args = c('a','b'))
# some example data
df <- data.frame(a = c(1:5,NA,7:10), b = c(1:3,NA,NA,6,NA,10:8))
df %>% mutate(ab =Coalesce(a,b))

Zauważ, że implementacja wektoryzacji w C / C ++ będzie szybsza, ale nie ma magicPonypakietu, który zapisze funkcję za Ciebie.

Musisz pogrupować według wiersza:

iris %>% group_by(1:n()) %>% mutate(Max.Len= max(Sepal.Length,Petal.Length))

Oto, co 1zrobili adply.

Aktualizacja 2017-08-03

Po napisaniu tego Hadley ponownie zmienił kilka rzeczy. Funkcje, które kiedyś znajdowały się w mruczeniu, są teraz w nowym mieszanym pakiecie o nazwie purrrlyr , opisanym jako:

purrrlyr zawiera pewne funkcje, które znajdują się na przecięciu purrr i dplyr. Zostały usunięte z mruczenia, aby opakowanie było lżejsze i ponieważ zostały zastąpione innymi rozwiązaniami w porządku.

Będziesz więc musiał zainstalować + załadować ten pakiet, aby poniższy kod działał.

Oryginalny post

Hadley często zmienia zdanie na temat tego, czego powinniśmy użyć, ale myślę, że powinniśmy przełączyć się na funkcje w mruczeniu, aby uzyskać funkcjonalność według wiersza. Przynajmniej, oferują taką samą funkcjonalność i mają prawie taki sam interfejs jak adplyz plyr .

Istnieją dwie powiązane funkcje by_rowi invoke_rows. Rozumiem, że używasz go, by_rowgdy chcesz zapętlić wiersze i dodać wyniki do data.frame. invoke_rowsjest używany, gdy zapętlasz wiersze data.frame i przekazujesz każdy col jako argument funkcji. Użyjemy tylko pierwszego.

Przykłady

library(tidyverse)

iris %>% 
  by_row(..f = function(this_row) {
    browser()
  })

To pozwala nam zobaczyć elementy wewnętrzne (abyśmy mogli zobaczyć, co robimy), co jest tym samym, co robienie tego z adply.

Called from: ..f(.d[[i]], ...)
Browse[1]> this_row
# A tibble: 1 × 5
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
         <dbl>       <dbl>        <dbl>       <dbl>  <fctr>
1          5.1         3.5          1.4         0.2  setosa
Browse[1]> Q

Domyślnie by_rowdodaje kolumnę listy na podstawie wyniku:

iris %>% 
  by_row(..f = function(this_row) {
      this_row[1:4] %>% unlist %>% mean
  })

daje:

# A tibble: 150 × 6
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species      .out
          <dbl>       <dbl>        <dbl>       <dbl>  <fctr>    <list>
1           5.1         3.5          1.4         0.2  setosa <dbl [1]>
2           4.9         3.0          1.4         0.2  setosa <dbl [1]>
3           4.7         3.2          1.3         0.2  setosa <dbl [1]>
4           4.6         3.1          1.5         0.2  setosa <dbl [1]>
5           5.0         3.6          1.4         0.2  setosa <dbl [1]>
6           5.4         3.9          1.7         0.4  setosa <dbl [1]>
7           4.6         3.4          1.4         0.3  setosa <dbl [1]>
8           5.0         3.4          1.5         0.2  setosa <dbl [1]>
9           4.4         2.9          1.4         0.2  setosa <dbl [1]>
10          4.9         3.1          1.5         0.1  setosa <dbl [1]>
# ... with 140 more rows

jeśli zamiast tego zwrócimy a data.frame, otrzymamy listę z data.frames:

iris %>% 
  by_row( ..f = function(this_row) {
    data.frame(
      new_col_mean = this_row[1:4] %>% unlist %>% mean,
      new_col_median = this_row[1:4] %>% unlist %>% median
    )
  })

daje:

# A tibble: 150 × 6
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species                 .out
          <dbl>       <dbl>        <dbl>       <dbl>  <fctr>               <list>
1           5.1         3.5          1.4         0.2  setosa <data.frame [1 × 2]>
2           4.9         3.0          1.4         0.2  setosa <data.frame [1 × 2]>
3           4.7         3.2          1.3         0.2  setosa <data.frame [1 × 2]>
4           4.6         3.1          1.5         0.2  setosa <data.frame [1 × 2]>
5           5.0         3.6          1.4         0.2  setosa <data.frame [1 × 2]>
6           5.4         3.9          1.7         0.4  setosa <data.frame [1 × 2]>
7           4.6         3.4          1.4         0.3  setosa <data.frame [1 × 2]>
8           5.0         3.4          1.5         0.2  setosa <data.frame [1 × 2]>
9           4.4         2.9          1.4         0.2  setosa <data.frame [1 × 2]>
10          4.9         3.1          1.5         0.1  setosa <data.frame [1 × 2]>
# ... with 140 more rows

Sposób dodawania danych wyjściowych funkcji jest kontrolowany przez .collateparametr. Dostępne są trzy opcje: lista, wiersze, kolumny. Kiedy nasze dane wyjściowe mają długość 1, nie ma znaczenia, czy używamy wierszy, czy kolumn.

iris %>% 
  by_row(.collate = "cols", ..f = function(this_row) {
    this_row[1:4] %>% unlist %>% mean
  })

iris %>% 
  by_row(.collate = "rows", ..f = function(this_row) {
    this_row[1:4] %>% unlist %>% mean
  })

oba produkują:

# A tibble: 150 × 6
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species  .out
          <dbl>       <dbl>        <dbl>       <dbl>  <fctr> <dbl>
1           5.1         3.5          1.4         0.2  setosa 2.550
2           4.9         3.0          1.4         0.2  setosa 2.375
3           4.7         3.2          1.3         0.2  setosa 2.350
4           4.6         3.1          1.5         0.2  setosa 2.350
5           5.0         3.6          1.4         0.2  setosa 2.550
6           5.4         3.9          1.7         0.4  setosa 2.850
7           4.6         3.4          1.4         0.3  setosa 2.425
8           5.0         3.4          1.5         0.2  setosa 2.525
9           4.4         2.9          1.4         0.2  setosa 2.225
10          4.9         3.1          1.5         0.1  setosa 2.400
# ... with 140 more rows

Jeśli wyprowadzimy ramkę data.frame z 1 wierszem, liczy się tylko nieznacznie, którego użyjemy:

iris %>% 
  by_row(.collate = "cols", ..f = function(this_row) {
    data.frame(
      new_col_mean = this_row[1:4] %>% unlist %>% mean,
      new_col_median = this_row[1:4] %>% unlist %>% median
      )
  })

iris %>% 
  by_row(.collate = "rows", ..f = function(this_row) {
    data.frame(
      new_col_mean = this_row[1:4] %>% unlist %>% mean,
      new_col_median = this_row[1:4] %>% unlist %>% median
    )
  })

obie dają:

# A tibble: 150 × 8
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species  .row new_col_mean new_col_median
          <dbl>       <dbl>        <dbl>       <dbl>  <fctr> <int>        <dbl>          <dbl>
1           5.1         3.5          1.4         0.2  setosa     1        2.550           2.45
2           4.9         3.0          1.4         0.2  setosa     2        2.375           2.20
3           4.7         3.2          1.3         0.2  setosa     3        2.350           2.25
4           4.6         3.1          1.5         0.2  setosa     4        2.350           2.30
5           5.0         3.6          1.4         0.2  setosa     5        2.550           2.50
6           5.4         3.9          1.7         0.4  setosa     6        2.850           2.80
7           4.6         3.4          1.4         0.3  setosa     7        2.425           2.40
8           5.0         3.4          1.5         0.2  setosa     8        2.525           2.45
9           4.4         2.9          1.4         0.2  setosa     9        2.225           2.15
10          4.9         3.1          1.5         0.1  setosa    10        2.400           2.30
# ... with 140 more rows

poza tym, że druga ma wywołaną kolumnę, .rowa pierwsza nie.

Wreszcie, jeśli nasze dane wyjściowe są dłuższe niż długość 1 jako a vectorlub jako a data.framez wierszami, wtedy ma znaczenie, czy użyjemy wierszy, czy kolumn do .collate:

mtcars[1:2] %>% by_row(function(x) 1:5)
mtcars[1:2] %>% by_row(function(x) 1:5, .collate = "rows")
mtcars[1:2] %>% by_row(function(x) 1:5, .collate = "cols")

produkuje odpowiednio:

# A tibble: 32 × 3
     mpg   cyl      .out
   <dbl> <dbl>    <list>
1   21.0     6 <int [5]>
2   21.0     6 <int [5]>
3   22.8     4 <int [5]>
4   21.4     6 <int [5]>
5   18.7     8 <int [5]>
6   18.1     6 <int [5]>
7   14.3     8 <int [5]>
8   24.4     4 <int [5]>
9   22.8     4 <int [5]>
10  19.2     6 <int [5]>
# ... with 22 more rows

# A tibble: 160 × 4
     mpg   cyl  .row  .out
   <dbl> <dbl> <int> <int>
1     21     6     1     1
2     21     6     1     2
3     21     6     1     3
4     21     6     1     4
5     21     6     1     5
6     21     6     2     1
7     21     6     2     2
8     21     6     2     3
9     21     6     2     4
10    21     6     2     5
# ... with 150 more rows

# A tibble: 32 × 7
     mpg   cyl .out1 .out2 .out3 .out4 .out5
   <dbl> <dbl> <int> <int> <int> <int> <int>
1   21.0     6     1     2     3     4     5
2   21.0     6     1     2     3     4     5
3   22.8     4     1     2     3     4     5
4   21.4     6     1     2     3     4     5
5   18.7     8     1     2     3     4     5
6   18.1     6     1     2     3     4     5
7   14.3     8     1     2     3     4     5
8   24.4     4     1     2     3     4     5
9   22.8     4     1     2     3     4     5
10  19.2     6     1     2     3     4     5
# ... with 22 more rows

Tak więc, podsumowanie. Jeśli chcesz mieć adply(.margins = 1, ...)funkcjonalność, możesz użyć by_row.

Rozszerzając odpowiedź BrodieG,

Jeśli funkcja zwraca więcej niż jeden wiersz mutate(), do()należy użyć zamiast . Następnie, aby ponownie połączyć, użyj rbind_all()z dplyropakowania.

W dplyrwersji dplyr_0.1.2używanie 1:n()w group_by()klauzuli nie działa dla mnie. Miejmy nadzieję, że Hadleyrowwise() wkrótce się wdroży .

iris %>%
    group_by(1:nrow(iris)) %>%
    do(do_fn) %>%
    rbind_all()

Testowanie wydajności,

library(plyr)    # plyr_1.8.4.9000
library(dplyr)   # dplyr_0.8.0.9000
library(purrr)   # purrr_0.2.99.9000
library(microbenchmark)

d1_count <- 1000
d2_count <- 10

d1 <- data.frame(a=runif(d1_count))

do_fn <- function(row){data.frame(a=row$a, b=runif(d2_count))}
do_fn2 <- function(a){data.frame(a=a, b=runif(d2_count))}

op <- microbenchmark(
        plyr_version = plyr::adply(d1, 1, do_fn),
        dplyr_version = d1 %>%
            dplyr::group_by(1:nrow(d1)) %>%
            dplyr::do(do_fn(.)) %>%
            dplyr::bind_rows(),
        purrr_version = d1 %>% purrr::pmap_dfr(do_fn2),
        times=50)

ma następujące wyniki:

Unit: milliseconds
          expr       min        lq      mean    median        uq       max neval
  plyr_version 1227.2589 1275.1363 1317.3431 1293.5759 1314.4266 1616.5449    50
 dplyr_version  977.3025 1012.6340 1035.9436 1025.6267 1040.5882 1449.0978    50
 purrr_version  609.5790  629.7565  643.8498  644.2505  656.1959  686.8128    50

To pokazuje, że nowa purrrwersja jest najszybsza

Coś takiego?

iris$Max.Len <- pmax(iris$Sepal.Length, iris$Petal.Length)