def test_fit(self, params='stmwc', niter=5, **kwargs): h = hmm.GMMHMM(self.nstates, self.ndim) h.startprob = self.startprob h.transmat = hmm.normalize(self.transmat + np.diag(np.random.rand(self.nstates)), 1) h.gmms = self.gmms # Create a training and testing set by sampling from the same # distribution. train_obs = [h.rvs(n=10) for x in xrange(50)] test_obs = [h.rvs(n=10) for x in xrange(5)] # Mess up the parameters and see if we can re-learn them. h.fit(train_obs, niter=0, minit='points') h.transmat = hmm.normalize(np.random.rand(self.nstates, self.nstates), axis=1) h.startprob = hmm.normalize(np.random.rand(self.nstates)) init_testll = [h.lpdf(x) for x in test_obs] trainll = h.fit(train_obs, niter=niter, params=params, **kwargs) if not np.all(np.diff(trainll) > 0): print print 'Test train: (%s)\n %s\n %s' % (params, trainll, np.diff(trainll)) self.assertTrue(np.all(np.diff(trainll) > -0.5)) post_testll = [h.lpdf(x) for x in test_obs] if not (np.sum(post_testll) > np.sum(init_testll)): print print 'Test train: (%s)\n %s\n %s' % (params, init_testll, post_testll) self.assertTrue(np.sum(post_testll) > np.sum(init_testll))
def test_fit(self, params='ste', niter=5, **kwargs): h = hmm.MultinomialHMM(self.nstates, self.nsymbols, startprob=self.startprob, transmat=self.transmat, emissionprob=self.emissionprob) # Create a training and testing set by sampling from the same # distribution. train_obs = [h.rvs(n=10) for x in xrange(50)] test_obs = [h.rvs(n=10) for x in xrange(5)] # Mess up the parameters and see if we can re-learn them. h.startprob = hmm.normalize(np.random.rand(self.nstates)) h.transmat = hmm.normalize(np.random.rand(self.nstates, self.nstates), axis=1) h.emissionprob = hmm.normalize( np.random.rand(self.nstates, self.nsymbols), axis=1) init_testll = [h.lpdf(x) for x in test_obs] trainll = h.fit(train_obs, niter=niter, params=params, **kwargs) if not np.all(np.diff(trainll) > 0): print print 'Test train: (%s)\n %s\n %s' % (params, trainll, np.diff(trainll)) self.assertTrue(np.all(np.diff(trainll) > 0)) post_testll = [h.lpdf(x) for x in test_obs] if not (np.sum(post_testll) > np.sum(init_testll)): print print 'Test train: (%s)\n %s\n %s' % (params, init_testll, post_testll) self.assertTrue(np.sum(post_testll) > np.sum(init_testll))
def test_fit_with_priors(self, params="stmc", n_iter=10, verbose=False): startprob_prior = 10 * self.startprob + 2.0 transmat_prior = 10 * self.transmat + 2.0 means_prior = self.means means_weight = 2.0 covars_weight = 2.0 if self.cvtype in ("full", "tied"): covars_weight += self.n_features covars_prior = self.covars[self.cvtype] h = hmm.GaussianHMM(self.n_components, self.cvtype) h.startprob = self.startprob h.startprob_prior = startprob_prior h.transmat = hmm.normalize(self.transmat + np.diag(self.prng.rand(self.n_components)), 1) h.transmat_prior = transmat_prior h.means = 20 * self.means h.means_prior = means_prior h.means_weight = means_weight h.covars = self.covars[self.cvtype] h.covars_prior = covars_prior h.covars_weight = covars_weight # Create training data by sampling from the HMM. train_obs = [h.rvs(n=10) for x in xrange(10)] # Mess up the parameters and see if we can re-learn them. h.fit(train_obs[:1], n_iter=0) trainll = train_hmm_and_keep_track_of_log_likelihood(h, train_obs, n_iter=n_iter, params=params)[1:] if not np.all(np.diff(trainll) > 0) and verbose: print print ("Test MAP train: %s (%s)\n %s\n %s" % (self.cvtype, params, trainll, np.diff(trainll))) self.assertTrue(np.all(np.diff(trainll) > -0.5))
def test_fit(self, params="ste", n_iter=15, verbose=False, **kwargs): np.random.seed(0) h = hmm.MultinomialHMM(self.n_components, startprob=self.startprob, transmat=self.transmat) h.emissionprob = self.emissionprob # Create training data by sampling from the HMM. train_obs = [h.rvs(n=10) for x in xrange(10)] # Mess up the parameters and see if we can re-learn them. h.startprob = hmm.normalize(self.prng.rand(self.n_components)) h.transmat = hmm.normalize(self.prng.rand(self.n_components, self.n_components), axis=1) h.emissionprob = hmm.normalize(self.prng.rand(self.n_components, self.n_symbols), axis=1) trainll = train_hmm_and_keep_track_of_log_likelihood(h, train_obs, n_iter=n_iter, params=params, **kwargs)[1:] if not np.all(np.diff(trainll) > 0) and verbose: print print "Test train: (%s)\n %s\n %s" % (params, trainll, np.diff(trainll)) self.assertTrue(np.all(np.diff(trainll) > 0))
def test_fit(self, params="stmwc", n_iter=5, verbose=False, **kwargs): h = hmm.GMMHMM(self.n_components) h.startprob = self.startprob h.transmat = hmm.normalize(self.transmat + np.diag(self.prng.rand(self.n_components)), 1) h.gmms = self.gmms # Create training data by sampling from the HMM. train_obs = [h.rvs(n=10, random_state=self.prng) for x in xrange(10)] # Mess up the parameters and see if we can re-learn them. h.fit(train_obs, n_iter=0) h.transmat = hmm.normalize(self.prng.rand(self.n_components, self.n_components), axis=1) h.startprob = hmm.normalize(self.prng.rand(self.n_components)) trainll = train_hmm_and_keep_track_of_log_likelihood( h, train_obs, n_iter=n_iter, params=params, covars_prior=1.0, **kwargs )[1:] if not np.all(np.diff(trainll) > 0) and verbose: print print "Test train: (%s)\n %s\n %s" % (params, trainll, np.diff(trainll)) self.assertTrue(np.all(np.diff(trainll) > -0.5))
def create_random_gmm(nmix, ndim, cvtype): from scikits.learn import gmm means = np.random.randint(-20, 20, (nmix, ndim)) mincv = 2 covars = {'spherical': (1.0 + mincv * np.random.rand(nmix))**2, 'tied': _generate_random_spd_matrix(ndim) + mincv * np.eye(ndim), 'diag': (1.0 + mincv * np.random.rand(nmix, ndim))**2, 'full': np.array([_generate_random_spd_matrix(ndim) + mincv * np.eye(ndim) for x in xrange(nmix)])}[cvtype] weights = hmm.normalize(np.random.rand(nmix)) return gmm.GMM(nmix, ndim, cvtype=cvtype, weights=weights, means=means, covars=covars)
def create_random_gmm(n_mix, n_features, cvtype, prng=prng): from scikits.learn import mixture g = mixture.GMM(n_mix, cvtype=cvtype) g.means = prng.randint(-20, 20, (n_mix, n_features)) mincv = 0.1 g.covars = { "spherical": (mincv + mincv * prng.rand(n_mix)) ** 2, "tied": (make_spd_matrix(n_features, random_state=prng) + mincv * np.eye(n_features)), "diag": (mincv + mincv * prng.rand(n_mix, n_features)) ** 2, "full": np.array( [make_spd_matrix(n_features, random_state=prng) + mincv * np.eye(n_features) for x in xrange(n_mix)] ), }[cvtype] g.weights = hmm.normalize(prng.rand(n_mix)) return g
def test_fit(self, params="stmc", n_iter=25, verbose=False, **kwargs): np.random.seed(0) h = hmm.GaussianHMM(self.n_components, self.cvtype) h.startprob = self.startprob h.transmat = hmm.normalize(self.transmat + np.diag(self.prng.rand(self.n_components)), 1) h.means = 20 * self.means h.covars = self.covars[self.cvtype] # Create training data by sampling from the HMM. train_obs = [h.rvs(n=10) for x in xrange(10)] # Mess up the parameters and see if we can re-learn them. h.fit(train_obs, n_iter=0) trainll = train_hmm_and_keep_track_of_log_likelihood(h, train_obs, n_iter=n_iter, params=params, **kwargs)[1:] if not np.all(np.diff(trainll) > 0) and verbose: print print ("Test train: %s (%s)\n %s\n %s" % (self.cvtype, params, trainll, np.diff(trainll))) delta_min = np.diff(trainll).min() self.assertTrue( delta_min > -0.8, "The min nll increase is %f which is lower than the admissible" " threshold of %f, for model %s. The likelihoods are %s." % (delta_min, -0.8, self.cvtype, trainll), )