ครอบครัวของ R ใช้มากกว่าน้ำตาลประโยคหรือไม่?

... เกี่ยวกับเวลาดำเนินการและ / หรือหน่วยความจำ

หากนี่ไม่เป็นจริงให้พิสูจน์ด้วยโค้ดขนาดสั้น โปรดทราบว่าการเร่งความเร็วโดย vectorization จะไม่นับรวม speedup ต้องมาจากapply( tapply, sapply, ... ) ตัวเอง

applyฟังก์ชั่นในการวิจัยไม่ให้ประสิทธิภาพที่เพิ่มขึ้นมากกว่าฟังก์ชั่นการวนลูปอื่น ๆ (เช่นfor) ข้อยกเว้นประการหนึ่งสำหรับสิ่งนี้คือlapplyสิ่งที่สามารถทำได้เร็วกว่าเล็กน้อยเนื่องจากทำงานในรหัส C มากกว่าใน R (ดูคำถามนี้สำหรับตัวอย่างของสิ่งนี้ )

แต่โดยทั่วไปกฎก็คือว่าคุณควรจะใช้ฟังก์ชั่นใช้เพื่อความชัดเจนไม่ได้สำหรับผลการดำเนินงาน

ฉันจะเพิ่มในสิ่งนี้ที่ใช้ฟังก์ชั่นไม่มีผลข้างเคียงซึ่งเป็นความแตกต่างที่สำคัญเมื่อมันมาถึงการเขียนโปรแกรมการทำงานกับอาร์นี้สามารถถูกแทนที่โดยใช้assignหรือ<<-แต่อาจเป็นอันตรายมาก ผลข้างเคียงยังทำให้โปรแกรมเข้าใจยากขึ้นเนื่องจากสถานะของตัวแปรขึ้นอยู่กับประวัติ

แก้ไข:

เพียงเพื่อเน้นสิ่งนี้ด้วยตัวอย่างเล็ก ๆ น้อย ๆ ที่คำนวณลำดับฟีโบนักชีซ้ำ ๆ สิ่งนี้สามารถเรียกใช้หลายครั้งเพื่อให้ได้การวัดที่แม่นยำ แต่ประเด็นก็คือไม่มีวิธีใดที่มีประสิทธิภาพแตกต่างกันอย่างมีนัยสำคัญ:

> fibo <- function(n) {
+   if ( n < 2 ) n
+   else fibo(n-1) + fibo(n-2)
+ }
> system.time(for(i in 0:26) fibo(i))
   user  system elapsed 
   7.48    0.00    7.52 
> system.time(sapply(0:26, fibo))
   user  system elapsed 
   7.50    0.00    7.54 
> system.time(lapply(0:26, fibo))
   user  system elapsed 
   7.48    0.04    7.54 
> library(plyr)
> system.time(ldply(0:26, fibo))
   user  system elapsed 
   7.52    0.00    7.58 

แก้ไข 2:

เกี่ยวกับการใช้งานของแพคเกจคู่ขนานสำหรับ R (เช่น rpvm, rmpi หิมะ) เหล่านี้โดยทั่วไปให้applyฟังก์ชั่นครอบครัว (แม้foreachแพคเกจจะเทียบเท่าเป็นหลักแม้จะมีชื่อ) นี่คือตัวอย่างง่ายๆของsapplyฟังก์ชั่นในsnow:

library(snow)
cl <- makeSOCKcluster(c("localhost","localhost"))
parSapply(cl, 1:20, get("+"), 3)

ตัวอย่างนี้ใช้ซ็อกเก็ตคลัสเตอร์ซึ่งไม่จำเป็นต้องติดตั้งซอฟต์แวร์เพิ่มเติม ไม่เช่นนั้นคุณจะต้องการอะไรเช่น PVM หรือ MPI (ดูหน้าการจัดกลุ่มของ Tierney ) snowมีฟังก์ชั่นการใช้งานต่อไปนี้:

parLapply(cl, x, fun, ...)
parSapply(cl, X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)
parApply(cl, X, MARGIN, FUN, ...)
parRapply(cl, x, fun, ...)
parCapply(cl, x, fun, ...)

มันทำให้รู้สึกว่าapplyฟังก์ชั่นที่ควรจะใช้สำหรับการดำเนินการคู่ขนานตั้งแต่พวกเขาไม่มีผลข้างเคียง เมื่อคุณเปลี่ยนค่าตัวแปรภายในforลูปมันจะถูกตั้งค่าทั่วโลก ในทางกลับกันapplyฟังก์ชั่นทั้งหมดสามารถใช้ได้อย่างปลอดภัยในแบบคู่ขนานเนื่องจากการเปลี่ยนแปลงเป็นแบบเฉพาะกับการเรียกใช้ฟังก์ชัน (เว้นแต่คุณจะพยายามใช้assignหรือ<<-ในกรณีนี้คุณสามารถแนะนำผลข้างเคียง) จำเป็นอย่างยิ่งที่จะต้องพูดอย่างระมัดระวังเกี่ยวกับตัวแปรท้องถิ่นและระดับโลกโดยเฉพาะอย่างยิ่งเมื่อต้องรับมือกับการประมวลผลแบบขนาน

แก้ไข:

นี่คือตัวอย่างเล็ก ๆ น้อย ๆ ที่แสดงให้เห็นถึงความแตกต่างระหว่างforและ*applyเท่าที่มีผลข้างเคียงที่เกี่ยวข้อง:

> df <- 1:10
> # *apply example
> lapply(2:3, function(i) df <- df * i)
> df
 [1]  1  2  3  4  5  6  7  8  9 10
> # for loop example
> for(i in 2:3) df <- df * i
> df
 [1]  6 12 18 24 30 36 42 48 54 60

หมายเหตุวิธีการdfในสภาพแวดล้อมของผู้ปกครองที่มีการเปลี่ยนแปลงโดยแต่ไม่for*apply

บางครั้งการเร่งความเร็วอาจมีความสำคัญเช่นเมื่อคุณต้องทำรังวนซ้ำเพื่อให้ได้ค่าเฉลี่ยโดยพิจารณาจากการจัดกลุ่มมากกว่าหนึ่งปัจจัย ที่นี่คุณมีสองวิธีที่ให้ผลลัพธ์ที่เหมือนกัน:

set.seed(1)  #for reproducability of the results

# The data
X <- rnorm(100000)
Y <- as.factor(sample(letters[1:5],100000,replace=T))
Z <- as.factor(sample(letters[1:10],100000,replace=T))

# the function forloop that averages X over every combination of Y and Z
forloop <- function(x,y,z){
# These ones are for optimization, so the functions 
#levels() and length() don't have to be called more than once.
  ylev <- levels(y)
  zlev <- levels(z)
  n <- length(ylev)
  p <- length(zlev)

  out <- matrix(NA,ncol=p,nrow=n)
  for(i in 1:n){
      for(j in 1:p){
          out[i,j] <- (mean(x[y==ylev[i] & z==zlev[j]]))
      }
  }
  rownames(out) <- ylev
  colnames(out) <- zlev
  return(out)
}

# Used on the generated data
forloop(X,Y,Z)

# The same using tapply
tapply(X,list(Y,Z),mean)

ทั้งคู่ให้ผลลัพธ์เหมือนกันทั้งหมดโดยเป็นเมทริกซ์ขนาด 5 x 10 ที่มีค่าเฉลี่ยและชื่อแถวและคอลัมน์ แต่:

> system.time(forloop(X,Y,Z))
   user  system elapsed 
   0.94    0.02    0.95 

> system.time(tapply(X,list(Y,Z),mean))
   user  system elapsed 
   0.06    0.00    0.06 

ไปแล้ว ฉันชนะอะไร ;-)

... และเมื่อฉันเพิ่งเขียนที่อื่นเพื่อนของคุณก็สมัครใจ! ... มันดูไพเราะ แต่คุณยังระบุประเภทค่าตอบแทนซึ่งทำให้เร็วขึ้นมาก

foo <- function(x) x+1
y <- numeric(1e6)

system.time({z <- numeric(1e6); for(i in y) z[i] <- foo(i)})
#   user  system elapsed 
#   3.54    0.00    3.53 
system.time(z <- lapply(y, foo))
#   user  system elapsed 
#   2.89    0.00    2.91 
system.time(z <- vapply(y, foo, numeric(1)))
#   user  system elapsed 
#   1.35    0.00    1.36 

อัปเดตเมื่อวันที่ 1 มกราคม 2020:

system.time({z1 <- numeric(1e6); for(i in seq_along(y)) z1[i] <- foo(y[i])})
#   user  system elapsed 
#   0.52    0.00    0.53 
system.time(z <- lapply(y, foo))
#   user  system elapsed 
#   0.72    0.00    0.72 
system.time(z3 <- vapply(y, foo, numeric(1)))
#   user  system elapsed 
#    0.7     0.0     0.7 
identical(z1, z3)
# [1] TRUE

ฉันได้เขียนที่อื่นว่าตัวอย่างเช่น Shane ไม่ได้เน้นถึงความแตกต่างในประสิทธิภาพการทำงานของไวยากรณ์วนลูปต่าง ๆ เพราะเวลาที่ใช้ในฟังก์ชั่นมากกว่าที่จะเน้นลูป นอกจากนี้รหัสเปรียบเทียบอย่างไม่เป็นธรรมสำหรับลูปที่ไม่มีหน่วยความจำกับการใช้ฟังก์ชั่นครอบครัวที่คืนค่า นี่คือตัวอย่างที่แตกต่างกันเล็กน้อยที่เน้นจุด

foo <- function(x) {
   x <- x+1
 }
y <- numeric(1e6)
system.time({z <- numeric(1e6); for(i in y) z[i] <- foo(i)})
#   user  system elapsed 
#  4.967   0.049   7.293 
system.time(z <- sapply(y, foo))
#   user  system elapsed 
#  5.256   0.134   7.965 
system.time(z <- lapply(y, foo))
#   user  system elapsed 
#  2.179   0.126   3.301 

หากคุณวางแผนที่จะบันทึกผลแล้วใช้ฟังก์ชั่นในครอบครัวสามารถมากขึ้นกว่าน้ำตาลประโยค

(unlist ที่ง่ายของ z เป็นเพียง 0.2s ดังนั้น lapply เร็วกว่ามากการเริ่มต้น z ใน for for loop ค่อนข้างเร็วเพราะฉันให้ค่าเฉลี่ยของการวิ่ง 5 จาก 6 ครั้งล่าสุดดังนั้นการเคลื่อนที่นอกระบบ แทบจะไม่ส่งผลกระทบต่อสิ่งต่าง ๆ )

อีกสิ่งหนึ่งที่ควรทราบคือมีอีกเหตุผลหนึ่งที่ใช้ฟังก์ชั่นครอบครัวโดยไม่ขึ้นกับประสิทธิภาพความชัดเจนหรือการขาดผลข้างเคียง forห่วงมักจะส่งเสริมการวางมากที่สุดเท่าที่เป็นไปได้ภายในวง นี่เป็นเพราะแต่ละวงต้องการการตั้งค่าตัวแปรเพื่อเก็บข้อมูล (ระหว่างการดำเนินการอื่น ๆ ที่เป็นไปได้) ใช้งบมีแนวโน้มที่จะลำเอียงในทางอื่น บ่อยครั้งที่คุณต้องการดำเนินการหลายอย่างกับข้อมูลของคุณซึ่งหลาย ๆ อย่างนั้นสามารถทำให้เป็นเวกเตอร์ได้ แต่บางอย่างอาจไม่สามารถทำได้ ใน R ซึ่งแตกต่างจากภาษาอื่น ๆ จะเป็นการดีที่สุดที่จะแยกการดำเนินการเหล่านั้นออกและเรียกใช้งานที่ไม่ได้ vectorized ในคำสั่งใช้ (หรือเวอร์ชัน vectorized ของฟังก์ชั่น) และคนที่ถูก vectorized เป็นการดำเนินงานเวกเตอร์ที่แท้จริง สิ่งนี้มักจะเพิ่มความเร็วในการทำงานอย่างมาก

ยกตัวอย่าง Joris Meys ที่เขาแทนที่แบบดั้งเดิมสำหรับลูปด้วยฟังก์ชั่น R ที่มีประโยชน์เราสามารถใช้มันเพื่อแสดงประสิทธิภาพของการเขียนโค้ดในลักษณะที่เป็นมิตรกับ R มากขึ้นสำหรับการเร่งความเร็วที่คล้ายกันโดยไม่ต้องใช้ฟังก์ชั่นพิเศษ

set.seed(1)  #for reproducability of the results

# The data - copied from Joris Meys answer
X <- rnorm(100000)
Y <- as.factor(sample(letters[1:5],100000,replace=T))
Z <- as.factor(sample(letters[1:10],100000,replace=T))

# an R way to generate tapply functionality that is fast and 
# shows more general principles about fast R coding
YZ <- interaction(Y, Z)
XS <- split(X, YZ)
m <- vapply(XS, mean, numeric(1))
m <- matrix(m, nrow = length(levels(Y)))
rownames(m) <- levels(Y)
colnames(m) <- levels(Z)
m

การทำแบบนี้จะเร็วกว่าforลูปมากและช้ากว่าtapplyฟังก์ชั่นที่ได้รับการปรับปรุงให้ดีขึ้นเล็กน้อย ไม่ใช่เพราะvapplyเร็วกว่ามากforแต่เป็นเพราะการดำเนินการเพียงครั้งเดียวในแต่ละรอบของการวนซ้ำ ในรหัสนี้ทุกอย่างอื่นจะถูกเวกเตอร์ ใน Joris Meys การforวนซ้ำแบบดั้งเดิมมีการดำเนินการจำนวนมาก (7?) เกิดขึ้นในแต่ละการวนซ้ำและมีการตั้งค่าค่อนข้างน้อย โปรดทราบว่าขนาดนี้กะทัดรัดกว่าforรุ่นเท่าใด

เมื่อใช้ฟังก์ชันกับชุดย่อยของเวกเตอร์tapplyอาจเร็วกว่าลูปสำหรับลูป ตัวอย่าง:

df <- data.frame(id = rep(letters[1:10], 100000),
                 value = rnorm(1000000))

f1 <- function(x)
  tapply(x$value, x$id, sum)

f2 <- function(x){
  res <- 0
  for(i in seq_along(l <- unique(x$id)))
    res[i] <- sum(x$value[x$id == l[i]])
  names(res) <- l
  res
}            

library(microbenchmark)

> microbenchmark(f1(df), f2(df), times=100)
Unit: milliseconds
   expr      min       lq   median       uq      max neval
 f1(df) 28.02612 28.28589 28.46822 29.20458 32.54656   100
 f2(df) 38.02241 41.42277 41.80008 42.05954 45.94273   100

applyอย่างไรก็ตามในสถานการณ์ส่วนใหญ่ไม่มีการเพิ่มความเร็วใด ๆ และในบางกรณีอาจช้ากว่านี้มาก:

mat <- matrix(rnorm(1000000), nrow=1000)

f3 <- function(x)
  apply(x, 2, sum)

f4 <- function(x){
  res <- 0
  for(i in 1:ncol(x))
    res[i] <- sum(x[,i])
  res
}

> microbenchmark(f3(mat), f4(mat), times=100)
Unit: milliseconds
    expr      min       lq   median       uq      max neval
 f3(mat) 14.87594 15.44183 15.87897 17.93040 19.14975   100
 f4(mat) 12.01614 12.19718 12.40003 15.00919 40.59100   100

แต่สำหรับสถานการณ์เหล่านี้เราได้colSumsและrowSums:

f5 <- function(x)
  colSums(x) 

> microbenchmark(f5(mat), times=100)
Unit: milliseconds
    expr      min       lq   median       uq      max neval
 f5(mat) 1.362388 1.405203 1.413702 1.434388 1.992909   100