variable.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Artificial Intelligence Techniques, S.L. and Roberto López González
 
#pragma once
 
#include "opennn/core/opennn_types.h"
#include "opennn/core/enum_map.h"
 
namespace opennn
{
 
enum class VariableType { None, Numeric, Binary, Integer, Categorical, DateTime, Constant };
 
inline const EnumMap<VariableType>& variable_type_map()
{
    static const EnumMap<VariableType> map{
        {VariableType::None,        "None"},
        {VariableType::Numeric,     "Numeric"},
        {VariableType::Binary,      "Binary"},
        {VariableType::Integer,     "Integer"},
        {VariableType::Categorical, "Categorical"},
        {VariableType::DateTime,    "DateTime"},
        {VariableType::Constant,    "Constant"}
    };
    return map;
}
 
inline const string& variable_type_to_string(VariableType type)
{
    return variable_type_map().to_string(type);
}
 
inline VariableType string_to_variable_type(string_view name)
{
    return variable_type_map().from_string(name);
}
 
enum class ScalerMethod
{
    None,
    MinimumMaximum,
    MeanStandardDeviation,
    StandardDeviation,
    Logarithm,
    ImageMinMax
};
 
inline const EnumMap<ScalerMethod>& scaler_method_map()
{
    static const EnumMap<ScalerMethod> map{
        {ScalerMethod::None,                 "None"},
        {ScalerMethod::MinimumMaximum,       "MinimumMaximum"},
        {ScalerMethod::MeanStandardDeviation, "MeanStandardDeviation"},
        {ScalerMethod::StandardDeviation,    "StandardDeviation"},
        {ScalerMethod::Logarithm,            "Logarithm"},
        {ScalerMethod::ImageMinMax,          "ImageMinMax"}
    };
    return map;
}
 
inline const string& scaler_method_to_string(ScalerMethod method)
{
    return scaler_method_map().to_string(method);
}
 
inline ScalerMethod string_to_scaler_method(string_view name)
{
    return scaler_method_map().from_string(name);
}
 
enum class VariableRole
{
    None,
    Input,
    Target,
    Decoder,
    InputTarget,
    Time,
    Evaluation
};
 
inline const EnumMap<VariableRole>& variable_role_map()
{
    static const EnumMap<VariableRole> map{
        {VariableRole::None,        "None"},
        {VariableRole::Input,       "Input"},
        {VariableRole::Target,      "Target"},
        {VariableRole::Decoder,     "Decoder"},
        {VariableRole::InputTarget, "InputTarget"},
        {VariableRole::Time,        "Time"},
        {VariableRole::Evaluation,  "Evaluation"}
    };
    return map;
}
 
inline const string& variable_role_to_string(VariableRole role)
{
    return variable_role_map().to_string(role);
}
 
inline VariableRole string_to_variable_role(string_view name)
{
    if (name == "Id") return VariableRole::None;
    return variable_role_map().from_string(name);
}
 
inline bool role_applies_to(VariableRole actual, VariableRole query)
{
    return actual == query
        || (actual == VariableRole::InputTarget && (query == VariableRole::Input || query == VariableRole::Target));
}
 
struct Variable
{
    Variable(const string& = {},
             const string& = "None",
             const VariableType& = VariableType::Numeric,
             const string& = "MeanStandardDeviation",
             const vector<string>& = {});
 
    void set(const string& = {},
             const string& = "None",
             const VariableType& = VariableType::Numeric,
             const string& = "MeanStandardDeviation",
             const vector<string>& = {});
 
    string name;
    VariableRole role = VariableRole::None;
    VariableType type = VariableType::None;
    vector<string> categories;
    ScalerMethod scaler = ScalerMethod::None;
 
    Index features = 1;
    const string& get_role() const { return variable_role_to_string(role); }
    VariableRole get_role_type() const noexcept { return role; }
    const string& get_scaler() const { return scaler_method_to_string(scaler); }
    ScalerMethod get_scaler_type() const noexcept { return scaler; }
    const string& get_type_string() const { return variable_type_to_string(type); }
    Index get_categories_number() const { return ssize(categories); }
 
    void set_scaler(const string& new_scaler) { scaler = string_to_scaler_method(new_scaler); }
    void set_scaler(ScalerMethod new_scaler) { scaler = new_scaler; }
    void set_role(const string& new_role) { role = string_to_variable_role(new_role); }
    void set_role(VariableRole new_role) { role = new_role; }
    void set_type(const string& new_variable_type) { type = string_to_variable_type(new_variable_type); }
    void set_categories(const vector<string>& new_categories) { categories = new_categories; }
 
    void to_JSON(JsonWriter&) const;
 
    bool is_binary() const noexcept { return type == VariableType::Binary; }
    bool is_categorical() const noexcept { return type == VariableType::Categorical; }
    bool is_used() const noexcept
    {
        return role != VariableRole::None
            && role != VariableRole::Time
            && role != VariableRole::Evaluation;
    }
 
    Index get_feature_count() const { return is_categorical() ? get_categories_number() : features; }
 
    vector<string> get_names() const;
 
};
 
vector<string> get_variable_feature_names(const vector<Variable>&);
 
// Name and first feature index of every single-feature variable.
vector<pair<string, Index>> get_variable_columns(const vector<Variable>&);
 
// First feature index and width of every multi-feature categorical variable.
vector<pair<Index, Index>> get_categorical_blocks(const vector<Variable>&);
 
inline vector<Index> get_feature_dimensions(const vector<Variable>& variables)
{
    vector<Index> dimensions(variables.size());
    ranges::transform(variables, dimensions.begin(),
                      [](const Variable& variable) { return variable.get_feature_count(); });
    return dimensions;
}
 
inline Index get_features_number(const vector<Variable>& variables)
{
    Index count = 0;
    for (const Variable& variable : variables)
        count += variable.get_feature_count();
    return count;
}
 
}