def get_edge_posteriors(self, seq):
nr_states = self.nr_states
node_potentials, edge_potentials = self.build_potentials(seq)
forward, backward = forward_backward(node_potentials, edge_potentials)
H, N = forward.shape
likelihood = np.sum(forward[:, N-1])
return self.get_edge_posteriors_aux(seq, forward, backward, node_potentials, edge_potentials, likelihood)
def get_edge_posteriors(self,seq):
nr_states = self.nr_states
node_potentials,edge_potentials = self.build_potentials(seq)
forward,backward = forward_backward(node_potentials,edge_potentials)
H,N = forward.shape
likelihood = np.sum(forward[:,N-1])
return self.get_edge_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
def get_posteriors(self, seq):
forward, backward = forward_backward(seq)
# self.sanity_check_fb(forward,backward)
H, N = forward.shape
likelihood = np.sum(forward[:, N-1])
node_posteriors = self.get_node_posteriors_aux(seq, forward, backward, likelihood)
edge_posteriors = self.get_edge_posteriors_aux(seq, forward, backward, likelihood)
return [node_posteriors, edge_posteriors], likelihood
def get_posteriors(self,seq):
forward,backward = forward_backward(seq)
#self.sanity_check_fb(forward,backward)
H,N = forward.shape
likelihood = np.sum(forward[:,N-1])
node_posteriors = self.get_node_posteriors_aux(seq,forward,backward,likelihood)
edge_posteriors = self.get_edge_posteriors_aux(seq,forward,backward,likelihood)
return [node_posteriors,edge_posteriors],likelihood
def get_posteriors(self,seq):
nr_states = self.nr_states
node_potentials,edge_potentials = self.build_potentials(seq)
forward,backward = forward_backward(node_potentials,edge_potentials)
#self.sanity_check_fb(forward,backward)
H,N = forward.shape
likelihood = np.sum(forward[:,N-1])
node_posteriors = self.get_node_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
edge_posteriors = self.get_edge_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
return [node_posteriors,edge_posteriors],likelihood
def get_posteriors(self, seq):
nr_states = self.nr_states
node_potentials, edge_potentials = self.build_potentials(seq)
forward, backward = forward_backward(node_potentials, edge_potentials)
# self.sanity_check_fb(forward,backward)
H, N = forward.shape
likelihood = np.sum(forward[:, N-1])
node_posteriors = self.get_node_posteriors_aux(seq, forward, backward, node_potentials, edge_potentials, likelihood)
edge_posteriors = self.get_edge_posteriors_aux(seq, forward, backward, node_potentials, edge_potentials, likelihood)
return [node_posteriors, edge_posteriors], likelihood
def get_objective_seq(self,parameters,seq,exp_counts):
#print seq.nr
# nr_states = self.nr_states
node_potentials,edge_potentials = self.build_potentials(seq)
forward,backward = forward_backward(node_potentials,edge_potentials)
H,N = forward.shape
likelihood = np.sum(forward[:,N-1])
# import pdb;pdb.set_trace()
#node_posteriors = self.get_node_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
#edge_posteriors = self.get_edge_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
# seq_objective = 0
seq_objective2 = 1
for pos in xrange(N):
true_y = seq.y[pos]
for state in xrange(H):
# node_f_list = self.feature_class.get_node_features(seq,pos,state)
# backward_aux = backward[state,pos]
# forward_aux = forward[state,pos]
# forward_aux_div_likelihood = forward_aux/likelihood
##Iterate over feature indexes
# prob_aux = forward_aux_div_likelihood*backward_aux
# for fi in node_f_list:
# ## For the objective add both the node features and edge feature dot the parameters for the true observation
# if(state == true_y):
# seq_objective += parameters[fi]
# ## For the gradient add the node_posterior ##Compute node posteriors on the fly
#
# exp_counts[fi] += prob_aux
if(state == true_y):
seq_objective2 *= node_potentials[state,pos]
#Handle transitions
if(pos < N-1):
true_next_y = seq.y[pos+1]
for next_state in xrange(H):
# backward_aux2 = backward[next_state,pos+1]
# node_pot_aux = node_potentials[next_state,pos+1]
# edge_f_list = self.feature_class.get_edge_features(seq,pos+1,next_state,state)
## For the gradient add the edge_posterior
# edge_aux = edge_potentials[state,next_state,pos]
# prob_aux = forward_aux_div_likelihood*edge_aux*node_pot_aux*backward_aux2
# for fi in edge_f_list:
# ## For the objective add both the node features and edge feature dot the parameters for the true observation
# if(next_state == true_next_y):
# seq_objective += parameters[fi]
# exp_counts[fi] += prob_aux
if(next_state == true_next_y):
seq_objective2 *= edge_potentials[state,next_state,pos]
if seq_objective2 > likelihood:
import pdb; pdb.set_trace()
seq_objective2 = np.log(seq_objective2)
# print seq_objective, seq_objective2
return seq_objective2,np.log(likelihood)
def get_objective_seq(self,parameters,seq,exp_counts):
#print seq.nr
nr_states = self.nr_states
node_potentials,edge_potentials = self.build_potentials(seq)
forward,backward = forward_backward(node_potentials,edge_potentials)
H,N = forward.shape
likelihood = np.sum(forward[:,N-1])
#node_posteriors = self.get_node_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
#edge_posteriors = self.get_edge_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
seq_objective = 0
for pos in xrange(N):
true_y = seq.y[pos]
for state in xrange(H):
node_f_list = self.feature_class.get_node_features(seq,pos,state)
backward_aux = backward[state,pos]
forward_aux = forward[state,pos]
forward_aux_div_likelihood = forward_aux/likelihood
##Iterate over feature indexes
prob_aux = forward_aux_div_likelihood*backward_aux
for fi in node_f_list:
## For the objective add both the node features and edge feature dot the parameters for the true observation
if(state == true_y):
seq_objective += parameters[fi]
## For the gradient add the node_posterior ##Compute node posteriors on the fly
exp_counts[fi] += prob_aux
#Handle transitions
if(pos < N-1):
true_next_y = seq.y[pos+1]
for next_state in xrange(H):
backward_aux2 = backward[next_state,pos+1]
node_pot_aux = node_potentials[next_state,pos+1]
edge_f_list = self.feature_class.get_edge_features(seq,pos+1,next_state,state)
## For the gradient add the edge_posterior
edge_aux = edge_potentials[state,next_state,pos]
prob_aux = forward_aux_div_likelihood*edge_aux*node_pot_aux*backward_aux2
for fi in edge_f_list:
## For the objective add both the node features and edge feature dot the parameters for the true observation
if(next_state == true_next_y):
seq_objective += parameters[fi]
exp_counts[fi] += prob_aux
return seq_objective,likelihood
def forward_backward(self,seq):
node_potentials,edge_potentials = self.build_potentials(seq)
forward,backward = forward_backward(node_potentials,edge_potentials)
#print sanity_check_forward_backward(forward,backward)
return forward,backward
def get_objective_seq(self,parameters,seq,exp_counts):
#print seq.nr
# nr_states = self.nr_states
node_potentials,edge_potentials = self.build_potentials(seq)
# import pdb
# pdb.set_trace()
forward,backward = forward_backward(node_potentials,edge_potentials)
if np.any(np.isnan(forward)):
import pdb
pdb.set_trace()
H,N = forward.shape
likelihood = np.sum(forward[:,N-1])
if np.any(np.isnan(likelihood)):
import pdb
pdb.set_trace()
node_posteriors = self.get_node_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
edge_posteriors = self.get_edge_posteriors_aux(seq,forward,backward,node_potentials,edge_potentials,likelihood)
seq_objective = 1.0
# Compute sequence objective looking at the gold sequence.
for pos in xrange(N):
true_y = seq.y[pos]
node_f_list = self.feature_class.get_node_features(seq,pos,true_y)
seq_objective *= node_potentials[true_y,pos]
if(pos < N-1):
true_next_y = seq.y[pos+1]
seq_objective *= edge_potentials[true_y,true_next_y,pos]
# Now compute expected counts.
# Take care of nodes.
for pos in xrange(N):
for state in xrange(H):
node_f_list = self.feature_class.get_node_features(seq,pos,state)
for fi in node_f_list:
exp_counts[fi] += node_posteriors[state,pos]
# Take care of edges.
# 1) Initial position.
for state in xrange(H):
edge_f_list = self.feature_class.get_edge_features(seq,0,state,-1)
for fi in edge_f_list:
exp_counts[fi] += node_posteriors[state,0]
# 2) Intermediate position.
for pos in xrange(N-1):
for state in xrange(H):
for next_state in xrange(H):
edge_f_list = self.feature_class.get_edge_features(seq,pos+1,next_state,state)
for fi in edge_f_list:
exp_counts[fi] += edge_posteriors[state,next_state,pos]
# 3) Final position.
for state in xrange(H):
edge_f_list = self.feature_class.get_edge_features(seq,N,-1,state)
for fi in edge_f_list:
exp_counts[fi] += node_posteriors[state,N-1]
if seq_objective > likelihood:
import pdb; pdb.set_trace()
seq_objective = np.log(seq_objective)
if np.any(np.isnan(seq_objective)):
import pdb
pdb.set_trace()
if np.any(np.isnan(np.log(likelihood))):
import pdb
pdb.set_trace()
return seq_objective,np.log(likelihood)
def compute_ess_dhmm(observation_vector,prior,transition_matrix,emission_matrix, dirichlet):
#print "__________________________________"
#print "Observation:",observation_vector,"\n","Hidden:",hidden,"\n","Prior",prior,"\n","Transition",transition_matrix,"\n","Emission",emission_matrix
(S,O)=np.shape(emission_matrix)
exp_num_trans=np.zeros((S,S))
exp_num_visits1=np.zeros((1,S)).flatten(1)
exp_num_visitsT=np.zeros((1,S)).flatten(1)
exp_num_emit = dirichlet*np.ones((S,O))
loglik = 0
num_sequences=len(observation_vector)
for i in range(num_sequences):
observation_i=observation_vector[i]
#Number of observations
T=len(observation_i)
obslik = evaluate_pdf_cond_multinomial(observation_i, emission_matrix)
#E
[alpha, beta, gamma, xi,xi_summed,current_ll] = forward_backward(prior, transition_matrix, emission_matrix,observation_i,True,obslik)
loglik = loglik + current_ll
exp_num_trans = exp_num_trans + xi_summed
#print "EXPETCED VISISTS 1 BEFORE",exp_num_visits1
exp_num_visits1 += gamma[:,0]
#print "EXPETCED VISISTS 1 AFTER",exp_num_visits1
exp_num_visitsT = exp_num_visitsT + gamma[:,T-1]
#print "Visits 1",exp_num_visits1
#print "Visits T",exp_num_visitsT
#print "EXP NUM TRANS",exp_num_trans
for t in range(0,T):
o = observation_i[t]
exp_num_emit[:,o] = exp_num_emit[:,o] + gamma[:,t]
#print "Log Likelihood:",loglik
#print "Exp Num Transitions",exp_num_trans
#print "Exp Num Visits 1",exp_num_visits1
#print "Exp Num Visits T",exp_num_visitsT
#print "Exp Num Emit",exp_num_emit
#print "Xi Summed",xi_summed
#print "Sequence",np.array(observation_i)+1
#print "Alpha",alpha
#print "Beta",beta
#raw_input('After iteration%s'%i)
new_pi=normalize(gamma[:,0])[0]
new_A=xi_summed/np.sum(gamma,1)
(number_of_hidden_states,number_of_observation_states)=np.shape(emission_matrix)
B_new = np.zeros(np.shape(emission_matrix))
for j in xrange(number_of_hidden_states):
for k in xrange(number_of_observation_states):
numer = 0.0
denom = 0.0
for t in xrange(T):
if observation_i[t] == k:
numer += gamma[j][t]
denom += gamma[j][t]
B_new[j][k] = numer/denom
#print "******************************"
#print "New Pi:",new_pi
#print "New A:",new_A
#print "After normalizing",mk_stochastic(new_A)
return [loglik,exp_num_visits1,exp_num_visitsT,exp_num_trans,exp_num_emit]
def forward_backward(self, seq):
node_potentials, edge_potentials = self.build_potentials(seq)
forward, backward = forward_backward(node_potentials, edge_potentials)
sanity_check_forward_backward(forward, backward)
return forward, backward
