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:

  1. Alguém pode melhorar meu código Rcpp? Muito obrigado.
  2. 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:

  1. 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.
  2. Muitas de suas declarações são apenas apelidos para elementos vetoriais e não parecem necessárias.
  3. Seus z{1…3}vetores não são necessários. C ++ tem a minfunção de encontrar o mínimo de dois elementos.
  4. dtpoi0contém dois loops principais. Ambos foram fortemente modificados em meu código:
    1. O primeiro loop itera sobre muitos ks que nunca podem ser usados, devido ao interno ifque testa se i + jexcede s2. Ao puxar essa verificação para a condição de loop de j, executamos menos kloops.
      1. 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 o andque é uma forma alternativa de ortografia &&em C ++; prefiro sua legibilidade).
    2. 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.
  5. A lógica de logtpoi0pode ser tornada mais idiomática e (IMHO) mais legível usando o operador condicional em vez de if.
  6. 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.
  7. Em termos de eficiência, o maior acerto na chamada dtpoiou logtpoi0provavelmente é a conversão de missypara misy, que causa alocações e cópias de memória. Somente converta para IntegerMatrixquando necessário, ou seja, quando realmente retornar esse valor para R. Por esse motivo, eu dividi dtpoi0em duas partes.
  8. 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.