node.h

Go to the documentation of this file.

/* Brush
copyright 2020 William La Cava
license: GNU/GPL v3
 
Node class design heavily inspired by Operon, (c) Heal Research
https://github.com/heal-research/operon/
*/
 
#ifndef NODE_H
#define NODE_H
 
#include "../data/data.h"
#include "nodetype.h"
#include "../util/utils.h"
#include <iostream>
// #include "nodes/base.h"
// #include "nodes/dx.h"
// #include "nodes/split.h"
// #include "nodes/terminal.h"
 
/*
Node overhaul:
 
- Incorporating new design principles, learning much from operon:
    - make Node trivial, so that it is easily copied around. 
    - use Enums and maps to define node information. This kind of abandons the 
      object oriented approach taken thus far, but it should make extensibility 
      easier and performance better in the long run. 
    - Leverage ceres for parameter optimization. No more defining analytical 
      derivatives for every function. Let ceres do that. 
        - sidenote: not sure ceres can handle the data flow of split nodes. 
          need to figure out. 
        - this also suggests turning TimeSeries back into EigenSparse matrices.
    - forget all the runtime node generation. It saves space at the cost of 
      unclear code. I might as well just define all the nodes that are available, 
      plainly. At run-time this will be faster. 
    - keep an eye towards extensibility by defining a custom node registration 
      function that works.
*/
 
using Brush::DataType;
using Brush::Data::Dataset;
 
namespace Brush{
 
template <DataType... T>
inline auto Isnt(DataType dt) -> bool { return !((dt == T) || ...); }
 
template<DataType DT>
inline auto IsWeighable() noexcept -> bool { 
        return Isnt<DataType::ArrayB,
                    DataType::MatrixB,
                    DataType::TimeSeriesB,
                    DataType::ArrayBJet,
                    DataType::MatrixBJet
                    >(DT);                
}
inline auto IsWeighable(DataType dt) noexcept -> bool { 
        return Isnt<DataType::ArrayB,
                    DataType::MatrixB,
                    DataType::TimeSeriesB,
                    DataType::ArrayBJet,
                    DataType::MatrixBJet
                    >(dt);                
}
 
struct uint32_vector_hasher {
    std::size_t operator()(std::vector<uint32_t> const& vec) const {
      std::size_t seed = vec.size();
      for(auto& i : vec) {
        seed ^= i + 0x9e3779b9 + (seed << 6) + (seed >> 2);
      }
      return seed;
    }
    std::size_t operator()(std::vector<Brush::DataType> const& vec) const {
      std::size_t seed = vec.size();
      for(auto& i : vec) {
        seed ^= uint32_t(i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
      }
      return seed;
    }
};

struct Node {

    string name;
    NodeType node_type;

    DataType ret_type;
    std::vector<DataType> arg_types;
    std::size_t sig_hash;
    std::size_t sig_dual_hash;
 
    // TODO: node_is_fixed, weight_is_fixed, and is_weighted accessed via getters/setters
 
    // The three flags below will help determine how to handle the node during mutation,
    // and can also be changed by the locking mechanism. prob_change is user-defined and
    // also interact with the flags

    bool node_is_fixed;
    bool weight_is_fixed;
    bool is_weighted;
    float prob_change; 

    float W; 
    
    // Retained for backwards-compatible program JSON. This has not being implemented yet
    // While doing some random_state tests, i realized that this feature was being set to true sometimes, undesirable. So we make sure to initialize it as false always
    bool center_op = false;
    
    // /// @brief a node hash / unique ID for the node, except weights
    // size_t node_hash; 
    using HashTuple = std::tuple< 
        UnderlyingNodeType,     // node type
        size_t,                 // sig_hash
        bool,                   // is_weighted
        string,                 // feature
        bool,                   // node_is_fixed
        bool,                   // weight_is_fixed
        int                     // rounded W
        // float                   // prob_change
    >;
 
    // Node(){init();}; 
    Node() = default;

    template<typename S>
    explicit Node(NodeType type, S signature, bool weighted=false, string feature_name="") noexcept
        : node_type(type)
        , name(NodeTypeName[type])
        , ret_type(S::get_ret_type())
        , arg_types(S::get_arg_types())
        , sig_hash(S::hash())
        , sig_dual_hash(S::Dual::hash())
        , is_weighted(weighted)
        , feature(feature_name)
    {
        init();
    }
 
    template<typename S>
    void set_signature()
    {
        ret_type = S::get_ret_type();
        arg_types = S::get_arg_types(); 
        sig_hash = S::hash();
        sig_dual_hash = S::Dual::hash();
        // set_node_hash();
    }
 
    void init(){
        center_op = false;
 
        // starting weights with neutral element of the operation. offsetsum
        // is the only node that does not multiply the weight --- instead, it adds it,
        // so we need to handle it differently
        W = (node_type == NodeType::OffsetSum) ? 0.0 : 1.0;
 
        // set_node_hash();
 
        // everything is unlocked. Special nodes (like the logistic root)
        // should be fixed during its creation (check `vary` source code)
        node_is_fixed=false;
        weight_is_fixed=false;
 
        set_prob_change(1.0);
 
        // TODO: confirm that this is really necessary (intializing this variable) and transform this line into a ternary if so
        // cant weight an boolean terminal
        this->is_weighted = IsWeighable(this->ret_type);
    }

    string get_name(bool include_weight=true) const noexcept; 
    string get_model(const vector<string>&) const noexcept; 
 
    // get return type and argument types. 
    inline DataType get_ret_type() const { return ret_type; }; 
    inline std::size_t args_type() const { return sig_hash; };
    inline auto get_arg_types() const { return arg_types; };
    inline size_t get_arg_count() const { return arg_types.size(); };
 
    // void set_node_hash(){
    //     node_hash = std::hash<HashTuple>{}(HashTuple{
    //             NodeTypes::GetIndex(node_type),
    //             sig_hash,
    //             is_weighted,
    //             feature,
    //             fixed,
    //             W,
    //             prob_change
    //     });
    //     // fmt::print("nodetype:{}; hash tuple:{}; node_hash={}\n", node_type, tmp, node_hash);
    // }
    size_t get_node_hash(bool include_const=true) const {
        // we ignore the constant only on simplification, because it will be tuned anyways
 
        return std::hash<HashTuple>{}(HashTuple{
                NodeTypes::GetIndex(node_type),
                sig_hash,
                get_is_weighted(),
                feature,
                node_is_fixed,
                weight_is_fixed,
                // include weights only if we want exact matches.
                // but we will indicate that constants are on using get is weighted,
                // just so we differentiate whether the weight exists or is ignored
                include_const ? int(W * 100) : (get_is_weighted() ? 1 : 0)
        });
    }

    //comparison operators
    inline auto operator==(const Node& rhs) const noexcept -> bool
    {
        // obs: this is declared as a member operator, so the lhs is implicit.
        // If i were to declare this outsize class definition, then I would have
        // to include lhs in the function signature
        
        /* return CalculatedHashValue == rhs.CalculatedHashValue; */
        return get_node_hash() == rhs.get_node_hash();
        /* return (*this) == rhs; */
    }
 
    inline auto operator!=(const Node& rhs) const noexcept -> bool
    {
        return !((*this) == rhs);
    }
 
    inline auto operator<(const Node& rhs) const noexcept -> bool
    {
        /* return std::tie(HashValue, CalculatedHashValue) < std::tie(rhs.HashValue, rhs.CalculatedHashValue); */
        return get_node_hash() < rhs.get_node_hash(); 
        return (*this) < rhs;
    }
 
    inline auto operator<=(const Node& rhs) const noexcept -> bool
    {
        return ((*this) == rhs || (*this) < rhs);
    }
 
    inline auto operator>(const Node& rhs) const noexcept -> bool
    {
        return !((*this) <= rhs);
    }
 
    inline auto operator>=(const Node& rhs) const noexcept -> bool
    {
        return !((*this) < rhs);
    }

    // getters and setters
    //TODO revisit
    float get_prob_change() const { return node_is_fixed ? 0.0 : this->prob_change;};
    void set_prob_change(float w){ this->prob_change = w;};
    float get_prob_keep() const { return node_is_fixed ? 1.0 : 1.0-this->prob_change;};
 
    inline void set_feature(string f){ feature = f; };
    inline string get_feature() const { return feature; };
    
    inline void set_feature_type(DataType ft){ this->feature_type = ft; };
    inline DataType get_feature_type() const { return this->feature_type; };
 
    inline void set_keep_split_feature(bool keep){ this->keep_split_feature = keep; };
    inline bool get_keep_split_feature() const { return this->keep_split_feature; };
 
    // Some types does not support weights, so we completely ignore the weights
    // if is not weighable
    inline bool get_is_weighted() const {
        if (IsWeighable(this->ret_type)) 
            return this->is_weighted;
        return false;
    };
    inline void set_is_weighted(bool is_weighted){
        if (IsWeighable(this->ret_type)) 
            this->is_weighted = is_weighted;
    };
 
    // private:
    string feature; 
    
    DataType feature_type = DataType::ArrayF; 

    bool keep_split_feature = false; // TODO: unittests for keep_split_feature
};
 
template <NodeType... T>
inline auto Is(NodeType nt) -> bool { return ((nt == T) || ...); }
 
template <NodeType... T>
inline auto Isnt(NodeType nt) -> bool { return !((nt == T) || ...); }
 
// TODO: I think there are places where I can replace some logic with IsLeaf --> Check that.
// TODO: create IsConstant, and add Constant and MeanLabel to it.
inline auto IsLeaf(NodeType nt) noexcept -> bool { 
    return Is<NodeType::Constant, NodeType::Terminal, NodeType::MeanLabel>(nt); 
}
 
inline auto IsCommutative(NodeType nt) noexcept -> bool { 
    return Is<NodeType::Add,
              NodeType::Mul,
              NodeType::Min,
              NodeType::Max,
              NodeType::And, 
              NodeType::Or
              >(nt); 
}
 
inline auto IsDifferentiable(NodeType nt) noexcept -> bool { 
    return Isnt<
                NodeType::Ceil,
                NodeType::Floor,
                NodeType::Before,       
                NodeType::After,          
                NodeType::During,
                NodeType::Count,
                NodeType::And, 
                NodeType::Or,
                NodeType::Not // TODO: should I include OffsetSum here? If I do so, then I should change the logic in the optimizer to not optimize the weight of OffsetSum nodes.
                >(nt);                
}
template<NodeType NT>
inline auto IsWeighable() noexcept -> bool { 
        return Isnt<
                    NodeType::Ceil,
                    NodeType::Floor,
                    NodeType::Before,       
                    NodeType::After,          
                    NodeType::During,
                    NodeType::Count,
                    NodeType::SplitOn,
                    NodeType::SplitBest,
                    NodeType::And, 
                    NodeType::Or,
                    NodeType::Not,
                    NodeType::MeanLabel
                    >(NT);                
}
inline auto IsWeighable(NodeType nt) noexcept -> bool { 
        return Isnt<
                    NodeType::Ceil,
                    NodeType::Floor,
                    NodeType::Before,       
                    NodeType::After,          
                    NodeType::During,
                    NodeType::Count,
                    NodeType::SplitOn,
                    NodeType::SplitBest,
                    NodeType::And, 
                    NodeType::Or,
                    NodeType::Not,
                    NodeType::MeanLabel
                    >(nt);                
}
 
ostream& operator<<(ostream& os, const Node& n);
ostream& operator<<(ostream& os, const NodeType& nt);
 
void from_json(const json &j, Node& p);
void to_json(json& j, const Node& p);
} // namespace Brush
 
// format overload for Nodes
template <> struct fmt::formatter<Brush::Node>: formatter<string_view> {
  // parse is inherited from formatter<string_view>.
  template <typename FormatContext>
  auto format(Brush::Node x, FormatContext& ctx) const {
    return formatter<string_view>::format(x.get_name(), ctx);
  }
};
 
 
 
#endif