Attualmente sto lavorando a un metodo bayesiano che richiede più passaggi di ottimizzazione di un modello logit multinomiale per iterazione. Sto usando optim () per eseguire quelle ottimizzazioni, e una funzione obiettiva scritta in R. Una profilatura ha rivelato che optim () è il principale collo di bottiglia.
Dopo aver scavato, ho trovato questa domanda in cui suggeriscono che la ricodifica della funzione obiettivo Rcpppotrebbe accelerare il processo. Ho seguito il suggerimento e ho ricodificato la mia funzione oggettiva Rcpp, ma alla fine è stata più lenta (circa due volte più lenta!).
Questa è stata la mia prima volta con Rcpp(o qualsiasi cosa relativa al C ++) e non sono stato in grado di trovare un modo per vettorializzare il codice. Qualche idea su come renderlo più veloce?
Tl; dr: l'attuale implementazione della funzione in Rcpp non è veloce come R vettoriale; come renderlo più veloce?
Un esempio riproducibile :
1) Definire le funzioni oggettive in Re Rcpp: probabilità logaritmica di un modello multinomiale di intercettazione
library(Rcpp)
library(microbenchmark)
llmnl_int <- function(beta, Obs, n_cat) {
n_Obs <- length(Obs)
Xint <- matrix(c(0, beta), byrow = T, ncol = n_cat, nrow = n_Obs)
ind <- cbind(c(1:n_Obs), Obs)
Xby <- Xint[ind]
Xint <- exp(Xint)
iota <- c(rep(1, (n_cat)))
denom <- log(Xint %*% iota)
return(sum(Xby - denom))
}
cppFunction('double llmnl_int_C(NumericVector beta, NumericVector Obs, int n_cat) {
int n_Obs = Obs.size();
NumericVector betas = (beta.size()+1);
for (int i = 1; i < n_cat; i++) {
betas[i] = beta[i-1];
};
NumericVector Xby = (n_Obs);
NumericMatrix Xint(n_Obs, n_cat);
NumericVector denom = (n_Obs);
for (int i = 0; i < Xby.size(); i++) {
Xint(i,_) = betas;
Xby[i] = Xint(i,Obs[i]-1.0);
Xint(i,_) = exp(Xint(i,_));
denom[i] = log(sum(Xint(i,_)));
};
return sum(Xby - denom);
}')
2) Confronta la loro efficienza:
## Draw sample from a multinomial distribution
set.seed(2020)
mnl_sample <- t(rmultinom(n = 1000,size = 1,prob = c(0.3, 0.4, 0.2, 0.1)))
mnl_sample <- apply(mnl_sample,1,function(r) which(r == 1))
## Benchmarking
microbenchmark("llmml_int" = llmnl_int(beta = c(4,2,1), Obs = mnl_sample, n_cat = 4),
"llmml_int_C" = llmnl_int_C(beta = c(4,2,1), Obs = mnl_sample, n_cat = 4),
times = 100)
## Results
# Unit: microseconds
# expr min lq mean median uq max neval
# llmnl_int 76.809 78.6615 81.9677 79.7485 82.8495 124.295 100
# llmnl_int_C 155.405 157.7790 161.7677 159.2200 161.5805 201.655 100
3) Ora chiamandoli in optim:
## Benchmarking with optim
microbenchmark("llmnl_int" = optim(c(4,2,1), llmnl_int, Obs = mnl_sample, n_cat = 4, method = "BFGS", hessian = T, control = list(fnscale = -1)),
"llmnl_int_C" = optim(c(4,2,1), llmnl_int_C, Obs = mnl_sample, n_cat = 4, method = "BFGS", hessian = T, control = list(fnscale = -1)),
times = 100)
## Results
# Unit: milliseconds
# expr min lq mean median uq max neval
# llmnl_int 12.49163 13.26338 15.74517 14.12413 18.35461 26.58235 100
# llmnl_int_C 25.57419 25.97413 28.05984 26.34231 30.44012 37.13442 100
Sono stato un po 'sorpreso che l'implementazione vettorializzata in R fosse più veloce. L'implementazione di una versione più efficiente in Rcpp (diciamo con RcppArmadillo?) Può produrre guadagni? È un'idea migliore ricodificare tutto in Rcpp usando un ottimizzatore C ++?
PS: prima pubblicazione su Stackoverflow!
ObscomeIntegerVectorrimuovere alcuni cast.