Python BaseTest.extract_sample_state Exemples

Exemple #1

Fichier : unit_hmh.py Projet : andreas-koukorinis/KS_iMGPE

	def test_singleton_phi_modified(self):
		x, y, _ = BaseTest.get_data()
		imgpe = iMGPE(x, y, initial_k=6, initial_gating_phi=0.1)
		BaseTest.divide_data(imgpe, singleton=True)
		BaseTest.prepare_kernels(imgpe)

		pre_c, pre_class_indices, pre_param_vals = BaseTest.extract_sample_state(imgpe)
		pre_priors = BaseTest.extract_prior_state(imgpe)
		pre_phi = imgpe.gating_phi

		np.random.seed(1008)
		imgpe.hmh_gating_phi()

		post_c, post_class_indices, post_param_vals = BaseTest.extract_sample_state(imgpe)
		post_priors = BaseTest.extract_prior_state(imgpe)
		post_phi = imgpe.gating_phi

		self.assertEqual(len(pre_c), len(post_c))
		for pre_c_i, post_c_i in zip(pre_c, post_c):
			self.assertEqual(pre_c_i, post_c_i)

		self.assertEqual(len(pre_class_indices), len(post_class_indices))
		for pre_class_indices_j, post_class_indices_j in zip(pre_class_indices, post_class_indices):
			self.assertTrue(np.array_equal(pre_class_indices_j, post_class_indices_j))

		self.assertEqual(pre_param_vals, post_param_vals)
		self.assertEqual(pre_priors, post_priors)

		self.assertNotEqual(pre_phi, post_phi)

Exemple #2

	def test_singleton_hyperparams_modified(self):
		x, y, _ = BaseTest.get_data()
		imgpe = iMGPE(x, y, initial_k=6)
		BaseTest.divide_data(imgpe, singleton=True)
		BaseTest.prepare_kernels(imgpe)

		pre_c, pre_class_indices, pre_param_vals = BaseTest.extract_sample_state(imgpe)
		pre_priors = BaseTest.extract_prior_state(imgpe)
		imgpe.hmc_round()
		post_c, post_class_indices, post_param_vals = BaseTest.extract_sample_state(imgpe)
		post_priors = BaseTest.extract_prior_state(imgpe)

		self.assertEqual(len(pre_c), len(post_c))
		for pre_c_i, post_c_i in zip(pre_c, post_c):
			self.assertEqual(pre_c_i, post_c_i)

		self.assertEqual(len(pre_class_indices), len(post_class_indices))
		for pre_class_indices_j, post_class_indices_j in zip(pre_class_indices, post_class_indices):
			self.assertTrue(np.array_equal(pre_class_indices_j, post_class_indices_j))

		self.assertEqual(len(pre_param_vals), len(post_param_vals))
		for pre_param_vals_j, post_param_vals_j in zip(pre_param_vals, post_param_vals):
			self.assertEqual(len(pre_param_vals_j), len(post_param_vals_j))
			self.assertNotEqual(pre_param_vals_j, post_param_vals_j)

		self.assertEqual(pre_priors, post_priors)

Exemple #3

	def test_non_singleton_hyperhypers_modified(self):
		x, y, _ = BaseTest.get_data()
		imgpe = iMGPE(x, y, initial_k=6)
		BaseTest.divide_data(imgpe, singleton=False)

		pre_c, pre_class_indices, pre_param_vals = BaseTest.extract_sample_state(imgpe)
		pre_priors = BaseTest.extract_prior_state(imgpe)
		imgpe.optimize_priors()
		post_c, post_class_indices, post_param_vals = BaseTest.extract_sample_state(imgpe)
		post_priors = BaseTest.extract_prior_state(imgpe)

		self.assertEqual(len(pre_c), len(post_c))
		for pre_c_i, post_c_i in zip(pre_c, post_c):
			self.assertEqual(pre_c_i, post_c_i)

		self.assertEqual(len(pre_class_indices), len(post_class_indices))
		for pre_class_indices_j, post_class_indices_j in zip(pre_class_indices, post_class_indices):
			self.assertTrue(np.array_equal(pre_class_indices_j, post_class_indices_j))

		self.assertEqual(pre_param_vals, post_param_vals)

		self.assertNotEqual(pre_priors, post_priors)
		priors_and_values = self.naive_prior_value_extraction(imgpe)
		for prior, values in priors_and_values:
			self.ensure_optimal_hyperhypers(prior, values)

Exemple #4

	def test_nonsingleton_different_old_class(self):
		x, y, _ = BaseTest.get_data()
		imgpe = iMGPE(x, y, initial_k=6)
		BaseTest.divide_data(imgpe, singleton=False)
		BaseTest.prepare_kernels(imgpe)
		target_cluster = 4
		BaseTest.boost_target_affinity(imgpe, 43, target_cluster)
		BaseTest.destroy_priors(imgpe)

		pre_c, pre_class_indices, pre_param_vals = BaseTest.extract_sample_state(imgpe)
		imgpe.gibbs(43)
		post_c, post_class_indices, post_param_vals = BaseTest.extract_sample_state(imgpe)

		self.assertEqual(len(pre_c), len(post_c))
		for index, (pre_c_i, post_c_i) in enumerate(zip(pre_c, post_c)):
			if index == 43:
				self.assertEqual(post_c_i, target_cluster)
			else:
				self.assertEqual(pre_c_i, post_c_i)

		pre_class_indices_compare = [pre_class_indices_j for index, pre_class_indices_j in enumerate(pre_class_indices) if index != 2 and index != target_cluster]
		post_class_indices_compare = [pre_class_indices_j for index, pre_class_indices_j in enumerate(post_class_indices) if index != 2 and index != target_cluster]
		self.assertEqual(len(pre_class_indices), len(post_class_indices))
		for pre_class_indices_j, post_class_indices_j in zip(pre_class_indices_compare, post_class_indices_compare):
			self.assertTrue(np.array_equal(pre_class_indices_j, post_class_indices_j))
		self.assertTrue(len(pre_class_indices[2]) - 1, len(post_class_indices[2]))
		self.assertTrue(np.array_equal(pre_class_indices[2][pre_class_indices[2] != 43], post_class_indices[2]))
		self.assertTrue(len(pre_class_indices[target_cluster] + 1), len(post_class_indices[target_cluster]))
		self.assertTrue(np.array_equal(np.append(pre_class_indices[target_cluster], 43), post_class_indices[target_cluster]))

		self.assertEqual(pre_param_vals, post_param_vals)

Exemple #5

	def test_singleton_different_class(self):
		x, y, _ = BaseTest.get_data()
		imgpe = iMGPE(x, y, initial_k=6)
		BaseTest.divide_data(imgpe, singleton=True)
		BaseTest.prepare_kernels(imgpe)
		target_cluster = 4
		BaseTest.boost_target_affinity(imgpe, 43, target_cluster)

		pre_c, pre_class_indices, pre_param_vals = BaseTest.extract_sample_state(imgpe)
		imgpe.gibbs(43)
		post_c, post_class_indices, post_param_vals = BaseTest.extract_sample_state(imgpe)

		self.assertEqual(len(pre_c), len(post_c))
		for index, (pre_c_i, post_c_i) in enumerate(zip(pre_c, post_c)):
			if index == 43:
				self.assertEqual(post_c_i, target_cluster - 1) # Shifted by one because target cluster is ahead
			else:
				if pre_c_i > 2:
					self.assertEqual(pre_c_i - 1, post_c_i)
				else:
					self.assertEqual(pre_c_i, post_c_i)

		pre_class_indices_compare = [pre_class_indices_j for index, pre_class_indices_j in enumerate(pre_class_indices) if index != 2 and index != target_cluster]
		post_class_indices_compare = [pre_class_indices_j for index, pre_class_indices_j in enumerate(post_class_indices) if index != target_cluster - 1]
		self.assertEqual(len(pre_class_indices) - 1, len(post_class_indices))
		for pre_class_indices_j, post_class_indices_j in zip(pre_class_indices_compare, post_class_indices_compare):
			self.assertTrue(np.array_equal(pre_class_indices_j, post_class_indices_j))
		self.assertTrue(np.array_equal(np.append(pre_class_indices[target_cluster], 43), post_class_indices[target_cluster - 1]))

		self.assertEqual(len(pre_param_vals) - 1, len(post_param_vals))
		pre_param_vals_compare = [pre_param_vals_j for index, pre_param_vals_j in enumerate(pre_param_vals) if index != 2]
		self.assertEqual(pre_param_vals_compare, post_param_vals)

Exemple #6

	def test_nonsingleton_reassignment(self):
		x, y, _ = BaseTest.get_data()
		imgpe = iMGPE(x, y, initial_k=6)
		BaseTest.divide_data(imgpe, singleton=False)
		BaseTest.prepare_kernels(imgpe)
		BaseTest.boost_self_affinity(imgpe, 43)

		pre_c, pre_class_indices, pre_param_vals = BaseTest.extract_sample_state(imgpe)
		imgpe.gibbs(43)
		post_c, post_class_indices, post_param_vals = BaseTest.extract_sample_state(imgpe)

		self.assertEqual(len(pre_c), len(post_c))
		for pre_c_i, post_c_i in zip(pre_c, post_c):
			self.assertEqual(pre_c_i, post_c_i)

		self.assertEqual(len(pre_class_indices), len(post_class_indices))
		for pre_class_indices_j, post_class_indices_j in zip(pre_class_indices, post_class_indices):
			self.assertTrue(np.array_equal(pre_class_indices_j, post_class_indices_j))

		self.assertEqual(pre_param_vals, post_param_vals)