def test_organic_topk_coldstart(self):
        """PrecomputedUserTopkBlueprintInterpreter test cold starts. """
        self._train_task()

        topk_req = MagicMock()
        topk_req.user_id = ['Foobar']
        topk_req.known_items = False
        topk_req.n_items = 20
        topk_req.threshold = None
        request = Request(scoring_data=topk_req)

        vertex = MagicMock()
        vertex.steps = [[self.task]]
        vertex_data = {'vertex_object': vertex}
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        model.vertex_factory = MagicMock()
        model.vertex_factory.get.return_value = vertex_data
        out = model.predict()
        self.assertEqual(len(out), len(topk_req.user_id))
        self.assertEqual(out[0][0], topk_req.user_id[0])
        topk = self.task.topk_[(-1, -1)]
        desired_items = map(lambda iid: topk.item_inv_map[iid], topk.coldstart_items[:topk_req.n_items])
        np.testing.assert_array_equal(out[0][1], desired_items)
        np.testing.assert_array_equal(out[0][2], topk.coldstart_ratings[:topk_req.n_items])

        # check if all output item ids are in training set
        item_set = set(np.unique(self.df['item_id']))
        items = out[0][1]
        for eid in items:
            self.assertTrue(eid in item_set)
    def test_organic_topk_smoke(self):
        """PrecomputedUserTopkBlueprintInterpreter smoke test. """
        self._train_task()

        topk_req = MagicMock()
        topk_req.user_id = ['UID-1']
        topk_req.known_items = False
        topk_req.n_items = 20
        topk_req.threshold = None
        request = Request(scoring_data=topk_req)

        vertex = MagicMock()
        vertex.steps = [[self.task]]
        vertex_data = {'vertex_object': vertex}
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        model.vertex_factory = MagicMock()
        model.vertex_factory.get.return_value = vertex_data
        out = model.predict()
        self.assertEqual(len(out), len(topk_req.user_id))
        self.assertEqual(out[0][0], topk_req.user_id[0])

        # check if all output item ids are in training set
        item_set = set(np.unique(self.df['item_id']))
        items = out[0][1]
        for eid in items:
            self.assertTrue(eid in item_set)
    def test_coldstart_threshold(self, mock_task_func):
        """Threshold applies to coldstart. """
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        topk_req = MagicMock()
        topk_req.user_id = ['UID-666']
        topk_req.known_items = False
        topk_req.n_items = 20
        topk_req.threshold = 3.1
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-666', [], tuple())])
    def test_threshold_known_items(self, mock_task_func):
        """Filter by threshold & known items - corner case with 0 items returned"""
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        topk_req = MagicMock()
        topk_req.user_id = ['UID-1']
        topk_req.known_items = False
        topk_req.n_items = 20
        topk_req.threshold = 1.0
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-1', [], tuple())])
    def test_coldstart_known(self, mock_task_func):
        """Known does not apply to coldstarts. """
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        topk_req = MagicMock()
        topk_req.user_id = ['UID-666']
        topk_req.known_items = False
        topk_req.n_items = 20
        topk_req.threshold = 3.0
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-666', ['IID-0', 'IID-1', 'IID-2'],
                               (3.0, 3.0, 3.0))])
    def test_known_items(self, mock_task_func):
        """Filter by known items"""
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        topk_req = MagicMock()
        topk_req.user_id = ['UID-1']
        topk_req.known_items = False
        topk_req.n_items = 20
        topk_req.threshold = None
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-1', ['IID-2'],
                                (0.1, ))])
    def test_threshold(self, mock_task_func):
        """Filter by threshold (filter out item IID-2)"""
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        topk_req = MagicMock()
        topk_req.user_id = ['UID-1']
        topk_req.known_items = True
        topk_req.n_items = 20
        topk_req.threshold = 1.0
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-1', ['IID-0', 'IID-1'],
                                (4.3, 2.3))])
    def test_smoke(self, mock_task_func):
        """Smoke test for PrecomputedUserTopkBlueprintInterpreter. """
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        # smoke test - get topk for UID-1
        topk_req = MagicMock()
        topk_req.user_id = ['UID-1']
        topk_req.known_items = True
        topk_req.n_items = 20
        topk_req.threshold = None
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-1', ['IID-0', 'IID-1', 'IID-2'],
                                (4.3, 2.3, 0.1))])
    def test_multiple_coldstart(self, mock_task_func):
        """Retrieve multiple user ids. """
        mock_task = MagicMock()
        mock_task.topk_ = {(-1, -1): self.topk}
        mock_task_func.return_value = mock_task

        topk_req = MagicMock()
        topk_req.user_id = ['UID-1', 'UID-666']
        topk_req.known_items = True
        topk_req.n_items = 20
        topk_req.threshold = None
        request = Request(scoring_data=topk_req)
        model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(),
                                                        request=request)
        out = model.predict()
        self.assertEqual(out, [('UID-1', ['IID-0', 'IID-1', 'IID-2'],
                                (4.3, 2.3, 0.1)),
                                ('UID-666', ['IID-0', 'IID-1', 'IID-2'],
                                (3.0, 3.0, 3.0))])