dual_perceptron.h

Go to the documentation of this file.

#ifndef META_CLASSIFY_DUAL_PERCEPTRON_H_
#define META_CLASSIFY_DUAL_PERCEPTRON_H_

#include "classify/classifier_factory.h"
#include "classify/classifier/classifier.h"
#include "classify/kernel/polynomial.h"
#include "util/functional.h"
#include "meta.h"

namespace meta
{
namespace classify
{

class dual_perceptron : public classifier
{
  public:
    const static constexpr double default_alpha = 0.1;

    const static constexpr double default_gamma = 0.05;

    const static constexpr double default_bias = 0;

    const static constexpr uint64_t default_max_iter = 100;

    const static std::string id;

    template <class Kernel>
    dual_perceptron(std::shared_ptr<index::forward_index> idx,
                    Kernel&& kernel_fn = kernel::polynomial{},
                    double alpha = default_alpha, double gamma = default_gamma,
                    double bias = default_bias,
                    uint64_t max_iter = default_max_iter)
        : classifier{std::move(idx)},
          alpha_{alpha},
          gamma_{gamma},
          bias_{bias},
          max_iter_{max_iter}
    {
        std::function<double(pdata, pdata)> fun
            = [=](const pdata& a, const pdata& b) {
                return kernel_fn(a, b);
            };
        kernel_ = functional::memoize(fun);
    }

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

    class_label classify(doc_id d_id) override;

    void reset() override;

  private:
    void decrease_weight(const class_label& label, const doc_id& id);

    std::unordered_map<class_label, std::unordered_map<doc_id, uint64_t>>
        weights_;

    using pdata = decltype(idx_->search_primary(doc_id{}));

    std::function<double(pdata, pdata)> kernel_;

    const double alpha_;

    const double gamma_;

    const double bias_;

    const uint64_t max_iter_;
};

template <>
std::unique_ptr<classifier> make_classifier<dual_perceptron>(
        const cpptoml::table&, std::shared_ptr<index::forward_index>);
}
}
#endif