def test_get_many(self):
doc_ids = [1, 2]
kw_ids = ["a", "the"]
self.assertEqual(Document.get_many([1, 2]), Document.get_many(doc_ids))
self.assertEqual(Keyword.get_many(["a", "the"]),
Keyword.get_many(kw_ids))
def test_one(self):
docs = [Document.get_many([1,2]), Document.get_many([1,2]), Document.get_many([2,1])]
kws = [Keyword.get_many(["redis", "database"]), Keyword.get_many(["redis", "database"]), Keyword.get_many(["redis", "database"])]
scores = self.e.evaluate(docs, kws)
expected = ([1,1,1], [1,1,1])
self.assertArrayAlmostEqual(expected[0], scores[0])
self.assertArrayAlmostEqual(expected[1], scores[1])
def test_get_many(self):
doc_ids = [1,2]
kw_ids = ["a", "the"]
self.assertEqual(Document.get_many([1,2]),
Document.get_many(doc_ids))
self.assertEqual(Keyword.get_many(["a", "the"]),
Keyword.get_many(kw_ids))
def test_filter_objs(self):
def has_redis_filter(objs = None):
return filter(lambda obj: Keyword.get("redis") in obj.keywords, objs)
def has_database_filter(objs = None):
return filter(lambda obj: Keyword.get("database") in obj.keywords, objs)
self.assertEqual(list(Document.get_many([1, 7])),
self.r._filter_objs([has_redis_filter, has_database_filter],
objs = Document.get_many([1, 7, 8])))
def test_associated_keywords_from_documents(self):
kws = self.r.associated_keywords_from_docs(Document.get_many([1,2]))
self.assertEqual(set(Keyword.get_many(["a", "database", "redis", "the"])),
set(kws))
exclude_kws = [Keyword.get("redis")]
kws = self.r.associated_keywords_from_docs(Document.get_many([1,2]), exclude_kws)
self.assertEqual(set(Keyword.get_many(["a", "database", "the"])),
set(kws))
def test_two(self):
docs = [Document.get_many([8,10]), Document.get_many([3,4]), Document.get_many([2,1])]
kws = [Keyword.get_many(["a", "the"]), Keyword.get_many(["python", "database"]), Keyword.get_many(["database", "redis"])]
scores = self.e.evaluate(docs, kws)
expected = ([0.34491169135422844, 0.1726882003112921, 1.0],
[0.4834283906452939, 0.759679156743632, 0.9999999999999999])
self.assertArrayAlmostEqual(expected[0], scores[0])
self.assertArrayAlmostEqual(expected[1], scores[1])
def test_associated_keywords_from_documents(self):
kws = self.r.associated_keywords_from_docs(Document.get_many([1, 2]))
self.assertEqual(
set(Keyword.get_many(["a", "database", "redis", "the"])), set(kws))
exclude_kws = [Keyword.get("redis")]
kws = self.r.associated_keywords_from_docs(Document.get_many([1, 2]),
exclude_kws)
self.assertEqual(set(Keyword.get_many(["a", "database", "the"])),
set(kws))
def test_doc_hashable(self):
d = {}
doclist1 = Document.get_many([1, 2, 3])
doclist2 = Document.get_many([2, 1, 3])
doclist3 = Document.get_many([4, 5, 6])
d[doclist1] = 1
d[doclist2] = 2 #override
d[doclist3] = 3
self.assertEqual({doclist1: 2, doclist3: 3}, d)
def test_doc_hashable(self):
d = {}
doclist1 = Document.get_many([1,2,3])
doclist2 = Document.get_many([2,1,3])
doclist3 = Document.get_many([4,5,6])
d[doclist1] = 1
d[doclist2] = 2 #override
d[doclist3] = 3
self.assertEqual({doclist1:2, doclist3: 3}, d)
def test_modellist2modellist_similarity(self):
#for keywords
kwlist1 = Keyword.get_many(["redis", "a"])
kwlist2 = Keyword.get_many(["database", "the"])
self.assertAlmostEqual(0.42205423035497763, kwlist1.similarity_to(kwlist2))
#for documents
doclist1 = Document.get_many([3,5])
doclist2 = Document.get_many([4,6])
self.assertAlmostEqual(0.6990609119502719, doclist1.similarity_to(doclist2))
def test_filter_objs(self):
def has_redis_filter(objs=None):
return filter(lambda obj: Keyword.get("redis") in obj.keywords,
objs)
def has_database_filter(objs=None):
return filter(lambda obj: Keyword.get("database") in obj.keywords,
objs)
self.assertEqual(
list(Document.get_many([1, 7])),
self.r._filter_objs([has_redis_filter, has_database_filter],
objs=Document.get_many([1, 7, 8])))
def test_equality_same_type(self):
kwlist1 = Keyword.get_many(["redis", "a", "the"])
kwlist2 = Keyword.get_many(["a", "the", "redis"])
kwlist3 = Keyword.get_many(["a", "the", "python"])
self.assertEqual(kwlist1, kwlist2)
self.assertNotEqual(kwlist3, kwlist2)
doclist1 = Document.get_many([1,2,3])
doclist2 = Document.get_many([2,3,1])
doclist3 = Document.get_many([4,5,6])
self.assertEqual(doclist1, doclist2)
self.assertNotEqual(doclist3, doclist2)
def sample_documents_associated_with_keywords(self, keywords, n):
"""
sample n documents from all documents that contain any of the keywords
"""
assert type(keywords) in (KeywordList, ListType) , "keywords should be KeywordList, but is %r" %(keywords)
#get all doc ids of which the document contains any of the keywords
doc_ids = self._doc_ids_that_contain_keywords([kw.id for kw in keywords])
#sample it
try:
return Document.get_many(random.sample(doc_ids, n))
except ValueError: #sample size larger than population
return Document.get_many(doc_ids)
def test_equality_same_type(self):
kwlist1 = Keyword.get_many(["redis", "a", "the"])
kwlist2 = Keyword.get_many(["a", "the", "redis"])
kwlist3 = Keyword.get_many(["a", "the", "python"])
self.assertEqual(kwlist1, kwlist2)
self.assertNotEqual(kwlist3, kwlist2)
doclist1 = Document.get_many([1, 2, 3])
doclist2 = Document.get_many([2, 3, 1])
doclist3 = Document.get_many([4, 5, 6])
self.assertEqual(doclist1, doclist2)
self.assertNotEqual(doclist3, doclist2)
def test_modellist2modellist_similarity(self):
#for keywords
kwlist1 = Keyword.get_many(["redis", "a"])
kwlist2 = Keyword.get_many(["database", "the"])
self.assertAlmostEqual(0.42205423035497763,
kwlist1.similarity_to(kwlist2))
#for documents
doclist1 = Document.get_many([3, 5])
doclist2 = Document.get_many([4, 6])
self.assertAlmostEqual(0.6990609119502719,
doclist1.similarity_to(doclist2))
def test_add_docs(self):
"""
as well as last_recom_docs
"""
iter1 = Document.get_many([1, 2, 3])
iter2 = Document.get_many([2, 3, 4])
self.session.add_doc_recom_list(iter1)
self.assertEqual([iter1], self.session.recom_docs)
self.session.add_doc_recom_list(iter2)
self.assertEqual([iter1, iter2], self.session.recom_docs)
self.assertEqual(iter2, self.session.last_recom_docs)
def setUp(self):
init_recommender = QueryBasedRecommender(3, 2,
3, 2,
**fmim.__dict__)
main_recommender = LinRelRecommender(3, 3,
1., .5,
1., .5,
None,None,
None,None,
**fmim.__dict__)
self.app = CmdApp(OnePassPropagator, OverrideUpdater,
init_recommender, main_recommender)
self.session = get_session()
#add recommended list
self.session.add_doc_recom_list(Document.get_many([1,2,3]))
self.session.add_kw_recom_list(Keyword.get_many(["a", "redis", "database"]))
self.fb = {
"docs": [[1, .5]],
"kws": [["redis", .5]],
"dockws": [["redis", 1, .5]]
}
random.seed(123456)
def setUp(self):
doc_goal = Document.get_many([1,2])
kw_goal = Keyword.get_many(["redis", "database"])
self.e = GoalBasedEvaluator()
self.e.setGoal(doc_goal, kw_goal)
def test_recommend(self):
docs, kws = self.r.recommend(self.session, 4, 4, 1, .5, 1., .5)
self.assertEqual(Document.get_many([1, 8, 2, 6]), docs)
self.assertEqual(
Keyword.get_many(
["redis", "database", "the", "mysql", "a", "python"]), kws)
def setUp(self):
doc_goal = Document.get_many([1, 2])
kw_goal = Keyword.get_many(["redis", "database"])
self.e = GoalBasedEvaluator()
self.e.setGoal(doc_goal, kw_goal)
def test_recommend(self):
docs, kws = self.r.recommend(self.session,
4, 4,
1, .5,
1., .5)
self.assertEqual(Document.get_many([1,8,2,6]), docs)
self.assertEqual(Keyword.get_many(["redis", "database", "the", "mysql", "a", "python"]), kws)
def test_one(self):
docs = [
Document.get_many([1, 2]),
Document.get_many([1, 2]),
Document.get_many([2, 1])
]
kws = [
Keyword.get_many(["redis", "database"]),
Keyword.get_many(["redis", "database"]),
Keyword.get_many(["redis", "database"])
]
scores = self.e.evaluate(docs, kws)
expected = ([1, 1, 1], [1, 1, 1])
self.assertArrayAlmostEqual(expected[0], scores[0])
self.assertArrayAlmostEqual(expected[1], scores[1])
def test_sample_documents_associated_with_keywords_sample_size_too_large(
self):
"""
in case the sample size is too large
"""
docs = self.r.sample_documents_associated_with_keywords(
Keyword.get_many(["python"]), 999)
self.assertEqual(Document.get_many([3, 4, 5, 6, 8]), docs)
def test_recommend_main(self):
#receive the feedback first
self.app.receive_feedbacks(self.session, self.fb)
docs, kws = self.app.recommend(start=False, session=self.session)
self.assertEqual(Document.get_many([1, 2, 6]), docs)
self.assertEqual(
Keyword.get_many(["redis", "database", "a", "python", "the"]), kws)
def test_doc_fb_threshold_filter_with_prefiltering(self):
#change the feedback
self.session.update_doc_feedback(Document.get(1), .2)
self.session.update_doc_feedback(Document.get(2), .0999999)
actual = doc_fb_threshold_filter(0.1, self.session, with_fb=True)
expected = Document.get_many([1])
self.assertEqual(expected, actual)
def test_recommend_main(self):
#receive the feedback first
self.app.receive_feedbacks(self.session, self.fb)
docs , kws = self.app.recommend(start = False, session = self.session)
self.assertEqual(Document.get_many([1,2,6]),
docs)
self.assertEqual(Keyword.get_many(["redis", "database", "a", "python", "the"]),
kws)
def test_recommend_documents_sensible_query(self):
"""
query that has keywords existing in the documents' keyword list
"""
query = "database, python, redis"
matched_docs, query_keywords = self.r.recommend_documents(query, 4)
self.assertEqual(Document.get_many([6,1,2,5]), matched_docs)
self.assertEqual(Keyword.get_many(["database", "python", "redis"]), query_keywords)
def test_kw_fb_filter(self):
kw = Keyword.get("redis")
kw.rec_fb_from_doc(Document.get(1), 1, self.session)
self.session.add_doc_recom_list(Document.get_many([1, 2, 6]))
self.session.update_kw_feedback(kw, kw.fb_weighted_sum(self.session))
actual = FilterRepository.filters["kw_fb"]([kw])
expected = Keyword.get_many(["redis"])
self.assertEqual(expected, actual)
def test_kw_fb_filter(self):
kw = Keyword.get("redis")
kw.rec_fb_from_doc(Document.get(1), 1, self.session)
self.session.add_doc_recom_list(Document.get_many([1, 2, 6]))
self.session.update_kw_feedback(kw, kw.fb_weighted_sum(self.session))
actual = FilterRepository.filters["kw_fb"]([kw])
expected = Keyword.get_many(["redis"])
self.assertEqual(expected, actual)
def test_doc_fb_threshold_filter(self):
#change the feedback
self.session.update_doc_feedback(Document.get(1), .2)
self.session.update_doc_feedback(Document.get(2), .0999999)
actual = doc_fb_threshold_filter(0.1, self.session,
docs = Document.all_docs, with_fb = False)
expected = Document.get_many([1])
self.assertEqual(expected, actual)
def test_recommend_documents_sensible_query(self):
"""
query that has keywords existing in the documents' keyword list
"""
query = "database, python, redis"
matched_docs, query_keywords = self.r.recommend_documents(query, 4)
self.assertEqual(Document.get_many([6, 1, 2, 5]), matched_docs)
self.assertEqual(Keyword.get_many(["database", "python", "redis"]),
query_keywords)
def test_two(self):
docs = [
Document.get_many([8, 10]),
Document.get_many([3, 4]),
Document.get_many([2, 1])
]
kws = [
Keyword.get_many(["a", "the"]),
Keyword.get_many(["python", "database"]),
Keyword.get_many(["database", "redis"])
]
scores = self.e.evaluate(docs, kws)
expected = ([0.34491169135422844, 0.1726882003112921, 1.0], [
0.4834283906452939, 0.759679156743632, 0.9999999999999999
])
self.assertArrayAlmostEqual(expected[0], scores[0])
self.assertArrayAlmostEqual(expected[1], scores[1])
def test_recommend(self):
docs, kws = self.r.recommend(self.session,
4, 4,
1, .5,
1., .5,
kw_filters = [self.my_kw_filter],
doc_filters = [self.kw_count_filter, self.has_database_filter])
print self.fmim.doc2kw_m.shape
self.assertEqual(Document.get_many([2,1,6,7]), docs)
self.assertEqual(Keyword.get_many(["redis", "database", "python", "mysql", "a", "the"]), kws)
def test_doc_fb_filter(self):
doc = Document.get(1)
doc.rec_fb_from_kw(Keyword.get("redis"), 1, self.session)
self.session.update_doc_feedback(doc, doc.fb_weighted_sum(self.session))
print "doc.fb(self.session)=", doc.fb(self.session)
actual = FilterRepository.filters["doc_fb"]([doc])
expected = Document.get_many([])
print doc.fb(self.session)
self.assertEqual(expected, actual)
def test_doc_fb_filter(self):
doc = Document.get(1)
doc.rec_fb_from_kw(Keyword.get("redis"), 1, self.session)
self.session.update_doc_feedback(doc,
doc.fb_weighted_sum(self.session))
print "doc.fb(self.session)=", doc.fb(self.session)
actual = FilterRepository.filters["doc_fb"]([doc])
expected = Document.get_many([])
print doc.fb(self.session)
self.assertEqual(expected, actual)
def test_model2modellist_similarity(self):
#for keywords
kw = Keyword.get("redis")
kwlist = Keyword.get_many(["database", "mysql"])
self.assertAlmostEqual(0.3754029265429976, kw.similarity_to(kwlist))
#for documents
doc = Document.get(6)
doclist = Document.get_many([1, 2])
self.assertAlmostEqual(0.7382455893131392, doc.similarity_to(doclist))
def test_keyword(self):
"""
whether id, documents are correct
"""
doc_ids = [1, 2, 6]
kw = Keyword.get("redis")
self.assertEqual(kw.id, "redis")
self.assertEqual(set(kw.docs), set(Document.get_many(doc_ids)))
#that is as far as we can test
#no numerical testing
self.assertTrue(type(kw._doc_weight) is DictType)
def test_model2modellist_similarity(self):
#for keywords
kw = Keyword.get("redis")
kwlist = Keyword.get_many(["database", "mysql"])
self.assertAlmostEqual(0.3754029265429976, kw.similarity_to(kwlist))
#for documents
doc = Document.get(6)
doclist = Document.get_many([1, 2])
self.assertAlmostEqual(0.7382455893131392, doc.similarity_to(doclist))
def test_keyword(self):
"""
whether id, documents are correct
"""
doc_ids = [1, 2, 6]
kw = Keyword.get("redis")
self.assertEqual(kw.id, "redis")
self.assertEqual(set(kw.docs), set(Document.get_many(doc_ids)))
#that is as far as we can test
#no numerical testing
self.assertTrue(type(kw._doc_weight) is DictType)
def test_document_centroid(self):
doc = Document.get(1)
doclist1 = DocumentList([doc])
self.assertArrayAlmostEqual(matrix2array(doclist1.centroid), doc.vec.toarray()[0])
doc1 = Document.get(1)
doc2 = Document.get(2)
doclist2 = Document.get_many([1, 2])
self.assertArrayAlmostEqual(matrix2array(doclist2.centroid),
(doc1.vec.toarray()[0] + doc2.vec.toarray()[0]) / 2)
def test_submatrix_and_indexing(self):
docs = Document.get_many([1,2])
kws = Keyword.get_many(["python", "redis"])
feature_matrix = fmim.doc2kw_m
doc2ind = fmim.doc_ind
kw2ind = fmim.kw_ind
submatrix, doc2ind_submap, ind2doc_submap = self.r._submatrix_and_indexing(docs, kws, feature_matrix, doc2ind, kw2ind)
self.assertEqual((2,2), submatrix.shape)
self.assertEqual({1: 0, 2: 1}, doc2ind_submap)
self.assertEqual({0: 1, 1: 2}, ind2doc_submap)
def test_receive_feedbacks(self):
self.app.receive_feedbacks(self.session, self.fb)
docs = Document.get_many([1,2,3])
self.assertAlmostEqual(0.183701573217 * .3 + .7 * .5, docs[0].fb(self.session))
self.assertAlmostEqual(0.191506501383, docs[1].fb(self.session))
self.assertAlmostEqual(0., docs[2].fb(self.session))
kws = Keyword.get_many(["a", "redis", "database", "python"])
self.assertAlmostEqual(0.56689342264886755 * .5 / (0.56689342264886755 + 0.49704058656839417), kws[0].fb(self.session))
self.assertAlmostEqual(1 / 4. * .3 + .5 * .7, kws[1].fb(self.session))
self.assertAlmostEqual(1 / 4., kws[2].fb(self.session))
self.assertAlmostEqual(0., kws[3].fb(self.session))
def test_recommend_together(self):
#### Iter 1 ######
docs, kws = self.app.recommend(start=True, query="python, redis")
self.assertEqual(3, len(docs))
self.assertTrue(len(kws) >= 3)
#### Iter 2 ######
# receive the feedback first
self.app.receive_feedbacks(self.session, self.fb)
docs, kws = self.app.recommend(start=False, session=self.session)
self.assertEqual(Document.get_many([1, 2, 6]), docs)
self.assertEqual(
Keyword.get_many(["redis", "database", "a", "python", "the"]), kws)
def test_submatrix_and_indexing(self):
docs = Document.get_many([1, 2])
kws = Keyword.get_many(["python", "redis"])
feature_matrix = fmim.doc2kw_m
doc2ind = fmim.doc_ind
kw2ind = fmim.kw_ind
submatrix, doc2ind_submap, ind2doc_submap = self.r._submatrix_and_indexing(
docs, kws, feature_matrix, doc2ind, kw2ind)
self.assertEqual((2, 2), submatrix.shape)
self.assertEqual({1: 0, 2: 1}, doc2ind_submap)
self.assertEqual({0: 1, 1: 2}, ind2doc_submap)
def test_document_centroid(self):
doc = Document.get(1)
doclist1 = DocumentList([doc])
self.assertArrayAlmostEqual(matrix2array(doclist1.centroid),
doc.vec.toarray()[0])
doc1 = Document.get(1)
doc2 = Document.get(2)
doclist2 = Document.get_many([1, 2])
self.assertArrayAlmostEqual(
matrix2array(doclist2.centroid),
(doc1.vec.toarray()[0] + doc2.vec.toarray()[0]) / 2)
def test_recommend_together(self):
#### Iter 1 ######
docs , kws = self.app.recommend(start = True, query = "python, redis")
self.assertEqual(3, len(docs))
self.assertTrue(len(kws) >= 3)
#### Iter 2 ######
# receive the feedback first
self.app.receive_feedbacks(self.session, self.fb)
docs , kws = self.app.recommend(start = False, session = self.session)
self.assertEqual(Document.get_many([1,2,6]),
docs)
self.assertEqual(Keyword.get_many(["redis", "database", "a", "python", "the"]),
kws)
def test_recommend(self):
docs, kws = self.r.recommend(
self.session,
4,
4,
1,
.5,
1.,
.5,
kw_filters=[self.my_kw_filter],
doc_filters=[self.kw_count_filter, self.has_database_filter])
print self.fmim.doc2kw_m.shape
self.assertEqual(Document.get_many([2, 1, 6, 7]), docs)
self.assertEqual(
Keyword.get_many(
["redis", "database", "python", "mysql", "a", "the"]), kws)
def test_recommend_keywords(self):
kws = self.r.recommend_keywords(Document.get_many([6, 1]), 5, 3,
query_keywords = Keyword.get_many(["python", "redis",
"non-existing"]))
kw_from_recom_docs = kws[:3]
kw_from_assoc_docs = kws[3:]
self.assertEqual(5, len(kws))
self.assertEqual(list(Keyword.get_many(["python", "redis"])), kw_from_recom_docs[:2]) #the first two should be python and redis
for kw in kw_from_recom_docs:
self.assertTrue(kw["recommended"])
for kw in kw_from_assoc_docs:
self.assertFalse(kw["recommended"])
#no easy way to further test the elements of the kws
pass
def test_receive_feedbacks(self):
self.app.receive_feedbacks(self.session, self.fb)
docs = Document.get_many([1, 2, 3])
self.assertAlmostEqual(0.183701573217 * .3 + .7 * .5,
docs[0].fb(self.session))
self.assertAlmostEqual(0.191506501383, docs[1].fb(self.session))
self.assertAlmostEqual(0., docs[2].fb(self.session))
kws = Keyword.get_many(["a", "redis", "database", "python"])
self.assertAlmostEqual(
0.56689342264886755 * .5 /
(0.56689342264886755 + 0.49704058656839417),
kws[0].fb(self.session))
self.assertAlmostEqual(1 / 4. * .3 + .5 * .7, kws[1].fb(self.session))
self.assertAlmostEqual(1 / 4., kws[2].fb(self.session))
self.assertAlmostEqual(0., kws[3].fb(self.session))
def test_interaction(self):
docs = Document.get_many([1, 2, 3])
kws = Keyword.get_many(["redis", "database", "a", "the"])
inputs = ["0 1", #docs
"0 1", #kws
"0 1", #kw in doc 1
"", #kw in doc 2, nothing
"2" #kw in doc 3
]
fb = self.app.interact_with_user(docs, kws, inputs)
expected = {
"docs": [[1L, 1], [2L, 1]],
"kws": [[u"redis", 1], [u"database", 1]],
"dockws": [[u"redis", 1L, 1], [u"database", 1L, 1], [u"python", 3L, 1]],
}
self.assertEqual(expected, fb)
def test_give_feedback(self):
docs = Document.get_many([1, 3])
kws = Keyword.get_many(
["redis", "database", "a", "tornado", "web", "python"])
# Iter 1
fb = self.r.give_feedback(docs, kws)
expected = {"docs": [[1, 1]], "kws": [["database", 1]]}
self.assertEqual(expected, fb)
# Iter 2
# what is selected in iter 1
# should not be selected any more
fb = self.r.give_feedback(docs, kws)
expected = {"docs": [[3, 1]], "kws": [["redis", 1]]}
self.assertEqual(expected, fb)
def test_give_feedback(self):
docs = Document.get_many([1, 3])
kws = Keyword.get_many(["redis", "database", "a", "tornado", "web", "python"])
# Iter 1
fb = self.r.give_feedback(docs, kws)
expected = {"docs": [[1, 1]],
"kws": [["database", 1]]}
self.assertEqual(expected, fb)
# Iter 2
# what is selected in iter 1
# should not be selected any more
fb = self.r.give_feedback(docs, kws)
expected = {"docs": [[3, 1]],
"kws": [["redis", 1]]}
self.assertEqual(expected, fb)
def test_interaction(self):
docs = Document.get_many([1, 2, 3])
kws = Keyword.get_many(["redis", "database", "a", "the"])
inputs = [
"0 1", #docs
"0 1", #kws
"0 1", #kw in doc 1
"", #kw in doc 2, nothing
"2" #kw in doc 3
]
fb = self.app.interact_with_user(docs, kws, inputs)
expected = {
"docs": [[1L, 1], [2L, 1]],
"kws": [[u"redis", 1], [u"database", 1]],
"dockws": [[u"redis", 1L, 1], [u"database", 1L, 1],
[u"python", 3L, 1]],
}
self.assertEqual(expected, fb)
def recommend_documents(self, fmim,
session, top_n, mu, c,
sampler = None):
"""
return a list of document ids as well as the scores
"""
docs = Document.get_many(fmim.doc_ind.keys())
fbs = dict([(doc.id, doc.fb(session)) for doc in docs])
id_with_scores, id_with_explt_scores, id_with_explr_scores = self.generic_rank(fmim.doc2kw_m, fbs,
fmim.doc_ind,fmim.doc_ind_r,
mu, c)
docs = []
for doc_id, score in id_with_scores.items()[:top_n]:
doc = Document.get(doc_id)
doc["score"] = score
doc['recommended'] = True
docs.append(doc)
return docs
def test_recommend_keywords(self):
kws = self.r.recommend_keywords(Document.get_many([6, 1]),
5,
3,
query_keywords=Keyword.get_many([
"python", "redis", "non-existing"
]))
kw_from_recom_docs = kws[:3]
kw_from_assoc_docs = kws[3:]
self.assertEqual(5, len(kws))
self.assertEqual(
list(Keyword.get_many(["python", "redis"])),
kw_from_recom_docs[:2]) #the first two should be python and redis
for kw in kw_from_recom_docs:
self.assertTrue(kw["recommended"])
for kw in kw_from_assoc_docs:
self.assertFalse(kw["recommended"])
#no easy way to further test the elements of the kws
pass
def setUp(self):
init_recommender = QueryBasedRecommender(3, 2, 3, 2, **fmim.__dict__)
main_recommender = LinRelRecommender(3, 3, 1., .5, 1., .5, None, None,
None, None, **fmim.__dict__)
self.app = CmdApp(OnePassPropagator, OverrideUpdater, init_recommender,
main_recommender)
self.session = get_session()
#add recommended list
self.session.add_doc_recom_list(Document.get_many([1, 2, 3]))
self.session.add_kw_recom_list(
Keyword.get_many(["a", "redis", "database"]))
self.fb = {
"docs": [[1, .5]],
"kws": [["redis", .5]],
"dockws": [["redis", 1, .5]]
}
random.seed(123456)
def test_type_mismatch(self):
kw = Keyword.get("redis")
kwlist = Keyword.get_many(["database", "mysql"])
doc = Document.get(6)
doclist = Document.get_many([1, 2])
#doc to kw
self.assertRaises(AssertionError, kw.similarity_to, doc)
#kw to doc
self.assertRaises(AssertionError, doc.similarity_to, kw)
#kw to doclist
self.assertRaises(AssertionError, kw.similarity_to, doclist)
#doclist to kw
self.assertRaises(AssertionError, doclist.similarity_to, kw)
#doc to kwlist
self.assertRaises(AssertionError, doc.similarity_to, kwlist)
#kwlist to doc
self.assertRaises(AssertionError, kwlist.similarity_to, doc)
