static wa::storage::retry_info create_fake_retry_info(wa::storage::storage_location target_location, wa::storage::location_mode updated_mode, std::chrono::milliseconds interval)
{
wa::storage::retry_context dummy_context(0, wa::storage::request_result(), target_location, updated_mode);
wa::storage::retry_info fake_info(dummy_context);
fake_info.set_retry_interval(interval);
return fake_info;
}
TEST(Services, do_bfgs_optimize__lbfgs) {
std::vector<double> cont_vector(2);
cont_vector[0] = -1; cont_vector[1] = 1;
std::vector<int> disc_vector;
static const std::string DATA("");
std::stringstream data_stream(DATA);
stan::io::dump dummy_context(data_stream);
Model model(dummy_context);
typedef stan::optimization::BFGSLineSearch<Model,stan::optimization::LBFGSUpdate<> > Optimizer_LBFGS;
Optimizer_LBFGS lbfgs(model, cont_vector, disc_vector, &std::cout);
double lp = 0;
bool save_iterations = true;
int refresh = 0;
int return_code;
unsigned int random_seed = 0;
rng_t base_rng(random_seed);
std::fstream* output_stream = 0;
mock_callback callback;
return_code = stan::services::optimization::do_bfgs_optimize(model, lbfgs, base_rng,
lp, cont_vector, disc_vector,
output_stream, &std::cout,
save_iterations, refresh,
callback);
EXPECT_FLOAT_EQ(return_code, 0);
EXPECT_EQ(35, callback.n);
}
TEST(advi_test, univar_no_constraint_meanfield) {
// Create mock data_var_context
static const std::string DATA = "";
std::stringstream data_stream(DATA);
stan::io::dump dummy_context(data_stream);
// Instantiate model
Model my_model(dummy_context);
// RNG
rng_t base_rng(0);
// Other params
int n_monte_carlo_grad = 10;
std::stringstream output;
stan::interface_callbacks::writer::stream_writer message_writer(output);
// Dummy input
Eigen::VectorXd cont_params = Eigen::VectorXd::Zero(1);
cont_params(0) = -0.75;
// ADVI
stan::variational::advi<Model, stan::variational::normal_meanfield, rng_t>
test_advi(my_model,
cont_params,
base_rng,
n_monte_carlo_grad,
1e4, // absurdly high!
100,
1);
// Create some arbitrary variational q() family to calculate the ELBO over
Eigen::VectorXd mu = Eigen::VectorXd::Constant(my_model.num_params_r(),
1.88);
Eigen::VectorXd sigma_tilde = Eigen::VectorXd::Constant(
my_model.num_params_r(),
0.0); // initializing sigma_tilde = 0
// means sigma = 1
stan::variational::normal_meanfield musigmatilde =
stan::variational::normal_meanfield(mu, sigma_tilde);
double elbo = 0.0;
elbo = test_advi.calc_ELBO(musigmatilde, message_writer);
// Can calculate ELBO analytically
double one_over_sigma_j_sq = 1.0 + 2*1.0;
double sigma_j_sq = 1.0/one_over_sigma_j_sq;
double mu_j = (1.5/1.0 + 1.6/1.0 + 1.4/1.0) * sigma_j_sq;
double S_j = 1.0/(2.0*stan::math::pi())
* sqrt( sigma_j_sq / (1.0) )
* exp( -0.5 * ( pow(1.5,2)
+ pow(1.4,2)
+ pow(1.6,2)
- pow(mu_j,2)/sigma_j_sq ) );
double elbo_true = 0.0;
elbo_true += log(S_j);
elbo_true += log(1.0/( sqrt( sigma_j_sq * 2.0 * stan::math::pi() ) ));
elbo_true += -0.5 * ( pow(mu_j - 1.88, 2)/sigma_j_sq + 1.0/sigma_j_sq );
elbo_true += 0.5 * (1 + log(2.0*stan::math::pi()));
double const EPSILON = 0.1;
EXPECT_NEAR(elbo_true, elbo, EPSILON);
Eigen::VectorXd mu_grad = Eigen::VectorXd::Zero(3);
Eigen::VectorXd st_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
std::string error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (3) and "
"Dimension of log std vector (1) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(0);
error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (0) and "
"Dimension of log std vector (1) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
st_grad = Eigen::VectorXd::Zero(3);
error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (1) and "
"Dimension of log std vector (3) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
st_grad = Eigen::VectorXd::Zero(0);
error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (1) and "
"Dimension of log std vector (0) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(3);
st_grad = Eigen::VectorXd::Zero(3);
stan::variational::normal_meanfield elbo_grad = stan::variational::normal_meanfield(mu_grad, st_grad);
error = "stan::variational::normal_meanfield::calc_grad: "
"Dimension of elbo_grad (3) and "
"Dimension of variational q (1) must match in size";
EXPECT_THROW_MSG(musigmatilde.calc_grad(elbo_grad,
my_model, cont_params, n_monte_carlo_grad,
base_rng, message_writer),
std::invalid_argument, error);
}
TEST(advi_test, multivar_no_constraint_meanfield) {
// Create mock data_var_context
static const std::string DATA = "";
std::stringstream data_stream(DATA);
stan::io::dump dummy_context(data_stream);
// Instantiate model
Model my_model(dummy_context);
// RNG
rng_t base_rng(0);
// Other params
int n_monte_carlo_grad = 10;
std::stringstream output;
stan::interface_callbacks::writer::stream_writer message_writer(output);
// Dummy input
Eigen::VectorXd cont_params = Eigen::VectorXd::Zero(2);
cont_params(0) = 0.75;
cont_params(1) = 0.75;
// ADVI
stan::variational::advi<Model, stan::variational::normal_meanfield, rng_t>
test_advi(my_model,
cont_params,
base_rng,
n_monte_carlo_grad,
1e4, // absurdly high!
100,
1);
// Create some arbitrary variational q() family to calculate the ELBO over
Eigen::VectorXd mu = Eigen::VectorXd::Constant(my_model.num_params_r(),
2.5);
Eigen::VectorXd sigma_tilde = Eigen::VectorXd::Constant(
my_model.num_params_r(),
0.0); // initializing sigma_tilde = 0
// means sigma = 1
stan::variational::normal_meanfield musigmatilde =
stan::variational::normal_meanfield(mu, sigma_tilde);
double elbo = 0.0;
elbo = test_advi.calc_ELBO(musigmatilde, message_writer);
// Can calculate ELBO analytically
double zeta = -0.5 * ( 3*2*log(2.0*stan::math::pi()) + 18.5 + 25 + 13 );
Eigen::VectorXd mu_J = Eigen::VectorXd::Zero(2);
mu_J(0) = 10.5;
mu_J(1) = 7.5;
double elbo_true = 0.0;
elbo_true += zeta;
elbo_true += mu_J.dot(mu);
elbo_true += -0.5 * ( 3*mu.dot(mu) + 3*2 );
elbo_true += 1 + log(2.0*stan::math::pi());
double const EPSILON = 0.1;
EXPECT_NEAR(elbo_true, elbo, EPSILON);
Eigen::VectorXd mu_grad = Eigen::VectorXd::Zero(3);
Eigen::VectorXd st_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
std::string error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (3) and "
"Dimension of log std vector (2) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(0);
error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (0) and "
"Dimension of log std vector (2) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
st_grad = Eigen::VectorXd::Zero(3);
error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (2) and "
"Dimension of log std vector (3) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
st_grad = Eigen::VectorXd::Zero(0);
error = "stan::variational::normal_meanfield: "
"Dimension of mean vector (2) and "
"Dimension of log std vector (0) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_meanfield(mu_grad, st_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(3);
st_grad = Eigen::VectorXd::Zero(3);
stan::variational::normal_meanfield elbo_grad = stan::variational::normal_meanfield(mu_grad, st_grad);
error = "stan::variational::normal_meanfield::calc_grad: "
"Dimension of elbo_grad (3) and "
"Dimension of variational q (2) must match in size";
EXPECT_THROW_MSG(musigmatilde.calc_grad(elbo_grad,
my_model, cont_params, n_monte_carlo_grad,
base_rng, message_writer),
std::invalid_argument, error);
}
TEST(advi_test, multivar_no_constraint_fullrank) {
// Create mock data_var_context
static const std::string DATA = "";
std::stringstream data_stream(DATA);
stan::io::dump dummy_context(data_stream);
// Instantiate model
Model my_model(dummy_context);
// RNG
rng_t base_rng(0);
// Other params
int n_monte_carlo_grad = 10;
int n_grad_samples = 1e4;
std::stringstream output;
stan::interface_callbacks::writer::stream_writer message_writer(output);
// Dummy input
Eigen::VectorXd cont_params = Eigen::VectorXd::Zero(2);
cont_params(0) = 0.75;
cont_params(1) = 0.75;
// ADVI
stan::variational::advi<Model, stan::variational::normal_fullrank, rng_t>
test_advi(my_model,
cont_params,
base_rng,
n_monte_carlo_grad,
n_grad_samples,
100,
1);
// Create some arbitrary variational q() family to calculate the ELBO over
Eigen::VectorXd mu = Eigen::VectorXd::Constant(my_model.num_params_r(),
2.5);
Eigen::MatrixXd L_chol = Eigen::MatrixXd::Identity(my_model.num_params_r(),
my_model.num_params_r());
stan::variational::normal_fullrank muL =
stan::variational::normal_fullrank(mu, L_chol);
double elbo = 0.0;
elbo = test_advi.calc_ELBO(muL, message_writer);
// Can calculate ELBO analytically
double zeta = -0.5 * ( 3*2*log(2.0*stan::math::pi()) + 18.5 + 25 + 13 );
Eigen::VectorXd mu_J = Eigen::VectorXd::Zero(2);
mu_J(0) = 10.5;
mu_J(1) = 7.5;
double elbo_true = 0.0;
elbo_true += zeta;
elbo_true += mu_J.dot(mu);
elbo_true += -0.5 * ( 3*mu.dot(mu) + 3*2 );
elbo_true += 1 + log(2.0*stan::math::pi());
double const EPSILON = 0.1;
EXPECT_NEAR(elbo_true, elbo, EPSILON);
Eigen::VectorXd mu_grad = Eigen::VectorXd::Zero(3);
Eigen::MatrixXd L_grad = Eigen::MatrixXd::Identity(my_model.num_params_r(),
my_model.num_params_r());
std::string error = "stan::variational::normal_fullrank: "
"Dimension of mean vector (3) and "
"Dimension of Cholesky factor (2) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_fullrank(mu_grad, L_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(0);
error = "stan::variational::normal_fullrank: "
"Dimension of mean vector (0) and "
"Dimension of Cholesky factor (2) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_fullrank(mu_grad, L_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
L_grad = Eigen::MatrixXd::Identity(3,3);
error = "stan::variational::normal_fullrank: "
"Dimension of mean vector (2) and "
"Dimension of Cholesky factor (3) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_fullrank(mu_grad, L_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
L_grad = Eigen::MatrixXd::Identity(0,0);
error = "stan::variational::normal_fullrank: "
"Dimension of mean vector (2) and "
"Dimension of Cholesky factor (0) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_fullrank(mu_grad, L_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(my_model.num_params_r());
L_grad = Eigen::MatrixXd::Identity(1,4);
error = "stan::variational::normal_fullrank: "
"Expecting a square matrix; rows of Cholesky factor (1) and columns "
"of Cholesky factor (4) must match in size";
EXPECT_THROW_MSG(stan::variational::normal_fullrank(mu_grad, L_grad),
std::invalid_argument, error);
mu_grad = Eigen::VectorXd::Zero(3);
L_grad = Eigen::MatrixXd::Identity(3,3);
stan::variational::normal_fullrank elbo_grad = stan::variational::normal_fullrank(mu_grad, L_grad);
error = "stan::variational::normal_fullrank::calc_grad: "
"Dimension of elbo_grad (3) and "
"Dimension of variational q (2) must match in size";
EXPECT_THROW_MSG(muL.calc_grad(elbo_grad,
my_model, cont_params, n_monte_carlo_grad,
base_rng, message_writer),
std::invalid_argument, error);
}
TEST(advi_test, multivar_with_constraint_fullrank) {
// Create mock data_var_context
static const std::string DATA = "";
std::stringstream data_stream(DATA);
stan::io::dump dummy_context(data_stream);
// Instantiate model
Model my_model(dummy_context);
// RNG
rng_t base_rng(0);
// Other params
int n_monte_carlo_grad = 10;
int n_monte_carlo_elbo = 1e6;
std::stringstream output;
// Dummy input
Eigen::VectorXd cont_params = Eigen::VectorXd::Zero(2);
cont_params(0) = 0.75;
cont_params(1) = 0.75;
// ADVI
stan::variational::advi<Model, stan::variational::normal_fullrank, rng_t> test_advi(my_model,
cont_params,
base_rng,
n_monte_carlo_grad,
n_monte_carlo_elbo,
100,
1,
&output,
&output,
&output);
// Create some arbitrary variational q() family to calculate the ELBO over
Eigen::VectorXd mu = Eigen::VectorXd::Constant(my_model.num_params_r(),
log(2.5));
Eigen::MatrixXd L_chol = Eigen::MatrixXd::Identity(my_model.num_params_r(),
my_model.num_params_r());
stan::variational::normal_fullrank muL =
stan::variational::normal_fullrank(mu, L_chol);
double elbo = 0.0;
elbo = test_advi.calc_ELBO(muL);
// Can calculate ELBO analytically
double zeta = -0.5 * ( 3*2*log(2.0*stan::math::pi()) + 18.5 + 25 + 13 );
Eigen::VectorXd mu_J = Eigen::VectorXd::Zero(2);
mu_J(0) = 10.5;
mu_J(1) = 7.5;
double elbo_true = 0.0;
elbo_true += zeta;
elbo_true += 74.192457181505773; // mu_J.dot( (mu + 0.5).exp() );
elbo_true += -0.5 * 3 * ( 92.363201236633131 );
elbo_true += 2*log(2.5);
elbo_true += 1 + log(2.0*stan::math::pi());
double const EPSILON = 1.0;
EXPECT_NEAR(elbo_true, elbo, EPSILON);
}
