node.cpp

Go to the documentation of this file.

#include "node.h"
 
namespace Brush {
 
ostream& operator<<(ostream& os, const NodeType& nt)
{
    os << "nt: " << nt << endl;
    os << NodeTypeName.at(nt);
    return os;
}
 
ostream& operator<<(ostream& os, const Node& n)
{
    os << n.get_name();
    return os;
}

auto Node::get_name(bool include_weight) const noexcept -> std::string 
{
    constexpr float atol = 1e-6f;
    const bool weight_is_one = std::fabs(W - 1.0f) <= atol;
 
    if (Is<NodeType::Terminal>(node_type))
    {
        if (is_weighted && !weight_is_one && include_weight)
            return fmt::format("{:.2f}*{}", W, feature);
        else
            return feature;
    }
    else if (Is<NodeType::Constant>(node_type) && include_weight)
    {
        return fmt::format("{:.2f}", W);
    }
    else if (Is<NodeType::MeanLabel>(node_type))
    {
        // this will show (MeanLabel) in the terminal name so we can differentiate 
        // a meanLabel from a constant.
        return fmt::format("{:.2f}", W);
    }
    else if (Is<NodeType::OffsetSum>(node_type))
    {
        if (is_weighted && !weight_is_one)
            return fmt::format("{:.2f}+Add", W);
 
        return "Sum";
    }
    else if (is_weighted && !weight_is_one && include_weight)
    {
        return fmt::format("{:.2f}*{}", W, name);
    }
 
    return name;
}
 
 
string Node::get_model(const vector<string>& children) const noexcept
{
    if (children.empty())
        return get_name();
    else if (Is<NodeType::SplitBest>(node_type)){
        return fmt::format("If({}>={:.2f},{},{})",
            feature,
            W,
            children.at(0),
            children.at(1)
            );
    }
    else if (Is<NodeType::SplitOn>(node_type)){
        if (arg_types.at(0) == DataType::ArrayB)
        {
            // booleans dont use thresholds (they are used directly as mask in split)
            return fmt::format("If({},{},{})",
                children.at(0),
                children.at(1),
                children.at(2)
            );
        }
        // integers or floating points (they have a threshold)
        return fmt::format("If({}>={:.2f},{},{})",
            children.at(0),
            W,
            children.at(1),
            children.at(2)
            );
    }
    else if (Is<NodeType::OffsetSum>(node_type)){
        string args = "";
 
        if (is_weighted && W != 1.0)
            args = fmt::format("{:.2f},", W);
    
        for (int i = 0; i < children.size(); ++i){
            args += children.at(i);
            if (i < children.size()-1)
                args += ",";
        }
 
        return fmt::format("Add({})", args);
    }
    else{
        string args = "";
        for (int i = 0; i < children.size(); ++i){
            args += children.at(i);
            if (i < children.size()-1)
                args += ",";
        }
 
        return fmt::format("{}({})", get_name(), args);
    }
 
}

// serialization
// serialization for Node
// using json = nlohmann::json;
 
void to_json(json& j, const Node& p) 
{
    j = json{
        {"name", p.name},
        // center_op is always set to false --> not implemented yet
        {"center_op", false},
        {"node_is_fixed", p.node_is_fixed}, 
        {"weight_is_fixed", p.weight_is_fixed}, 
        {"prob_change", p.prob_change}, 
        {"is_weighted", p.is_weighted}, 
        {"W", p.W}, 
        {"node_type", p.node_type}, 
        {"sig_hash", p.sig_hash}, 
        {"sig_dual_hash", p.sig_dual_hash}, 
        {"ret_type", p.ret_type}, 
        {"arg_types", p.arg_types}, 
        {"feature", p.get_feature()},
        {"feature_type", p.get_feature_type()}
        // {"node_hash", p.get_node_hash()} 
    };
}
 
using NT = NodeType;
void init_node_with_default_signature(Node& node)
{
    // if (Is<
    //     NT::Add,
    //     NT::Mul,
    //     NT::Min,
    //     NT::Max
    //     >(nt)) 
    //     return Signature<ArrayXf(ArrayXf,ArrayXf)>{};
    NT n = node.node_type;
    if (Is<
        NT::Abs,
        NT::Acos,
        NT::Asin,
        NT::Atan,
        NT::Cos,
        NT::Cosh,
        NT::Sin,
        NT::Sinh,
        NT::Tan,
        NT::Tanh,
        NT::Ceil,
        NT::Floor,
        NT::Exp,
        NT::Log,
        NT::Logabs,
        NT::Log1p,
        NT::Sqrt,
        NT::Sqrtabs,
        NT::Square,
        NT::Logistic,
        NT::OffsetSum, // unary version
        NT::CustomUnaryOp
        >(n)) 
    {
        node.set_signature<Signature<ArrayXf(ArrayXf)>>();
    }
    else if (Is<
        NT::Add,
        NT::Sub,
        NT::Mul,
        NT::Div,
        NT::Pow,
        NT::SplitBest,
        NT::CustomSplit
        >(n))
    {
        node.set_signature<Signature<ArrayXf(ArrayXf,ArrayXf)>>();
    }
    else if (Is<
        NT::And,
        NT::Or
        >(n))
    {
        node.set_signature<Signature<ArrayXb(ArrayXb,ArrayXb)>>();
    }  
    else if (Is<
        NT::Not
        >(n))
    {
        node.set_signature<Signature<ArrayXb(ArrayXb)>>();
    }
    else if (Is<
        NT::Geq
        >(n))
    {
        node.set_signature<Signature<ArrayXb(ArrayXf,ArrayXf)>>();
    }
    else if (Is<
        NT::Equals
        >(n))
    {
        node.set_signature<Signature<ArrayXb(ArrayXi,ArrayXi)>>();
    }
    else if (Is<
        NT::Before,
        NT::After,
        NT::During
        >(n))
    {
        node.set_signature<Signature<TimeSeriesf(TimeSeriesf,TimeSeriesf)>>();
    }
    else if (Is<
        NT::Count
        >(n))
    {
        node.set_signature<Signature<ArrayXf(TimeSeriesf)>>();
    }
    else if (Is<
        NT::ArgMax
        >(n))
    {
        node.set_signature<Signature<ArrayXi(ArrayXXf)>>();
    }
    else if (Is<
        NT::Min,
        NT::Max,
        NT::Mean,
        NT::Median,
        NT::Sum,
        // NT::OffsetSum,
        NT::Prod,
        NT::Softmax,
        // NT::SplitOn,
        NT::SplitBest
        >(n))
    {
        auto msg = fmt::format("Can't infer arguments for {} from json."
            " Please provide them.\n",n);
        HANDLE_ERROR_THROW(msg);
    }
    else if (Is<NT::SplitOn>(n))
    {
        // lets make split on always defaults to floats (so it will work
        // regardless of datatype).
        // This only matters for weakly defined nodes when doing manual
        // construction of brush programs as json objects, and this behavior
        // can be ignored by avoiding the need of generating the signature 
        // (that is, defining the node with missing hash values and ret types)
        node.set_signature<Signature<ArrayXf(ArrayXb,ArrayXf,ArrayXf)>>();
    }
    else if (Is<NT::Constant>(n))
    {
        // "feature" starts with "const"
        char last_char = node.feature.back();
 
        switch (last_char) {
            case 'F':
                node.set_signature<Signature<ArrayXf()>>();
                break;
            case 'I':
                node.set_signature<Signature<ArrayXi()>>();
                break;
            case 'B':
                node.set_signature<Signature<ArrayXb()>>();
                break;
            default:
                node.set_signature<Signature<ArrayXf()>>();
        }
    } 
    else if (Is<NT::MeanLabel>(n))
        node.set_signature<Signature<ArrayXb()>>();
    else if (Is<NT::Terminal>(n))
    {
        // For terminals, use feature_type to determine the correct signature
        switch (node.get_feature_type()) {
            case DataType::ArrayB:
                node.set_signature<Signature<ArrayXb()>>();
                break;
            case DataType::ArrayI:
                node.set_signature<Signature<ArrayXi()>>();
                break;
            case DataType::ArrayF:
            default:
                node.set_signature<Signature<ArrayXf()>>();
                break;
        }
    }
    else
        node.set_signature<Signature<ArrayXf()>>();
}
 
void from_json(const json &j, Node& p)
{
    // This serialization tries to build the nodes with the fewest information possible,
    // so interface is easier when doing manual generation of trees.
 
    // First we start with required information, then we set the optional ones
    // (they can be inferred from the required ones)
 
    if (j.contains("node_type"))
        j.at("node_type").get_to(p.node_type);
    else
        HANDLE_ERROR_THROW("Node json must contain node_type");
 
    if (j.contains("name"))
        j.at("name").get_to(p.name);
    else        
        p.name = NodeTypeName[p.node_type];
 
    // used in split nodes
    if (j.contains("feature"))
    {
        j.at("feature").get_to(p.feature);
    }
 
    if (j.contains("feature_type"))
    {
        j.at("feature_type").get_to(p.feature_type);
    }
 
    // if node has a ret_type and arg_types, get them. if not we need to make 
    // a signature
    bool make_signature=false;
 
    if (j.contains("ret_type"))
        j.at("ret_type").get_to(p.ret_type);
    else
        make_signature=true;
    if (j.contains("arg_types"))
        j.at("arg_types").get_to(p.arg_types);
    else
        make_signature=true;
    if (j.contains("sig_hash"))
        j.at("sig_hash").get_to(p.sig_hash);
    else
        make_signature=true;
    if (j.contains("sig_dual_hash"))
        j.at("sig_dual_hash").get_to(p.sig_dual_hash);
    else
        make_signature=true;
 
    if (make_signature){
        p.is_weighted = false; // TODO: remove this line
        init_node_with_default_signature(p);
    }
 
    // after this point we set attributes that are modified in init
    p.init();
    // center_op is intentionally ignored
    p.center_op = false;
    
    // these below needs to be set after init(), since `init` sets these values
    if (j.contains("node_is_fixed"))
    {
        j.at("node_is_fixed").get_to(p.node_is_fixed);
    }
 
    if (j.contains("weight_is_fixed"))
    {
        j.at("weight_is_fixed").get_to(p.weight_is_fixed);
    }
 
    if (j.contains("is_weighted"))
    {
        j.at("is_weighted").get_to(p.is_weighted);
    }
 
    if (j.contains("prob_change"))
    {
        j.at("prob_change").get_to(p.prob_change);
    }
    
    if (j.contains("W"))
    {
        j.at("W").get_to(p.W);
    }
}
 
}