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 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)
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])