Эффективный способ векторизации R для циклов - PullRequest
1 голос
/ 27 января 2020

Как можно векторизовать следующий код R для сокращения времени вычислений?

q = matrix(0,n,p)
for(u in 1 : n){
    q1 <- matrix(0,p,1)
  for(iprime in 1 : n){
    for(i in 1 : n){
      if(cause[iprime]==1 & cause[i]>1 & (time[i]<time[u]) & (time[u] <= time[iprime])){
          q1 = q1 + (covs[i,] - S1byS0hat[iprime,])*G[iprime]/G[i]*expz[i]/S0hat[iprime]
      }
    }

  }
    q[u,] = q1/(m*m)
}

В качестве примера можно использовать следующие значения:

n = 2000
m = 500
p=3
G = runif(n)
time = runif(n,0.01,5)
cause = c(rep(0,600),rep(1,1000),rep(2,400))
covs = matrix(rnorm(n*p),n,p)
S1byS0hat = matrix(rnorm(n*p),n,p)
S0hat = rnorm(n)
expz = rnorm(n)

1 Ответ

2 голосов
/ 28 января 2020

Сравнительный анализ вашего решения:

coeff <- 10
n = 20 * coeff
m = 500
p = 3
G = runif(n)
time = runif(n, 0.01, 5)
cause = c(rep(0, 6 * coeff), rep(1, 10 * coeff), rep(2, 4 * coeff))
covs = matrix(rnorm(n * p), n, p)
S1byS0hat = matrix(rnorm(n * p), n, p)
S0hat = rnorm(n)
expz = rnorm(n)

system.time({
  q = matrix(0,n,p)
  for(u in 1 : n){
    q1 <- matrix(0,p,1)
    for(iprime in 1 : n){
      for(i in 1 : n){
        if(cause[iprime]==1 & cause[i]>1 & (time[i]<time[u]) & (time[u] <= time[iprime])){
          q1 = q1 + (covs[i,] - S1byS0hat[iprime,])*G[iprime]/G[i]*expz[i]/S0hat[iprime]
        }
      }

    }
    q[u,] = q1/(m*m)
  }
})

На моем компьютере требуется 9 se c (с coeff = 10 вместо 100, мы можем увеличить его позже для других решений).


Одним из первых решений будет предварительное вычисление некоторых вещей:

q2 = matrix(0, n, p)
c1 <- G / S0hat
c2 <- expz / G
for (u in 1:n) {
  q1 <- rep(0, p)
  ind_iprime <- which(cause == 1 & time[u] <= time)
  ind_i <- which(cause > 1 & time < time[u])
  for (iprime in ind_iprime) {
    for (i in ind_i) {
      q1 = q1 + (covs[i, ] - S1byS0hat[iprime, ]) * c1[iprime] * c2[i]
    }
  }
  q2[u, ] = q1
}
q2 <- q2 / (m * m)

Это займет 0,3 сек c для coeff = 10 и 6 минут для coeff = 100.


Затем вы можете векторизовать, по крайней мере, один l oop:

q3 <- matrix(0, n, p)
c1 <- G / S0hat
c2 <- expz / G
covs_c2 <- sweep(covs, 1, c2, '*')
S1byS0hat_c1 <- sweep(S1byS0hat, 1, c1, '*')
for (u in 1:n) {
  q1 <- rep(0, p)
  ind_iprime <- which(cause == 1 & time[u] <= time)
  ind_i <- which(cause > 1 & time < time[u])
  for (iprime in ind_iprime) {
    q1 <- q1 + colSums(covs_c2[ind_i, , drop = FALSE]) * c1[iprime] - 
      S1byS0hat_c1[iprime, ] * sum(c2[ind_i])
  }
  q3[u, ] <- q1
}
q3 <- q3 / (m * m)

Это займет всего 15 сек c.


Если вам нужна дополнительная производительность, хороший Стратегия может заключаться в том, чтобы перекодировать это в R cpp, особенно во избежание большого выделения памяти.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...