Loading...
Searching...
No Matches
EST_Ngrammar.h
/*************************************************************************/
/* */
/* Centre for Speech Technology Research */
/* University of Edinburgh, UK */
/* Copyright (c) 1996 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/*************************************************************************/
/* Author : Simon King & Alan W Black */
/* Date : February 1997 */
/*-----------------------------------------------------------------------*/
/* */
/* A general class for ngrams (bi-gram, tri-gram etc) */
/* */
/*=======================================================================*/
#ifndef __EST_NGRAMMAR_H__
#define __EST_NGRAMMAR_H__
#include <cstdarg>
#include <cstdlib>
using namespace std;
#include "EST_String.h"
#include "EST_Val.h"
#include "EST_rw_status.h"
#include "EST_types.h"
#include "EST_FMatrix.h"
#include "EST_TList.h"
#include "EST_StringTrie.h"
#include "EST_simplestats.h"
#include "EST_PST.h"
#include "EST_string_aux.h"
#include "EST_math.h"
// HTK style
#define SENTENCE_START_MARKER "!ENTER"
#define SENTENCE_END_MARKER "!EXIT"
#define OOV_MARKER "!OOV"
#define EST_NGRAMBIN_MAGIC 1315402337
// for compressed save/load
#define GZIP_FILENAME_EXTENSION "gz"
#define COMPRESS_FILENAME_EXTENSION "Z"
// Ultimate floor
#define TINY_FREQ 1.0e-10
// ngram state - represents the N-1 word history and contains
// the pdf of the next word
class EST_NgrammarState {
private:
protected:
EST_DiscreteProbDistribution p_pdf;
int p_id; // a 'name'
public:
EST_NgrammarState() :
p_pdf()
{
init();
};
EST_NgrammarState(int id,EST_Discrete *d){clear();init(id,d);};
EST_NgrammarState(int id,const EST_DiscreteProbDistribution &pdf)
{clear();init(id,pdf);};
EST_NgrammarState(const EST_NgrammarState &s);
EST_NgrammarState(const EST_NgrammarState *const s);
~EST_NgrammarState();
EST_IVector path; // how we got here
// initialise
void clear();
void init();
void init(int id, EST_Discrete *d);
void init(int id, const EST_DiscreteProbDistribution &pdf);
// build
void cumulate(const int index, const double count=1)
{p_pdf.cumulate(index,count);};
void cumulate(const EST_String &word, const double count=1)
{p_pdf.cumulate(word,count);};
// access
int id() const {return p_id; };
const EST_DiscreteProbDistribution &pdf_const() const {return p_pdf; };
EST_DiscreteProbDistribution &pdf() {return p_pdf; };
double probability(const EST_String &w) const
{return p_pdf.probability(w);}
double probability(int w) const {return p_pdf.probability(w);}
double frequency(const EST_String &w) const
{return p_pdf.frequency(w);}
double frequency(int w) const {return p_pdf.frequency(w);}
const EST_String &most_probable(double *prob = NULL) const
{return p_pdf.most_probable(prob);}
friend ostream& operator<<(ostream& s, const EST_NgrammarState &a);
};
class EST_BackoffNgrammarState {
private:
protected:
int p_level; // = 0 for root node
double backoff_weight;
EST_DiscreteProbDistribution p_pdf;
EST_StringTrie children;
EST_BackoffNgrammarState* add_child(const EST_Discrete *d,
const EST_StrVector &words);
EST_BackoffNgrammarState* add_child(const EST_Discrete *d,
const EST_IVector &words);
public:
EST_BackoffNgrammarState()
{ init(); };
EST_BackoffNgrammarState(const EST_Discrete *d,int level)
{clear();init(d,level);};
EST_BackoffNgrammarState(const EST_DiscreteProbDistribution &pdf,int level)
{clear();init(pdf,level);};
EST_BackoffNgrammarState(const EST_BackoffNgrammarState &s);
EST_BackoffNgrammarState(const EST_BackoffNgrammarState *const s);
~EST_BackoffNgrammarState();
// initialise
void clear();
void init();
void init(const EST_Discrete *d, int level);
void init(const EST_DiscreteProbDistribution &pdf, int level);
// build
bool accumulate(const EST_StrVector &words,
const double count=1);
bool accumulate(const EST_IVector &words,
const double count=1);
// access
const EST_DiscreteProbDistribution &pdf_const() const {return p_pdf; };
EST_DiscreteProbDistribution &pdf() {return p_pdf; };
double probability(const EST_String &w) const
{return p_pdf.probability(w);}
double frequency(const EST_String &w) const
{return p_pdf.frequency(w);}
const EST_String &most_probable(double *prob = NULL) const
{return p_pdf.most_probable(prob);}
const int level() const {return p_level;}
EST_BackoffNgrammarState* get_child(const EST_String &word) const
{
return (EST_BackoffNgrammarState*)children.lookup(word);
}
EST_BackoffNgrammarState* get_child(const int word) const
{
return (EST_BackoffNgrammarState*)children.lookup(p_pdf.get_discrete()->name(word));
}
void remove_child(EST_BackoffNgrammarState *child,
const EST_String &name);
// recursive delete of contents and children
void zap();
const EST_BackoffNgrammarState *const get_state(const EST_StrVector &words) const;
bool ngram_exists(const EST_StrVector &words,
const double threshold) const;
const double get_backoff_weight() const {return backoff_weight; }
const double get_backoff_weight(const EST_StrVector &words) const;
bool set_backoff_weight(const EST_StrVector &words, const double w);
void frequency_of_frequencies(EST_DVector &ff);
void print_freqs(ostream &os,const int order,EST_String followers="");
friend ostream& operator<<(ostream& s, const EST_BackoffNgrammarState &a);
};
class EST_Ngrammar {
public:
// 3 representations : sparse, dense and backed off. User specifies which.
enum representation_t {sparse, dense, backoff};
// now only keep frequencies (or log frequencies)
// probabilities (or log probabilities) can be done
// on the fly quickly enough
enum entry_t {frequencies, log_frequencies};
protected:
// each instance of an EST_Ngrammar is a grammar of fixed order
// e.g. a bigram (order = 2)
int p_order;
int p_num_samples;
double p_number_of_sentences; // which were used to build this grammar
EST_String p_sentence_start_marker;
EST_String p_sentence_end_marker;
// only one representation in use at a time
representation_t p_representation;
entry_t p_entry_type;
// sparse representation is a tree structure
// holding only those N-grams which were seen
EST_PredictionSuffixTree sparse_representation;
bool init_sparse_representation();
// dense representation is just an array of all states
bool init_dense_representation();
// backoff representation is also a tree structure
// but the root state pdf is the most recent word in the
// ngram and going down the tree is going back in time....
// here is the root node :
EST_BackoffNgrammarState *backoff_representation;
double backoff_threshold;
// need a non-zero unigram floor to enable backing off
double backoff_unigram_floor_freq;
// instead of simple discounting, we have a (possibly) different
// discount per order and per frequency
// e.g. backoff_discount[2](4) contains the discount to be
// applied to a trigram frequency of 4
// backoff_discount[0] is unused (we don't discount unigrams)
EST_DVector *backoff_discount;
const double get_backoff_discount(const int order, const double freq) const;
bool init_backoff_representation();
void prune_backoff_representation(EST_BackoffNgrammarState *start_state=NULL); // remove any zero frequency branches
void backoff_restore_unigram_states();
int p_num_states; // == p_vocab_size ^ (p_ord-1) if fully dense
EST_NgrammarState *p_states; // state id is index into this array
int find_dense_state_index(const EST_IVector &words, int index=0) const;
// and the reverse
const EST_StrVector &make_ngram_from_index(const int i) const;
// vocabulary
EST_Discrete *vocab;
EST_Discrete *pred_vocab; // may be different from state vocab
bool init_vocab(const EST_StrList &wordlist);
bool init_vocab(const EST_StrList &word_list,
const EST_StrList &pred_list);
// make sure vocab matches a given wordlist
bool check_vocab(const EST_StrList &wordlist);
EST_DiscreteProbDistribution vocab_pdf; // overall pdf
const EST_String &lastword(const EST_StrVector &words) const
{ return words(p_order-1); }
const int lastword(const EST_IVector &words) const
{ return words(p_order-1); }
// are we allowing out-of-vocabulary words, or is the vocabulary closed?
bool allow_oov;
bool sparse_to_dense();
bool dense_to_sparse();
// these aren't sorted yet ...
void take_logs();
void take_exps();
void freqs_to_probs(); // just calls normalise
bool build_sparse(const EST_String &filename,
const EST_String &prev,
const EST_String &prev_prev,
const EST_String &last);
// for dense and backoff
bool build_ngram(const EST_String &filename,
const EST_String &prev,
const EST_String &prev_prev,
const EST_String &last,
const EST_String &input_format);
// go through all matching ngrams ( *(ngram[i])="" matches anything )
void iterate(EST_StrVector &words,
void (*function)(EST_Ngrammar *n,
EST_StrVector &words,
void *params),
void *params);
// same, but with a constant Ngrammar
void const_iterate(EST_StrVector &words,
void (*function)(const EST_Ngrammar *const n,
EST_StrVector &words,
void *params),
void *params) const;
bool p_init(int o, representation_t r);
// new filename returned of we had to copy stdin to a
// temporary file - must delete it later !
bool oov_preprocess(const EST_String &filename,
EST_String &new_filename,
const EST_String &what);
const EST_NgrammarState &find_state_const(const EST_StrVector &words)const;
EST_NgrammarState &find_state(const EST_StrVector &words);
const EST_NgrammarState &find_state_const(const EST_IVector &words) const;
EST_NgrammarState &find_state(const EST_IVector &words);
// special versions for backoff grammars
const EST_DiscreteProbDistribution &backoff_prob_dist(const EST_StrVector &words) const;
const double backoff_reverse_probability_sub(const EST_StrVector &words,
const EST_BackoffNgrammarState *root) const;
const double backoff_probability(const EST_StrVector &words,
const bool trace=false) const;
const double backoff_reverse_probability(const EST_StrVector &words) const;
const EST_String & backoff_most_probable(const EST_StrVector &words,
double *prob = NULL) const;
// backoff representation isn't a nice array of states
// so use this to visit every node in the tree
// and apply the function to that node
void backoff_traverse(EST_BackoffNgrammarState *start_state,
void (*function)(EST_BackoffNgrammarState *s,
void *params),
void *params);
// visit every node at a given level
void backoff_traverse(EST_BackoffNgrammarState *start_state,
void (*function)(EST_BackoffNgrammarState *s,
void *params),
void *params, const int level);
public:
EST_Ngrammar() {default_values();}
EST_Ngrammar(int o, representation_t r,
const EST_StrList &wordlist)
{
default_values(); init(o,r,wordlist);
}
// When state trans vocab differs from prediction vocab
EST_Ngrammar(int o, representation_t r,
const EST_StrList &wordlist,
const EST_StrList &predlist)
{
default_values(); init(o,r,wordlist,predlist);
}
EST_Ngrammar(int o, representation_t r, EST_Discrete &v)
{
default_values(); init(o,r,v);
}
~EST_Ngrammar();
void default_values();
void clear();
bool init(int o, representation_t r,
const EST_StrList &wordlist);
bool init(int o, representation_t r,
const EST_StrList &wordlist,
const EST_StrList &predlist);
bool init(int o, representation_t r, EST_Discrete &v);
bool init(int o, representation_t r,
EST_Discrete &v,EST_Discrete &pv);
// access
int num_states(void) const { return p_num_states;}
double samples(void) const { return p_num_samples;}
int order() const { return p_order; }
int get_vocab_length() const { return vocab?vocab->length():0; }
EST_String get_vocab_word(int i) const;
int get_vocab_word(const EST_String &s) const;
int get_pred_vocab_length() const { return pred_vocab->length(); }
EST_String get_pred_vocab_word(int i) const { return pred_vocab->name(i); }
int get_pred_vocab_word(const EST_String &s) const
{ return pred_vocab->name(s); }
int closed_vocab() const {return !allow_oov; }
entry_t entry_type() const {return p_entry_type;}
representation_t representation() const
{ return p_representation;}
// build
bool build(const EST_StrList &filenames,
const EST_String &prev = SENTENCE_START_MARKER,
const EST_String &prev_prev = SENTENCE_END_MARKER,
const EST_String &last = SENTENCE_END_MARKER,
const EST_String &input_format = "",
const EST_String &oov_mode = "",
const int mincount=1,
const int maxcount=10);
// Accumulate ngrams
void accumulate(const EST_StrVector &words,
const double count=1);
//const int index=0);
void accumulate(const EST_IVector &words,
const double count=1);
//const int index=0);
// hack - fix enter/exit probs s.t. P(...,!ENTER)=P(!EXIT,...)=0, for all x
void make_htk_compatible();
// I/O functions
EST_read_status load(const EST_String &filename);
EST_read_status load(const EST_String &filename, const EST_StrList &wordlist);
EST_write_status save(const EST_String &filename,
const EST_String type="cstr_ascii",
const bool trace=false,
double floor=0.0);
int wordlist_index(const EST_String &word, const bool report=true) const;
const EST_String &wordlist_index(int i) const;
int predlist_index(const EST_String &word) const;
const EST_String &predlist_index(int i) const;
// set
bool set_entry_type(entry_t new_type);
bool set_representation(representation_t new_representation);
// probability distributions
// -------------------------
// flag 'force' forces computation of probs on-the-fly if necessary
double probability(const EST_StrVector &words, bool force=false,
const bool trace=false) const;
double frequency(const EST_StrVector &words, bool force=false,
const bool trace=false) const;
const EST_String &predict(const EST_StrVector &words,
double *prob,int *state) const;
const EST_String &predict(const EST_StrVector &words) const
{double p; int state; return predict(words,&p,&state); }
const EST_String &predict(const EST_StrVector &words,double *prob) const
{int state; return predict(words,prob,&state); }
const EST_String &predict(const EST_IVector &words,double *prob,int *state) const;
const EST_String &predict(const EST_IVector &words) const
{double p; int state; return predict(words,&p,&state); }
const EST_String &predict(const EST_IVector &words,double *prob) const
{int state; return predict(words,prob,&state); }
int find_state_id(const EST_StrVector &words) const;
int find_state_id(const EST_IVector &words) const;
int find_next_state_id(int state, int word) const;
// fast versions for common N
//const double probability(const EST_String w1);
//const double probability(const EST_String w1,const EST_String w2);
//const double probability(const EST_String w1,const EST_String w2,
//const EST_String w2);
// reverse - probability of words[0..order-2] given word[order-1]
double reverse_probability(const EST_StrVector &words,
bool force=false) const;
double reverse_probability(const EST_IVector &words,
bool force=false) const;
// predict, where words has 'order' elements and the last one is "" or NULL
const EST_DiscreteProbDistribution &prob_dist(const EST_StrVector &words) const;
const EST_DiscreteProbDistribution &prob_dist(const EST_IVector &words) const;
const EST_DiscreteProbDistribution &prob_dist(int state) const;
// bool stats(const EST_String filename,
// double &raw_entropy, double &count,
// double &entropy, double &perplexity,
// const EST_String &prev = SENTENCE_START_MARKER,
// const EST_String &prev_prev = SENTENCE_END_MARKER,
// const EST_String &last = SENTENCE_END_MARKER,
// const EST_String &input_format = "") const;
void fill_window_start(EST_IVector &window,
const EST_String &prev,
const EST_String &prev_prev) const;
void fill_window_start(EST_StrVector &window,
const EST_String &prev,
const EST_String &prev_prev) const;
// why anybody would want to do this ....
//EST_Ngrammar &operator =(const EST_Ngrammar &a);
bool ngram_exists(const EST_StrVector &words) const;
bool ngram_exists(const EST_StrVector &words, const double threshold) const;
const double get_backoff_weight(const EST_StrVector &words) const;
bool set_backoff_weight(const EST_StrVector &words, const double w);
void print_freqs(ostream &os,double floor=0.0);
// i/o functions
// -------------
friend ostream& operator<<(ostream& s, EST_Ngrammar &n);
friend EST_read_status load_ngram_htk_ascii(const EST_String filename,
EST_Ngrammar &n);
friend EST_read_status load_ngram_htk_binary(const EST_String filename,
EST_Ngrammar &n);
friend EST_read_status load_ngram_arpa(const EST_String filename,
EST_Ngrammar &n,
const EST_StrList &vocab);
friend EST_read_status load_ngram_cstr_ascii(const EST_String filename,
EST_Ngrammar &n);
friend EST_read_status load_ngram_cstr_bin(const EST_String filename,
EST_Ngrammar &n);
friend EST_write_status save_ngram_htk_ascii_sub(const EST_String &word,
ostream *ost,
EST_Ngrammar &n,
double floor);
friend EST_write_status save_ngram_htk_ascii(const EST_String filename,
EST_Ngrammar &n,
double floor);
//friend EST_write_status save_ngram_htk_binary(const EST_String filename,
// EST_Ngrammar &n);
friend EST_write_status save_ngram_cstr_ascii(const EST_String filename,
EST_Ngrammar &n,
const bool trace,
double floor);
friend EST_write_status save_ngram_cstr_bin(const EST_String filename,
EST_Ngrammar &n,
const bool trace,
double floor);
friend EST_write_status save_ngram_arpa(const EST_String filename,
EST_Ngrammar &n);
friend EST_write_status save_ngram_arpa_sub(ostream *ost,
EST_Ngrammar &n,
const EST_StrVector &words);
friend EST_write_status save_ngram_wfst(const EST_String filename,
EST_Ngrammar &n);
// Auxiliary functions
// smoothing
friend void frequency_of_frequencies(EST_DVector &ff, EST_Ngrammar &n,int this_order);
friend void map_frequencies(EST_Ngrammar &n, const EST_DVector &map, const int this_order);
friend bool Good_Turing_smooth(EST_Ngrammar &n, int maxcount, int mincount);
friend void Good_Turing_discount(EST_Ngrammar &ngrammar, const int maxcount,
const double default_discount);
friend void fs_build_backoff_ngrams(EST_Ngrammar *backoff_ngrams,
EST_Ngrammar &ngram);
friend int fs_backoff_smooth(EST_Ngrammar *backoff_ngrams,
EST_Ngrammar &ngram, int smooth_thresh);
// frequencies below mincount get backed off
// frequencies above maxcount are not smoothed(discounted)
bool compute_backoff_weights(const int mincount=1,
const int maxcount=10);
bool merge(EST_Ngrammar &n,float weight);
friend class EST_BackoffNgrammar;
};
void Ngram_freqsmooth(EST_Ngrammar &ngram,
int smooth_thresh1,
int smooth_thresh2);
// utils
void slide(EST_IVector &i, const int l);
void slide(EST_StrVector &i, const int l);
bool test_stats(EST_Ngrammar &ngram,
const EST_String &filename,
double &raw_entropy,
double &count,
double &entropy,
double &perplexity,
const EST_String &input_format,
const EST_String &prev = SENTENCE_START_MARKER,
const EST_String &prev_prev = SENTENCE_END_MARKER,
const EST_String &last = SENTENCE_END_MARKER);
VAL_REGISTER_CLASS_DCLS(ngrammar,EST_Ngrammar)
#endif // __EST_NGRAMMAR_H__
EST_BackoffNgrammarState
Definition EST_Ngrammar.h:131
EST_DVector
Definition EST_DMatrix.h:113
EST_DiscreteProbDistribution
Definition EST_simplestats.h:210
EST_Discrete
Definition EST_simplestats.h:61
EST_NgrammarState
Definition EST_Ngrammar.h:77
EST_Ngrammar
Definition EST_Ngrammar.h:209
EST_PredictionSuffixTree
Definition EST_PST.h:83
EST_StringTrie
Definition EST_StringTrie.h:83
EST_String
Definition EST_String.h:70