Class AverageFeatureMain

src/tools/graph/average_feature_main.cc:66–164

}

class AverageFeatureMain : public MainUtil {
 private:
  std::unique_ptr<GraphClient> graph_client_;
  GraphConfig graph_config_;

  int batch_node_;
  int count_;
  std::string entry_flag_;

 public:
  ~AverageFeatureMain() override = default;

  bool Init() override {
    if (FLAGS_dist) {
      graph_config_.set_ip_ports(FLAGS_gs_addrs);
    } else {
      graph_config_.set_node_graph(FLAGS_node_graph);
      graph_config_.set_node_feature(FLAGS_node_feature);
      graph_config_.set_node_config(FLAGS_node_config);
      graph_config_.set_thread_num(FLAGS_gs_thread_num);
    }

    graph_client_ = NewGraphClient(graph_config_, (GraphClientEnum)FLAGS_dist);
    // if (!graph_client_->Init(config_)) {
    if (!graph_client_) {
      return false;
    }

    // used by RunEntry
    batch_node_ = FLAGS_batch_node;
    count_ = FLAGS_sample_num;
    entry_flag_ = FLAGS_dist ? "Worker" : "Thread";
    return true;
  }

 private:
  const char* task_name() const noexcept override { return "AverageFeature"; }

  bool RunEntry(int entry_id, const vec_str_t& files,
                const std::string& out) override {
    DXINFO("%s id: %d is processing ...", entry_flag_.c_str(), entry_id);

    LineParser line_parser;
    deepx_core::AutoOutputFileStream ofs;
    std::ostringstream oss;
    for (const auto& file : files) {
      DXINFO("Processed file: %s", file.c_str());
      if (!line_parser.Open(file)) {
        return false;
      }

      auto out_file = deepx_core::GetOutputPredictFile(out, file);
      if (!ofs.Open(out_file)) {
        return false;
      }

      // averaging feature
      std::vector<NodeValue> values;