review rec

Author: shawroad

Review_REC/D-Attn/config.py

@@ -0,0 +1,41 @@
+"""
+@file   : config.py
+@time   : 2024-07-16
+"""
+import argparse
+
+
+def set_args():
+    parser = argparse.ArgumentParser(description='基于用户评论的推荐')
+    parser.add_argument('--output_dir', type=str, default='./output', help='输入的模型保存的路径')
+    parser.add_argument('--train_data', type=str, default='./data/train.csv', help='训练数据')
+    parser.add_argument('--dev_data', type=str, default='./data/valid.csv', help='验证集')
+    parser.add_argument('--word2vec_file', type=str, default='./data/glove.6B.300d.txt', help='词向量文件')
+
+    parser.add_argument('--batch_size', type=int, default=64, help='批次大小')
+    parser.add_argument('--num_epochs', type=int, default=50, help='训练多少轮')
+
+    parser.add_argument('--lowest_review_count', type=int, default=2)
+    parser.add_argument('--review_length', type=int, default=40)
+    parser.add_argument('--review_count', type=int, default=10)
+
+    parser.add_argument('--learning_rate', type=float, default=2e-5, help='学习率')
+    parser.add_argument('--l2_regularization', type=float, default=1e-6, help='权重衰减程度')
+    parser.add_argument('--learning_rate_decay', type=float, default=0.99, help='学习率衰减')
+
+    parser.add_argument('--kernel_count', type=int, default=100, help='卷积核个数')
+
+    parser.add_argument('--kernel_size', type=int, default=3, help='卷积核尺寸')
+    parser.add_argument('--dropout_prob', type=float, default=0.5, help='dropout rate')
+    parser.add_argument('--cnn_out_dim', type=int, default=50, help='cnn的输出')
+
+    parser.add_argument('--logging_steps', type=int, default=5, help='每间隔几步记录一次loss变化')
+    parser.add_argument('--seed', default=2024, type=int, help='随机种子')
+
+    parser.add_argument('--pointer_count', type=int, default=2)
+    parser.add_argument('--fm_hidden', type=int, default=10)
+
+    parser.add_argument('--filters_num', type=int, default=100)
+    parser.add_argument('--id_emb_size', type=int, default=32)
+    args = parser.parse_args()
+    return args

Review_REC/D-Attn/data_helper.py

@@ -0,0 +1,97 @@
+"""
+@file   : data_helper.py
+@time   : 2024-07-16
+"""
+import torch
+import pandas as pd
+from config import set_args
+from torch.utils.data import Dataset
+
+
+args = set_args()
+
+
+def load_embedding(word2vec_file):
+    with open(word2vec_file, encoding='utf-8') as f:
+        word_emb = list()
+        word_dict = dict()
+        word_emb.append([0])
+        word_dict['<UNK>'] = 0
+        for line in f.readlines():
+            tokens = line.split(' ')
+            word_emb.append([float(i) for i in tokens[1:]])
+            word_dict[tokens[0]] = len(word_dict)
+        word_emb[0] = [0] * len(word_emb[1])
+    return word_emb, word_dict
+
+
+class Review_REDataset(Dataset):
+    def __init__(self, data_path, word_dict, retain_rui=True):
+        self.word_dict = word_dict
+        self.PAD_WORD_idx = self.word_dict["<UNK>"]
+        self.retain_rui = retain_rui  # 是否在最终样本中，保留user和item的公共review
+        self.lowest_r_count = args.lowest_review_count  # lowest amount of reviews wrote by exactly one user/item
+        self.review_length = args.review_length
+        self.review_count = args.review_count
+
+        df = pd.read_csv(data_path, header=None, names=['userID', 'itemID', 'review', 'rating'])
+        df['review'] = df['review'].apply(self._review2id)  # 分词->数字
+        # print(df.head())
+        '''
+            userID  itemID                                             review  rating
+        0    3748     934  [366, 1780, 6381, 79575, 10268, 0, 1590, 17427...       4
+        1    4795    2280  [3538, 1575, 9038, 1138, 0, 8391, 12971, 2685,...       5
+        '''
+        self.sparse_idx = set()  # 暂存稀疏样本的下标，最后删除他们
+        user_reviews = self._get_reviews(df)  # 收集每个user的评论列表
+        # print(user_reviews.size())   # torch.Size([51764, 10, 40])
+        item_reviews = self._get_reviews(df, 'itemID', 'userID')
+        # print(item_reviews.size())   # torch.Size([51764, 10, 40])
+
+        rating = torch.Tensor(df['rating'].to_list()).view(-1, 1)
+
+        self.user_reviews = user_reviews[[idx for idx in range(user_reviews.shape[0]) if idx not in self.sparse_idx]]
+        self.item_reviews = item_reviews[[idx for idx in range(item_reviews.shape[0]) if idx not in self.sparse_idx]]
+        self.rating = rating[[idx for idx in range(rating.shape[0]) if idx not in self.sparse_idx]]
+
+    def __getitem__(self, idx):
+        return self.user_reviews[idx], self.item_reviews[idx], self.rating[idx]
+
+    def __len__(self):
+        return self.rating.shape[0]
+
+    def _get_reviews(self, df, lead='userID', costar='itemID'):
+        # 对于每条训练数据，生成用户的所有评论汇总
+        reviews_by_lead = dict(list(df[[costar, 'review']].groupby(df[lead])))  # 每个user/item评论汇总
+
+        lead_reviews = []
+        for idx, (lead_id, costar_id) in enumerate(zip(df[lead], df[costar])):
+            # userid   itemid
+            df_data = reviews_by_lead[lead_id]  # 取出lead的所有评论：DataFrame
+            if self.retain_rui:
+                reviews = df_data['review'].to_list()  # 取lead所有评论：列表
+            else:
+                reviews = df_data['review'][df_data[costar] != costar_id].to_list()  # 不含lead与costar的公共评论
+
+            if len(reviews) < self.lowest_r_count:
+                self.sparse_idx.add(idx)
+            reviews = self._adjust_review_list(reviews, self.review_length, self.review_count)
+            lead_reviews.append(reviews)
+        return torch.LongTensor(lead_reviews)
+
+    def _adjust_review_list(self, reviews, r_length, r_count):
+        reviews = reviews[:r_count] + [[self.PAD_WORD_idx] * r_length] * (r_count - len(reviews))  # 评论数量固定
+        reviews = [r[:r_length] + [0] * (r_length - len(r)) for r in reviews]  # 每条评论定长
+        return reviews
+
+    def _review2id(self, review):
+        # 将一个评论字符串分词并转为数字
+        if not isinstance(review, str):
+            return []
+        wids = []
+        for word in review.split():
+            if word in self.word_dict:
+                wids.append(self.word_dict[word])  # 单词映射为数字
+            else:
+                wids.append(self.PAD_WORD_idx)
+        return wids

Review_REC/D-Attn/model.py

@@ -0,0 +1,129 @@
+"""
+@file   : model.py
+@time   : 2024-07-16
+"""
+
+import torch
+import torch.nn as nn
+from config import set_args
+import torch.nn.functional as F
+
+args = set_args()
+
+
+class LocalAttention(nn.Module):
+    def __init__(self, seq_len, win_size, emb_size, filters_num):
+        super(LocalAttention, self).__init__()
+        self.att_conv = nn.Sequential(
+            nn.Conv2d(1, 1, kernel_size=(win_size, emb_size), padding=((win_size-1)//2, 0)),
+            nn.Sigmoid()
+        )
+        self.cnn = nn.Conv2d(1, filters_num, kernel_size=(1, emb_size))
+
+    def forward(self, x):
+        # print(x.size())   #  torch.Size([64, 10, 300])
+        score = self.att_conv(x.unsqueeze(1)).squeeze(1)
+        # print(score.size())   #  torch.Size([64, 10, 1])
+        out = x.mul(score)
+
+        out = out.unsqueeze(1)   # torch.Size([64, 1, 10, 300])
+        out = torch.tanh(self.cnn(out)).squeeze(3)
+        # print(out.size())    #  torch.Size([64, 100, 10])
+        out = F.max_pool1d(out, out.size(2)).squeeze(2)
+        # print(out.size())    #  torch.Size([64, 100])
+        return out
+
+
+class GlobalAttention(nn.Module):
+    def __init__(self, seq_len, emb_size, filters_size=[2, 3, 4], filters_num=100):
+        super(GlobalAttention, self).__init__()
+        self.att_conv = nn.Sequential(
+            nn.Conv2d(1, 1, kernel_size=(seq_len, emb_size)),
+            nn.Sigmoid()
+        )
+        self.convs = nn.ModuleList([nn.Conv2d(1, filters_num, (k, emb_size)) for k in filters_size])
+
+    def forward(self, x):
+        x = x.unsqueeze(1)
+        score = self.att_conv(x)
+        x = x.mul(score)
+        conv_outs = [torch.tanh(cnn(x).squeeze(3)) for cnn in self.convs]
+        conv_outs = [F.max_pool1d(out, out.size(2)).squeeze(2) for out in conv_outs]
+        return conv_outs
+
+
+class Net(nn.Module):
+    def __init__(self, word_emb):
+        super(Net, self).__init__()
+        self.embedding = nn.Embedding.from_pretrained(torch.Tensor(word_emb))
+        emb_size = self.embedding.embedding_dim
+        self.local_att = LocalAttention(args.review_count, win_size=5, emb_size=emb_size, filters_num=args.filters_num)
+        self.global_att = GlobalAttention(args.review_count, emb_size=emb_size, filters_num=args.filters_num)
+
+        fea_dim = args.filters_num * 4
+        self.fc = nn.Sequential(
+            nn.Linear(fea_dim, fea_dim),
+            nn.Dropout(0.5),
+            nn.ReLU(),
+            nn.Linear(fea_dim, args.id_emb_size),
+        )
+        self.dropout = nn.Dropout(0.5)
+        self.reset_para()
+
+    def forward(self, docs):
+        docs = self.embedding(docs)  # size * 300
+        docs = docs.sum(dim=-2)  # output(batch_size, review_count, word_dim)
+        local_fea = self.local_att(docs)   # torch.Size([64, 100])
+
+        global_fea = self.global_att(docs)
+        r_fea = torch.cat([local_fea]+global_fea, 1)
+        r_fea = self.dropout(r_fea)
+        r_fea = self.fc(r_fea)
+        return torch.stack([r_fea], 1)
+
+    def reset_para(self):
+        cnns = [self.local_att.cnn, self.local_att.att_conv[0]]
+        for cnn in cnns:
+            nn.init.xavier_uniform_(cnn.weight, gain=1)
+            nn.init.uniform_(cnn.bias, -0.1, 0.1)
+        for cnn in self.global_att.convs:
+            nn.init.xavier_uniform_(cnn.weight, gain=1)
+            nn.init.uniform_(cnn.bias, -0.1, 0.1)
+        nn.init.uniform_(self.fc[0].weight, -0.1, 0.1)
+        nn.init.uniform_(self.fc[-1].weight, -0.1, 0.1)
+
+
+class FactorizationMachine(nn.Module):
+    def __init__(self, in_dim, k):
+        super(FactorizationMachine, self).__init__()
+        self.v = nn.Parameter(torch.zeros(2 * in_dim, k))
+        self.linear = nn.Linear(2 * in_dim, 1)
+
+    def forward(self, x):
+        linear_part = self.linear(x)  # input shape(batch_size, in_dim), output shape(batch_size, 1)
+        inter_part1 = torch.mm(x, self.v)
+        inter_part2 = torch.mm(x ** 2, self.v ** 2)
+        pair_interactions = torch.sum(inter_part1 ** 2 - inter_part2, dim=1)
+        output = linear_part.t() + 0.5 * pair_interactions
+        return output.view(-1, 1)  # output shape(batch_size, 1)
+
+
+class D_ATTN(nn.Module):
+    def __init__(self, word_emb):
+        super(D_ATTN, self).__init__()
+        self.user_net = Net(word_emb)
+        self.item_net = Net(word_emb)
+        self.fm = FactorizationMachine(in_dim=args.id_emb_size, k=args.fm_hidden)
+
+    def forward(self, user_reviews, item_reviews):
+        u_fea = self.user_net(user_reviews)
+        i_fea = self.item_net(item_reviews)
+        # print(u_fea.size())   #
+        # print(i_fea.size())   #
+        i_fea = i_fea.squeeze(1)
+        u_fea = u_fea.squeeze(1)
+        # print(u_fea.size())   # torch.Size([64, 32])
+        # print(i_fea.size())   #  torch.Size([64, 32])
+
+        prediction = self.fm(torch.cat([u_fea, i_fea], dim=-1))
+        return prediction

Review_REC/D-Attn/run_data_process.py

@@ -0,0 +1,70 @@
+"""
+@file   : run_data_process.py
+@time   : 2024-07-16
+"""
+import argparse
+import os
+import sys
+import time
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from nltk.tokenize import WordPunctTokenizer
+import warnings
+warnings.filterwarnings('ignore')
+
+pd.set_option('display.max_columns', None)
+
+
+def load_vocab(path):
+    all_vocab = []
+    with open(path, 'r', encoding="utf8") as f:
+        for line in f.readlines():
+            line = line.strip()
+            all_vocab.append(line)
+    return all_vocab
+
+
+def process_dataset(json_path, select_cols, train_rate, csv_path):
+    df = pd.read_json(json_path, lines=True)
+    df = df[select_cols]
+    df.columns = ['userID', 'itemID', 'review', 'rating']
+    df['userID'] = df.groupby(df['userID']).ngroup()   # ngroup:分配组号
+    df['itemID'] = df.groupby(df['itemID']).ngroup()
+    stop_words = load_vocab('./data/stopwords.txt')
+    punctuations = load_vocab('./data/punctuations.txt')
+
+    df = df.drop(df[[not isinstance(x, str) or len(x) == 0 for x in df['review']]].index)  # erase null reviews
+    def clean_review(review):
+        review = review.lower()
+        for p in punctuations:
+            review = review.replace(p, ' ')  # replace punctuations by space
+        review = WordPunctTokenizer().tokenize(review)  # split words
+        review = [word for word in review if word not in stop_words]  # remove stop words
+        # review = [nltk.WordNetLemmatizer().lemmatize(word) for word in review]  # extract root of word
+        return ' '.join(review)
+    df['review'] = df['review'].apply(clean_review)
+    train, valid = train_test_split(df, test_size=1 - train_rate, random_state=3)  # split dataset including random
+    valid, test = train_test_split(valid, test_size=0.5, random_state=4)
+    print(f'Split and saved dataset as csv: train {len(train)}, valid {len(valid)}, test {len(test)}')
+    # Split and saved dataset as csv: train 51764, valid 6470, test 6471
+    print(f'Total: {len(df)} reviews, {len(df.groupby("userID"))} users, {len(df.groupby("itemID"))} items.')
+    # Total: 64705 reviews, 5541 users, 3568 items.
+    return train, valid, test
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_path', dest='data_path',
+                        default='./data/reviews_Digital_Music_5.json',
+                        help='Selected columns of above dataset in json format.')
+    parser.add_argument('--select_cols', dest='select_cols', nargs='+',
+                        default=['reviewerID', 'asin', 'reviewText', 'overall'])
+    # 'reviewerID', 'asin', 'reviewText', 'overall'
+    # 'reviewerID' - 评论者ID  'asin' - 产品ID   'reviewText' - 评论内容  'overall' - 总体评分
+    parser.add_argument('--train_rate', dest='train_rate', default=0.8)
+    parser.add_argument('--save_dir', dest='save_dir', default='./music')
+    args = parser.parse_args()
+    train, valid, test = process_dataset(args.data_path, args.select_cols, args.train_rate, args.save_dir)
+    train.to_csv('./data/train.csv', index=False, header=False)
+    valid.to_csv('./data/valid.csv', index=False, header=False)
+    test.to_csv('./data/test.csv', index=False, header=False)