mosesdecoder/mert/FeatureStats.h

157 lines
3.6 KiB
C
Raw Normal View History

/*
* FeatureStats.h
2012-02-20 03:29:53 +04:00
* mert - Minimum Error Rate Training
*
* Created by Nicola Bertoldi on 13/05/08.
*
*/
#ifndef MERT_FEATURE_STATS_H_
#define MERT_FEATURE_STATS_H_
2011-11-14 14:52:21 +04:00
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <boost/unordered_map.hpp>
2014-08-02 01:44:35 +04:00
#include "util/string_piece.hh"
#include "Types.h"
namespace MosesTuning
{
2013-05-29 21:16:15 +04:00
// Minimal sparse vector
2013-05-29 21:16:15 +04:00
class SparseVector
{
2011-11-12 04:24:19 +04:00
public:
typedef std::map<std::size_t,FeatureStatsType> fvector_t;
typedef std::map<std::string, std::size_t> name2id_t;
2011-11-12 04:24:19 +04:00
typedef std::vector<std::string> id2name_t;
FeatureStatsType get(const std::string& name) const;
FeatureStatsType get(std::size_t id) const;
void set(const std::string& name, FeatureStatsType value);
void set(size_t id, FeatureStatsType value);
2011-11-12 04:24:19 +04:00
void clear();
void load(const std::string& file);
2013-05-29 21:16:15 +04:00
std::size_t size() const {
return m_fvector.size();
}
2011-11-12 04:24:19 +04:00
void write(std::ostream& out, const std::string& sep = " ") const;
2011-11-12 04:24:19 +04:00
SparseVector& operator-=(const SparseVector& rhs);
SparseVector& operator+=(const SparseVector& rhs);
FeatureStatsType inner_product(const SparseVector& rhs) const;
// Added by cherryc
std::vector<std::size_t> feats() const;
friend bool operator==(SparseVector const& item1, SparseVector const& item2);
friend std::size_t hash_value(SparseVector const& item);
static std::size_t encode(const std::string& feat);
static std::string decode(std::size_t feat);
// End added by cherryc
2011-11-12 04:24:19 +04:00
private:
static name2id_t m_name_to_id;
static id2name_t m_id_to_name;
fvector_t m_fvector;
};
SparseVector operator-(const SparseVector& lhs, const SparseVector& rhs);
FeatureStatsType inner_product(const SparseVector& lhs, const SparseVector& rhs);
class FeatureStats
{
private:
std::size_t m_available_size;
std::size_t m_entries;
// TODO: Use smart pointer for exceptional-safety.
featstats_t m_array;
SparseVector m_map;
public:
FeatureStats();
explicit FeatureStats(const std::size_t size);
~FeatureStats();
// We intentionally allow copying.
FeatureStats(const FeatureStats &stats);
FeatureStats& operator=(const FeatureStats &stats);
void Copy(const FeatureStats &stats);
2013-05-29 21:16:15 +04:00
bool isfull() const {
return (m_entries < m_available_size) ? 0 : 1;
}
void expand();
void add(FeatureStatsType v);
void addSparse(const std::string& name, FeatureStatsType v);
void clear() {
memset((void*)m_array, 0, GetArraySizeWithBytes());
m_map.clear();
}
void reset() {
m_entries = 0;
clear();
}
2013-05-29 21:16:15 +04:00
FeatureStatsType get(std::size_t i) {
return m_array[i];
}
FeatureStatsType get(std::size_t i)const {
return m_array[i];
}
featstats_t getArray() const {
return m_array;
}
2012-03-10 14:27:52 +04:00
2013-05-29 21:16:15 +04:00
const SparseVector& getSparse() const {
return m_map;
}
void set(std::string &theString, const SparseVector& sparseWeights);
2013-05-29 21:16:15 +04:00
inline std::size_t bytes() const {
return GetArraySizeWithBytes();
}
std::size_t GetArraySizeWithBytes() const {
return m_entries * sizeof(FeatureStatsType);
}
2013-05-29 21:16:15 +04:00
std::size_t size() const {
return m_entries;
}
2013-05-29 21:16:15 +04:00
std::size_t available() const {
return m_available_size;
}
void savetxt(const std::string &file);
void savetxt(std::ostream* os);
void savebin(std::ostream* os);
void savetxt();
void loadtxt(std::istream* is, const SparseVector& sparseWeights);
void loadbin(std::istream* is);
/**
* Write the whole object to a stream.
*/
friend std::ostream& operator<<(std::ostream& o, const FeatureStats& e);
};
2011-12-12 17:48:42 +04:00
bool operator==(const FeatureStats& f1, const FeatureStats& f2);
}
2011-12-12 17:48:42 +04:00
#endif // MERT_FEATURE_STATS_H_