stan/src/test/unit/services/optimize/bfgs_test.cpp at 9d4e620f9095ecf68a6f058762fa968b619c24d1 · stan-dev/stan · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <stan/services/optimize/bfgs.hpp>
#include <gtest/gtest.h>
#include <stan/io/empty_var_context.hpp>
#include <test/test-models/good/optimization/rosenbrock.hpp>
#include <test/unit/services/instrumented_callbacks.hpp>
#include <stan/callbacks/stream_writer.hpp>

struct ServicesOptimize : public testing::Test {
  ServicesOptimize()
      : init(init_ss), parameter(parameter_ss), model(context, 0, &model_ss) {}

  std::stringstream init_ss, parameter_ss, model_ss;
  stan::test::unit::instrumented_logger logger;
  stan::callbacks::stream_writer init;
  stan::test::unit::values_writer parameter;
  stan::io::empty_var_context context;
  stan_model model;
};

TEST_F(ServicesOptimize, rosenbrock) {
  unsigned int seed = 0;
  unsigned int chain = 1;
  double init_radius = 0;

  bool save_iterations = true;
  int refresh = 0;
  stan::test::unit::instrumented_interrupt interrupt;

  int return_code = stan::services::optimize::bfgs(
      model, context, seed, chain, init_radius, 0.001, 1e-12, 10000, 1e-8,
      10000000, 1e-8, 2000, save_iterations, refresh, interrupt, logger, init,
      parameter);

  EXPECT_EQ(logger.call_count(), logger.call_count_info())
      << "all output to info";
  EXPECT_EQ(1, logger.find("Initial log joint probability = -1"));
  EXPECT_EQ(1, logger.find("Optimization terminated normally: "));
  EXPECT_EQ(1, logger.find("  Convergence detected: relative gradient "
                           "magnitude is below tolerance"));

  EXPECT_EQ("0,0\n", init_ss.str());

  ASSERT_EQ(4, parameter.names_.size());
  EXPECT_EQ("lp__", parameter.names_[0]);
  EXPECT_EQ("converged__", parameter.names_[1]);
  EXPECT_EQ("x", parameter.names_[2]);
  EXPECT_EQ("y", parameter.names_[3]);

  EXPECT_EQ(20, parameter.states_.size());
  EXPECT_FLOAT_EQ(0, parameter.states_.front()[2])
      << "initial value should be (0, 0)";
  EXPECT_FLOAT_EQ(0, parameter.states_.front()[3])
      << "initial value should be (0, 0)";
  EXPECT_FLOAT_EQ(1, parameter.states_.back()[2])
      << "optimal value should be (1, 1)";
  EXPECT_FLOAT_EQ(1, parameter.states_.back()[3])
      << "optimal value should be (1, 1)";
  EXPECT_FLOAT_EQ(return_code, 0);
  EXPECT_EQ(19, interrupt.call_count());
}

TEST_F(ServicesOptimize, bfgs_timing_info) {
  unsigned int seed = 0;
  unsigned int chain = 1;
  double init_radius = 0;

  bool save_iterations = true;
  int refresh = 0;
  stan::test::unit::instrumented_interrupt interrupt;

  int return_code = stan::services::optimize::bfgs(
      model, context, seed, chain, init_radius, 0.001, 1e-12, 10000, 1e-8,
      10000000, 1e-8, 2000, save_iterations, refresh, interrupt, logger, init,
      parameter);

  EXPECT_EQ(return_code, 0);
  EXPECT_TRUE(parameter_ss.str().find("Elapsed Time:") != std::string::npos)
      << "Should find 'Elapsed Time:' in parameter_writer output";
  EXPECT_TRUE(logger.find_info("Elapsed Time:") > 0)
      << "Should find 'Elapsed Time:' in logger info output";
}