double Hmm::getPseudoCounts(PseudoCounts& counts)
{
double PofObs = obsProb(); // this call includes a forward() call.
backward();
// print();
// Compute the pseudo counts of transitions, emissions, and initializations
for (unsigned int t = 0; t<_timeSlots.size(); t++) {
TimeSlot* ts = _timeSlots[t];
TimeSlot::iterator it = ts->begin();
// P(X_t=s|e_1:T) = alpha_s(t)*beta_s(t)/P(e_t+1:T|e_1:t)
// The value sum below is log P(e_t+1:T|e_1:t)
vector<double> logprobs;
for (; it!=ts->end(); it++) {
logprobs.push_back((*it)->logAlpha()+(*it)->logBeta());
}
double sum = sumLogProb(logprobs);
// add the pseudo counts into counts
for (it = ts->begin(); it!=ts->end(); it++) {
HmmNode* node = *it;
//stateCount=P(X_t=s|e_1:T)
double stateCount = node->logAlpha()+node->logBeta()-sum;
counts.stateCount().add(node->state(), stateCount);
vector<Transition*>& ins = node->ins();
unsigned int k;
for (k = 0; k<ins.size(); k++) {
Transition* trans = ins[k];
HmmNode* from = trans->_from;
double transCount = from->logAlpha()+getTransProb(trans)
+getEmitProb(trans)+node->logBeta()-PofObs;
// cerr << _str2id.getStr(node->state()) << '\t'
// << _str2id.getStr(trans->_obs) << '\t'
// << exp(transCount) << endl;
counts.emitCount().add(node->state(), trans->_obs, transCount);
}
vector<Transition*>& outs = node->outs();
for (k = 0; k<outs.size(); k++) {
Transition* trans = outs[k];
HmmNode* to = trans->_to;
double transCount = node->logAlpha()+getTransProb(trans)
+getEmitProb(trans)+to->logBeta()-PofObs;
counts.transCount().add(node->state(), to->state(), transCount);
}
}
}
// counts.print(_str2id);
return PofObs;
}
// Compute P(e_1:T) = sum_s P(e_1:T, x_T=s) = sum_s alpha_s(T);
double Hmm::obsProb()
{
if (_timeSlots.size()<1)
return 1; // no observations
forward();
TimeSlot* last = _timeSlots[_timeSlots.size()-1];
vector<double> alphaT;
for (TimeSlot::iterator it = last->begin(); it!=last->end(); it++) {
alphaT.push_back((*it)->logAlpha());
}
return sumLogProb(alphaT);
}
void Hmm::forward()
{
// compute forward probabilities at time 0
TimeSlot* t0 = _timeSlots[0];
HmmNode* init = (*t0)[0];
init->logAlpha(0);
// compute forward probabilities at time t using the alpha values for time t-1
for (unsigned int t = 1; t<_timeSlots.size(); t++) {
TimeSlot* ts = _timeSlots[t];
for (TimeSlot::iterator it = ts->begin(); it!=ts->end(); it++) {
vector<Transition*>& ins = (*it)->ins();
vector<double> logProbs(ins.size());
for (unsigned int i = 0; i<ins.size(); i++) {
Transition* trans = ins[i];
double logProb = trans->_from->logAlpha()+getTransProb(trans)+getEmitProb(trans);
logProbs[i] = logProb;
}
(*it)->logAlpha(sumLogProb(logProbs));
}
}
}
int MaxEntModel::getProbs(MaxEntEvent& event, vector<double>& probs)
{
probs.clear();
probs.assign(_classes, 0);
int max = -1;
for (unsigned int c = 0; c<_classes; c++) {
double s = 0;
for (unsigned int f = 0; f<event.size(); f++) {
FtMap::iterator it = _index.find(event[f]);
if (it!=_index.end())
s += _lambda[it->second+c];
}
probs[c] = s;
if (max<0 || probs[max]<s)
max = c;
}
double sum = sumLogProb(probs);
for (unsigned int i = 0; i<_classes; i++) {
probs[i] = exp(probs[i])/exp(sum);
}
return max;
}
void Hmm::backward()
{
int T = _timeSlots.size()-1;
if (T<1) // no observation
return;
for (int t = T; t>=0; t--) {
TimeSlot* ts = _timeSlots[t];
for (TimeSlot::iterator it = ts->begin(); it!=ts->end(); it++) {
HmmNode* node = *it;
if (t==T)
node->logBeta(0);
else {
vector<Transition*>& outs = node->outs();
vector<double> logProbs(outs.size());
for (unsigned int i = 0; i<outs.size(); i++) {
Transition* trans = outs[i];
double logProb = trans->_to->logBeta()+getTransProb(trans)+getEmitProb(trans);
logProbs[i] =logProb;
}
node->logBeta(sumLogProb(logProbs));
}
}
}
}
