def test_8():
#"Sample from a VMHMM and then fit to it"
n_states = 2
vm = VonMisesHMM(n_states=n_states)
means = np.array([[0, 0, 0], [np.pi, np.pi, np.pi]])
kappas = np.array([[1, 2, 3], [2, 3, 4]])
transmat = np.array([[0.9, 0.1], [0.1, 0.9]])
vm.means_ = means
vm.kappas_ = kappas
vm.transmat_ = transmat
x, s = vm.sample(1000)
vm = VonMisesHMM(n_states=2)
vm.fit([x])
mappingcost = np.zeros((n_states, n_states))
for i in range(n_states):
for j in range(n_states):
mappingcost[i, j] = np.sum(
circwrap(vm.means_[i, :] - means[j, :])**2)
mapping = Munkres().compute(mappingcost)
means_ = np.array([vm.means_[j, :] for i, j in mapping])
kappas_ = np.array([vm.kappas_[j, :] for i, j in mapping])
transmat_ = vm.transmat_
print('means\n', means, '\nmeans_\n', means_)
print('kappas\n', kappas, '\nkappas_\n', kappas_)
print('transmat\n', transmat, '\ntransmat_\n', transmat_)
#vm.score(x)
assert np.all(np.abs(kappas - kappas_) < 0.5)
assert np.all(circwrap(means - means_) < 0.25)
def fit(self, data, n_states, lag_time, outfile):
model = VonMisesHMM(n_states=n_states,
reversible_type=self.args.reversible_type,
n_iter=self.args.n_em_iter, thresh=self.args.thresh)
start = time.time()
model.fit(data)
end = time.time()
result = {
'model': 'VonMisesHMM',
'timescales': (model.timescales_() * lag_time).tolist(),
'transmat': model.transmat_.tolist(),
'populations': model.populations_.tolist(),
'n_states': model.n_states,
'split': self.args.split,
'train_lag_time': lag_time,
'train_time': end - start,
'means': model.means_.tolist(),
'kappas': model.kappas_.tolist(),
'train_logprobs': model.fit_logprob_,
'n_train_observations': sum(len(t) for t in data),
}
if not np.all(np.isfinite(model.transmat_)):
print('Nonfinite numbers in transmat !!')
json.dump(result, outfile)
outfile.write('\n')
def fit(self, data, n_states, lag_time, outfile):
model = VonMisesHMM(n_states=n_states,
reversible_type=self.args.reversible_type,
n_iter=self.args.n_em_iter,
thresh=self.args.thresh)
start = time.time()
model.fit(data)
end = time.time()
result = {
'model': 'VonMisesHMM',
'timescales': (model.timescales_() * lag_time).tolist(),
'transmat': model.transmat_.tolist(),
'populations': model.populations_.tolist(),
'n_states': model.n_states,
'split': self.args.split,
'train_lag_time': lag_time,
'train_time': end - start,
'means': model.means_.tolist(),
'kappas': model.kappas_.tolist(),
'train_logprobs': model.fit_logprob_,
'n_train_observations': sum(len(t) for t in data),
}
if not np.all(np.isfinite(model.transmat_)):
print('Nonfinite numbers in transmat !!')
json.dump(result, outfile)
outfile.write('\n')
def test_8():
#"Sample from a VMHMM and then fit to it"
n_states = 2
vm = VonMisesHMM(n_states=n_states)
means = np.array([[0, 0, 0], [np.pi, np.pi, np.pi]])
kappas = np.array([[1, 2, 3], [2, 3, 4]])
transmat = np.array([[0.9, 0.1], [0.1, 0.9]])
vm.means_ = means
vm.kappas_ = kappas
vm.transmat_ = transmat
x, s = vm.sample(1000)
vm = VonMisesHMM(n_states=2)
vm.fit([x])
mappingcost = np.zeros((n_states, n_states))
for i in range(n_states):
for j in range(n_states):
mappingcost[i, j] = np.sum(circwrap(vm.means_[i, :] - means[j, :])**2)
mapping = Munkres().compute(mappingcost)
means_ = np.array([vm.means_[j, :] for i, j in mapping])
kappas_ = np.array([vm.kappas_[j, :] for i, j in mapping])
transmat_ = vm.transmat_
print('means\n', means, '\nmeans_\n', means_)
print('kappas\n', kappas, '\nkappas_\n', kappas_)
print('transmat\n', transmat, '\ntransmat_\n', transmat_)
#vm.score(x)
assert np.all(np.abs(kappas - kappas_) < 0.5)
assert np.all(circwrap(means - means_) < 0.25)
def test_log_likelihood():
n_samples, n_states, n_features = 1000, 27, 16
obs = np.random.rand(n_samples, n_features)
vm = VonMisesHMM(n_states=n_states)
vm.fit([obs])
t0 = time.time()
from scipy.stats.distributions import vonmises
reference = np.array([np.sum(vonmises.logpdf(obs, vm.kappas_[i], vm.means_[i]), axis=1) for i in range(n_states)]).T
t1 = time.time()
value = _vmhmm._compute_log_likelihood(obs, vm.means_, vm.kappas_)
t2 = time.time()
print("Log likeihood timings")
print('reference time ', t1-t0)
print('c time ', t2-t1)
np.testing.assert_array_almost_equal(reference, value)
def test_log_likelihood():
n_samples, n_states, n_features = 1000, 27, 16
obs = np.random.rand(n_samples, n_features)
vm = VonMisesHMM(n_states=n_states)
vm.fit([obs])
t0 = time.time()
from scipy.stats.distributions import vonmises
reference = np.array([
np.sum(vonmises.logpdf(obs, vm.kappas_[i], vm.means_[i]), axis=1)
for i in range(n_states)
]).T
t1 = time.time()
value = _vmhmm._compute_log_likelihood(obs, vm.means_, vm.kappas_)
t2 = time.time()
print("Log likeihood timings")
print('reference time ', t1 - t0)
print('c time ', t2 - t1)
np.testing.assert_array_almost_equal(reference, value)
def test_6():
""""Test that _c_fitkappa is consistent with the two-step python
implementation"""
np.random.seed(42)
vm = VonMisesHMM(n_states=13)
kappas = np.random.randn(13, 7)
posteriors = np.random.randn(100, 13)
obs = np.random.randn(100, 7)
means = np.random.randn(13, 7)
vm.kappas_ = kappas
vm._c_fitkappas(posteriors, obs, means)
c_kappas = np.copy(vm._kappas_)
vm._py_fitkappas(posteriors, obs, means)
py_kappas = np.copy(vm._kappas_)
np.testing.assert_array_almost_equal(py_kappas, c_kappas)
def test_6():
""""Test that _c_fitkappa is consistent with the two-step python
implementation"""
np.random.seed(42)
vm = VonMisesHMM(n_states=13)
kappas = np.random.randn(13, 7)
posteriors = np.random.randn(100, 13)
obs = np.random.randn(100, 7)
means = np.random.randn(13, 7)
vm.kappas_ = kappas
vm._c_fitkappas(posteriors, obs, means)
c_kappas = np.copy(vm._kappas_)
vm._py_fitkappas(posteriors, obs, means)
py_kappas = np.copy(vm._kappas_)
np.testing.assert_array_almost_equal(py_kappas, c_kappas)
print("Reading from web: day=%d/12" % day)
# KDSM is the airport code in Des Moines, IA
df = load_weather("KDSM", day=day)
df = df[["DateUTC", "WindDirDegrees"]]
dfs.append(df)
df = pd.concat(dfs)
# Reshape to [n_samples, n_features=1], change to radians
X = df["WindDirDegrees"].values.reshape(-1, 1) * (np.pi / 180)
# ------------------------------------------------------------------------
# Fit model
# ------------------------------------------------------------------------
n_components = 3
model = VonMisesHMM(n_components, n_iter=1000)
model.fit([X])
hidden_states = model.predict(X)
# ------------------------------------------------------------------------
# Plot Results
# ------------------------------------------------------------------------
pp.figure(figsize=(12, 6))
c = itertools.cycle(["r", "g", "b"])
for i in range(n_components):
idx = hidden_states == i
pp.plot_date(
date2num(df["DateUTC"][idx]), df["WindDirDegrees"][idx], "o", c=next(c), label="%dth state" % i, xdate=True
)
pp.ylim(-10, 370)
def test_1():
vm = VonMisesHMM(n_states=5)
gm = GaussianHMM(n_components=5)
X1 = np.random.randn(100,2)
yield lambda: vm.fit([X1])
yield lambda: gm.fit([X1])
def test_1():
vm = VonMisesHMM(n_states=5)
gm = GaussianHMM(n_components=5)
X1 = np.random.randn(100, 2)
yield lambda: vm.fit([X1])
yield lambda: gm.fit([X1])
