Skip to content

Add signatures for laplace #1511

@SteveBronder

Description

@SteveBronder

Laplace Signatures

template <typename ThetaMatrix, typename CovarFun, typename CovarArgs,
          typename TrainTuple, typename PredTuple, class RNG,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double>
laplace_marginal_tol_bernoulli_logit_rng(
    const std::vector<int>& y, const std::vector<int>& n_samples,
    const ThetaMatrix& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, TrainTuple&& train_tuple, PredTuple&& pred_tuple,
    const double tolerance, const int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, RNG& rng, std::ostream* msgs);

template <typename CovarFun, typename ThetaMatrix, class RNG,
          typename TrainTuple, typename PredTuple, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double>
laplace_marginal_bernoulli_logit_rng(
    const std::vector<int>& y, const std::vector<int>& n_samples,
    const ThetaMatrix& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, TrainTuple&& train_tuple, PredTuple&& pred_tuple,
    RNG& rng, std::ostream* msgs);

template <typename CovarF, typename ThetaMatrix, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline auto laplace_marginal_tol_bernoulli_logit_lpmf(
    const std::vector<int>& y, const std::vector<int>& n_samples,
    const ThetaMatrix& theta_0, CovarF&& covariance_function,
    CovarArgs&& covar_args, double tolerance, int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, std::ostream* msgs);

template <typename CovarF, typename ThetaMatrix, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline auto laplace_marginal_bernoulli_logit_lpmf(
    const std::vector<int>& y, const std::vector<int>& n_samples,
    const ThetaMatrix& theta_0, CovarF&& covariance_function,
    CovarArgs&& covar_args, std::ostream* msgs);

template <bool propto = false, typename LFun, typename LArgs, typename CovarFun,
          typename Theta0, typename CovarArgs,
          require_all_eigen_vector_t<Theta0>* = nullptr>
inline auto laplace_marginal_tol_lpdf(
    LFun&& L_f, LArgs&& l_args, const Theta0& theta_0, CovarFun&& K_f,
    CovarArgs&& covar_args, double tolerance, int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, std::ostream* msgs);

template <bool propto = false, typename LFun, typename LArgs, typename CovarFun,
          typename Theta0, typename CovarArgs>
inline auto laplace_marginal_tol_lpmf(
    LFun&& L_f, LArgs&& l_args, const Theta0& theta_0, CovarFun&& K_f,
    CovarArgs&& covar_args, const double tolerance, const int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, std::ostream* msgs);

template <typename CovarFun, typename Eta, typename ThetaVec,
          typename CovarArgs, require_all_eigen_vector_t<ThetaVec>* = nullptr>
inline auto laplace_marginal_tol_neg_binomial_2_log_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
    const ThetaVec& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, double tolerance, int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, std::ostream* msgs);

template <typename CovarFun, typename Eta, typename Theta0, typename CovarArgs>
inline auto laplace_marginal_neg_binomial_2_log_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
    const Theta0& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, std::ostream* msgs);

template <typename CovarFun, typename YeVec, typename ThetaVec,
          typename CovarArgs,
          require_all_eigen_vector_t<YeVec, ThetaVec>* = nullptr>
inline auto laplace_marginal_tol_poisson_2_log_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
    const ThetaVec& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, double tolerance, int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, std::ostream* msgs);

template <typename CovarFun, typename YeVec, typename ThetaVec,
          typename CovarArgs,
          require_all_eigen_vector_t<YeVec, ThetaVec>* = nullptr>
inline auto laplace_marginal_poisson_2_log_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
    const ThetaVec& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, std::ostream* msgs);

template <typename CovarFun, typename ThetaVec, typename CovarArgs,
          require_all_eigen_vector_t<ThetaVec>* = nullptr>
inline auto laplace_marginal_tol_poisson_log_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index,
    const ThetaVec& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, double tolerance, int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, std::ostream* msgs);

template <typename CovarFun, typename ThetaVec, typename CovarArgs,
          require_eigen_vector_t<ThetaVec>* = nullptr>
inline auto laplace_marginal_poisson_log_lpmf(const std::vector<int>& y,
                                              const std::vector<int>& y_index,
                                              const ThetaVec& theta_0,
                                              CovarFun&& covariance_function,
                                              CovarArgs&& covar_args,
                                              std::ostream* msgs)

template <typename CovarFun, typename Eta, typename ThetaMatrix, class RNG,
          typename TrainTuple, typename PredTuple, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double> laplace_marginal_tol_neg_binomial_2_log_rng(
    const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
    const ThetaMatrix& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, TrainTuple&& train_tuple, PredTuple&& pred_tuple,
    const double tolerance, const int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, RNG& rng, std::ostream* msgs);

template <typename CovarFun, typename Eta, typename ThetaMatrix, class RNG,
          typename TrainTuple, typename PredTuple, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double> laplace_marginal_neg_binomial_2_log_rng(
    const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
    const ThetaMatrix& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, TrainTuple&& train_tuple, PredTuple&& pred_tuple,
    RNG& rng, std::ostream* msgs);


 
template <typename ThetaMatrix, typename CovarFun, typename CovarArgs,
          typename TrainTuple, typename PredTuple, class RNG,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double>
laplace_marginal_tol_poisson_2_log_rng(
    const std::vector<int>& y, const std::vector<int>& y_index,
    const Eigen::VectorXd& ye, const ThetaMatrix& theta_0,
    CovarFun&& covariance_function, CovarArgs&& covar_args,
    TrainTuple&& train_tuple, PredTuple&& pred_tuple, const double tolerance,
    const int64_t max_num_steps, const int hessian_block_size, const int solver,
    const int max_steps_line_search, RNG& rng, std::ostream* msgs);

template <typename ThetaMatrix, typename CovarFun, typename CovarArgs,
          typename TrainTuple, typename PredTuple, class RNG,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double>
laplace_marginal_poisson_2_log_rng(
    const std::vector<int>& y, const std::vector<int>& y_index,
    const Eigen::VectorXd& ye, const ThetaMatrix& theta_0,
    CovarFun&& covariance_function, CovarArgs&& covar_args,
    TrainTuple&& train_tuple, PredTuple&& pred_tuple, RNG& rng,
    std::ostream* msgs);

template <typename CovarFun, typename ThetaMatrix, class RNG,
          typename TrainTuple, typename PredTuple, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double> laplace_marginal_tol_poisson_log_rng(
    const std::vector<int>& y, const std::vector<int>& y_index,
    const ThetaMatrix& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, TrainTuple&& train_tuple, PredTuple&& pred_tuple,
    const double tolerance, const int64_t max_num_steps,
    const int hessian_block_size, const int solver,
    const int max_steps_line_search, RNG& rng, std::ostream* msgs);

template <typename CovarFun, typename ThetaMatrix, class RNG,
          typename TrainTuple, typename PredTuple, typename CovarArgs,
          require_eigen_t<ThetaMatrix>* = nullptr>
inline std::vector<double> laplace_marginal_poisson_log_rng(
    const std::vector<int>& y, const std::vector<int>& y_index,
    const ThetaMatrix& theta_0, CovarFun&& covariance_function,
    CovarArgs&& covar_args, TrainTuple&& train_tuple, PredTuple&& pred_tuple,
    RNG& rng, std::ostream* msgs);

template <typename LLFunc, typename LLArgs, typename ThetaMatrix,
          typename CovarFun, typename CovarArgs, typename TrainTuple,
          typename PredTuple, typename RNG>
inline std::vector<double> laplace_marginal_tol_rng(
    LLFunc&& L_f, LLArgs&& l_args, const ThetaMatrix& theta_0,
    CovarFun&& covariance_function, CovarArgs&& covar_args,
    TrainTuple&& train_tuple, PredTuple&& pred_tuple, const double tolerance,
    const int64_t max_num_steps, const int hessian_block_size, const int solver,
    const int max_steps_line_search, RNG& rng, std::ostream* msgs);

template <typename LLFunc, typename LLArgs, typename ThetaMatrix,
          typename CovarFun, typename CovarArgs, typename TrainTuple,
          typename PredTuple, typename RNG>
inline std::vector<double> laplace_marginal_rng(LLFunc&& L_f, LLArgs&& l_args,
                                            const ThetaMatrix& theta_0,
                                            CovarFun&& covariance_function,
                                            CovarArgs&& covar_args,
                                            TrainTuple&& train_tuple,
                                            PredTuple&& pred_tuple, RNG& rng,
                                            std::ostream* msgs);

Here are the stan signatures for each translated to Stan. Some things to note.

  1. The tuple's for the covariance function need to be the same types as the types in the covariance functors arguments
  2. Same for the likelihoods in the general laplace
  3. Each function has a standard version as well as a tol version that exposes the tolerance parameters for the laplace approximation
  4. The rng functions have a bit of an odd signature with respect to the covariance function. In those signatures the covariance function is called twice. Once with covar_args and train_tuple and another time time covar_args and test_tuple. The train_tuple and test_tuple can be different types, but valid covariance function signatures should exist for both
covariance_function(covar_args..., train_tuple...);
covariance_function(covar_args..., test_tuple...);
functions {

  // 1. Laplace marginal for bernoulli_logit with tolerance _rng
  // C++: std::vector<double> laplace_marginal_tol_bernoulli_logit_rng( ... )
  vector laplace_marginal_tol_bernoulli_logit_rng(
    int[] y,
    int[] n_samples,
    vector theta_0,                // or matrix theta_0 if appropriate
    // covariance_function: a user-supplied function (replace ... with its required signature)
    matrix covariance_function(...),  
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 2. Laplace marginal for bernoulli_logit without tolerance _rng
  vector laplace_marginal_bernoulli_logit_rng(
    int[] y,
    int[] n_samples,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple
  ) 


  // 3. Laplace marginal for bernoulli_logit with tolerance lpmf
  real laplace_marginal_tol_bernoulli_logit_lpmf(
    int[] y,
    int[] n_samples,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 4. Laplace marginal for bernoulli_logit lpmf (without tolerance control)
  real laplace_marginal_bernoulli_logit_lpmf(
    int[] y,
    int[] n_samples,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args
  ) 


  // 5. Laplace marginal with tolerance lpdf (generic likelihood version)
  // Here we include a propto flag as the first parameter.
  real laplace_marginal_tol_lpdf(
    bool propto,                      // typically false by default
    real likelihood_function(...),            // likelihood function; adjust its signature as needed
    tuple l_args,
    vector theta_0,                  // constrained to be an Eigen vector equivalent
    real K_f(real, tuple),            // covariance (or second-order) function pointer
    tuple covar_args,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 6. Laplace marginal with tolerance lpmf (generic likelihood version)
  real laplace_marginal_tol_lpmf(
    bool propto,
    real likelihood_function(...),
    tuple l_args,
    vector theta_0,
    real K_f(real, tuple),
    tuple covar_args,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 7. Laplace marginal tol for neg_binomial_2_log lpmf
  real laplace_marginal_tol_neg_binomial_2_log_lpmf(
    int[] y,
    int[] y_index,
    vector eta,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 8. Laplace marginal for neg_binomial_2_log lpmf (without tolerance)
  real laplace_marginal_neg_binomial_2_log_lpmf(
    int[] y,
    int[] y_index,
    vector eta,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args
  )


  // 9. Laplace marginal tol for poisson_2_log lpmf
  real laplace_marginal_tol_poisson_2_log_lpmf(
    int[] y,
    int[] y_index,
    vector ye,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 10. Laplace marginal for poisson_2_log lpmf (without tolerance)
  real laplace_marginal_poisson_2_log_lpmf(
    int[] y,
    int[] y_index,
    vector ye,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args
  ) 


  // 11. Laplace marginal tol for poisson log lpmf
  real laplace_marginal_tol_poisson_log_lpmf(
    int[] y,
    int[] y_index,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 12. Laplace marginal for poisson log lpmf (without tolerance)
  real laplace_marginal_poisson_log_lpmf(
    int[] y,
    int[] y_index,
    vector theta_0,
    matrix covariance_function(...),
    tuple covar_args
  ) 


  // 13. Laplace marginal tol for neg_binomial_2_log _rng version
  vector laplace_marginal_tol_neg_binomial_2_log_rng(
    int[] y,
    int[] y_index,
    vector eta,
    matrix theta_0,                 // here ThetaMatrix is represented as a matrix
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 14. Laplace marginal for neg_binomial_2_log _rng version (without tolerance)
  vector laplace_marginal_neg_binomial_2_log_rng(
    int[] y,
    int[] y_index,
    vector eta,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple
  ) 


  // 15. Laplace marginal tol for poisson_2_log _rng version
  vector laplace_marginal_tol_poisson_2_log_rng(
    int[] y,
    int[] y_index,
    vector ye,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  )


  // 16. Laplace marginal for poisson_2_log _rng version (without tolerance)
  vector laplace_marginal_poisson_2_log_rng(
    int[] y,
    int[] y_index,
    vector ye,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple
  ) 


  // 17. Laplace marginal tol for poisson log _rng version
  vector laplace_marginal_tol_poisson_log_rng(
    int[] y,
    int[] y_index,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 18. Laplace marginal for poisson log _rng version (without tolerance)
  vector laplace_marginal_poisson_log_rng(
    int[] y,
    int[] y_index,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple
  )


  // 19. Laplace marginal tol _rng for a generic likelihood function
  vector laplace_marginal_tol_rng(
    real likelihood_function(...),            // generic likelihood function
    tuple l_args,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple,
    real tolerance,
    int max_num_steps,
    int hessian_block_size,
    int solver,
    int max_steps_line_search
  ) 


  // 20. Laplace marginal _rng for a generic likelihood function (without tolerance)
  vector laplace_marginal_rng(
    real likelihood_function(...),
    tuple l_args,
    matrix theta_0,
    matrix covariance_function(...),
    tuple covar_args,
    tuple train_tuple,
    tuple pred_tuple
  ) 

}

Metadata

Metadata

Assignees

Labels

big-exciting-projectLarge projects that we're excited about but might take a long time and possibly not end up working o

Projects

No projects

Milestone

No milestone

Relationships

None yet

Development

No branches or pull requests

Issue actions