linear.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_LINEAR_H
#define DISMEC_LINEAR_H
 
#include "objective.h"
#include "utils/hash_vector.h"
 
namespace dismec::objective {
    class LinearClassifierBase : public Objective {
    public:
        LinearClassifierBase(std::shared_ptr<const GenericFeatureMatrix> X);
 
        [[nodiscard]] long num_instances() const noexcept;
        [[nodiscard]] long num_variables() const noexcept override;
 
        [[nodiscard]] BinaryLabelVector& get_label_ref();
        void update_costs(real_t positive, real_t negative);
    protected:
        const DenseRealVector& x_times_w(const HashVector& w);
 
        template<class Derived>
        void update_xtw_cache(const HashVector& new_weight, const Eigen::MatrixBase<Derived>& new_result) {
            // update the cached result to the new value
            m_X_times_w.noalias() = new_result;
            // and set the hash so that we can identify calls using the new weights
            m_Last_W = new_weight.hash();
        }
 
        void project_linear_to_line(const HashVector& location, const DenseRealVector& direction);
 
        [[nodiscard]] auto line_interpolation(real_t t) const {
            return m_LsCache_xTw + t * m_LsCache_xTd;
        }
 
        void declare_vector_on_last_line(const HashVector& location, real_t t) override {
            update_xtw_cache(location, m_LsCache_xTw + t * m_LsCache_xTd);
        }
 
        [[nodiscard]] const GenericFeatureMatrix& generic_features() const;
        [[nodiscard]] const DenseFeatures& dense_features() const;
        [[nodiscard]] const SparseFeatures& sparse_features() const;
 
        [[nodiscard]] const DenseRealVector& costs() const;
        [[nodiscard]] const BinaryLabelVector& labels() const;
    private:
        std::shared_ptr<const GenericFeatureMatrix> m_FeatureMatrix;
 
        VectorHash m_Last_W{};
        DenseRealVector m_X_times_w;
 
        DenseRealVector m_LsCache_xTd;
        DenseRealVector m_LsCache_xTw;
 
        DenseRealVector m_Costs;
 
        BinaryLabelVector m_Y;
 
        virtual void invalidate_labels() = 0;
    };
 
    template<class Derived>
    class LinearClassifierImpBase : public LinearClassifierBase {
    public:
        LinearClassifierImpBase(std::shared_ptr<const GenericFeatureMatrix> X, std::unique_ptr<Objective> regularizer) :
        LinearClassifierBase( std::move(X) ), m_Regularizer( std::move(regularizer) ) {};
    protected:
        const Derived& derived() const {
            return static_cast<const Derived&>(*this);
        }
 
        Derived& derived() {
            return static_cast<Derived&>(*this);
        }
 
        real_t value_unchecked(const HashVector& location) override {
            const DenseRealVector& xTw = x_times_w(location);
            return derived().value_from_xTw(costs(), labels(), xTw) + m_Regularizer->value(location);
        }
 
        real_t lookup_on_line(real_t position) override {
            real_t f = Derived::value_from_xTw(costs(), labels(), line_interpolation(position));
            return f + m_Regularizer->lookup_on_line(position);
        }
 
        void project_to_line_unchecked(const HashVector& location, const DenseRealVector& direction) override {
            project_linear_to_line(location, direction);
            m_Regularizer->project_to_line(location, direction);
        }
 
        void gradient_unchecked(const HashVector& location, Eigen::Ref<DenseRealVector> target) override {
            m_Regularizer->gradient(location, target);
            derived().gradient_imp(location, target);
        }
 
 
        void gradient_at_zero_unchecked(Eigen::Ref<DenseRealVector> target) override {
            m_Regularizer->gradient_at_zero(target);
            derived().gradient_at_zero_imp(target);
        }
 
        void hessian_times_direction_unchecked(const HashVector& location,
                                               const DenseRealVector& direction,
                                               Eigen::Ref<DenseRealVector> target) override {
            m_Regularizer->hessian_times_direction(location, direction, target);
            derived().hessian_times_direction_imp(location, direction, target);
        }
 
        void diag_preconditioner_unchecked(const HashVector& location, Eigen::Ref<DenseRealVector> target) override {
            m_Regularizer->diag_preconditioner(location, target);
            derived().diag_preconditioner_imp(location, target);
        }
 
        void gradient_and_pre_conditioner_unchecked(const HashVector& location, Eigen::Ref<DenseRealVector> gradient,
                                                    Eigen::Ref<DenseRealVector> pre) override {
            m_Regularizer->gradient_and_pre_conditioner(location, gradient, pre);
            derived().gradient_and_pre_conditioner_imp(location, gradient, pre);
        }
    private:
        std::unique_ptr<Objective> m_Regularizer;
    };
}
 
#endif //DISMEC_LINEAR_H