sgd.h

Go to the documentation of this file.

#ifndef META_CLASSIFY_SGD_H_
#define META_CLASSIFY_SGD_H_

#include "classify/binary_classifier_factory.h"
#include "classify/classifier/binary_classifier.h"
#include "classify/loss/loss_function.h"
#include "util/disk_vector.h"
#include "meta.h"

namespace meta
{
namespace classify
{

class sgd : public binary_classifier
{
  public:
    const static constexpr double default_alpha = 0.001;
    const static constexpr double default_gamma = 1e-6;
    const static constexpr double default_bias = 1;
    const static constexpr double default_lambda = 0.0001;
    const static constexpr size_t default_max_iter = 50;

    sgd(const std::string& prefix, std::shared_ptr<index::forward_index> idx,
        class_label positive, class_label negative,
        std::unique_ptr<loss::loss_function> loss, double alpha = default_alpha,
        double gamma = default_gamma, double bias = default_bias,
        double lambda = default_lambda, size_t max_iter = default_max_iter);

    double predict(doc_id d_id) const;

    void train(const std::vector<doc_id>& docs) override;

    void reset() override;

    const static std::string id;

  private:
    util::disk_vector<double> weights_;

    double coeff_{1.0};

    const double alpha_;

    const double gamma_;

    double bias_;

    const double bias_weight_;

    const double lambda_;

    const size_t max_iter_;

    std::unique_ptr<loss::loss_function> loss_;

    using counts_t = std::vector<std::pair<term_id, double>>;

    double predict(const counts_t& doc) const;
};

template <>
std::unique_ptr<binary_classifier>
    make_binary_classifier<sgd>(const cpptoml::table& config,
                                std::shared_ptr<index::forward_index> idx,
                                class_label positive, class_label negative);
}
}
#endif