spec.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_TRAINING_SPEC_H
#define DISMEC_TRAINING_SPEC_H
 
#include <memory>
#include "fwd.h"
#include "matrix_types.h"
#include "spdlog/fwd.h"
#include "objective/regularizers.h"
 
namespace dismec
{
    class TrainingSpec {
    public:
        explicit TrainingSpec(std::shared_ptr<const DatasetBase> data) :
                m_Data(std::move(data)) {
        }
        virtual ~TrainingSpec() = default;
 
        [[nodiscard]] const DatasetBase& get_data() const { return *m_Data; }
 
        [[nodiscard]] virtual long num_features() const;
 
        [[nodiscard]] virtual std::shared_ptr<objective::Objective> make_objective() const = 0;
 
        [[nodiscard]] virtual std::unique_ptr<solvers::Minimizer> make_minimizer() const = 0;
 
        [[nodiscard]] virtual std::unique_ptr<init::WeightsInitializer> make_initializer() const = 0;
 
        [[nodiscard]] virtual std::unique_ptr<postproc::PostProcessor> make_post_processor(const std::shared_ptr<objective::Objective>& objective) const = 0;
 
        [[nodiscard]] virtual std::shared_ptr<model::Model> make_model(long num_features, model::PartialModelSpec spec) const = 0;
 
        virtual void update_minimizer(solvers::Minimizer& minimizer, label_id_t label_id) const = 0;
 
        virtual void update_objective(objective::Objective& objective, label_id_t label_id) const = 0;
 
        [[nodiscard]] virtual TrainingStatsGatherer& get_statistics_gatherer() = 0;
 
        // logger
        [[nodiscard]] const std::shared_ptr<spdlog::logger>& get_logger() const {
            return m_Logger;
        }
 
        void set_logger(std::shared_ptr<spdlog::logger> l) {
            m_Logger = std::move(l);
        }
 
    private:
        std::shared_ptr<const DatasetBase> m_Data;
 
        std::shared_ptr<spdlog::logger> m_Logger;
    };
 
    enum class RegularizerType {
        REG_L2,
        REG_L1,
        REG_L1_RELAXED,
        REG_HUBER,
        REG_ELASTIC_50_50,
        REG_ELASTIC_90_10
    };
 
    enum class LossType {
        SQUARED_HINGE,
        LOGISTIC,
        HUBER_HINGE,
        HINGE
    };
 
    using real_t = float;
 
    std::shared_ptr<objective::Objective> make_loss(
            LossType type,
            std::shared_ptr<const GenericFeatureMatrix> X,
            std::unique_ptr<objective::Objective> regularizer);
 
    using RegularizerSpec = std::variant<objective::SquaredNormConfig, objective::HuberConfig, objective::ElasticConfig>;
 
    struct DismecTrainingConfig {
        std::shared_ptr<WeightingScheme> Weighting;
        std::shared_ptr<init::WeightInitializationStrategy> Init;
        std::shared_ptr<postproc::PostProcessFactory> PostProcessing;
        std::shared_ptr<TrainingStatsGatherer> StatsGatherer;
        bool Sparse;
        RegularizerSpec Regularizer;
        LossType Loss;
    };
 
    struct CascadeTrainingConfig {
        std::shared_ptr<init::WeightInitializationStrategy> DenseInit;
        std::shared_ptr<init::WeightInitializationStrategy> SparseInit;
        std::shared_ptr<postproc::PostProcessFactory> PostProcessing;
        std::shared_ptr<TrainingStatsGatherer> StatsGatherer;
 
        real_t DenseReg  = 1.0;
        real_t SparseReg = 1.0;
    };
 
    std::shared_ptr<TrainingSpec> create_dismec_training(std::shared_ptr<const DatasetBase> data,
                                                         HyperParameters params,
                                                         DismecTrainingConfig config);
 
    std::shared_ptr<TrainingSpec> create_cascade_training(std::shared_ptr<const DatasetBase> data,
                                                          std::shared_ptr<const GenericFeatureMatrix> dense,
                                                          std::shared_ptr<const std::vector<std::vector<long>>> shortlist,
                                                          HyperParameters params,
                                                          CascadeTrainingConfig config);
}
 
#endif //DISMEC_TRAINING_SPEC_H