losses.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <vector>
#include "utils/autograd.hpp"
#include "utils/matrix.hpp"
 
namespace dl::loss {
    using utils::Variable;
    using utils::VariableD;
    using utils::VariableF;
    using utils::Matrix;
    using utils::MatrixD;
    using utils::MatrixF;
 
    template<typename T>
    class AutogradLoss {
    public:
        virtual ~AutogradLoss() = default;
        
        virtual Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) = 0;
        
        Variable<T> operator()(const Variable<T>& predictions, const Variable<T>& targets) {
            return forward(predictions, targets);
        }
    };
 
    template<typename T>
    class MSELoss : public AutogradLoss<T> {
    public:
        explicit MSELoss(const std::string& reduction = "mean") : reduction_(reduction) {}
        
        Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) override;
        
    private:
        std::string reduction_;
    };
 
    template<typename T>
    class CrossEntropyLoss : public AutogradLoss<T> {
    public:
        explicit CrossEntropyLoss(const std::string& reduction = "mean") : reduction_(reduction) {}
        
        Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) override;
        
    private:
        std::string reduction_;
        
        Variable<T> softmax(const Variable<T>& logits);
        
        Variable<T> log_softmax(const Variable<T>& logits);
    };
 
    template<typename T>
    class BCELoss : public AutogradLoss<T> {
    public:
        explicit BCELoss(const std::string& reduction = "mean") : reduction_(reduction) {}
        
        Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) override;
        
    private:
        std::string reduction_;
    };
 
    template<typename T>
    class BCEWithLogitsLoss : public AutogradLoss<T> {
    public:
        explicit BCEWithLogitsLoss(const std::string& reduction = "mean") : reduction_(reduction) {}
        
        Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) override;
        
    private:
        std::string reduction_;
    };
 
    template<typename T>
    class HingeLoss : public AutogradLoss<T> {
    public:
        explicit HingeLoss(const std::string& reduction = "mean") : reduction_(reduction) {}
        
        Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) override;
        
    private:
        std::string reduction_;
    };
 
    template<typename T>
    class HuberLoss : public AutogradLoss<T> {
    public:
        explicit HuberLoss(T delta = 1.0, const std::string& reduction = "mean") 
            : delta_(delta), reduction_(reduction) {}
        
        Variable<T> forward(const Variable<T>& predictions, const Variable<T>& targets) override;
        
    private:
        T delta_;
        std::string reduction_;
    };
 
    // Type aliases for convenience
    using MSELossD = MSELoss<double>;
    using MSELossF = MSELoss<float>;
    using CrossEntropyLossD = CrossEntropyLoss<double>;
    using CrossEntropyLossF = CrossEntropyLoss<float>;
    using BCELossD = BCELoss<double>;
    using BCELossF = BCELoss<float>;
    using BCEWithLogitsLossD = BCEWithLogitsLoss<double>;
    using BCEWithLogitsLossF = BCEWithLogitsLoss<float>;
    using HingeLossD = HingeLoss<double>;
    using HingeLossF = HingeLoss<float>;
    using HuberLossD = HuberLoss<double>;
    using HuberLossF = HuberLoss<float>;
 
} // namespace dl::loss