예제 #1
0
 def test_empty_sampling_rate_getSampleUserIDs(self):
     numUsers = 4
     minSimilarity = 0.0
     samplingRate = 0.0
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity, samplingRate)
     self.assertEquals(0, len(n.getSampleUserIDs()))
예제 #2
0
	def test_identity_estimatePreference(self):
		numUsers = 4
		userID = 'Marcel Caraciolo'
		otherUserID = 'Marcel Caraciolo'
		minSimilarity = 0.0
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity)
		self.assertEquals(None,n.estimatePreference(thingID=userID,similarity=self.similarity,otherUserID=otherUserID))
예제 #3
0
	def test_user_dissimilar_estimatePreference(self):
		numUsers = 4
		userID = 'Marcel Caraciolo'
		otherUserID = 'Maria Gabriela'
		minSimilarity = 0.0
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity)
		self.assertAlmostEquals(0.0,n.estimatePreference(thingID=userID,similarity=self.similarity,otherUserID=otherUserID))
예제 #4
0
	def test_estimatePreference(self):
		numUsers = 4
		userID = 'Marcel Caraciolo'
		otherUserID = 'Luciana Nunes'
		minSimilarity = 0.0
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity)
		self.assertAlmostEquals(0.294298055,n.estimatePreference(thingID=userID,similarity=self.similarity,otherUserID=otherUserID))
예제 #5
0
    def setUp(self):
        #SIMILARITY BY RATES.
        movies = {
            'Marcel Caraciolo': {
                'Lady in the Water': 2.5,
                'Snakes on a Plane': 3.5,
                'Just My Luck': 3.0,
                'Superman Returns': 3.5,
                'You, Me and Dupree': 2.5,
                'The Night Listener': 3.0
            },
            'Luciana Nunes': {
                'Lady in the Water': 3.0,
                'Snakes on a Plane': 3.5,
                'Just My Luck': 1.5,
                'Superman Returns': 5.0,
                'The Night Listener': 3.0,
                'You, Me and Dupree': 3.5
            },
            'Leopoldo Pires': {
                'Lady in the Water': 2.5,
                'Snakes on a Plane': 3.0,
                'Superman Returns': 3.5,
                'The Night Listener': 4.0
            },
            'Lorena Abreu': {
                'Snakes on a Plane': 3.5,
                'Just My Luck': 3.0,
                'The Night Listener': 4.5,
                'Superman Returns': 4.0,
                'You, Me and Dupree': 2.5
            },
            'Steve Gates': {
                'Lady in the Water': 3.0,
                'Snakes on a Plane': 4.0,
                'Just My Luck': 2.0,
                'Superman Returns': 3.0,
                'The Night Listener': 3.0,
                'You, Me and Dupree': 2.0
            },
            'Sheldom': {
                'Lady in the Water': 3.0,
                'Snakes on a Plane': 4.0,
                'The Night Listener': 3.0,
                'Superman Returns': 5.0,
                'You, Me and Dupree': 3.5
            },
            'Penny Frewman': {
                'Snakes on a Plane': 4.5,
                'You, Me and Dupree': 1.0,
                'Superman Returns': 4.0
            },
            'Maria Gabriela': {}
        }

        self.model = DictDataModel(movies)
        self.similarity = UserSimilarity(self.model, sim_euclidian)
        self.neighbor = NearestNUserNeighborhood(self.similarity, self.model,
                                                 4, 0.0)
예제 #6
0
	def test_userNeighborhood(self):
		numUsers = 4
		userID = 'Marcel Caraciolo'
		minSimilarity = 0.0
		scorer =  NaiveScorer()
		self.similarity = UserSimilarity(self.model,sim_tanimoto)
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity)
		self.assertEquals(['Luciana Nunes', 'Steve Gates', 'Lorena Abreu', 'Sheldom'],n.userNeighborhood(userID,scorer))
예제 #7
0
 def test_otherUserNeighborhood(self):
     numUsers = 4
     userID = 'Luciana Nunes'
     minSimilarity = 0.0
     scorer = TanHScorer()
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertEquals(
         ['Maria Gabriela', 'Penny Frewman', 'Steve Gates', 'Lorena Abreu'],
         n.userNeighborhood(userID, scorer))
예제 #8
0
 def test_userNeighborhood(self):
     numUsers = 4
     userID = 'Marcel Caraciolo'
     minSimilarity = 0.0
     scorer = NaiveScorer()
     self.similarity = UserSimilarity(self.model, sim_tanimoto)
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertEquals(
         ['Luciana Nunes', 'Steve Gates', 'Lorena Abreu', 'Sheldom'],
         n.userNeighborhood(userID, scorer))
예제 #9
0
 def test_identity_estimatePreference(self):
     numUsers = 4
     userID = 'Marcel Caraciolo'
     otherUserID = 'Marcel Caraciolo'
     minSimilarity = 0.0
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertEquals(
         None,
         n.estimatePreference(thingID=userID,
                              similarity=self.similarity,
                              otherUserID=otherUserID))
예제 #10
0
 def test_estimatePreference(self):
     numUsers = 4
     userID = 'Marcel Caraciolo'
     otherUserID = 'Luciana Nunes'
     minSimilarity = 0.0
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertAlmostEquals(
         0.294298055,
         n.estimatePreference(thingID=userID,
                              similarity=self.similarity,
                              otherUserID=otherUserID))
예제 #11
0
 def test_user_dissimilar_estimatePreference(self):
     numUsers = 4
     userID = 'Marcel Caraciolo'
     otherUserID = 'Maria Gabriela'
     minSimilarity = 0.0
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertAlmostEquals(
         0.0,
         n.estimatePreference(thingID=userID,
                              similarity=self.similarity,
                              otherUserID=otherUserID))
예제 #12
0
	def test_otherUserNeighborhood(self):
		numUsers = 4
		userID = 'Luciana Nunes'
		minSimilarity = 0.0
		scorer = TanHScorer()
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity)
		self.assertEquals(['Maria Gabriela', 'Penny Frewman', 'Steve Gates', 'Lorena Abreu'],n.userNeighborhood(userID,scorer))
예제 #13
0
 def test_invalid_UserID_userNeighborhood(self):
     numUsers = 4
     userID = 'Marcel'
     minSimilarity = 0.0
     scorer = NaiveScorer()
     self.similarity = UserSimilarity(self.model, sim_tanimoto)
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertRaises(ValueError, n.userNeighborhood, userID, scorer)
예제 #14
0
 def test_create_nearestNUserNeighborhood(self):
     numUsers = 4
     minSimilarity = 0.5
     samplingRate = 0.4
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity, samplingRate)
     self.assertEquals(n.similarity, self.similarity)
     self.assertEquals(n.samplingRate, samplingRate)
     self.assertEquals(n.numUsers, numUsers)
     self.assertEquals(self.model, n.model)
예제 #15
0
    def setUp(self):
        # SIMILARITY BY RATES.
        movies = {
            "Marcel Caraciolo": {
                "Lady in the Water": 2.5,
                "Snakes on a Plane": 3.5,
                "Just My Luck": 3.0,
                "Superman Returns": 3.5,
                "You, Me and Dupree": 2.5,
                "The Night Listener": 3.0,
            },
            "Luciana Nunes": {
                "Lady in the Water": 3.0,
                "Snakes on a Plane": 3.5,
                "Just My Luck": 1.5,
                "Superman Returns": 5.0,
                "The Night Listener": 3.0,
                "You, Me and Dupree": 3.5,
            },
            "Leopoldo Pires": {
                "Lady in the Water": 2.5,
                "Snakes on a Plane": 3.0,
                "Superman Returns": 3.5,
                "The Night Listener": 4.0,
            },
            "Lorena Abreu": {
                "Snakes on a Plane": 3.5,
                "Just My Luck": 3.0,
                "The Night Listener": 4.5,
                "Superman Returns": 4.0,
                "You, Me and Dupree": 2.5,
            },
            "Steve Gates": {
                "Lady in the Water": 3.0,
                "Snakes on a Plane": 4.0,
                "Just My Luck": 2.0,
                "Superman Returns": 3.0,
                "The Night Listener": 3.0,
                "You, Me and Dupree": 2.0,
            },
            "Sheldom": {
                "Lady in the Water": 3.0,
                "Snakes on a Plane": 4.0,
                "The Night Listener": 3.0,
                "Superman Returns": 5.0,
                "You, Me and Dupree": 3.5,
            },
            "Penny Frewman": {"Snakes on a Plane": 4.5, "You, Me and Dupree": 1.0, "Superman Returns": 4.0},
            "Maria Gabriela": {},
        }

        self.model = DictDataModel(movies)
        self.similarity = UserSimilarity(self.model, sim_euclidian)
        self.neighbor = NearestNUserNeighborhood(self.similarity, self.model, 4, 0.0)
예제 #16
0
 def test_minItems_UserItem_topItems(self):
     userID = 'Leopoldo Pires'
     numItems = 0
     allItemIDs = self.model.ItemIDs()
     preferenceEstimator = estimateUserItem
     n = NearestNUserNeighborhood(self.similarity, self.model, 4, 0.0)
     self.assertEquals([],
                       topItems(
                           userID,
                           allItemIDs,
                           numItems,
                           preferenceEstimator,
                           self.similarity,
                           None,
                           model=self.model,
                           neighborhood=n,
                       ))
예제 #17
0
 def test_UserItem_topItems(self):
     userID = 'Leopoldo Pires'
     numItems = 4
     allItemIDs = self.model.ItemIDs()
     preferenceEstimator = estimateUserItem
     rescorer = NaiveScorer()
     n = NearestNUserNeighborhood(self.similarity, self.model, 4, 0.0)
     self.assertEquals([
         'The Night Listener', 'Superman Returns', 'Snakes on a Plane',
         'Just My Luck'
     ],
                       topItems(userID,
                                allItemIDs,
                                numItems,
                                preferenceEstimator,
                                self.similarity,
                                None,
                                model=self.model,
                                neighborhood=n))
예제 #18
0
 def test_rescorer_UserItem_topItems(self):
     userID = 'Leopoldo Pires'
     numItems = 4
     allItemIDs = self.model.ItemIDs()
     preferenceEstimator = estimateUserItem
     rescorer = TanHScorer()
     n = NearestNUserNeighborhood(self.similarity, self.model, 4, 0.0)
     self.assertEquals([
         'Lady in the Water', 'You, Me and Dupree', 'Snakes on a Plane',
         'Superman Returns'
     ],
                       topItems(userID,
                                allItemIDs,
                                numItems,
                                preferenceEstimator,
                                self.similarity,
                                rescorer,
                                model=self.model,
                                neighborhood=n))
예제 #19
0
 def test_maxItems_UserItem_topItems(self):
     userID = 'Leopoldo Pires'
     numItems = 9
     allItemIDs = self.model.ItemIDs()
     preferenceEstimator = estimateUserItem
     n = NearestNUserNeighborhood(self.similarity, self.model, 4, 0.0)
     self.assertEquals([
         'The Night Listener', 'Superman Returns', 'Snakes on a Plane',
         'Just My Luck', 'Lady in the Water', 'You, Me and Dupree'
     ],
                       topItems(
                           userID,
                           allItemIDs,
                           numItems,
                           preferenceEstimator,
                           self.similarity,
                           None,
                           model=self.model,
                           neighborhood=n,
                       ))
예제 #20
0
	def setUp(self):
		#SIMILARITY BY RATES.
		movies={'Marcel Caraciolo': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,
		 'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5, 
		 'The Night Listener': 3.0},
		'Luciana Nunes': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5, 
		 'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0, 
		 'You, Me and Dupree': 3.5}, 
		'Leopoldo Pires': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,
		 'Superman Returns': 3.5, 'The Night Listener': 4.0},
		'Lorena Abreu': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,
		 'The Night Listener': 4.5, 'Superman Returns': 4.0, 
		 'You, Me and Dupree': 2.5},
		'Steve Gates': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, 
		 'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,
		 'You, Me and Dupree': 2.0}, 
		'Sheldom': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
		 'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},
		'Penny Frewman': {'Snakes on a Plane':4.5,'You, Me and Dupree':1.0,'Superman Returns':4.0},
		'Maria Gabriela': {}}

		self.model = DictDataModel(movies)
		self.similarity = UserSimilarity(self.model,sim_euclidian)
		self.neighbor = NearestNUserNeighborhood(self.similarity,self.model,4,0.0)
예제 #21
0
	def test_min_numUsers_getSampleUserIDs(self):
		numUsers = 4
		minSimilarity = 0.0
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity)				
		self.assertEquals(8,len(n.getSampleUserIDs()))
예제 #22
0
	def test_empty_sampling_rate_getSampleUserIDs(self):
		numUsers = 4
		minSimilarity = 0.0
		samplingRate = 0.0
		n = NearestNUserNeighborhood(self.similarity,self.model,numUsers,minSimilarity,samplingRate)				
		self.assertEquals(0,len(n.getSampleUserIDs()))
예제 #23
0
 def test_min_numUsers_getSampleUserIDs(self):
     numUsers = 4
     minSimilarity = 0.0
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertEquals(8, len(n.getSampleUserIDs()))
예제 #24
0
 def test_maximum_limit_getSampleUserIDs(self):
     numUsers = 9
     minSimilarity = 0.0
     n = NearestNUserNeighborhood(self.similarity, self.model, numUsers,
                                  minSimilarity)
     self.assertEquals(8, n.numUsers)
예제 #25
0
class TestUserBasedRecommender(unittest.TestCase):
    def setUp(self):
        # SIMILARITY BY RATES.
        movies = {
            "Marcel Caraciolo": {
                "Lady in the Water": 2.5,
                "Snakes on a Plane": 3.5,
                "Just My Luck": 3.0,
                "Superman Returns": 3.5,
                "You, Me and Dupree": 2.5,
                "The Night Listener": 3.0,
            },
            "Luciana Nunes": {
                "Lady in the Water": 3.0,
                "Snakes on a Plane": 3.5,
                "Just My Luck": 1.5,
                "Superman Returns": 5.0,
                "The Night Listener": 3.0,
                "You, Me and Dupree": 3.5,
            },
            "Leopoldo Pires": {
                "Lady in the Water": 2.5,
                "Snakes on a Plane": 3.0,
                "Superman Returns": 3.5,
                "The Night Listener": 4.0,
            },
            "Lorena Abreu": {
                "Snakes on a Plane": 3.5,
                "Just My Luck": 3.0,
                "The Night Listener": 4.5,
                "Superman Returns": 4.0,
                "You, Me and Dupree": 2.5,
            },
            "Steve Gates": {
                "Lady in the Water": 3.0,
                "Snakes on a Plane": 4.0,
                "Just My Luck": 2.0,
                "Superman Returns": 3.0,
                "The Night Listener": 3.0,
                "You, Me and Dupree": 2.0,
            },
            "Sheldom": {
                "Lady in the Water": 3.0,
                "Snakes on a Plane": 4.0,
                "The Night Listener": 3.0,
                "Superman Returns": 5.0,
                "You, Me and Dupree": 3.5,
            },
            "Penny Frewman": {"Snakes on a Plane": 4.5, "You, Me and Dupree": 1.0, "Superman Returns": 4.0},
            "Maria Gabriela": {},
        }

        self.model = DictDataModel(movies)
        self.similarity = UserSimilarity(self.model, sim_euclidian)
        self.neighbor = NearestNUserNeighborhood(self.similarity, self.model, 4, 0.0)

    def test_create_UserBasedRecommender(self):
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        self.assertEquals(recSys.similarity, self.similarity)
        self.assertEquals(recSys.capper, True)
        self.assertEquals(recSys.neighborhood, self.neighbor)
        self.assertEquals(recSys.model, self.model)

    def test_all_watched_allOtherItems(self):
        userID = "Luciana Nunes"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        nearestN = self.neighbor.userNeighborhood(userID)
        self.assertEquals([], recSys.allOtherItems(userID, nearestN))

    def test_semi_watched_allOtherItems(self):
        userID = "Leopoldo Pires"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        nearestN = self.neighbor.userNeighborhood(userID)
        self.assertEquals(["Just My Luck", "You, Me and Dupree"], recSys.allOtherItems(userID, nearestN))

    def test_non_watched_allOtherItems(self):
        userID = "Maria Gabriela"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        nearestN = self.neighbor.userNeighborhood(userID)
        self.assertEquals(
            [
                "Lady in the Water",
                "Snakes on a Plane",
                "Just My Luck",
                "Superman Returns",
                "You, Me and Dupree",
                "The Night Listener",
            ],
            recSys.allOtherItems(userID, nearestN),
        )

    def test_mostSimilarUserIDs(self):
        userID = "Marcel Caraciolo"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        self.assertEquals(
            ["Leopoldo Pires", "Steve Gates", "Lorena Abreu", "Penny Frewman"], recSys.mostSimilarUserIDs(userID, 4)
        )

    def test_user_no_preference_mostSimilarUserIDs(self):
        userID = "Maria Gabriela"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        self.assertEquals(
            ["Leopoldo Pires", "Lorena Abreu", "Luciana Nunes", "Marcel Caraciolo"],
            recSys.mostSimilarUserIDs(userID, 4),
        )

    def test_empty_mostSimilarUserIDs(self):
        userID = "Maria Gabriela"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        self.assertEquals([], recSys.mostSimilarUserIDs(userID, 0))

    def test_local_estimatePreference(self):
        userID = "Marcel Caraciolo"
        itemID = "Superman Returns"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        self.assertAlmostEquals(
            3.5, recSys.estimatePreference(userID=userID, similarity=self.similarity, itemID=itemID)
        )

    def test_local_not_existing_estimatePreference(self):
        userID = "Leopoldo Pires"
        itemID = "You, Me and Dupree"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, True)
        self.assertAlmostEquals(
            2.065394689, recSys.estimatePreference(userID=userID, similarity=self.similarity, itemID=itemID)
        )

    def test_local_not_existing_capper_False_estimatePreference(self):
        userID = "Leopoldo Pires"
        itemID = "You, Me and Dupree"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, False)
        self.assertAlmostEquals(
            2.065394689, recSys.estimatePreference(userID=userID, similarity=self.similarity, itemID=itemID)
        )

    def test_local_not_existing_rescorer_estimatePreference(self):
        userID = "Leopoldo Pires"
        itemID = "You, Me and Dupree"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, False)
        scorer = TanHScorer()
        self.assertAlmostEquals(
            2.5761016605,
            recSys.estimatePreference(userID=userID, similarity=self.similarity, itemID=itemID, rescorer=scorer),
        )

    def test_recommend(self):
        userID = "Leopoldo Pires"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, False)
        self.assertEquals(["Just My Luck", "You, Me and Dupree"], recSys.recommend(userID, 4))

    def test_empty_recommend(self):
        userID = "Marcel Caraciolo"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, False)
        self.assertEquals([], recSys.recommend(userID, 4))

    def test_full_recommend(self):
        userID = "Maria Gabriela"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, False)
        self.assertEquals([], recSys.recommend(userID, 4))

    def test_semi_recommend(self):
        userID = "Leopoldo Pires"
        recSys = UserRecommender(self.model, self.similarity, self.neighbor, False)
        self.assertEquals(["Just My Luck"], recSys.recommend(userID, 1))
예제 #26
0
class TestUserBasedRecommender(unittest.TestCase):
    def setUp(self):
        #SIMILARITY BY RATES.
        movies = {
            'Marcel Caraciolo': {
                'Lady in the Water': 2.5,
                'Snakes on a Plane': 3.5,
                'Just My Luck': 3.0,
                'Superman Returns': 3.5,
                'You, Me and Dupree': 2.5,
                'The Night Listener': 3.0
            },
            'Luciana Nunes': {
                'Lady in the Water': 3.0,
                'Snakes on a Plane': 3.5,
                'Just My Luck': 1.5,
                'Superman Returns': 5.0,
                'The Night Listener': 3.0,
                'You, Me and Dupree': 3.5
            },
            'Leopoldo Pires': {
                'Lady in the Water': 2.5,
                'Snakes on a Plane': 3.0,
                'Superman Returns': 3.5,
                'The Night Listener': 4.0
            },
            'Lorena Abreu': {
                'Snakes on a Plane': 3.5,
                'Just My Luck': 3.0,
                'The Night Listener': 4.5,
                'Superman Returns': 4.0,
                'You, Me and Dupree': 2.5
            },
            'Steve Gates': {
                'Lady in the Water': 3.0,
                'Snakes on a Plane': 4.0,
                'Just My Luck': 2.0,
                'Superman Returns': 3.0,
                'The Night Listener': 3.0,
                'You, Me and Dupree': 2.0
            },
            'Sheldom': {
                'Lady in the Water': 3.0,
                'Snakes on a Plane': 4.0,
                'The Night Listener': 3.0,
                'Superman Returns': 5.0,
                'You, Me and Dupree': 3.5
            },
            'Penny Frewman': {
                'Snakes on a Plane': 4.5,
                'You, Me and Dupree': 1.0,
                'Superman Returns': 4.0
            },
            'Maria Gabriela': {}
        }

        self.model = DictDataModel(movies)
        self.similarity = UserSimilarity(self.model, sim_euclidian)
        self.neighbor = NearestNUserNeighborhood(self.similarity, self.model,
                                                 4, 0.0)

    def test_create_UserBasedRecommender(self):
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        self.assertEquals(recSys.similarity, self.similarity)
        self.assertEquals(recSys.capper, True)
        self.assertEquals(recSys.neighborhood, self.neighbor)
        self.assertEquals(recSys.model, self.model)

    def test_all_watched_allOtherItems(self):
        userID = 'Luciana Nunes'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        nearestN = self.neighbor.userNeighborhood(userID)
        self.assertEquals([], recSys.allOtherItems(userID, nearestN))

    def test_semi_watched_allOtherItems(self):
        userID = 'Leopoldo Pires'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        nearestN = self.neighbor.userNeighborhood(userID)
        self.assertEquals(['Just My Luck', 'You, Me and Dupree'],
                          recSys.allOtherItems(userID, nearestN))

    def test_non_watched_allOtherItems(self):
        userID = 'Maria Gabriela'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        nearestN = self.neighbor.userNeighborhood(userID)
        self.assertEquals([
            'Lady in the Water', 'Snakes on a Plane', 'Just My Luck',
            'Superman Returns', 'You, Me and Dupree', 'The Night Listener'
        ], recSys.allOtherItems(userID, nearestN))

    def test_mostSimilarUserIDs(self):
        userID = 'Marcel Caraciolo'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        self.assertEquals(
            ['Leopoldo Pires', 'Steve Gates', 'Lorena Abreu', 'Penny Frewman'],
            recSys.mostSimilarUserIDs(userID, 4))

    def test_user_no_preference_mostSimilarUserIDs(self):
        userID = 'Maria Gabriela'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        self.assertEquals([
            'Leopoldo Pires', 'Lorena Abreu', 'Luciana Nunes',
            'Marcel Caraciolo'
        ], recSys.mostSimilarUserIDs(userID, 4))

    def test_empty_mostSimilarUserIDs(self):
        userID = 'Maria Gabriela'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        self.assertEquals([], recSys.mostSimilarUserIDs(userID, 0))

    def test_local_estimatePreference(self):
        userID = 'Marcel Caraciolo'
        itemID = 'Superman Returns'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        self.assertAlmostEquals(
            3.5,
            recSys.estimatePreference(userID=userID,
                                      similarity=self.similarity,
                                      itemID=itemID))

    def test_local_not_existing_estimatePreference(self):
        userID = 'Leopoldo Pires'
        itemID = 'You, Me and Dupree'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 True)
        self.assertAlmostEquals(
            2.065394689,
            recSys.estimatePreference(userID=userID,
                                      similarity=self.similarity,
                                      itemID=itemID))

    def test_local_not_existing_capper_False_estimatePreference(self):
        userID = 'Leopoldo Pires'
        itemID = 'You, Me and Dupree'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 False)
        self.assertAlmostEquals(
            2.065394689,
            recSys.estimatePreference(userID=userID,
                                      similarity=self.similarity,
                                      itemID=itemID))

    def test_local_not_existing_rescorer_estimatePreference(self):
        userID = 'Leopoldo Pires'
        itemID = 'You, Me and Dupree'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 False)
        scorer = TanHScorer()
        self.assertAlmostEquals(
            2.5761016605,
            recSys.estimatePreference(userID=userID,
                                      similarity=self.similarity,
                                      itemID=itemID,
                                      rescorer=scorer))

    def test_recommend(self):
        userID = 'Leopoldo Pires'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 False)
        self.assertEquals(['Just My Luck', 'You, Me and Dupree'],
                          recSys.recommend(userID, 4))

    def test_empty_recommend(self):
        userID = 'Marcel Caraciolo'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 False)
        self.assertEquals([], recSys.recommend(userID, 4))

    def test_full_recommend(self):
        userID = 'Maria Gabriela'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 False)
        self.assertEquals([], recSys.recommend(userID, 4))

    def test_semi_recommend(self):
        userID = 'Leopoldo Pires'
        recSys = UserRecommender(self.model, self.similarity, self.neighbor,
                                 False)
        self.assertEquals(['Just My Luck'], recSys.recommend(userID, 1))
예제 #27
0
class TestUserBasedRecommender(unittest.TestCase):
	
	def setUp(self):
		#SIMILARITY BY RATES.
		movies={'Marcel Caraciolo': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,
		 'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5, 
		 'The Night Listener': 3.0},
		'Luciana Nunes': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5, 
		 'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0, 
		 'You, Me and Dupree': 3.5}, 
		'Leopoldo Pires': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,
		 'Superman Returns': 3.5, 'The Night Listener': 4.0},
		'Lorena Abreu': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,
		 'The Night Listener': 4.5, 'Superman Returns': 4.0, 
		 'You, Me and Dupree': 2.5},
		'Steve Gates': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, 
		 'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,
		 'You, Me and Dupree': 2.0}, 
		'Sheldom': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
		 'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},
		'Penny Frewman': {'Snakes on a Plane':4.5,'You, Me and Dupree':1.0,'Superman Returns':4.0},
		'Maria Gabriela': {}}

		self.model = DictDataModel(movies)
		self.similarity = UserSimilarity(self.model,sim_euclidian)
		self.neighbor = NearestNUserNeighborhood(self.similarity,self.model,4,0.0)
		
	
	def test_create_UserBasedRecommender(self):
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		self.assertEquals(recSys.similarity,self.similarity)
		self.assertEquals(recSys.capper,True)
		self.assertEquals(recSys.neighborhood,self.neighbor)
		self.assertEquals(recSys.model,self.model)
	
	
	def test_all_watched_allOtherItems(self):
		userID = 'Luciana Nunes'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		nearestN = self.neighbor.userNeighborhood(userID)
		self.assertEquals([],recSys.allOtherItems(userID,nearestN))	
		
	def test_semi_watched_allOtherItems(self):
		userID = 'Leopoldo Pires'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		nearestN = self.neighbor.userNeighborhood(userID)
		self.assertEquals(['Just My Luck', 'You, Me and Dupree'],recSys.allOtherItems(userID,nearestN))	

	def test_non_watched_allOtherItems(self):
		userID = 'Maria Gabriela'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		nearestN = self.neighbor.userNeighborhood(userID)
		self.assertEquals(['Lady in the Water', 'Snakes on a Plane', 'Just My Luck', 'Superman Returns', 
							'You, Me and Dupree', 'The Night Listener'],recSys.allOtherItems(userID,nearestN))

	def test_mostSimilarUserIDs(self):
		userID = 'Marcel Caraciolo'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		self.assertEquals(['Leopoldo Pires', 'Steve Gates', 'Lorena Abreu', 'Penny Frewman'],recSys.mostSimilarUserIDs(userID,4))	
	
	def test_user_no_preference_mostSimilarUserIDs(self):
		userID = 'Maria Gabriela'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		self.assertEquals(['Leopoldo Pires', 'Lorena Abreu', 'Luciana Nunes', 'Marcel Caraciolo'],recSys.mostSimilarUserIDs(userID,4))
	
	
	def test_empty_mostSimilarUserIDs(self):
		userID = 'Maria Gabriela'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		self.assertEquals([],recSys.mostSimilarUserIDs(userID,0))
	
	def test_local_estimatePreference(self):
		userID = 'Marcel Caraciolo'
		itemID = 'Superman Returns'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		self.assertAlmostEquals(3.5,recSys.estimatePreference(userID=userID,similarity=self.similarity,itemID=itemID))
		
		
	def test_local_not_existing_estimatePreference(self):
		userID = 'Leopoldo Pires'
		itemID = 'You, Me and Dupree'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,True)
		self.assertAlmostEquals(2.065394689,recSys.estimatePreference(userID=userID,similarity=self.similarity,itemID=itemID))
		

	def test_local_not_existing_capper_False_estimatePreference(self):
		userID = 'Leopoldo Pires'
		itemID = 'You, Me and Dupree'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,False)
		self.assertAlmostEquals(2.065394689,recSys.estimatePreference(userID=userID,similarity=self.similarity,itemID=itemID))
	
	
	def test_local_not_existing_rescorer_estimatePreference(self):
		userID = 'Leopoldo Pires'
		itemID = 'You, Me and Dupree'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,False)
		scorer = TanHScorer()
		self.assertAlmostEquals(2.5761016605,recSys.estimatePreference(userID=userID,similarity=self.similarity,itemID=itemID,rescorer=scorer))

	def test_recommend(self):
		userID = 'Leopoldo Pires'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,False)
		self.assertEquals(['Just My Luck', 'You, Me and Dupree'],recSys.recommend(userID,4))
		
	
	def test_empty_recommend(self):
		userID = 'Marcel Caraciolo'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,False)
		self.assertEquals([],recSys.recommend(userID,4))
	
	def test_full_recommend(self):
		userID = 'Maria Gabriela'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,False)
		self.assertEquals([],recSys.recommend(userID,4))

	def test_semi_recommend(self):
		userID = 'Leopoldo Pires'
		recSys = UserRecommender(self.model,self.similarity,self.neighbor,False)
		self.assertEquals(['Just My Luck'],recSys.recommend(userID,1))