def test8_helper(num_obs, num_passes):
"""
This tests mimics a run ChrisW did with HTK. The models are 2-D single-mode Gaussians embedded
in a 3-state Hmm. Each observation is a sequence of length 11, taken by sampling 2, 3, and 6
times, respectively, from three target distributions. This is identical to test5 except that
here I have built the Hmm with only one Gmm, which is shared by all three states.
"""
import pprint
num_states = 3
dimension = 2
# Data generator setup
target_means = ((1,1), (2,2), (3,3))
target_vars = ((0.1,0.1), (0.2,0.2), (0.3,0.3))
target_durations = (2, 3, 6)
num_steps = sum(target_durations)
generators = [SimpleGaussianModel(dimension, SimpleGaussianModel.DIAGONAL_COVARIANCE) for i in xrange(num_states)]
[m.set_model(tm, tv) for (m, tm, tv) in izip(generators, target_means, target_vars)]
SimpleGaussianModel.seed(0)
# Gmm setup
num_states = 3
gmm = GaussianMixtureModel(dimension, GaussianMixtureModel.DIAGONAL_COVARIANCE, 1)
gmm.set_weights(array((1.0,)))
mu = array(((0.0,0.0),))
v = array(((1.0,1.0),))
gmm.set_model(mu, v)
models = (gmm,)
mm = GmmMgr(models)
# Here's where we're using the same Gmm in all three states of this Hmm.
models = (0, 0, 0)
# Hmm setup
trans = array(((0.0, 1.0, 0.0, 0.0, 0.0),
(0.0, 0.5, 0.5, 0.0, 0.0),
(0.0, 0.0, 0.5, 0.5, 0.0),
(0.0, 0.0, 0.0, 0.5, 0.5),
(0.0, 0.0, 0.0, 0.0, 0.0)))
hmm0 = Hmm(num_states, log_domain=True)
hmm0.build_model(mm, models, 1, 1, trans)
print hmm0.to_string(True)
for p in xrange(num_passes):
# Reseeding here ensures we are repeating the same observations in each pass
SimpleGaussianModel.seed(0)
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
obs_gen = obs_generator(generators, target_durations)
for i in xrange(num_obs):
obs = obs_gen.next()
hmm0.adapt_one_sequence(obs)
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
print hmm0.to_string(True)
def test6():
"""
This test builds an Hmm with dummy models which always give a score of 1, but
with a somewhat unusual topology in which there are 6 actual states chained together
with 2 virtual inputs and 3 virtual outputs. The point is to make sure we can handle
this asymetric case correctly.
"""
import pprint
num_states = 6
dimension = 2
# GmmMgr setup
models = []
for i in xrange(num_states):
dm = DummyModel(dimension, 1.0)
models.append(dm)
mm = GmmMgr(models)
models = range(num_states)
# Hmm setup T0: i1 i2 1 2 3 4 5 6 o1 o2 o3 FROM:
trans = array(((0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), # i1
(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), # i2
(0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), # 1
(0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), # 2
(0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0), # 3
(0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.4, 0.0, 0.1, 0.0, 0.0), # 4
(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.4, 0.0, 0.1, 0.0), # 5
(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.5), # 6
(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), # o1
(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), # o2
(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0))) # o3
hmm0 = Hmm(num_states, log_domain=True)
hmm0.build_model(mm, models, 2, 3, trans)
print hmm0.to_string(True)
num_passes = 1
for p in xrange(num_passes):
# Reseeding here ensures we are repeating the same observations in each pass
SimpleGaussianModel.seed(0)
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
obs = [array((0,0))] * 11 # Dummy sequence of length 11
hmm0.adapt_one_sequence(obs)
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
print hmm0.to_string(True)
def test2a(num_obs, num_passes):
dimension = 2
# Data generator setup
target_means = (1,1)
target_vars = (0.1,0.1)
generator = SimpleGaussianModel(dimension, SimpleGaussianModel.DIAGONAL_COVARIANCE)
generator.set_model(target_means, target_vars)
SimpleGaussianModel.seed(0)
data = [generator.sample() for i in xrange(num_obs)]
# Gmm setup
num_mixtures = 2
gmm0 = make_gmm_diag(dimension, num_mixtures)
gmm1 = make_gmm_diag(dimension, num_mixtures)
mm = GmmMgr((gmm1,))
# Hmm setup
# A transition probability matrix with a p ~= 1 self-loop for the real state.
# The entry state feeds into the real state with p=1. We use p ~= 1 for the
# second self loop since we need *some* probability of finishing.
trans = array(((0.0, 1.0, 0.0),
(0.0, 0.999999999999, 0.000000000001),
(0.0, 0.0, 0.0)))
hmm0 = Hmm(1, log_domain=True)
hmm0.build_model(mm, (0,), 1, 1, trans)
print hmm0.to_string(True) + '\n'
print gmm0
print '\n\n'
# Try some adaptation
for p in xrange(num_passes):
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
hmm0.adapt_one_sequence(data)
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
really_print = False
with DebugPrint("gaussian", "gaussian_pt", "gaussian_gmm_score") if really_print else DebugPrint():
gmm0.adapt(data, max_iters = num_passes)
print hmm0.to_string(True) + '\n'
print gmm0
def test1(num_obs, num_passes):
dimension = 2
# Data generator setup
target_means = (1,1)
target_vars = (0.1,0.1)
generator = SimpleGaussianModel(dimension, SimpleGaussianModel.DIAGONAL_COVARIANCE)
generator.set_model(target_means, target_vars)
SimpleGaussianModel.seed(0)
GaussianMixtureModel.seed(0)
# Gmm setup
num_mixtures = 2
gmm0 = make_gmm(dimension, num_mixtures)
gmm1 = make_gmm(dimension, num_mixtures)
mm = GmmMgr((gmm1,))
# Hmm setup
hmm0 = Hmm(1, log_domain=True)
# A transition probability matrix with a p=1/2 exit for the real state.
# The entry state feeds into the real state with p=1.
trans = array(((0.0, 1.0, 0.0),
(0.0, 0.5, 0.5),
(0.0, 0.0, 0.0)))
hmm0.build_model(mm, (0,), 1, 1, trans)
print hmm0.to_string(True)
print gmm0
# Try some adaptation. Note that we are feeding the entire data set as one stream
# to the Hmm adaption call.
data = [generator.sample() for i in xrange(num_obs)]
for p in xrange(num_passes):
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
hmm0.adapt_one_sequence(data)
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
gmm0.adapt(data, max_iters = num_passes)
print hmm0.to_string(True)
print gmm0
def test3_helper(dataset_idx, num_passes):
"""
This tests mimics a run ChrisW did with HTK. The models are 2-D single-mode Gaussians
embedded in a 1-state Hmm. Each data point is taken as a sequence of length 1.
"""
dimension = 2
# Gmm setup
gmm = GaussianMixtureModel(dimension, GaussianMixtureModel.DIAGONAL_COVARIANCE, 1)
gmm.set_weights(array((1.0,)))
mu = array(((0.0,0.0),))
v = array(((1.0,1.0),))
gmm.set_model(mu, v)
mm = GmmMgr((gmm,))
# Hmm setup
# A transition probability matrix with a p=1 self-loop for the real state.
# The entry state feeds into the real state with p=1.
trans = array(((0.0, 1.0, 0.0),
(0.0, 0.0, 1.0),
(0.0, 0.0, 0.0)))
hmm0 = Hmm(1, log_domain=True)
hmm0.build_model(mm, (0,), 1, 1, trans)
print hmm0.to_string(True)
# adaptation
data = datasets[dataset_idx]
for p in xrange(num_passes):
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
for point in data:
s = array(point)
# We treat each point as an entire sequence
hmm0.adapt_one_sequence((s,))
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
print hmm0.to_string(True)
def test0(num_obs, num_passes):
dimension = 2
# Data generator setup
target_means = (1,1)
target_vars = (0.1,0.1)
generator = SimpleGaussianModel(dimension, SimpleGaussianModel.DIAGONAL_COVARIANCE)
generator.set_model(target_means, target_vars)
SimpleGaussianModel.seed(0)
GaussianMixtureModel.seed(0)
mm = GmmMgr(dimension)
# Hmm setup
hmm0 = Hmm(0, log_domain=True)
# A transition probability matrix with no real state.
# The entry state feeds into the exit state with p=1.
trans = array(((0.0, 1.0),
(0.0, 0.0)))
hmm0.build_model(mm, (), 1, 1, trans)
print hmm0.to_string(True)
# Try some adaptation. Note that we are feeding the entire data set as one stream
# to the Hmm adaption call.
data = [generator.sample() for i in xrange(num_obs)]
for p in xrange(num_passes):
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
with DebugPrint("hmm_gxfs", "hmm_aos") if False else DebugPrint():
hmm0.adapt_one_sequence(data)
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
print hmm0.to_string(True)
def test5_helper(num_obs, num_passes):
"""
This tests mimics a run ChrisW did with HTK. The models are 2-D single-mode Gaussians
embedded in a 3-state Hmm. Each observation is a sequence of length 11, taken by sampling
2, 3, and 6 times, respectively, from three target distributions.
"""
import pprint
num_states = 3
dimension = 2
# Data generator setup
target_means = ((1,1), (2,2), (3,3))
target_vars = ((0.1,0.1), (0.2,0.2), (0.3,0.3))
target_durations = (2, 3, 6)
num_steps = sum(target_durations)
generators = [SimpleGaussianModel(dimension, SimpleGaussianModel.DIAGONAL_COVARIANCE) for i in xrange(num_states)]
[m.set_model(tm, tv) for (m, tm, tv) in izip(generators, target_means, target_vars)]
SimpleGaussianModel.seed(0)
# Gmm setup
num_states = 3
models = []
for i in xrange(num_states):
gmm = GaussianMixtureModel(dimension, GaussianMixtureModel.DIAGONAL_COVARIANCE, 1)
gmm.set_weights(array((1.0,)))
mu = array(((0.0,0.0),))
v = array(((1.0,1.0),))
gmm.set_model(mu, v)
models.append(gmm)
mm = GmmMgr(models)
models = range(num_states)
# Hmm setup
trans = array(((0.0, 1.0, 0.0, 0.0, 0.0),
(0.0, 0.5, 0.5, 0.0, 0.0),
(0.0, 0.0, 0.5, 0.5, 0.0),
(0.0, 0.0, 0.0, 0.5, 0.5),
(0.0, 0.0, 0.0, 0.0, 0.0)))
hmm0 = Hmm(num_states, log_domain=True)
hmm0.build_model(mm, models, 1, 1, trans)
print hmm0.to_string(True)
for p in xrange(num_passes):
# Reseeding here ensures we are repeating the same observations in each pass
SimpleGaussianModel.seed(0)
mm.set_adaptation_state("INITIALIZING")
mm.clear_all_accumulators()
hmm0.begin_adapt("STANDALONE")
mm.set_adaptation_state("ACCUMULATING")
obs_gen = obs_generator(generators, target_durations)
for i in xrange(num_obs):
obs = obs_gen.next()
hmm0.adapt_one_sequence(obs)
obs2 = [tuple(a) for a in obs]
# Uncomment these lines to show observations as nicely formatted sequences; this
# is what I gave ChrisW to use with his HTK runs.
# pprint.pprint(obs2)
# print
mm.set_adaptation_state("APPLYING")
hmm0.end_adapt()
mm.apply_all_accumulators()
mm.set_adaptation_state("NOT_ADAPTING")
print hmm0.to_string(True)
