def reestimateA(self, observ, xi, gamma):
new_A = np.zeros((self.n, self.n), dtype=self.precision)
for i in xrange(self.n):
for j in xrange(self.n):
numer = safemath.LOGZERO
denom = safemath.LOGZERO
for t in xrange(len(observ) - 1):
numer = safemath.safelnsum(numer, xi[t][i][j])
denom = safemath.safelnsum(denom, gamma[t][i])
new_A[i][j] = safemath.safeexp(
safemath.safelnprod(numer, -1 * denom))
return new_A
def calcxi(self, observ, alpha=None, beta=None):
if alpha is None:
alpha = self._calcalpha(observ)
if beta is None:
beta = self._calcbeta(observ)
xi = np.zeros((len(observ), self.n, self.n), dtype=self.precision)
for t in xrange(len(observ) - 1):
normalizer = safemath.LOGZERO
for i in xrange(self.n):
for j in xrange(self.n):
xi[t][i][j] = safemath.safelnprod(
alpha[t][i],
safemath.safelnprod(
safemath.safeln(self.A[i][j]),
safemath.safelnprod(
safemath.safeln(self.B[j][t + 1]),
beta[t + 1][j])))
normalizer = safemath.safelnsum(normalizer, xi[t][i][j])
for i in xrange(self.n):
for j in xrange(self.n):
xi[t][i][j] = safemath.safelnprod(xi[t][i][j],
-1 * normalizer)
return xi
def forwardbackward(self, observ, cache=False):
if not cache:
self.calcB(observ)
alpha = self.calcalpha(observ)
loglikelihood = safemath.LOGZERO
for i in xrange(self.n):
loglikelihood = safemath.safelnsum(loglikelihood, alpha[-1][i])
return loglikelihood
def calcgamma(self, alpha, beta, seqlen):
gamma = np.zeros((seqlen, self.n), dtype=self.precision)
for t in xrange(seqlen):
normalizer = safemath.LOGZERO
for i in xrange(self.n):
gamma[t][i] = safemath.safelnprod(alpha[t][i], beta[t][i])
normalizer = safemath.safelnsum(normalizer, gamma[t][i])
for i in xrange(self.n):
gamma[t][i] = safemath.safelnprod(gamma[t][i], -1 * normalizer)
return gamma
def calcbeta(self, observ):
beta = np.zeros((len(observ), self.n), dtype=self.precision)
# induction
for t in xrange(len(observ) - 2, -1, -1):
for i in xrange(self.n):
logbeta = safemath.LOGZERO
for j in xrange(self.n):
logbeta = safemath.safelnsum(
logbeta,
safemath.safelnprod(
safemath.safeln(self.A[i][j]),
safemath.safelnprod(
safemath.safeln(self.B[j][t + 1]),
beta[t + 1][j])))
beta[t][i] = logbeta
return beta
def calcalpha(self, observ):
alpha = np.ones((len(observ), self.n),
dtype=self.precision) # allocation
# init stage - alpha_1(x) = pi(x)b_x(O1)
for x in xrange(self.n):
alpha[0][x] = safemath.safelnprod(safemath.safeln(self.pi[x]),
safemath.safeln(self.B[x][0]))
# induction
for t in xrange(1, len(observ)):
for j in xrange(self.n):
logalpha = safemath.LOGZERO
for i in xrange(self.n):
logalpha = safemath.safelnsum(
logalpha,
safemath.safelnprod(alpha[t - 1][i],
safemath.safeln(self.A[i][j])))
alpha[t][j] = safemath.safelnprod(
logalpha, safemath.safeln(self.B[j][t]))
return alpha