linear_model.h

Go to the documentation of this file.

#ifndef META_CLASSIFY_MODEL_LINEAR_MODEL_H_
#define META_CLASSIFY_MODEL_LINEAR_MODEL_H_

#include <istream>
#include <ostream>
#include <unordered_map>

#include "meta.h"
#include "util/sparse_vector.h"

namespace meta
{
namespace classify
{

class linear_model_exception : public std::runtime_error
{
  public:
    using std::runtime_error::runtime_error;
};

template <class FeatureId, class FeatureValue, class ClassId>
class linear_model
{
  public:
    using feature_id = FeatureId;

    using feature_value = FeatureValue;

    using class_id = ClassId;

    using weight_vector = util::sparse_vector<class_id, feature_value>;

    using weight_vectors = std::unordered_map<feature_id, weight_vector>;

    using scored_class = std::pair<class_id, feature_value>;

    using scored_classes = std::vector<scored_class>;

    using exception = linear_model_exception;

    void load(std::istream& is);

    void save(std::ostream& os) const;

    template <class FeatureVector, class Filter>
    class_id best_class(FeatureVector&& features, Filter&& filter) const;

    template <class FeatureVector>
    class_id best_class(FeatureVector&& features) const;

    template <class FeatureVector, class Filter>
    scored_classes best_classes(FeatureVector&& features, size_t num,
                                Filter&& filter) const;

    template <class FeatureVector>
    scored_classes best_classes(FeatureVector&& features, size_t num) const;

    void update(const weight_vectors& updates, feature_value scale = 1);

    void update(const class_id& cid, const feature_id& fid,
                feature_value delta);

    void condense(bool log = false);

    const weight_vectors& weights() const;

  private:
    weight_vectors weights_;
};
}
}

#include "classify/models/linear_model.tcc"
#endif