推荐系统_所有评价模块

1: BPR推荐______ ‘ndcg@10’: 0.0095, ‘hit@10’: 0.0753
3: GRU4RecF推荐. _ndcg@10 : 0.0417 hit@10 : 0.087
4:LightGCN推荐 ____ndcg@10 : 0.1337 hit@10 : 0.5652
5: BERT4Rec推荐 ___ndcg@10 : 0.0161 hit@10 : 0.0392
6:KGAT推荐 ________ndcg@10 : 0.0398 hit@10 : 0.2439
7:RippleNet推荐 _____ndcg@10 : 0.1109 hit@10 : 0.4867
2: XDeepFM推荐. _ ‘auc’: 0.5953, ‘logloss’: 0.6748

1: BPR推荐
在评价模块输入用户ID为用户推荐出来合适的商品

def full_sort_predict(self, interaction):
     user = interaction[self.USER_ID] #[1, 2]
     user_e = self.get_user_embedding(user)
     all_item_e = self.item_embedding.weight #[1683, 64]
     score = torch.matmul(user_e, all_item_e.transpose(0, 1)) #[2, 1683]
   return score.view(-1) 
1
2
3
4
5
6

求出来两个用户对分别对1683个商品的评分。
之后获取用户评分最高的的top10商品。top10的商品为推荐系统为用户推荐的商品，之后我们根据用户id获取evl数据中用户所对应的商品。我们根据这两者商品进行下面推荐指标的计算。

{‘recall@10’: 0.0083, ‘mrr@10’: 0.0214, ‘ndcg@10’: 0.0095, ‘hit@10’: 0.0753, ‘precision@10’: 0.0083}

2: XDeepFM推荐
对于评价模块输入是每个[batch_size, num_field, embed_dim]。因为采用的是0-1lable方式，我们对于每一条记录我们都可以将其传入特征提取模块，计算出来评分，然后根据每一条评分和lable的值，计算auc，以及logloss。

 def forward(self, interaction):
        # Get the output of CIN.
        xdeepfm_input = self.concat_embed_input_fields(interaction)  # [batch_size, num_field, embed_dim]
        cin_output = self.compressed_interaction_network(xdeepfm_input)
        cin_output = self.cin_linear(cin_output)
        # Get the output of MLP layer.
        batch_size = xdeepfm_input.shape[0]
        dnn_output = self.mlp_layers(xdeepfm_input.view(batch_size, -1))
        # Get predicted score.
        y_p = self.first_order_linear(interaction) + cin_output + dnn_output
        y = self.sigmoid(y_p)
        return y.squeeze(1)
1
2
3
4
5
6
7
8
9
10
11
12

{‘auc’: 0.5953, ‘logloss’: 0.6748}

3: GRU4RecF推荐
在评价模块中，输入是item序列，每个批次的长度为50 。input为[943, 50]。经过forward()函数提取特征输出为[943, 64]。获取test_items_emb商品数据[1683, 64]。获得每个item序列所对应的特征向量[943, 1683]。求出来943个用户对分别对1683个商品的评分。之后获取用户评分最高的的top10商品。top10的商品为推荐系统为用户推荐的商品，之后我们根据用户id获取evl数据中用户所对应的商品。我们根据这两者商品进行下面推荐指标的计算。

def full_sort_predict(self, interaction):
     item_seq = interaction[self.ITEM_SEQ]
     item_seq_len = interaction[self.ITEM_SEQ_LEN]
     seq_output = self.forward(item_seq, item_seq_len)
     test_items_emb = self.item_embedding.weight
     scores = torch.matmul(seq_output, test_items_emb.transpose(0, 1))  # [B n_items]
return scores
1
2
3
4
5
6
7

{recall@10 : 0.087 mrr@10 : 0.0283 ndcg@10 : 0.0417 hit@10 : 0.087 precision@10 : 0.0087 }

4:LightGCN推荐
在评价模块中，输入是用户ID序列。
求出来两个用户对分别对1683个商品的评分。
之后获取用户评分最高的的top10商品。top10的商品为推荐系统为用户推荐的商品，之后我们根据用户id获取evl数据中用户所对应的商品。我们根据这两者商品进行下面推荐指标的计算。

 def full_sort_predict(self, interaction):
     user = interaction[self.USER_ID]
     if self.restore_user_e is None or self.restore_item_e is None:
      self.restore_user_e, self.restore_item_e = self.forward()
        # get user embedding from storage variable
     u_embeddings = self.restore_user_e[user]
        # dot with all item embedding to accelerate
     scores = torch.matmul(u_embeddings, self.restore_item_e.transpose(0, 1))
     return scores.view(-1)
1
2
3
4
5
6
7
8
9

{recall@10 : 0.1235 mrr@10 : 0.2539 ndcg@10 : 0.1337 hit@10 : 0.5652 precision@10 : 0.0917 }

5: BERT4Rec推荐
在评价模块中，输入是item序列，每个批次的长度为50 。input为[943, 50]。经过forward()函数提取特征输出为[943, 64]。获取test_items_emb商品数据[1683, 64]。获得每个item序列所对应的特征向量[943, 1683]。求出来943个用户对分别对1683个商品的评分。之后获取用户评分最高的的top10商品。top10的商品为推荐系统为用户推荐的商品，之后我们根据用户id获取evl数据中用户所对应的商品。我们根据这两者商品进行下面推荐指标的计算。

def full_sort_predict(self, interaction):
        item_seq = interaction[self.ITEM_SEQ]
        item_seq_len = interaction[self.ITEM_SEQ_LEN]
        item_seq = self.reconstruct_test_data(item_seq, item_seq_len)
        seq_output = self.forward(item_seq)
        seq_output = self.gather_indexes(seq_output, item_seq_len - 1)  # [B H]
        test_items_emb = self.item_embedding.weight[:self.n_items]  # delete masked token
        scores = torch.matmul(seq_output, test_items_emb.transpose(0, 1))  # [B, item_num]
        return scores
1
2
3
4
5
6
7
8
9

{recall@10 : 0.0392 mrr@10 : 0.0094 ndcg@10 : 0.0161 hit@10 : 0.0392 precision@10 : 0.0039 }

6:KGAT推荐
在评价模块中，输入是用户ID序列。
求出来两个用户对分别对1683个商品的评分。
之后获取用户评分最高的的top10商品。top10的商品为推荐系统为用户推荐的商品，之后我们根据用户id获取evl数据中用户所对应的商品。我们根据这两者商品进行下面推荐指标的计算。

def full_sort_predict(self, interaction):
        user = interaction[self.USER_ID]
        if self.restore_user_e is None or self.restore_entity_e is None:
            self.restore_user_e, self.restore_entity_e = self.forward()
        u_embeddings = self.restore_user_e[user]
        i_embeddings = self.restore_entity_e[:self.n_items]

        scores = torch.matmul(u_embeddings, i_embeddings.transpose(0, 1))

        return scores.view(-1)
1
2
3
4
5
6
7
8
9
10

{recall@10 : 0.0342 mrr@10 : 0.0833 ndcg@10 : 0.0398 hit@10 : 0.2439 precision@10 : 0.0335 }

7:RippleNet推荐
在评价模块中，输入是用户的ID序列。
求出来两个用户对分别对1683个商品的评分。
之后获取用户评分最高的的top10商品。top10的商品为推荐系统为用户推荐的商品，之后我们根据用户id获取evl数据中用户所对应的商品。我们根据这两者商品进行下面推荐指标的计算。

 def full_sort_predict(self, interaction):
        users = interaction[self.USER_ID].cpu().numpy()
        memories_h, memories_r, memories_t = {}, {}, {}
        for hop in range(self.n_hop):
            memories_h[hop] = []
            memories_r[hop] = []
            memories_t[hop] = []
            for user in users:
                memories_h[hop].append(self.ripple_set[user][hop][0])
                memories_r[hop].append(self.ripple_set[user][hop][1])
                memories_t[hop].append(self.ripple_set[user][hop][2])
        # memories_h, memories_r, memories_t = self.ripple_set[user]
        # item = interaction[self.ITEM_ID]
        self.item_embeddings = self.entity_embedding.weight[:self.n_items]
        # self.item_embeddings = self.entity_embedding(item)

        self.h_emb_list = []
        self.r_emb_list = []
        self.t_emb_list = []
        for i in range(self.n_hop):
            # [batch size * n_memory]
            head_ent = torch.cat(memories_h[i], dim=0)
            relation = torch.cat(memories_r[i], dim=0)
            tail_ent = torch.cat(memories_t[i], dim=0)
            # self.logger.info("Hop {}, size {}".format(i, head_ent.size(), relation.size(), tail_ent.size()))

            # [batch size * n_memory, dim]
            self.h_emb_list.append(self.entity_embedding(head_ent))

            # [batch size * n_memory, dim * dim]
            self.r_emb_list.append(self.relation_embedding(relation))

            # [batch size * n_memory, dim]
            self.t_emb_list.append(self.entity_embedding(tail_ent))

        o_list = self._key_addressing_full()
        y = o_list[-1]
        for i in range(self.n_hop - 1):
            y = y + o_list[i]
        # [batch_size, n_item, dim] [batch_size, n_item, dim]
        scores = torch.sum(self.item_embeddings * y, dim=-1)
        return scores.view(-1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

{recall@10 : 0.0873 mrr@10 : 0.227 ndcg@10 : 0.1109 hit@10 : 0.4867 precision@10 : 0.0854 }