Esempio n. 1
0
    def eval_one_epoch(self, epoch):
        uid1, iid1, uid2, iid2 = [], [], [], []
        for u in range(self.num_user1):
            uid1.extend([u] * self.num_ranking_list)
            iid1.extend(self.test_dict1[u])
            uid2.extend([u] * self.num_ranking_list)
            iid2.extend(self.test_dict2[u])

        batch_size = self.num_ranking_list

        n_batches = 0
        n_mrr1 = 0
        n_mrr2 = 0
        total_hr1 = 0
        total_hr2 = 0
        total_ndcg1 = 0
        total_ndcg2 = 0
        total_mrr1 = 0
        total_mrr2 = 0

        for i in range(self.num_user1):
            batch_uid1, batch_iid1, batch_uid2, batch_iid2 = \
                uid1[i * batch_size:(i+1) * batch_size],\
                iid1[i * batch_size:(i+1) * batch_size],\
                uid2[i * batch_size:(i+1) * batch_size],\
                iid2[i * batch_size:(i+1) * batch_size]

            rk1, rk2 = self.session.run(
                [self.scores1, self.scores2],
                feed_dict={
                    self.dom1_uid: batch_uid1,
                    self.dom1_iid: batch_iid1,
                    self.dom2_uid: batch_uid2,
                    self.dom2_iid: batch_iid2
                })

            _, hr1, ndcg1, mrr1 = evl.evalTopK(rk1, batch_iid1, self.topk)
            _, hr2, ndcg2, mrr2 = evl.evalTopK(rk2, batch_iid2, self.topk)

            n_batches += 1
            total_hr1 += hr1
            total_hr2 += hr2
            total_ndcg1 += ndcg1
            total_ndcg2 += ndcg2
            if np.isinf(mrr1):
                pass
            else:
                n_mrr1 += 1
                total_mrr1 += mrr1
            if np.isinf(mrr2):
                pass
            else:
                n_mrr2 += 1
                total_mrr2 += mrr2
        print("Epoch {0}: [HR] {1} and {2}".format(epoch,
                                                   total_hr1 / n_batches,
                                                   total_hr2 / n_batches))
        print("Epoch {0}: [nDCG@{1}] {2} and {3}".format(
            epoch, self.topk, total_ndcg1 / n_batches,
            total_ndcg2 / n_batches))
Esempio n. 2
0
    def eval_one_epoch(self, session, init, epoch):
        session.run(init)
        self.training = False
        n_batches = 0
        n_mrr1 = 0
        n_mrr2 = 0
        total_hr1 = 0
        total_hr2 = 0
        total_ndcg1 = 0
        total_ndcg2 = 0
        total_mrr1 = 0
        total_mrr2 = 0

        try:
            while True:
                rk1, rk2, iid1, iid2 = session.run(
                    [self.scores1, self.scores2, self.dom1_iid, self.dom2_iid])
                _, hr1, ndcg1, mrr1 = evl.evalTopK(rk1, iid1, self.K)
                _, hr2, ndcg2, mrr2 = evl.evalTopK(rk2, iid2, self.K)
                n_batches += 1
                total_hr1 += hr1
                total_hr2 += hr2
                total_ndcg1 += ndcg1
                total_ndcg2 += ndcg2
                if np.isinf(mrr1):
                    pass
                else:
                    n_mrr1 += 1
                    total_mrr1 += mrr1
                if np.isinf(mrr2):
                    pass
                else:
                    n_mrr2 += 1
                    total_mrr2 += mrr2
        except tf.errors.OutOfRangeError:
            pass

        print("Epoch {0}: [HR] {1} and {2}".format(epoch,
                                                   total_hr1 / n_batches,
                                                   total_hr2 / n_batches))
        print("Epoch {0}: [nDCG@{1}] {2} and {3}".format(
            epoch, self.K, total_ndcg1 / n_batches, total_ndcg2 / n_batches))
Esempio n. 3
0
    def eval_one_epoch_np(self, epoch):
        # Ranking in all the testing data
        n_batches, n_mrr, total_hr, total_ndcg, total_mrr = 0, 0, 0, 0, 0

        for uid in self.ranking_dict:
            # Prediction to form the ranking list
            rk = []
            for iid in self.ranking_dict[uid]:
                rk.append(np.dot(self.P[uid, :], self.Q[iid, :]))

            _, hr, ndcg, mrr = evl.evalTopK(rk, self.test_dict[uid], self.topk)

            n_batches += 1
            total_hr += hr
            total_ndcg += ndcg
            if np.isinf(mrr):
                pass
            else:
                n_mrr += 1
                total_mrr += mrr

        print("Epoch {0}: [HR] {1} and [nDCG@{2}] {3}".format(
            epoch, total_hr / n_batches, self.topk, total_ndcg / n_batches))