def test_get_maximum_for_dataset3(self):
keywords_dont_matter_here = ['']
kwc1 = KeywordCoordinate(6, 6, keywords_dont_matter_here)
kwc2 = KeywordCoordinate(8, 8, keywords_dont_matter_here)
kwc3 = KeywordCoordinate(9, 9, keywords_dont_matter_here)
kwc4 = KeywordCoordinate(13, 13, keywords_dont_matter_here)
kwc5 = KeywordCoordinate(24, 24, keywords_dont_matter_here)
kwc6 = KeywordCoordinate(35, 35, keywords_dont_matter_here)
dataset: dataset_type = [kwc1, kwc2, kwc3, kwc4, kwc5, kwc6]
cf = CostFunction(euclidean_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
result = cf.get_maximum_for_dataset(dataset)
self.assertAlmostEqual(result, 41.01, delta=0.01)
def test_get_minimum_for_dataset2(self):
keywords_dont_matter_here = ['']
kwc1 = KeywordCoordinate(5, 5, keywords_dont_matter_here)
kwc2 = KeywordCoordinate(6, 6, keywords_dont_matter_here)
kwc3 = KeywordCoordinate(7, 7, keywords_dont_matter_here)
kwc4 = KeywordCoordinate(8, 8, keywords_dont_matter_here)
kwc5 = KeywordCoordinate(9, 9, keywords_dont_matter_here)
kwc6 = KeywordCoordinate(10, 10, keywords_dont_matter_here)
dataset: dataset_type = [kwc1, kwc2, kwc3, kwc4, kwc5, kwc6]
cf = CostFunction(manhattan_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
result = cf.get_minimum_for_dataset(dataset)
self.assertAlmostEqual(result, 2.0, delta=0.01)
def test_get_maximum_for_dataset1(self):
keywords_dont_matter_here = ['']
kwc1 = KeywordCoordinate(0, 0, keywords_dont_matter_here)
kwc2 = KeywordCoordinate(1, 1, keywords_dont_matter_here)
kwc3 = KeywordCoordinate(2, 2, keywords_dont_matter_here)
kwc4 = KeywordCoordinate(3, 3, keywords_dont_matter_here)
kwc5 = KeywordCoordinate(4, 4, keywords_dont_matter_here)
kwc6 = KeywordCoordinate(5, 5, keywords_dont_matter_here)
dataset: dataset_type = [kwc1, kwc2, kwc3, kwc4, kwc5, kwc6]
cf = CostFunction(euclidean_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
result = cf.get_maximum_for_dataset(dataset)
self.assertAlmostEqual(result, 7.07, delta=0.01)
def test_get_minimum_for_dataset3(self):
keywords_dont_matter_here = ['']
kwc1 = KeywordCoordinate(0, 0, keywords_dont_matter_here)
kwc2 = KeywordCoordinate(13, 13, keywords_dont_matter_here)
kwc3 = KeywordCoordinate(20, 20, keywords_dont_matter_here)
kwc4 = KeywordCoordinate(800, 800, keywords_dont_matter_here)
kwc5 = KeywordCoordinate(9000, 9000, keywords_dont_matter_here)
kwc6 = KeywordCoordinate(10000, 10000, keywords_dont_matter_here)
dataset: dataset_type = [kwc1, kwc2, kwc3, kwc4, kwc5, kwc6]
cf = CostFunction(euclidean_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
result = cf.get_minimum_for_dataset(dataset)
self.assertAlmostEqual(result, 9.9, delta=0.01)
def test_get_minimum_for_query4(self):
keywords_dont_matter_here = ['']
query = KeywordCoordinate(0, 0, keywords_dont_matter_here)
kwc1 = KeywordCoordinate(8, 8, keywords_dont_matter_here)
kwc2 = KeywordCoordinate(9, 9, keywords_dont_matter_here)
kwc3 = KeywordCoordinate(13, 13, keywords_dont_matter_here)
kwc4 = KeywordCoordinate(24, 24, keywords_dont_matter_here)
kwc5 = KeywordCoordinate(35, 35, keywords_dont_matter_here)
dataset: dataset_type = [kwc1, kwc2, kwc3, kwc4, kwc5]
cf = CostFunction(manhattan_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
result = cf.get_minimum_for_query(query, dataset)
self.assertAlmostEqual(result, 16.0, delta=0.01)
def test_get_min_inter_dataset_distance(self):
query_keywords = ['family', 'food', 'outdoor']
kwc1_keywords = ['family', 'food', 'outdoor']
kwc2_keywords = ['food']
kwc3_keywords = ['outdoor']
query = KeywordCoordinate(0, 0, query_keywords)
kwc1 = KeywordCoordinate(1, 1, kwc1_keywords)
kwc2 = KeywordCoordinate(2, 2, kwc2_keywords)
kwc3 = KeywordCoordinate(3, 3, kwc3_keywords)
data = [kwc1, kwc2, kwc3]
cf = CostFunction(euclidean_distance, combined_cosine_similarity, 0.3,
0.3, 0.4)
so = Solver(query, data, cf, normalize=False)
fs1 = frozenset([kwc1])
fs2 = frozenset([kwc2])
fs3 = frozenset([kwc3])
fs4 = frozenset([kwc1, kwc2])
fs5 = frozenset([kwc1, kwc3])
fs6 = frozenset([kwc2, kwc3])
fs7 = frozenset([kwc1, kwc2, kwc3])
result = so.get_min_inter_dataset_distance()
self.assertEqual(len(result), 7)
self.assertAlmostEqual(result.get(fs1), 0.0, delta=0.01)
self.assertAlmostEqual(result.get(fs2), 0.0, delta=0.01)
self.assertAlmostEqual(result.get(fs3), 0.0, delta=0.01)
self.assertAlmostEqual(result.get(fs4), 1.41, delta=0.01)
self.assertAlmostEqual(result.get(fs5), 2.83, delta=0.01)
self.assertAlmostEqual(result.get(fs6), 1.41, delta=0.01)
self.assertAlmostEqual(result.get(fs7), 1.41, delta=0.01)
def test_get_maximum_keyword_distance4(self):
keywords_query = ['food', 'fun', 'outdoor']
keywords_kwc1 = ['food', 'fun', 'outdoor']
keywords_kwc2 = ['food', 'fun', 'outdoor']
keywords_kwc3 = ['food', 'fun', 'outdoor']
coordinates_dont_matter_here = 0
query = KeywordCoordinate(coordinates_dont_matter_here,
coordinates_dont_matter_here, keywords_query)
kwc1 = KeywordCoordinate(coordinates_dont_matter_here,
coordinates_dont_matter_here, keywords_kwc1)
kwc2 = KeywordCoordinate(coordinates_dont_matter_here,
coordinates_dont_matter_here, keywords_kwc2)
kwc3 = KeywordCoordinate(coordinates_dont_matter_here,
coordinates_dont_matter_here, keywords_kwc3)
dataset: dataset_type = [kwc1, kwc2, kwc3]
cf = CostFunction(euclidean_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
result = cf.get_maximum_keyword_distance(query, dataset)
self.assertAlmostEqual(result, 0.0, delta=0.01)
def get_min_inter_dataset_distances(costfunction: CostFunction, subsets):
"""
This function gets executed inside every minimum inter-dataset distance process.
:param costfunction: The CostFunction
:param subsets: The subsets for the process
:return: A list with tuples of the costs and their corresponding subset
"""
results = []
for subset in subsets:
current_cost = costfunction.get_minimum_for_dataset(subset)
results.append((current_cost, subset))
return results
def get_max_keyword_similarity(costfunction: CostFunction,
query: KeywordCoordinate, subsets):
"""
This function gets executed inside every maximum keyword similarity process.
:param costfunction: The CostFunction
:param query: The Query
:param subsets: The subsets for the process
:return: A list with tuples of the costs and their corresponding subset
"""
results = []
for subset in subsets:
current_cost = costfunction.get_maximum_keyword_distance(query, subset)
results.append((current_cost, subset))
return results
def test_instantiation(self):
cf = CostFunction(euclidean_distance, separated_cosine_similarity, 0.3,
0.3, 0.4, 0.5, 0.6, 0.7, False)
self.assertEqual(euclidean_distance.__get__,
cf.distance_metric.__get__)
self.assertEqual(separated_cosine_similarity.__get__,
cf.similarity_metric.__get__)
self.assertAlmostEqual(cf.alpha, 0.3, delta=0.01)
self.assertAlmostEqual(cf.beta, 0.3, delta=0.01)
self.assertAlmostEqual(cf.omega, 0.4, delta=0.01)
self.assertAlmostEqual(cf.query_distance_threshold, 0.5, delta=0.01)
self.assertAlmostEqual(cf.dataset_distance_threshold, 0.6, delta=0.01)
self.assertAlmostEqual(cf.keyword_similarity_threshold,
0.7,
delta=0.01)
self.assertEqual(cf.disable_thresholds, False)
def test_instantiation(self):
query_keywords = ['family', 'food', 'outdoor']
kwc1_keywords = ['family', 'food', 'outdoor']
kwc2_keywords = ['food']
kwc3_keywords = ['outdoor']
query = KeywordCoordinate(0, 0, query_keywords)
kwc1 = KeywordCoordinate(1, 1, kwc1_keywords)
kwc2 = KeywordCoordinate(2, 2, kwc2_keywords)
kwc3 = KeywordCoordinate(3, 3, kwc3_keywords)
data = [kwc1, kwc2, kwc3]
cf = CostFunction(euclidean_distance, separated_cosine_similarity, 0.3,
0.3, 0.4)
so = Solver(query, data, cf, normalize=False, result_length=10)
self.assertAlmostEqual(so.query.coordinates.x, 0, delta=0.01)
self.assertAlmostEqual(so.query.coordinates.y, 0, delta=0.01)
self.assertListEqual(so.data, data)
self.assertAlmostEqual(so.data[0].coordinates.x, 1, delta=0.01)
self.assertAlmostEqual(so.data[0].coordinates.y, 1, delta=0.01)
self.assertListEqual(so.data[0].keywords, kwc1_keywords)
for index in range(len(so.data[0].keywords)):
self.assertEqual(so.data[0].keywords[index], kwc1_keywords[index])
self.assertAlmostEqual(so.data[1].coordinates.x, 2, delta=0.01)
self.assertAlmostEqual(so.data[1].coordinates.y, 2, delta=0.01)
self.assertListEqual(so.data[1].keywords, kwc2_keywords)
for index in range(len(so.data[1].keywords)):
self.assertEqual(so.data[1].keywords[index], kwc2_keywords[index])
self.assertAlmostEqual(so.data[2].coordinates.x, 3, delta=0.01)
self.assertAlmostEqual(so.data[2].coordinates.y, 3, delta=0.01)
self.assertListEqual(so.data[2].keywords, kwc3_keywords)
for index in range(len(so.data[2].keywords)):
self.assertEqual(so.data[2].keywords[index], kwc3_keywords[index])
self.assertEqual(euclidean_distance.__get__,
so.cost_function.distance_metric.__get__)
self.assertEqual(separated_cosine_similarity.__get__,
so.cost_function.similarity_metric.__get__)
self.assertAlmostEqual(so.cost_function.alpha, 0.3, delta=0.01)
self.assertAlmostEqual(so.cost_function.beta, 0.3, delta=0.01)
self.assertAlmostEqual(so.cost_function.omega, 0.4, delta=0.01)
self.assertEqual(so.normalize_data, False)
self.assertEqual(so.result_length, 10)
self.assertAlmostEqual(so.denormalize_max_x, 0.0, delta=0.01)
self.assertAlmostEqual(so.denormalize_min_x, 0.0, delta=0.01)
self.assertAlmostEqual(so.denormalize_max_y, 0.0, delta=0.01)
self.assertAlmostEqual(so.denormalize_min_y, 0.0, delta=0.01)
