Existe alguma função de otimização no Rcpp
Sep 05 2020
A seguir está meu código Rcpp e eu quero minimizar a função objetivo logtpoi (x, theta) em relação a theta em R por 'nlminb'. Achei que é lento. Eu tenho duas perguntas:
- Alguém pode melhorar meu código Rcpp? Muito obrigado.
- Existe alguma função de otimização no Rcpp? Se sim, talvez eu possa usá-los diretamente no Rcpp. E como usá-los? Muito obrigado.
Meu código:
#include <RcppArmadillo.h>
using namespace Rcpp;
using namespace arma;
// [[Rcpp::depends("RcppArmadillo")]]
// [[Rcpp::export]]
List dtpoi0(const IntegerVector& x, const NumericVector& theta){
//x is 3-dim vector; theta is a 6-dim parameter vector.
//be careful the order of theta1,...,theta6.
double theta1 = theta[0]; double theta2 = theta[1];
double theta3 = theta[2]; double theta4 = theta[3];
double theta5 = theta[4]; double theta6 = theta[5];
int x1 = x[0]; int x2 = x[1]; int x3 = x[2];
IntegerVector z1 = IntegerVector::create(x1,x2);
IntegerVector z2 = IntegerVector::create(x1,x3);
IntegerVector z3 = IntegerVector::create(x2,x3);
int s1 = min(z1); int s2 = min(z2); int s3 = min(z3);
arma::imat missy(1,3,fill::zeros); arma::irowvec ijk={0,0,0};
for (int i = 0; i <= s1; ++i) {
for (int j = 0; j <= s2; ++j) {
for (int k = 0; k <= s3; ++k) {
if ((i+j <= s1) & (i+k <= s2) & ( j+k <= s3))
{ ijk = {i,j,k};
missy = join_cols(missy,ijk);}
}
}
}
IntegerMatrix misy = as<IntegerMatrix>(wrap(missy));
IntegerVector u1 = IntegerVector::create(0);
IntegerVector u2 = IntegerVector::create(0);
IntegerVector u3 = IntegerVector::create(0);
IntegerVector u4 = IntegerVector::create(0);
IntegerVector u5 = IntegerVector::create(0);
IntegerVector u6 = IntegerVector::create(0);
int total = misy.nrow();
double fvalue = 0;
NumericVector part1(1); NumericVector part2(1);
NumericVector part3(1); NumericVector part4(1);
NumericVector part5(1); NumericVector part6(1);
for (int l = 1; l < total; ++l) {
u1 = IntegerVector::create(x1-misy(l,0)-misy(l,1));
u2 = IntegerVector::create(x2-misy(l,0)-misy(l,2));
u3 = IntegerVector::create(x3-misy(l,1)-misy(l,2));
u4 = IntegerVector::create(misy(l,0));
u5 = IntegerVector::create(misy(l,1));
u6 = IntegerVector::create(misy(l,2));
part1 = dpois(u1,theta1);
part2 = dpois(u2,theta2);
part3 = dpois(u3,theta3);
part4 = dpois(u4,theta4);
part5 = dpois(u5,theta5);
part6 = dpois(u6,theta6);
fvalue = fvalue + (part1*part2*part3*part4*part5*part6)[0]; }
return(List::create(Named("misy") = misy,Named("fvalue") = fvalue));
}
// [[Rcpp::export]]
NumericVector dtpoi(const IntegerMatrix& x, const NumericVector& theta){
//x is n*3 matrix, n is the number of observations.
int n = x.nrow();
NumericVector density(n);
for (int i = 0; i < n; ++i){
density(i) = dtpoi0(x.row(i),theta)["fvalue"];
}
return(density);
}
// [[Rcpp::export]]
double logtpoi0(const IntegerMatrix& x,const NumericVector theta){
// theta must be a 6-dimiension parameter.
double nln = -sum(log( dtpoi(x,theta) + 1e-60 ));
if(arma::is_finite(nln)) {nln = nln;} else {nln = -1e10;}
return(nln);
}
Respostas
3 KonradRudolph Sep 05 2020 at 21:10
Grande advertência à frente: eu realmente não conheço Armadillo. Mas eu tentei fazer isso porque o código parece interessante.
Algumas coisas gerais:
- Você não precisa declarar coisas antes de atribuí-las pela primeira vez. Em particular, geralmente não é necessário declarar vetores fora de um loop se eles forem usados apenas dentro do loop. Esta é , provavelmente, não menos eficiente do que declará-los dentro do loop. No entanto, se o seu código for muito lento, faz sentido criar um perfil cuidadoso e testar se a suposição é válida.
- Muitas de suas declarações são apenas apelidos para elementos vetoriais e não parecem necessárias.
- Seus
z{1…3}vetores não são necessários. C ++ tem aminfunção de encontrar o mínimo de dois elementos. dtpoi0contém dois loops principais. Ambos foram fortemente modificados em meu código:- O primeiro loop itera sobre muitos
ks que nunca podem ser usados, devido ao internoifque testa sei + jexcedes2. Ao puxar essa verificação para a condição de loop dej, executamos menoskloops.- Seus
ifusos em&vez de&&. Como em R, usar em&&vez de&causa curto-circuito . Embora isso provavelmente não seja mais eficiente neste caso, o uso&&é idiomático, enquanto&causa confusão (meu código usa oandque é uma forma alternativa de ortografia&&em C ++; prefiro sua legibilidade).
- Seus
- O segundo loop executa efetivamente uma operação de matriz manualmente. Acho que deveria haver uma maneira de expressar isso puramente com operações de matriz - mas, como mencionei, não sou um usuário Armadillo. Ainda assim, minhas alterações tentam vetorizar o máximo possível dessa operação (se nada mais, isso torna o código mais curto). O
dpoisproduto interno infelizmente ainda está dentro de um loop.
- O primeiro loop itera sobre muitos
- A lógica de
logtpoi0pode ser tornada mais idiomática e (IMHO) mais legível usando o operador condicional em vez deif. - const-correção é um grande negócio em C ++, uma vez que elimina modificações acidentais. Use
constliberalmente ao declarar variáveis que não devem ser alteradas. - Em termos de eficiência, o maior acerto na chamada
dtpoioulogtpoi0provavelmente é a conversão demissyparamisy, que causa alocações e cópias de memória. Somente converta paraIntegerMatrixquando necessário, ou seja, quando realmente retornar esse valor para R. Por esse motivo, eu divididtpoi0em duas partes. - Outra ineficiência é o fato de que o primeiro loop
dtpoi0desenvolve uma matriz anexando colunas. Isso é uma grande falta de não. No entanto, reescrever o código para evitar isso não é trivial.
#include <algorithm>
#include <RcppArmadillo.h>
// [[Rcpp::depends("RcppArmadillo")]]
using namespace Rcpp;
using namespace arma;
imat dtpoi0_mat(const IntegerVector& x) {
const int s1 = std::min(x[0], x[1]);
const int s2 = std::min(x[0], x[2]);
const int s3 = std::min(x[1], x[2]);
imat missy(1, 3, fill::zeros);
for (int i = 0; i <= s1; ++i) {
for (int j = 0; j <= s2 and i + j <= s1; ++j) {
for (int k = 0; k <= s3 and i + k <= s2 and j + k <= s3; ++k) {
missy = join_cols(missy, irowvec{i, j, k});
}
}
}
return missy;
}
double dtpoi0_fvalue(const IntegerVector& x, const NumericVector& theta, imat& missy) {
double fvalue = 0.0;
ivec xx = as<ivec>(x);
missy.each_row([&](irowvec& v) {
const ivec u(join_cols(xx - v(uvec{0, 0, 1}) - v(uvec{1, 2, 3}), v));
double prod = 1;
for (int i = 0; i < u.n_elem; ++i) {
prod *= R::dpois(u[i], theta[i], 0);
}
fvalue += prod;
});
return fvalue;
}
double dtpoi0_fvalue(const IntegerVector& x, const NumericVector& theta) {
imat missy = dtpoi0_mat(x);
return dtpoi0_fvalue(x, theta, missy);
}
// [[Rcpp::export]]
List dtpoi0(const IntegerVector& x, const NumericVector& theta) {
imat missy = dtpoi0_mat(x);
const double fvalue = dtpoi0_fvalue(x, theta, missy);
return List::create(Named("misy") = as<IntegerMatrix>(wrap(missy)), Named("fvalue") = fvalue);
}
// [[Rcpp::export]]
NumericVector dtpoi(const IntegerMatrix& x, const NumericVector& theta) {
//x is n*3 matrix, n is the number of observations.
int n = x.nrow();
NumericVector density(n);
for (int i = 0; i < n; ++i){
density(i) = dtpoi0_fvalue(x.row(i), theta);
}
return density;
}
// [[Rcpp::export]]
double logtpoi0(const IntegerMatrix& x, const NumericVector theta) {
// theta must be a 6-dimension parameter.
const double nln = -sum(log(dtpoi(x, theta) + 1e-60));
return is_finite(nln) ? nln : -1e10;
}
Importante: Compila, mas não consigo testar se está correto. É inteiramente possível (até provável!) Que meu refatorador tenha introduzido erros. Portanto, deve ser visto apenas como um esboço de solução e não deve, de forma alguma, ser copiado e colado em um aplicativo.
O que significa um erro “Não é possível encontrar o símbolo” ou “Não é possível resolver o símbolo”?
George Harrison ficou chateado por suas letras de 'Hurdy Gurdy Man' de Donovan não terem sido usadas