def run_viterbi(self, i, out):
vpath = None
hidden.set_implementation(self.kernel)
time1 = time.time()
for k in range(self.nrep):
vpath = hidden.viterbi(self.A[i], self.pobs[i], self.pi[i])
# compare
time2 = time.time()
d = (time2-time1)/(1.0*self.nrep)
return (vpath, d)
def run_viterbi(self, i, out):
vpath = None
hidden.set_implementation(self.kernel)
time1 = time.time()
for k in range(self.nrep):
vpath = hidden.viterbi(self.A[i], self.pobs[i], self.pi[i])
# compare
time2 = time.time()
d = (time2-time1) / (1.0*self.nrep)
return vpath, d
def run_viterbi(self, i, kernel, out):
nrep = max(1, int(10000/self.T[i]))
vpath = None
hidden.set_implementation(kernel)
time1 = time.time()
for k in range(nrep):
vpath = hidden.viterbi(self.A[i], self.pobs[i], self.pi[i])
# compare
time2 = time.time()
d = (time2-time1) / (1.0*nrep)
return vpath, d
def run_viterbi(self, i, kernel, out):
nrep = max(1, int(10000 / self.T[i]))
vpath = None
hidden.set_implementation(kernel)
time1 = time.time()
for k in range(nrep):
vpath = hidden.viterbi(self.A[i], self.pobs[i], self.pi[i])
# compare
time2 = time.time()
d = (time2 - time1) / (1.0 * nrep)
return (vpath, d)
def run_all(self, A, pobs, pi):
# forward
logprob, alpha = hidden.forward(A, pobs, pi)
# backward
beta = hidden.backward(A, pobs)
# gamma
gamma = hidden.state_probabilities(alpha, beta)
# state counts
T = pobs.shape[0]
statecount = hidden.state_counts(gamma, T)
# transition counts
C = hidden.transition_counts(alpha, beta, A, pobs)
# viterbi path
vpath = hidden.viterbi(A, pobs, pi)
# return
return logprob, alpha, beta, gamma, statecount, C, vpath
def run_all(self, A, pobs, pi):
# forward
logprob, alpha = hidden.forward(A, pobs, pi)
# backward
beta = hidden.backward(A, pobs)
# gamma
gamma = hidden.state_probabilities(alpha, beta)
# state counts
T = pobs.shape[0]
statecount = hidden.state_counts(gamma, T)
# transition counts
C = hidden.transition_counts(alpha, beta, A, pobs)
# viterbi path
vpath = hidden.viterbi(A, pobs, pi)
# return
return (logprob, alpha, beta, gamma, statecount, C, vpath)
def run_all_mem(self, A, pobs, pi):
T = pobs.shape[0]
N = A.shape[0]
alpha = np.zeros((T, N))
beta = np.zeros((T, N))
gamma = np.zeros((T, N))
C = np.zeros((N, N))
logprob, alpha = hidden.forward(A, pobs, pi, alpha_out=alpha)
# backward
hidden.backward(A, pobs, beta_out=beta)
# gamma
hidden.state_probabilities(alpha, beta, gamma_out=gamma)
# state counts
statecount = hidden.state_counts(gamma, T)
# transition counts
hidden.transition_counts(alpha, beta, A, pobs, out=self.C)
# viterbi path
vpath = hidden.viterbi(A, pobs, pi)
# return
return logprob, alpha, beta, gamma, statecount, C, vpath
def run_all_mem(self, A, pobs, pi):
T = pobs.shape[0]
N = A.shape[0]
alpha = np.zeros((T, N))
beta = np.zeros((T, N))
gamma = np.zeros((T, N))
C = np.zeros((N, N))
logprob, alpha = hidden.forward(A, pobs, pi, alpha_out=alpha)
# backward
hidden.backward(A, pobs, beta_out=beta)
# gamma
hidden.state_probabilities(alpha, beta, gamma_out=gamma)
# state counts
statecount = hidden.state_counts(gamma, T)
# transition counts
hidden.transition_counts(alpha, beta, A, pobs, out=self.C)
# viterbi path
vpath = hidden.viterbi(A, pobs, pi)
# return
return (logprob, alpha, beta, gamma, statecount, C, vpath)
def compute_viterbi_paths(self):
"""
Computes the viterbi paths using the current HMM model
"""
# get parameters
K = len(self._observations)
A = self._hmm.transition_matrix
pi = self._hmm.initial_distribution
# compute viterbi path for each trajectory
paths = np.empty(K, dtype=object)
for itraj in range(K):
obs = self._observations[itraj]
# compute output probability matrix
pobs = self._hmm.output_model.p_obs(obs)
# hidden path
paths[itraj] = hidden.viterbi(A, pobs, pi)
# done
return paths
def compute_viterbi_paths(self):
"""
Computes the viterbi paths using the current HMM model
"""
# get parameters
K = len(self._observations)
A = self._hmm.transition_matrix
pi = self._hmm.initial_distribution
# compute viterbi path for each trajectory
paths = np.empty(K, dtype=object)
for itraj in range(K):
obs = self._observations[itraj]
# compute output probability matrix
pobs = self._hmm.output_model.p_obs(obs)
# hidden path
paths[itraj] = hidden.viterbi(A, pobs, pi)
# done
return paths
