Json.hpp

Go to the documentation of this file.

#pragma once
 
#include "models/TreeNode.hpp"
#include "models/TreeCondition.hpp"
#include "models/TreeResponse.hpp"
#include "models/Tree.hpp"
#include "models/BootstrapTree.hpp"
#include "models/Forest.hpp"
#include "models/VariableImportance.hpp"
#include "stats/ConfusionMatrix.hpp"
 
#include <nlohmann/json.hpp>
#include <optional>
#include <ostream>

namespace ppforest2::serialization {
  using json = nlohmann::json;

  using GroupNames = std::vector<std::string>;

  template<typename T> struct Export {
    T model;
    GroupNames groups;
    TrainingSpec::Ptr spec;
    int n_observations = 0;
    int n_features     = 0;
    std::vector<std::string> feature_names;

    std::optional<VariableImportance> variable_importance;
    std::optional<stats::ConfusionMatrix> training_confusion_matrix;
    std::optional<stats::ConfusionMatrix> oob_confusion_matrix;
    std::optional<double> oob_error;

    json to_json() const;

    void compute_metrics(types::FeatureMatrix const& x, types::ResponseVector const& y);
  };
 
  // Explicit specialization declarations for Export<Model::Ptr>.
  template<> json Export<Model::Ptr>::to_json() const;
  template<> void Export<Model::Ptr>::compute_metrics(types::FeatureMatrix const&, types::ResponseVector const&);

  struct JsonNodeVisitor : public TreeNode::Visitor {
    json result;
    GroupNames const* group_names = nullptr;
    void visit(TreeCondition const& node) override;
    void visit(TreeResponse const& node) override;
  };

  struct JsonModelVisitor : public Model::Visitor {
    json result;
    GroupNames const* group_names = nullptr;
    void visit(Tree const& tree) override;
    void visit(Forest const& forest) override;
  };

  std::vector<std::string> to_labels(types::ResponseVector const& predictions,
                                     std::vector<std::string> const& group_names);

  json to_json(Model const& model);
  json to_json(TreeNode const& node);
  json to_json(Tree const& tree);
  json to_json(BootstrapTree const& tree);
  json to_json(Forest const& forest);
  json to_json(stats::ConfusionMatrix const& cm);
  json to_json(VariableImportance const& vi);
  json to_json(types::FeatureMatrix const& matrix);

  json to_json(Model const& model, GroupNames const& group_names);
  json to_json(TreeNode const& node, GroupNames const& group_names);
  json to_json(Tree const& tree, GroupNames const& group_names);
  json to_json(BootstrapTree const& tree, GroupNames const& group_names);
  json to_json(Forest const& forest, GroupNames const& group_names);
  json to_json(stats::ConfusionMatrix const& cm, GroupNames const& group_names);


  template<typename T> T from_json(json const& j);
 
  template<> Tree from_json<Tree>(json const& j);
  template<> Forest from_json<Forest>(json const& j);
  template<> stats::ConfusionMatrix from_json<stats::ConfusionMatrix>(json const& j);
  template<> VariableImportance from_json<VariableImportance>(json const& j);

  std::ostream& operator<<(std::ostream& os, TreeNode const& node);
  std::ostream& operator<<(std::ostream& os, TreeCondition const& condition);
  std::ostream& operator<<(std::ostream& os, TreeResponse const& response);
  std::ostream& operator<<(std::ostream& os, Tree const& tree);
  std::ostream& operator<<(std::ostream& os, Forest const& forest);
 
  template<typename V> std::ostream& operator<<(std::ostream& ostream, std::vector<V> const& vec) {
    json json_vector(vec);
    return ostream << json_vector.dump();
  }
 
  template<typename V, typename C1, typename C2>
  std::ostream& operator<<(std::ostream& ostream, std::set<V, C1, C2> const& set) {
    json json_set(set);
    return ostream << json_set.dump();
  }
 
  template<typename K, typename V> std::ostream& operator<<(std::ostream& ostream, std::map<K, V> const& map) {
    json json_map(map);
    return ostream << json_map.dump();
  }
 
  template<typename V> std::ostream& operator<<(std::ostream& ostream, std::map<int, V> const& map) {
    std::map<std::string, V> string_map;
 
    for (auto const& [key, val] : map) {
      string_map[std::to_string(key)] = val;
    }
 
    json json_map(string_map);
    return ostream << json_map.dump();
  }

}
 
// ADL serializer specializations — enables j.get<T>() for all types.
namespace nlohmann {
  template<> struct adl_serializer<ppforest2::Tree> {
    static ppforest2::Tree from_json(json const& j) { return ppforest2::serialization::from_json<ppforest2::Tree>(j); }
  };
 
  template<> struct adl_serializer<ppforest2::Forest> {
    static ppforest2::Forest from_json(json const& j) {
      return ppforest2::serialization::from_json<ppforest2::Forest>(j);
    }
  };
 
  template<> struct adl_serializer<ppforest2::stats::ConfusionMatrix> {
    static ppforest2::stats::ConfusionMatrix from_json(json const& j) {
      return ppforest2::serialization::from_json<ppforest2::stats::ConfusionMatrix>(j);
    }
  };
 
  template<> struct adl_serializer<ppforest2::VariableImportance> {
    static ppforest2::VariableImportance from_json(json const& j) {
      return ppforest2::serialization::from_json<ppforest2::VariableImportance>(j);
    }
  };
 
  template<> struct adl_serializer<ppforest2::serialization::Export<ppforest2::Tree>> {
    static ppforest2::serialization::Export<ppforest2::Tree> from_json(json const& j);
  };
 
  template<> struct adl_serializer<ppforest2::serialization::Export<ppforest2::Forest>> {
    static ppforest2::serialization::Export<ppforest2::Forest> from_json(json const& j);
  };
 
  template<> struct adl_serializer<ppforest2::serialization::Export<ppforest2::Model::Ptr>> {
    static ppforest2::serialization::Export<ppforest2::Model::Ptr> from_json(json const& j);
  };
}