sequence_analyzer.h

Go to the documentation of this file.

#ifndef META_SEQUENCE_SEQUENCE_ANALYZER_H_
#define META_SEQUENCE_SEQUENCE_ANALYZER_H_

#include <algorithm>
#include <vector>
#include <functional>
#include <unordered_map>

#include "meta.h"
#include "sequence/sequence.h"
#include "util/invertible_map.h"

namespace meta
{
namespace sequence
{

class sequence_analyzer
{
  public:
    sequence_analyzer() = default;

    sequence_analyzer(const std::string& prefix);

    sequence_analyzer(const sequence_analyzer&) = default;

    sequence_analyzer(sequence_analyzer&&) = default;

    sequence_analyzer& operator=(const sequence_analyzer&) = default;

    sequence_analyzer& operator=(sequence_analyzer&&) = default;

    void load(const std::string& prefix);

    void save(const std::string& prefix) const;

    void analyze(sequence& sequence);

    void analyze(sequence& sequence, uint64_t idx);

    void analyze(sequence& sequence) const;

    void analyze(sequence& sequence, uint64_t idx) const;

    feature_id feature(const std::string& feature);

    feature_id feature(const std::string& feature) const;

    uint64_t num_features() const;

    label_id label(tag_t lbl) const;

    tag_t tag(label_id lbl) const;

    uint64_t num_labels() const;

    const std::string& prefix() const;

    const util::invertible_map<tag_t, label_id>& labels() const;

    template <class Function>
    void add_observation_function(Function&& function)
    {
        obs_fns_.emplace_back(std::forward<Function>(function));
    }

    class collector
    {
      public:
        collector(observation* obs) : obs_{obs}
        {
            // nothing
        }

        ~collector()
        {
            using pair = std::pair<feature_id, double>;
            std::sort(feats_.begin(), feats_.end(),
                      [](const pair& lhs, const pair& rhs)
                      {
                return lhs.first < rhs.first;
            });

            obs_->features(std::move(feats_));
        }

        virtual void add(const std::string& feat, double amount)
        {
            feats_.emplace_back(feature(feat), amount);
        }

      protected:
        virtual feature_id feature(const std::string& feat) = 0;

        observation* obs_;
        observation::feature_vector feats_;
    };

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

  private:
    template <class Analyzer>
    class basic_collector : public collector
    {
      public:
        basic_collector(Analyzer* analyzer, observation* obs)
            : collector{obs}, analyzer_{analyzer}
        {
            // nothing
        }

      protected:
        Analyzer* analyzer_;

        virtual feature_id feature(const std::string& feat)
        {
            return analyzer_->feature(feat);
        }
    };

  public:
    class default_collector : public basic_collector<sequence_analyzer>
    {
      public:
        using basic_collector<sequence_analyzer>::basic_collector;
    };

    class const_collector : public basic_collector<const sequence_analyzer>
    {
      public:
        using basic_collector<const sequence_analyzer>::basic_collector;

        // special case add to not actually add if a brand new feature id
        // is found
        virtual void add(const std::string& feat, double amount)
        {
            auto fid = feature(feat);
            if (fid != analyzer_->num_features())
                feats_.emplace_back(fid, amount);
        }
    };

  private:
    void load_feature_id_mapping(const std::string& prefix);

    void load_label_id_mapping(const std::string& prefix);

    void add_feature(observation& obs, const std::string& feature,
                     double weight = 1.0);

    std::vector<std::function<void(const sequence&, uint64_t, collector&)>>
        obs_fns_;

    std::unordered_map<std::string, feature_id> feature_id_mapping_;

    util::invertible_map<tag_t, label_id> label_id_mapping_;
};

sequence_analyzer default_pos_analyzer();
}
}
#endif