`Feature/1180 pathfinder single path csvs

src/cmdstan/arguments/arg_pathfinder.hpp

@@ -18,6 +18,9 @@ class arg_pathfinder : public arg_lbfgs {
         "num_psis_draws", "Number of draws from PSIS sample", 1000));
     _subarguments.push_back(
         new arg_single_int_pos("num_paths", "Number of single pathfinders", 4));
+    _subarguments.push_back(new arg_single_bool(
+        "save_single_paths", "Output single-path pathfinder draws as CSV",
+        false));
     _subarguments.push_back(new arg_single_int_pos(
         "max_lbfgs_iters", "Maximum number of LBFGS iterations", 1000));
     _subarguments.push_back(new arg_single_int_pos(

src/cmdstan/command.hpp

@@ -195,6 +195,7 @@ int command(int argc, const char *argv[]) {
       diagnostic_csv_writers;
   std::vector<stan::callbacks::json_writer<std::ofstream>>
       diagnostic_json_writers;
+
   init_callbacks(parser, sample_writers, diagnostic_csv_writers,
                  diagnostic_json_writers);
 
@@ -207,9 +208,11 @@ int command(int argc, const char *argv[]) {
     init = "";
   } catch (const std::logic_error &e) {
   }
+
   std::vector<std::shared_ptr<stan::io::var_context>> init_contexts
       = get_vec_var_context(init, num_chains);
   std::vector<std::string> model_compile_info = model.model_compile_info();
+
   for (int i = 0; i < num_chains; ++i) {
     write_stan(sample_writers[i]);
     write_model(sample_writers[i], model.model_name());
@@ -253,8 +256,8 @@ int command(int argc, const char *argv[]) {
         = get_arg_val<int_argument>(*pathfinder_arg, "num_psis_draws");
     int num_paths = get_arg_val<int_argument>(*pathfinder_arg, "num_paths");
     bool save_iterations
-        = !get_arg_val<string_argument>(parser, "output", "diagnostic_file")
-               .empty();
+        = get_arg_val<bool_argument>(*pathfinder_arg, "save_single_paths");
+
     if (num_paths == 1) {
       return_code = stan::services::pathfinder::pathfinder_lbfgs_single<
           false, stan::model::model_base>(
@@ -264,16 +267,13 @@ int command(int argc, const char *argv[]) {
           save_iterations, refresh, interrupt, logger, init_writer,
           sample_writers[0], diagnostic_json_writers[0]);
     } else {
-      std::string output_file
-          = get_arg_val<string_argument>(parser, "output", "file");
-      auto base_sfx = get_basename_suffix(output_file);
-      if (base_sfx.second.empty())
-        base_sfx.second = ".csv";
-      auto ofs = std::make_unique<std::ofstream>(base_sfx.first + "_pathfinder"
-                                                 + base_sfx.second);
-      if (sig_figs > -1) {
+      auto ofs = std::make_unique<std::ofstream>(
+          get_basename_suffix(
+              get_arg_val<string_argument>(parser, "output", "file"))
+              .first
+          + ".csv");
+      if (sig_figs > -1)
         ofs->precision(sig_figs);
-      }
       stan::callbacks::unique_stream_writer<std::ofstream> pathfinder_writer(
           std::move(ofs), "# ");
       write_stan(pathfinder_writer);

src/cmdstan/command_helper.hpp

@@ -738,6 +738,7 @@ void check_file_config(argument_parser &parser) {
 }
 
 std::vector<std::string> make_filenames(const std::string &filename,
+                                        const std::string &tag,
                                         const std::string &type,
                                         unsigned int num_chains,
                                         unsigned int id) {
@@ -754,7 +755,7 @@ std::vector<std::string> make_filenames(const std::string &filename,
     }
   };
   for (int i = 0; i < num_chains; ++i) {
-    names[i] = base_sfx.first + name_iterator(i) + base_sfx.second;
+    names[i] = base_sfx.first + tag + name_iterator(i) + base_sfx.second;
   }
   return names;
 }
@@ -771,48 +772,92 @@ void init_callbacks(
   unsigned int num_chains = get_num_chains(parser);
   unsigned int id = get_arg_val<int_argument>(parser, "id");
   int sig_figs = get_arg_val<int_argument>(parser, "output", "sig_figs");
-
+  bool save_single_paths
+      = user_method->arg("pathfinder")
+        && get_arg_val<bool_argument>(parser, "method", "pathfinder",
+                                      "save_single_paths");
+  std::string output_file
+      = get_arg_val<string_argument>(parser, "output", "file");
+  std::string diagnostic_file
+      = get_arg_val<string_argument>(parser, "output", "diagnostic_file");
+  std::vector<std::string> output_filenames;
+  std::vector<std::string> diagnostic_filenames;
   sample_writers.reserve(num_chains);
-  std::vector<std::string> output_filenames
-      = make_filenames(get_arg_val<string_argument>(parser, "output", "file"),
-                       ".csv", num_chains, id);
-  for (int i = 0; i < num_chains; ++i) {
-    auto ofs = std::make_unique<std::ofstream>(output_filenames[i]);
-    if (sig_figs > -1)
-      ofs->precision(sig_figs);
-    sample_writers.emplace_back(std::move(ofs), "# ");
-  }
-
-  diag_json_writers.reserve(num_chains);
   diag_csv_writers.reserve(num_chains);
-  // create no-op writers by default
+  diag_json_writers.reserve(num_chains);
+
+  // default - no diagnostics
   for (int i = 0; i < num_chains; ++i) {
+    diag_csv_writers.emplace_back(nullptr, "# ");
     diag_json_writers.emplace_back(
         stan::callbacks::json_writer<std::ofstream>());
   }
-  for (int i = 0; i < num_chains; ++i) {
-    diag_csv_writers.emplace_back(nullptr, "# ");
-  }
-  // create json, csv writers as needed.
-  std::string diagnostic_file
-      = get_arg_val<string_argument>(parser, "output", "diagnostic_file");
-  if (!diagnostic_file.empty()) {
-    std::vector<std::string> diag_filenames;
-    if (user_method->arg("pathfinder")) {
-      diag_json_writers.clear();
-      diag_filenames = make_filenames(diagnostic_file, ".json", num_chains, id);
+
+  if (user_method->arg("pathfinder")) {
+    std::string basename = get_basename_suffix(output_file).first;
+    std::string diag_basename = get_basename_suffix(diagnostic_file).first;
+    bool inst_writers = true;
+    bool inst_diags = true;
+    if (num_chains == 1) {
+      output_filenames.emplace_back(basename + ".csv");
+      if (!diag_basename.empty()) {
+        diagnostic_filenames.emplace_back(diag_basename + ".json");
+      } else if (save_single_paths) {
+        diagnostic_filenames.emplace_back(basename + ".json");
+      } else {
+        inst_diags = false;
+      }
+    } else if (save_single_paths) {  // filenames for single-path outputs
+      output_filenames
+          = make_filenames(basename, "_path", ".csv", num_chains, id);
+      diagnostic_filenames
+          = make_filenames(basename, "_path", ".json", num_chains, id);
+    } else {  // multi-path default: don't save single-path outputs
+      inst_writers = false;
+      inst_diags = false;
       for (int i = 0; i < num_chains; ++i) {
-        auto ofs = std::make_unique<std::ofstream>(diag_filenames[i]);
-        if (sig_figs > -1)
+        sample_writers.emplace_back(nullptr, "# ");
+      }
+    }
+    // allocate writers
+    if (inst_writers) {
+      for (int i = 0; i < num_chains; ++i) {
+        auto ofs = std::make_unique<std::ofstream>(output_filenames[i]);
+        if (sig_figs > -1) {
           ofs->precision(sig_figs);
-        stan::callbacks::json_writer<std::ofstream> jwriter(std::move(ofs));
+        }
+        sample_writers.emplace_back(std::move(ofs), "# ");
+      }
+    }
+    if (inst_diags) {
+      diag_json_writers.clear();
+      for (int i = 0; i < num_chains; ++i) {
+        auto ofs_diag
+            = std::make_unique<std::ofstream>(diagnostic_filenames[i]);
+        if (sig_figs > -1) {
+          ofs_diag->precision(sig_figs);
+        }
+        stan::callbacks::json_writer<std::ofstream> jwriter(
+            std::move(ofs_diag));
         diag_json_writers.emplace_back(std::move(jwriter));
       }
-    } else {
+    }
+  } else {  // not pathfinder
+    output_filenames
+        = make_filenames(get_arg_val<string_argument>(parser, "output", "file"),
+                         "", ".csv", num_chains, id);
+    for (int i = 0; i < num_chains; ++i) {
+      auto ofs = std::make_unique<std::ofstream>(output_filenames[i]);
+      if (sig_figs > -1)
+        ofs->precision(sig_figs);
+      sample_writers.emplace_back(std::move(ofs), "# ");
+    }
+    if (!diagnostic_file.empty()) {
       diag_csv_writers.clear();
-      diag_filenames = make_filenames(diagnostic_file, ".csv", num_chains, id);
+      diagnostic_filenames
+          = make_filenames(diagnostic_file, "", ".csv", num_chains, id);
       for (int i = 0; i < num_chains; ++i) {
-        auto ofs = std::make_unique<std::ofstream>(diag_filenames[i]);
+        auto ofs = std::make_unique<std::ofstream>(diagnostic_filenames[i]);
         if (sig_figs > -1)
           ofs->precision(sig_figs);
         diag_csv_writers.emplace_back(std::move(ofs), "# ");