def L_top(rho=None, omega=None, alpha=None,
gamma=None, kappa=0, startAlpha=0, **kwargs):
''' Evaluate the top-level term of the surrogate objective
'''
if startAlpha == 0:
startAlpha = alpha
K = rho.size
eta1 = rho * omega
eta0 = (1 - rho) * omega
digamma_omega = digamma(omega)
ElogU = digamma(eta1) - digamma_omega
Elog1mU = digamma(eta0) - digamma_omega
diff_cBeta = K * c_Beta(1.0, gamma) - c_Beta(eta1, eta0)
tAlpha = K * K * np.log(alpha) + K * np.log(startAlpha)
if kappa > 0:
coefU = K + 1.0 - eta1
coef1mU = K * OptimizerRhoOmega.kvec(K) + 1.0 + gamma - eta0
sumEBeta = np.sum(rho2beta(rho, returnSize='K'))
tBeta = sumEBeta * (np.log(alpha + kappa) - np.log(kappa))
tKappa = K * (np.log(kappa) - np.log(alpha + kappa))
else:
coefU = (K + 1) + 1.0 - eta1
coef1mU = (K + 1) * OptimizerRhoOmega.kvec(K) + gamma - eta0
tBeta = 0
tKappa = 0
diff_logU = np.inner(coefU, ElogU) \
+ np.inner(coef1mU, Elog1mU)
return tAlpha + tKappa + tBeta + diff_cBeta + diff_logU
def testHasSaneOutput__objFunc_constrained(self):
''' Verify objective and gradient vector have correct type and size
f should be a finite scalar
g should be a vector of size 2K (first half is drho, second is domega)
'''
for K in [1, 2, 10, 101]:
for seed in [33, 77, 888]:
for oScale in [1, 10]:
for approx_grad in [0, 1]:
PRNG = np.random.RandomState(seed)
rho = PRNG.rand(K)
omega = oScale * PRNG.rand(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=1,
gamma=1,
nDoc=0,
sumLogPi=np.zeros(K + 1))
if approx_grad:
f = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=1, **kwargs)
g = np.ones(
2 * K
) # placeholder, this would be done automatically
else:
f, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
assert isinstance(f, np.float64)
assert g.ndim == 1
assert g.size == 2 * K
assert np.isfinite(f)
assert np.all(np.isfinite(g))
def learn_rhoomega_fromFixedCounts(DocTopicCount_d=None,
nDoc=0,
alpha=None,
gamma=None,
initrho=None,
initomega=None):
Nd = np.sum(DocTopicCount_d)
K = DocTopicCount_d.size
if initrho is None:
rho = OptimizerRhoOmega.create_initrho(K)
else:
rho = initrho
if initomega is None:
omega = OptimizerRhoOmega.create_initomega(K, nDoc, gamma)
else:
omega = initomega
evalELBOandPrint(
rho=rho,
omega=omega,
DocTopicCount=np.tile(DocTopicCount_d, (nDoc, 1)),
alpha=alpha,
gamma=gamma,
msg='init',
)
betaK = rho2beta(rho, returnSize="K")
prevbetaK = np.zeros_like(betaK)
iterid = 0
while np.sum(np.abs(betaK - prevbetaK)) > 0.000001:
iterid += 1
theta_d = DocTopicCount_d + alpha * betaK
thetaRem = alpha * (1 - np.sum(betaK))
assert np.allclose(theta_d.sum() + thetaRem, alpha + Nd)
digammaSum = digamma(theta_d.sum() + thetaRem)
Elogpi_d = digamma(theta_d) - digammaSum
ElogpiRem = digamma(thetaRem) - digammaSum
sumLogPi = nDoc * np.hstack([Elogpi_d, ElogpiRem])
rho, omega, f, Info = OptimizerRhoOmega.\
find_optimum_multiple_tries(
alpha=alpha,
gamma=gamma,
sumLogPi=sumLogPi,
nDoc=nDoc,
initrho=rho,
initomega=omega,
approx_grad=1,
)
prevbetaK = betaK.copy()
betaK = rho2beta(rho, returnSize="K")
if iterid < 5 or iterid % 10 == 0:
evalELBOandPrint(
rho=rho,
omega=omega,
DocTopicCount=np.tile(DocTopicCount_d, (nDoc, 1)),
alpha=alpha,
gamma=gamma,
msg=str(iterid),
)
return rho, omega
def testHasSaneOutput__objFunc_unconstrained(self):
''' Verify objective and gradient vector have correct type and size
'''
for K in [1, 2, 10, 100]:
for seed in [33, 77, 444]:
for oScale in [1, 45]:
for approx_grad in [0, 1]:
PRNG = np.random.RandomState(seed)
rho = PRNG.rand(K)
omega = oScale * PRNG.rand(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=1,
gamma=1,
nDoc=0,
sumLogPi=np.zeros(K + 1))
c = OptimizerRhoOmega.rhoomega2c(rhoomega)
if approx_grad:
f = OptimizerRhoOmega.objFunc_unconstrained(
c, approx_grad=1, **kwargs)
g = np.ones(2 * K)
else:
f, g = OptimizerRhoOmega.objFunc_unconstrained(
c, approx_grad=0, **kwargs)
assert isinstance(f, np.float64)
assert g.ndim == 1
assert g.size == 2 * K
assert np.isfinite(f)
assert np.all(np.isfinite(g))
def update_global_params_VB(self, SS,
mergeCompA=None, mergeCompB=None,
**kwargs):
''' Update global parameters.
'''
self.K = SS.K
if not hasattr(self, 'rho') or self.rho.size != SS.K:
# Big change from previous model is being proposed.
# We'll init rho from scratch, and need more iters to improve.
nGlobalIters = self.nGlobalItersBigChange
else:
# Small change required. Current rho is good initialization.
nGlobalIters = self.nGlobalIters
# Special update case for merges:
# Fast, heuristic update for new rho given original value
if mergeCompA is not None:
beta = OptimizerRhoOmega.rho2beta_active(self.rho)
beta[mergeCompA] += beta[mergeCompB]
beta = np.delete(beta, mergeCompB, axis=0)
self.rho = OptimizerRhoOmega.beta2rho(beta, SS.K)
omega = self.omega
omega[mergeCompA] += omega[mergeCompB]
self.omega = np.delete(omega, mergeCompB, axis=0)
# TODO think about smarter init for rho/omega??
# Update theta with recently updated info from suff stats
self.transTheta, self.startTheta = self._calcTheta(SS)
for giter in range(nGlobalIters):
# Update rho, omega through numerical optimization
self.rho, self.omega = self.find_optimum_rhoOmega(**kwargs)
# Update theta again to reflect the new rho, omega
self.transTheta, self.startTheta = self._calcTheta(SS)
def testRecoverAnalyticOptimum__find_optimum(self):
''' Verify find_optimum's result is indistiguishable from analytic opt
'''
for K in [1, 10, 23, 61, 68, 100]:
for alpha in [0.1, 0.95]:
for gamma in [1.1, 3.141, 9.45, 21.1337]:
for kappa in [0, 100]:
print('============== K %d | gamma %.2f' % (K, gamma))
for seed in [111, 222, 333]:
PRNG = np.random.RandomState(seed)
initrho = PRNG.rand(K)
initomega = 100 * PRNG.rand(K)
scaleVec = np.hstack(
[np.ones(K), gamma * np.ones(K)])
kwargs = dict(alpha=alpha,
gamma=gamma,
scaleVector=scaleVec,
nDoc=0,
sumLogPi=np.zeros(K + 1))
ro, f, Info = OptimizerRhoOmega.find_optimum(
initrho=initrho, initomega=initomega, **kwargs)
rho_est, omega_est, KK = OptimizerRhoOmega._unpack(
ro)
assert np.all(np.isfinite(rho_est))
assert np.all(np.isfinite(omega_est))
assert np.isfinite(f)
print(Info['task'])
rho_opt = 1.0 / (1. + gamma) * np.ones(K)
omega_opt = (1. + gamma) * np.ones(K)
print(' rho_est', np2flatstr(rho_est,
fmt='%9.6f'))
print(' rho_opt', np2flatstr(rho_opt,
fmt='%9.6f'))
print(' omega_est',
np2flatstr(omega_est, fmt='%9.6f'))
print(' omega_opt',
np2flatstr(omega_opt, fmt='%9.6f'))
beta_est = OptimizerRhoOmega.rho2beta_active(
rho_est)
beta_opt = OptimizerRhoOmega.rho2beta_active(
rho_opt)
print(' beta_est',
np2flatstr(beta_est, fmt='%9.6f'))
print(' beta_opt',
np2flatstr(beta_opt, fmt='%9.6f'))
assert np.allclose(beta_est, beta_opt, atol=1e-4)
assert np.allclose(omega_est,
omega_opt,
atol=1e-5,
rtol=0.01)
def _calcTheta(self, SS):
''' Update parameters theta to maximize objective given suff stats.
Returns
---------
transTheta : 2D array, size K x K+1
startTheta : 1D array, size K
'''
K = SS.K
if not hasattr(self, 'rho') or self.rho.size != K:
self.rho = OptimizerRhoOmega.create_initrho(K)
# Calculate E_q[alpha * Beta_l] for l = 1, ..., K+1
Ebeta = StickBreakUtil.rho2beta(self.rho)
alphaEBeta = self.transAlpha * Ebeta
# transTheta_kl = M_kl + E_q[alpha * Beta_l] + kappa * 1_{k==l}
transTheta = np.zeros((K, K + 1))
transTheta += alphaEBeta[np.newaxis, :]
transTheta[:K, :K] += SS.TransStateCount + self.kappa * np.eye(self.K)
# startTheta_k = r_1k + E_q[alpha * Beta_l] (where r_1,>K = 0)
startTheta = self.startAlpha * Ebeta
startTheta[:K] += SS.StartStateCount
return transTheta, startTheta
def testHasSaneOutput__objFunc_constrained(self, hmmKappa=10.0):
''' Verify objective and gradient vector have correct type and size
'''
for K in [1, 2, 10]:
for alpha in [0.1, 0.9]:
for seed in [333, 777, 888]:
PRNG = np.random.RandomState(seed)
u = np.linspace(0.1, 0.9, K)
Vd = sampleVd(u, K + 1, alpha, PRNG=PRNG)
sumLogPi = summarizeVdToPi(Vd)
# Randomly initialize rho and omega
rho = PRNG.rand(K)
omega = K * PRNG.rand(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=alpha,
gamma=1,
nDoc=K + 1,
kappa=hmmKappa,
sumLogPi=sumLogPi)
# Compute objective function
# and its gradient (if approximation not occuring)
for approx_grad in [0, 1]:
if approx_grad:
f = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=1, **kwargs)
fapprox = f
else:
f, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
fexact = f
assert isinstance(f, np.float64)
assert np.isfinite(f)
if not approx_grad:
assert g.ndim == 1
assert g.size == 2 * K
assert np.all(np.isfinite(g))
print fexact
print fapprox
print ''
assert np.allclose(fexact, fapprox)
def _convert_beta2rhoomega(self, beta, nDoc=10):
''' Find vectors rho, omega that are probable given beta
Returns
--------
rho : 1D array, size K
omega : 1D array, size K
'''
assert abs(np.sum(beta) - 1.0) < 0.001
rho = OptimizerRhoOmega.beta2rho(beta, self.K)
omega = (nDoc + self.gamma) * np.ones(rho.size)
return rho, omega
def testGradientExactAndApproxAgree__objFunc_constrained(self):
''' Verify computed gradient similar for exact and approx methods
'''
print ''
for K in [1, 10, 107]:
for alpha in [0.1, 0.95]:
for gamma in [1., 3.14, 9.45]:
for seed in [111, 222, 333]:
PRNG = np.random.RandomState(seed)
rho = PRNG.rand(K)
omega = 100 * PRNG.rand(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=alpha,
gamma=gamma,
nDoc=0,
sumLogPi=np.zeros(K + 1))
# Exact gradient
_, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
# Numerical gradient
objFunc_cons = OptimizerRhoOmega.objFunc_constrained
objFunc = lambda x: objFunc_cons(
x, approx_grad=1, **kwargs)
epsvec = np.hstack(
[1e-8 * np.ones(K), 1e-8 * np.ones(K)])
gapprox = approx_fprime(rhoomega, objFunc, epsvec)
print ' rho 1:10 ', np2flatstr(rho)
print ' grad 1:10 ', np2flatstr(g[:K], fmt='% .6e')
print ' grad 1:10 ', np2flatstr(gapprox[:K],
fmt='% .6e')
if K > 10:
print ' rho K-10:K ', np2flatstr(rho[-10:])
print ' grad K-10:K ', np2flatstr(g[K - 10:K],
fmt='% .6e')
print 'gapprox K-10:K ', np2flatstr(gapprox[K -
10:K],
fmt='% .6e')
assert np.allclose(g[:K],
gapprox[:K],
atol=1e-6,
rtol=0.01)
print np2flatstr(g[K:])
print np2flatstr(gapprox[K:])
assert np.allclose(g[K:],
gapprox[K:],
atol=1e-4,
rtol=0.05)
def testGradientZeroAtOptimum__objFunc_unconstrained(self):
''' Verify computed gradient at optimum is indistinguishable from zero
'''
print ''
for K in [1, 10, 107]:
for alpha in [0.1, 0.95]:
for gamma in [1., 3.14, 9.45]:
rho = 1.0 / (1. + gamma) * np.ones(K)
omega = (1 + gamma) * np.ones(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=alpha,
gamma=gamma,
scaleVector=np.hstack(
[np.ones(K), gamma * np.ones(K)]),
nDoc=0,
sumLogPi=np.zeros(K + 1))
c = OptimizerRhoOmega.rhoomega2c(
rhoomega, scaleVector=kwargs['scaleVector'])
f, g = OptimizerRhoOmega.objFunc_unconstrained(
c, approx_grad=0, **kwargs)
print ' rho ', np2flatstr(rho[:K])
print ' grad rho ', np2flatstr(g[:K])
assert np.allclose(g, np.zeros(2 * K))
def testHasSaneOutput__objFunc_constrained(self):
''' Verify objective and gradient vector have correct type and size
'''
for K in [1, 2, 10, 101]:
for seed in [33, 77, 888]:
for alpha in [0.1, 0.9]:
for nDoc in [1, 50, 5000]:
PRNG = np.random.RandomState(seed)
u = np.linspace(0.1, 0.9, K)
Vd = sampleVd(u, nDoc, alpha, PRNG=PRNG)
sumLogPi = summarizeVdToPi(Vd)
rho = PRNG.rand(K)
omega = nDoc * PRNG.rand(K)
for approx_grad in [0, 1]:
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=0.5,
gamma=1,
nDoc=nDoc,
sumLogPi=sumLogPi)
if approx_grad:
f = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=1, **kwargs)
g = np.ones(2 * K)
fapprox = f
else:
f, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
fexact = f
assert isinstance(f, np.float64)
assert g.ndim == 1
assert g.size == 2 * K
assert np.isfinite(f)
assert np.all(np.isfinite(g))
print fexact
print fapprox
print ''
def init_global_params(self, Data, K=0, **initArgs):
''' Initialize rho, omega, and theta to reasonable values.
This is only called by "from scratch" init routines.
'''
self.K = K
self.rho = OptimizerRhoOmega.create_initrho(K)
self.omega = (1.0 + self.gamma) * np.ones(K)
# To initialize theta, perform standard update given rho, omega
# but with "empty" sufficient statistics.
SS = SuffStatBag(K=self.K, D=Data.dim)
SS.setField('StartStateCount', np.ones(K), dims=('K'))
SS.setField('TransStateCount', np.ones((K, K)), dims=('K', 'K'))
self.transTheta, self.startTheta = self._calcTheta(SS)
def testGradientExactAndApproxAgree__objFunc_constrained(
self, hmmKappa=100):
''' Verify computed gradient similar for exact and approx methods
'''
print ''
for K in [1, 2, 10]:
for gamma in [1.0, 2.0, 6.28]:
for alpha in [0.1, 0.9, 1.5]:
for seed in [333, 777, 888]:
PRNG = np.random.RandomState(seed)
u = np.linspace(0.1, 0.9, K)
Vd = sampleVd(u, K + 1, alpha, PRNG=PRNG)
sumLogPi = summarizeVdToPi(Vd)
# Randomly initialize rho and omega
rho = PRNG.rand(K)
omega = K * PRNG.rand(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=alpha,
gamma=1,
nDoc=K + 1,
kappa=hmmKappa,
sumLogPi=sumLogPi)
# Exact gradient
f, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
# Approx gradient
oFunc_cons = OptimizerRhoOmega.objFunc_constrained
def objFunc(x):
return oFunc_cons(x, approx_grad=1, **kwargs)
epsvec = np.hstack(
[1e-8 * np.ones(K), 1e-8 * np.ones(K)])
gapprox = approx_fprime(rhoomega, objFunc, epsvec)
print np2flatstr(g)
print np2flatstr(gapprox)
print ''
assert np.allclose(g, gapprox, atol=0, rtol=0.001)
def testGradientZeroAtOptimum__objFunc_constrained(self):
''' Verify gradient at optimum is indistinguishable from zero
'''
for K in [1, 10, 107]:
for alpha in [0.1, 0.95]:
for gamma in [1., 3.14, 9.45]:
for kappa in [0, 100]:
rho = 1. / (1. + gamma) * np.ones(K)
omega = (1 + gamma) * np.ones(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=alpha,
gamma=gamma,
kappa=kappa,
nDoc=0,
sumLogPi=np.zeros(K + 1))
f, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
print ' rho ', np2flatstr(rho[:K])
print ' grad rho ', np2flatstr(g[:K])
assert np.allclose(g, np.zeros(2 * K))
def testRecoverRhoThatGeneratedData__find_optimum(self):
''' Verify find_optimum's result is indistiguishable from analytic opt
'''
print ''
gamma = 1.0
for K in [93, 107, 85]: # , 10, 107]:
for alpha in [0.9999]:
for nDoc in [10000]:
print '============== K %d | alpha %.2f | nDoc %d' \
% (K, alpha, nDoc)
for seed in [111, 222, 333]:
PRNG = np.random.RandomState(seed)
u_true = np.linspace(0.01, 0.99, K)
Vd = sampleVd(u_true, nDoc, alpha, PRNG=PRNG)
sumLogPi = summarizeVdToPi(Vd)
initrho = PRNG.rand(K)
initomega = 100 * PRNG.rand(K)
scale = 1.0 # float(1+nDoc)/K
kwargs = dict(alpha=alpha,
gamma=gamma,
nDoc=nDoc,
scaleVector=np.hstack([
np.ones(K),
float(scale) * np.ones(K)
]),
sumLogPi=sumLogPi)
rho_est, omega_est, f_est, Info = \
OptimizerRhoOmega.find_optimum_multiple_tries(
initrho=initrho,
initomega=initomega,
**kwargs)
assert np.all(np.isfinite(rho_est))
assert np.all(np.isfinite(omega_est))
assert np.isfinite(f_est)
print Info['msg']
rho_orig = u_true
omega_orig = (1 + gamma) * np.ones(K)
ro_orig = np.hstack([rho_orig, omega_orig])
rho_hot, omega_hot, f_hot, Ihot = \
OptimizerRhoOmega.find_optimum_multiple_tries(
initrho=rho_orig,
initomega=omega_orig,
**kwargs)
f_orig, _ = OptimizerRhoOmega.objFunc_constrained(
ro_orig, **kwargs)
print ' f_orig %.7f' % (f_orig)
print ' f_hot %.7f' % (f_hot)
print ' f_est %.7f' % (f_est)
print ' rho_orig', np2flatstr(rho_orig, fmt='%9.6f')
print ' rho_hot ', np2flatstr(rho_hot, fmt='%9.6f')
print ' rho_est ', np2flatstr(rho_est, fmt='%9.6f')
assert f_hot <= f_orig
assert np.allclose(f_est, f_hot, rtol=0.01)
assert np.allclose(rho_est,
rho_hot,
atol=0.02,
rtol=1e-5)
def testGradientExactAndApproxAgree__sumLogPiRemVec(self):
''' Verify computed gradient similar for exact and approx methods
'''
print ''
for K in [1, 2, 10, 54]:
for alpha in [0.1, 0.95]:
for gamma in [1., 9.45]:
for nDoc in [1, 100, 1000]:
print '============= K %d | nDoc %d | alpha %.2f' \
% (K, nDoc, alpha)
for seed in [111, 222, 333]:
PRNG = np.random.RandomState(seed)
u = np.linspace(0.01, 0.99, K)
Vd = sampleVd(u, nDoc, alpha, PRNG=PRNG)
sumLogPi = summarizeVdToPi(Vd)
sumLogPiRemVec = np.zeros(K)
sumLogPiActiveVec = np.zeros(K)
sumLogPiActiveVec[:] = sumLogPi[:-1]
sumLogPiRemVec[-1] = sumLogPi[-1]
rho = PRNG.rand(K)
omega = 100 * PRNG.rand(K)
rhoomega = np.hstack([rho, omega])
kwargs = dict(alpha=alpha,
gamma=gamma,
nDoc=nDoc,
sumLogPiActiveVec=sumLogPiActiveVec,
sumLogPiRemVec=sumLogPiRemVec)
# Exact gradient
f, g = OptimizerRhoOmega.objFunc_constrained(
rhoomega, approx_grad=0, **kwargs)
# Approx gradient
oFunc_cons = OptimizerRhoOmega.objFunc_constrained
objFunc = lambda x: oFunc_cons(
x, approx_grad=1, **kwargs)
epsvec = np.hstack(
[1e-8 * np.ones(K), 1e-8 * np.ones(K)])
gapprox = approx_fprime(rhoomega, objFunc, epsvec)
print ' rho 1:10 ', np2flatstr(rho)
print ' grad 1:10 ', np2flatstr(g[:K],
fmt='% .6e')
print ' autograd 1:10 ', np2flatstr(gapprox[:K],
fmt='% .6e')
if K > 10:
print ' rho K-10:K ', np2flatstr(rho[-10:])
print ' grad K-10:K ', np2flatstr(
g[K - 10:K], fmt='% .6e')
print 'autograd K-10:K ', np2flatstr(
gapprox[K - 10:K], fmt='% .6e')
rtol_rho = 0.01
atol_rho = 1e-6
rtol_omega = 0.05
atol_omega = 0.01
# Note: small omega derivas cause lots of problems
# so we should use high atol to avoid these issues
assert np.allclose(g[:K],
gapprox[:K],
atol=atol_rho,
rtol=rtol_rho)
oGradOK = np.allclose(g[K:],
gapprox[K:],
atol=atol_omega,
rtol=rtol_omega)
if not oGradOK:
print 'VIOLATION DETECTED!'
print 'grad_approx DOES NOT EQUAL grad_exact'
absDiff = np.abs(g[K:] - gapprox[K:])
tolDiff = (atol_omega +
rtol_omega * np.abs(gapprox[K:]) -
absDiff)
worstIDs = np.argsort(tolDiff)
print 'Top 5 worst mismatches'
print np2flatstr(g[K + worstIDs[:5]],
fmt='% .6f')
print np2flatstr(gapprox[K + worstIDs[:5]],
fmt='% .6f')
assert oGradOK
def f_objFunc(rho, omega, **kwargs):
f, grad = OptimizerRhoOmega.objFunc_constrained(
np.hstack([rho, omega]), **kwargs)
return -1 * kwargs['nDoc'] * f
def find_optimum_rhoOmega(self, **kwargs):
''' Performs numerical optimization of rho and omega for M-step update.
Note that the optimizer forces rho to be in [EPS, 1-EPS] for
the sake of numerical stability
Returns
-------
rho : 1D array, size K
omega : 1D array, size K
Info : dict of information about optimization.
'''
# Calculate expected log transition probability
# using theta vectors for all K states plus initial state
ELogPi = digamma(self.transTheta) \
- digamma(np.sum(self.transTheta, axis=1))[:, np.newaxis]
sumELogPi = np.sum(ELogPi, axis=0)
startELogPi = digamma(self.startTheta) \
- digamma(np.sum(self.startTheta))
# Select initial rho, omega values for gradient descent
if hasattr(self, 'rho') and self.rho.size == self.K:
initRho = self.rho
else:
initRho = None
if hasattr(self, 'omega') and self.omega.size == self.K:
initOmega = self.omega
else:
initOmega = None
# Do the optimization
try:
rho, omega, fofu, Info = \
OptimizerRhoOmega.find_optimum_multiple_tries(
sumLogPi=sumELogPi,
sumLogPiActiveVec=None,
sumLogPiRemVec=None,
startAlphaLogPi=self.startAlpha * startELogPi,
nDoc=self.K + 1,
gamma=self.gamma,
alpha=self.transAlpha,
kappa=self.kappa,
initrho=initRho,
initomega=initOmega)
self.OptimizerInfo = Info
self.OptimizerInfo['fval'] = fofu
except ValueError as error:
if hasattr(self, 'rho') and self.rho.size == self.K:
Log.error(
'***** Optim failed. Remain at cur val. ' +
str(error))
rho = self.rho
omega = self.omega
else:
Log.error('***** Optim failed. Set to prior. ' + str(error))
omega = (self.gamma + 1) * np.ones(SS.K)
rho = 1 / float(1 + self.gamma) * np.ones(SS.K)
return rho, omega
