Những lợi thế của một máy tạo ngẫu nhiên theo cấp số nhân sử dụng phương pháp của AhDR và ​​Dieter (1972) thay vì biến đổi nghịch đảo là gì?

Câu hỏi của tôi được lấy cảm hứng từ hàm tạo số ngẫu nhiên theo hàm mũ tích hợp của R , hàm rexp(). Khi cố gắng tạo các số ngẫu nhiên phân tán theo cấp số nhân, nhiều sách giáo khoa khuyên dùng phương pháp biến đổi nghịch đảo như được nêu trong trang Wikipedia này . Tôi biết rằng có những phương pháp khác để hoàn thành nhiệm vụ này. Cụ thể, mã nguồn của R sử dụng thuật toán được phác thảo trong một bài báo của Ahrens & Dieter (1972) .

Tôi đã thuyết phục bản thân mình rằng phương pháp AhDR-Dieter (AD) là chính xác. Tuy nhiên, tôi không thấy lợi ích của việc sử dụng phương pháp của họ so với phương pháp biến đổi nghịch đảo (IT). AD không chỉ phức tạp để thực hiện hơn CNTT. Dường như cũng không có lợi ích về tốc độ. Đây là mã R của tôi để điểm chuẩn cả hai phương pháp theo sau là kết quả.

invTrans <- function(n)
    -log(runif(n))
print("For the inverse transform:")
print(system.time(invTrans(1e8)))
print("For the Ahrens-Dieter algorithm:")
print(system.time(rexp(1e8)))

Các kết quả:

[1] "For the inverse transform:" 
user     system     elapsed
4.227    0.266      4.597 
[1] "For the Ahrens-Dieter algorithm:"
user     system     elapsed
4.919    0.265      5.213

So sánh mã cho hai phương thức, AD rút ra ít nhất hai số ngẫu nhiên đồng nhất (với hàm Cunif_rand() ) để có được một số ngẫu nhiên theo cấp số nhân. CNTT chỉ cần một số ngẫu nhiên thống nhất. Có lẽ nhóm lõi R đã quyết định chống lại việc triển khai CNTT vì họ cho rằng việc lấy logarit có thể chậm hơn so với việc tạo ra các số ngẫu nhiên thống nhất hơn. Tôi hiểu rằng tốc độ lấy logarit có thể phụ thuộc vào máy, nhưng ít nhất với tôi thì điều ngược lại là đúng. Có lẽ có những vấn đề xung quanh độ chính xác số của CNTT phải làm với điểm kỳ dị của logarit ở 0? Nhưng sau đó, mã nguồn R sexp.ccho thấy việc thực hiện AD cũng làm mất một số độ chính xác bằng số vì phần sau của mã C sẽ loại bỏ các bit hàng đầu khỏi số ngẫu nhiên thống nhất u .

double u = unif_rand();
while(u <= 0. || u >= 1.) u = unif_rand();
for (;;) {
    u += u;
    if (u > 1.)
        break;
    a += q[0];
}
u -= 1.;

u sau được tái chế như một số ngẫu nhiên thống nhất trong phần còn lại của sexp.c . Cho đến nay, nó xuất hiện như thể

• CNTT dễ mã hóa hơn,
• CNTT nhanh hơn, và
• cả CNTT và AD đều có thể mất độ chính xác về số.

Tôi thực sự sẽ đánh giá cao nếu ai đó có thể giải thích tại sao R vẫn thực hiện AD là lựa chọn khả dụng duy nhất cho rexp().

Trên máy tính của tôi (xin lỗi tiếng Pháp của tôi!):

> print(system.time(rexp(1e8)))
utilisateur     système      écoulé 
      4.617       0.320       4.935 
> print(system.time(rexp(1e8)))
utilisateur     système      écoulé 
      4.589       2.045       6.629 
> print(system.time(-log(runif(1e8))))
utilisateur     système      écoulé 
      7.455       1.080       8.528 
> print(system.time(-log(runif(1e8))))
utilisateur     système      écoulé 
      9.140       1.489      10.623

biến đổi nghịch đảo làm tồi tệ hơn. Nhưng bạn nên coi chừng sự thay đổi. Giới thiệu một tham số tỷ lệ dẫn đến sự biến đổi thậm chí nhiều hơn cho biến đổi nghịch đảo:

> print(system.time(rexp(1e8,rate=.01)))
utilisateur     système      écoulé 
      4.594       0.456       5.047 
> print(system.time(rexp(1e8,rate=.01)))
utilisateur     système      écoulé 
      4.661       1.319       5.976 
> print(system.time(-log(runif(1e8))/.01))
utilisateur     système      écoulé 
     15.675       2.139      17.803 
> print(system.time(-log(runif(1e8))/.01))
utilisateur     système      écoulé 
      7.863       1.122       8.977 
> print(system.time(rexp(1e8,rate=101.01)))
utilisateur     système      écoulé 
      4.610       0.220       4.826 
> print(system.time(rexp(1e8,rate=101.01)))
utilisateur     système      écoulé 
      4.621       0.156       4.774 
> print(system.time(-log(runif(1e8))/101.01))
utilisateur     système      écoulé 
      7.858       0.965       8.819 > 
> print(system.time(-log(runif(1e8))/101.01))
utilisateur     système      écoulé 
     13.924       1.345      15.262 

Dưới đây là các so sánh sử dụng rbenchmark:

> benchmark(x=rexp(1e6,rate=101.01))
  elapsed user.self sys.self
  4.617     4.564    0.056
> benchmark(x=-log(runif(1e6))/101.01)
  elapsed user.self sys.self
  14.749   14.571    0.184
> benchmark(x=rgamma(1e6,shape=1,rate=101.01))
  elapsed user.self sys.self
  14.421   14.362    0.063
> benchmark(x=rexp(1e6,rate=.01))
  elapsed user.self sys.self
  9.414     9.281    0.136
> benchmark(x=-log(runif(1e6))/.01)
  elapsed user.self sys.self
  7.953     7.866    0.092
> benchmark(x=rgamma(1e6,shape=1,rate=.01))
  elapsed user.self sys.self
  26.69    26.649    0.056

Vì vậy, số dặm vẫn thay đổi, tùy thuộc vào quy mô!

Đây chỉ là trích dẫn bài viết trong phần "Thuật toán LG: (Phương pháp logarit)":

$X=-ALOG(REGOL(IR))$$\mu$$\mu$$\mu$$u$

Vì vậy, có vẻ như các tác giả đã chọn các phương pháp khác để tránh giới hạn "nhà sản xuất" này của logarit chậm. Có lẽ câu hỏi này sau đó được chuyển tốt nhất sang stackoverflow nơi ai đó có kiến ​​thức về can đảm của R có thể nhận xét.

Chỉ cần chạy này với microbenchmark; trên máy của tôi, cách tiếp cận riêng của R nhanh hơn:

library(microbenchmark)
microbenchmark(times = 10L,
               R_native = rexp(1e8),
               dir_inv = -log(runif(1e8)))
# Unit: seconds
#      expr      min       lq     mean   median       uq      max neval
#  R_native 3.643980 3.655015 3.687062 3.677351 3.699971 3.783529    10
#   dir_inv 5.780103 5.783707 5.888088 5.912384 5.946964 6.050098    10

$\lambda = 1$

lambdas = seq(0, 10, length.out = 25L)[-1L]
png("~/Desktop/micro.png")
matplot(lambdas, 
        ts <- 
          t(sapply(lambdas, function(ll)
            print(microbenchmark(times = 50L,
                                 R_native = rexp(5e5, rate = ll),
                                 dir_inv = -log(runif(5e5))/ll),
                  unit = "relative")[ , "median"])),
        type = "l", lwd = 3L, xlab = expression(lambda),
        ylab = "Relative Timing", lty = 1L,
        col = c("black", "red"), las = 1L,
        main = paste0("Direct Computation of Exponential Variates\n",
                      "vs. R Native Generator (Ahrens-Dieter)"))
text(lambdas[1L], ts[1L, ], c("A-D", "Direct"), pos = 3L)
dev.off()