crf.h

Go to the documentation of this file.

#ifndef META_SEQUENCE_CRF_H_
#define META_SEQUENCE_CRF_H_

#include "sequence/observation.h"
#include "sequence/sequence.h"
#include "sequence/sequence_analyzer.h"
#include "sequence/trellis.h"
#include "util/dense_matrix.h"
#include "util/disk_vector.h"
#include "util/optional.h"
#include "util/range.h"

namespace meta
{
namespace sequence
{

MAKE_NUMERIC_IDENTIFIER(crf_feature_id, uint64_t)


class crf
{
  public:
    struct parameters
    {
        double c2 = 1;

        double delta = 1e-5;

        uint64_t period = 10;

        double lambda = 0;

        double t0 = 0;

        uint64_t max_iters = 1000;

        double calibration_eta = 0.1;

        double calibration_rate = 2.0;

        uint64_t calibration_samples = 1000;

        uint64_t calibration_trials = 10;
    };

    class tagger;

    crf(const std::string& prefix);

    double train(parameters params, const std::vector<sequence>& examples);

    tagger make_tagger() const;

    uint64_t num_labels() const;

  private:

    using double_matrix = util::dense_matrix<double>;

    using feature_range = util::basic_range<crf_feature_id>;

    class scorer;
    // grant the scorer access to the model weights
    friend scorer;
    class viterbi_scorer;

    void initialize(const std::vector<sequence>& examples);

    void load_model();

    void reset();

    double calibrate(parameters params, const std::vector<uint64_t>& indices,
                     const std::vector<sequence>& examples);

    const double& obs_weight(crf_feature_id idx) const;

    double& obs_weight(crf_feature_id idx);

    const double& trans_weight(crf_feature_id idx) const;

    double& trans_weight(crf_feature_id idx);

    feature_range obs_range(feature_id fid) const;

    feature_range trans_range(label_id lbl) const;

    label_id observation(crf_feature_id idx) const;

    label_id transition(crf_feature_id idx) const;

    double epoch(parameters params, printing::progress& progress,
                 uint64_t iter, const std::vector<uint64_t>& indices,
                 const std::vector<sequence>& examples, scorer& scorer);

    double iteration(parameters params, uint64_t iter, const sequence& seq,
                     scorer& scorer);

    void gradient_observation_expectation(const sequence& seq, double gain);

    void gradient_model_expectation(const sequence& seq, double gain,
                                    const scorer& scr);

    double l2norm() const;

    void rescale();

    util::optional<util::disk_vector<crf_feature_id>> observation_ranges_;

    util::optional<util::disk_vector<crf_feature_id>> transition_ranges_;

    util::optional<util::disk_vector<label_id>> observations_;

    util::optional<util::disk_vector<label_id>> transitions_;

    util::optional<util::disk_vector<double>> observation_weights_;

    util::optional<util::disk_vector<double>> transition_weights_;

    double scale_;
    uint64_t num_labels_;
    const std::string& prefix_;
};
}
}
#endif