def test_time_correct_M(hmm1, hmm2, hmm3):
M = zeros((hmm1.N, hmm1.N))
k = 1
p = 1. / hmm1.N
timecall("HMM.correct_M ", hmm1.correct_M, M, k, p)
timecall("HMM_F.correct_M ", hmm2.correct_M, M, k, p)
timecall("HMM_C.CorretM ", hmm3.correct_M, M, k, p)
def test_time_ksi(hmm1, hmm2, hmm3, observation):
Bo = take(hmm1.B, observation, 0)
alpha, scale_factors = hmm3.alpha_scaled(hmm3.A, Bo, hmm3.pi)
beta = hmm3.beta_scaled(hmm3.A, Bo, scale_factors)
timecall("HMM.ksi ", hmm1.ksi, hmm1.A, Bo, alpha, beta)
timecall("HMM_F.ksi ", hmm2.ksi, hmm2.A, Bo, alpha, beta)
timecall("HMM_C.ksi ", hmm3.ksi, hmm3.A, Bo, alpha, beta)
def time_alphabeta(size_states, size_observations, op="alpha"): # by size here I mean the size of the space (hidden state space and observation space AKA "alphabet")
S = range(size_states)
O = range(size_observations)
OBS = range(size_observations)*4
shuffle(OBS)
test = HMM( S, O )
test.random_initialisation()
print OBS
print test
test1 = HMM( S, O, test.A, test.B, test.pi )
bo = take( test.B, OBS, 0 )
print "bo = take( test.B, OBS, 0 )"
print str(bo)
print "A.shape = ", test.A.shape
print "bo.shape = ", bo.shape
a1, s1 = test1.alpha_scaled( test.A, bo, test.pi )
print "a1,s1",a1,s1
print "s1.shape = ", s1.shape
if op == "alpha": timecall( "alpha scaled ", test1.alpha_scaled, (test.A, bo, test.pi) )
else: timecall( "beta scaled ", test1.beta_scaled, (test.A, bo, s1) )
def test_time_beta(hmm1, hmm2, hmm3, observation):
Bo = take(hmm1.B, observation, 0)
alpha, scale_factors = hmm3.alpha_scaled(hmm3.A, Bo, hmm3.pi)
timecall("HMM.beta_scaled ", hmm1.beta_scaled, hmm1.A, Bo,
scale_factors)
timecall("HMM_F.beta_scaled ", hmm2.beta_scaled, hmm2.A, Bo,
scale_factors)
timecall("HMM_C.beta_scaled ", hmm3.beta_scaled, hmm3.A, Bo,
scale_factors)
def test_time_update_iter_B(hmm1, hmm2, hmm3, observation):
Bo = take(hmm1.B, observation, 0)
obs_ind = hmm3._get_observationIndices(observation)
alpha, scale_factors = hmm3.alpha_scaled(hmm3.A, Bo, hmm3.pi)
beta = hmm3.beta_scaled(hmm3.A, Bo, scale_factors)
gamma = hmm3._gamma(alpha, beta, scale_factors)
B1 = zeros((hmm1.M, hmm1.N), float, order=hmm1.ORDER)
B2 = zeros((hmm2.M, hmm2.N), float, order=hmm2.ORDER)
B3 = zeros((hmm3.M, hmm3.N), float, order=hmm3.ORDER)
timecall("HMM.update_iter_B ", hmm1.update_iter_B, gamma, obs_ind, B1)
timecall("HMM_F.update_iter_B ", hmm2.update_iter_B, gamma, obs_ind, B2)
timecall("HMM_C.update_iter_B ", hmm3.update_iter_B, gamma, obs_ind, B3)
def test_time_alpha():
S = range(20)
O = range(40)
OBS = range(40) * 4
test = HMM(S, O)
test.set_random_proba()
test1 = HMM(S, O, test.A, test.B, test.pi)
test2 = HMM_F(S, O, test.A, test.B, test.pi)
test3 = HMM_C(S, O, test.A, test.B, test.pi)
bo = take(test.B, OBS, 0)
timecall("HMM.alpha_scaled ", test1.alpha_scaled, test.A, bo, test.pi)
timecall("HMM_F.alpha_scaled", test2.alpha_scaled, test.A, bo, test.pi)
timecall("HMM_C.alpha_scaled", test3.alpha_scaled, test.A, bo, test.pi)
def test_time_beta():
S = range(40)
O = range(80)
OBS = range(80) * 4
test = HMM(S, O)
test.set_random_proba()
test1 = HMM(S, O, test.A, test.B, test.pi)
test2 = HMM_F(S, O, test.A, test.B, test.pi)
test3 = HMM_C(S, O, test.A, test.B, test.pi)
bo = take(test.B, OBS, 0)
a1, s1 = test1.alpha_scaled(test.A, bo, test.pi)
print "A.shape = ", test.A.shape
print "bo.shape = ", bo.shape
print "s1.shape = ", s1.shape
timecall("HMM.beta_scaled ", test1.beta_scaled, test.A, bo, s1)
timecall("HMM_F.beta_scaled ", test2.beta_scaled, test.A, bo, s1)
timecall("HMM_C.beta_scaled ", test3.beta_scaled, test.A, bo, s1)
def test_time_multiple_learn(hmm1, hmm2, hmm3, chains):
timecall("HMM.multiple_learn ", hmm1.multiple_learn, chains, 1000, 0)
timecall("HMM_F.multiple_learn", hmm2.multiple_learn, chains, 1000, 0)
timecall("HMM_C.multiple_learn", hmm3.multiple_learn, chains, 1000, 0)
def test_time_learn(hmm1, hmm2, hmm3, obs):
timecall("HMM.learn ", hmm1.learn, obs, 1000, 0)
timecall("HMM_F.learn ", hmm2.learn, obs, 1000, 0)
timecall("HMM_C.learn ", hmm3.learn, obs, 1000, 0)
def test_time_analyze_log(hmm1, hmm2, hmm3, obs):
timecall("HMM.analyze_log ", hmm1.analyze_log, obs)
timecall("HMM_F.analyze_log ", hmm2.analyze_log, obs)
timecall("HMM_C.analyze_log ", hmm3.analyze_log, obs)
def test_time_normalize_B(hmm1, hmm2, hmm3):
SGB = 2 * ones(hmm1.N)
B_bar = ones((hmm1.M, hmm1.N))
timecall("HMM.normalize_B ", hmm1.normalize_B, B_bar, SGB)
timecall("HMM_F.normalize_B ", hmm2.normalize_B, B_bar, SGB)
timecall("HMM_C.normalize_B ", hmm3.normalize_B, B_bar, SGB)
def test_time_alpha(hmm1, hmm2, hmm3, observation):
bo = take(hmm1.B, observation, 0)
timecall("HMM.alpha_scaled ", hmm1.alpha_scaled, hmm1.A, bo, hmm1.pi)
timecall("HMM_F.alpha_scaled ", hmm2.alpha_scaled, hmm2.A, bo, hmm2.pi)
timecall("HMM_C.alpha_scaled ", hmm3.alpha_scaled, hmm3.A, bo, hmm3.pi)
