• PyTorch搭建基于图神经网络（GCN）的天气推荐系统（附源码和数据集）

    需要源码和数据集请点赞关注收藏后评论区留言留下QQ~~~

    一、背景

    极端天气情况一直困扰着人们的工作和生活。部分企业或者工种对极端天气的要求不同，但是目前主流的天气推荐系统是直接将天气信息推送给全部用户。这意味着重要的天气信息在用户手上得不到筛选，降低用户的满意度，甚至导致用户的经济损失。我们计划开发一个基于图神经网络的天气靶向模型，根据用户的历史交互行为，判断不同天气对他的利害程度。如果有必要，则将该极端天气情况推送给该用户，让其有时间做好应对准备。该模型能够减少不必要的信息传递，提高用户的体验感。

    二、模型介绍

    四、模型介绍

    （一）数据集共有三个txt文件，分别是user.txt，weather.txt，rating.txt。这些文件一共包含900名用户，1600个天气状况，95964条用户的历史交互记录。

    1. user.txt

    用户的信息记录在user.txt中。格式如下：

    用户ID\t年龄\t性别\t职业\t地理位置

    1. weather.txt

    天气的信息记录在weather.txt中。格式如下：

    天气ID\t天气类型\t温度\t湿度\t风速 

    1. rating.txt

    用户的历史交互记录在rating.txt中。格式如下：

    用户ID\t天气ID\t评分

    三、项目结构

    如下图 data里面存放了数据集

    四、运行结果

    开始训练  可以看到第一行显示了一些训练的基本配置内容 包括用的设备cpu 训练批次 学习率等等

     可以看出随着训练次数的增加 损失率在不断降低

    最后会自动选出一个最佳的测试和训练集的损失值

     结果可视化如下

     五、代码

    部分源码如下

    train类

    1. import pandas as pd
    2. import time
    3. from utils import fix_seed_torch, draw_loss_pic
    4. import argparse
    5. from model import GCN
    6. from Logger import Logger
    7. from mydataset import MyDataset
    8. import torch
    9. from torch.nn import MSELoss
    10. from torch.optim import Adam
    11. from torch.utils.data import DataLoader, random_split
    12. import sys
    13. import os
    14. os.environ['KMP_DUPLICATE_LIB_OK']='TRUE'
    15.  
    16.  
    17. # 固定随机数种子
    18. fix_seed_torch(seed=2021)
    19. # 设置训练的超参数
    20. parser = argparse.ArgumentParser()
    21. parser.add_argument('--gcn_layers', type=int, default=2, help='the number of gcn layers')
    22. parser.add_argument('--n_epochs', type=int, default=20, help='the number of epochs')
    23. parser.add_argument('--embedSize', type=int, default=64, help='dimension of user and entity embeddings')
    24. parser.add_argument('--batch_size', type=int, default=1024, help='batch size')
    25. parser.add_argument('--lr', type=float, default=0.001, help='learning rate')
    26. parser.add_argument('--ratio', type=float, default=0.8, help='size of training dataset')
    27. args = parser.parse_args()
    28. # 设备是否支持cuda
    29. device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
    30. args.device = device
    31. # 读取用户特征、天气特征、评分
    32. user_feature = pd.read_csv('./data/user.txt', encoding='utf-8', sep='\t')
    33. item_feature = pd.read_csv('./data/weather.txt', encoding='utf-8', sep='\t')
    34. rating = pd.read_csv('./data/rating.txt', encoding='utf-8', sep='\t')
    35. # 构建数据集
    36. dataset = MyDataset(rating)
    37. trainLen = int(args.ratio * len(dataset))
    38. train, test = random_split(dataset, [trainLen, len(dataset) - trainLen])
    39. train_loader = DataLoader(train, batch_size=args.batch_size, shuffle=True, pin_memory=True)
    40. test_loader = DataLoader(test, batch_size=len(test))
    41. # 记录训练的超参数
    42. start_time = '{}'.format(time.strftime("%m-%d-%H-%M", time.localtime()))
    43. logger = Logger('./log/log-{}.txt'.format(start_time))
    44. logger.info(' '.join('%s: %s' % (k, str(v)) for k, v in sorted(dict(vars(args)).items())))
    45. # 定义模型
    46. model = GCN(args, user_feature, item_feature, rating)
    47. model.to(device)
    48. # 定义优化器
    49. optimizer = Adam(model.parameters(), lr=args.lr, weight_decay=0.001)
    50. # 定义损失函数
    51. loss_function = MSELoss()
    52. train_result = []
    53. test_result = []
    54. # 最好的epoch
    55. best_loss = sys.float_info.max
    56. # 训练
    57. for i in range(args.n_epochs):
    58.     model.train()
    59.     for batch in train_loader:
    60.         optimizer.zero_grad()
    61.         prediction=model(batch[0].to(device),batch[1].to(device))
    62.         train_loss=torch.sqrt(loss_function(batch[2].float().to(device),prediction))
    63.         train_loss.backward()
    64.         optimizer.step()
    65.     train_result.append(train_loss.item())
    66.     model.eval()
    67.     for data in test_loader:
    68.         prediction=model(data[0].to(device),data[1].to(device))
    69.         test_loss=torch.sqrt(loss_function(data[2].float().to(device),prediction))
    70.         test_loss=test_loss.item()
    71.         if best_loss>test_loss:
    72.             best_loss=test_loss
    73.             torch.save(model.state_dict(),'./model/bestModeParms-{}.pth'.format(start_time))
    74.     test_result.append(test_loss)
    75.     logger.info("Epoch{:d}:trainLoss{:.4f},testLoss{:.4f}".format(i,train_loss,test_loss))
    76. else:
    77.     model.load_state_dict(torch.load("./model/bestModeParms-11-18-19-47.pth"))
    78.     user_id=input("请输入用户id")
    79.     item_num=rating['itemId'].max()+1
    80.     u=torch.tensor([int(user_id)for i in range(item_num)],dtype=float)
    81.   气ID".format(user_id))
    82.     print(i[0]for i in result)
    88. # 画图
    89. draw_loss_pic(train_result, test_result)

    Logger类

    1. import sys
    2. import os
    3. import logging
    6. class Logger(object):
    8.     def __init__(self, filename):
    10.         self.logger = logging.getLogger(filename)
    11.         self.logger.setLevel(logging.DEBUG)
    12.         formatter = logging.Formatter('%(asctime)s: %(message)s',
    13.                                       datefmt='%Y-%m-%d %H-%M-%S')
    15.         # write into file
    16.         fh = logging.FileHandler(filename)
    17.         fh.setLevel(logging.DEBUG)
    18.         fh.setFormatter(formatter)
    20.         # show on console
    21.         ch = logging.StreamHandler(sys.stdout)
    22.         ch.setLevel(logging.DEBUG)
    23.         ch.setFormatter(formatter)
    25.         # add to Handler
    26.         self.logger.addHandler(fh)
    27.         self.logger.addHandler(ch)
    30.     def _flush(self):
    31.         for handler in self.logger.handlers:
    32.             handler.flush()
    34.     def info(self, message):
    35.         self.logger.info(message)
    36.         self._flush()

    model类

    1. import numpy as np
    2. import torch.nn
    3. import torch.nn as nn
    4. from utils import *
    5. from torch.nn import Module
    6. import scipy.sparse as sp
    7.  
    8.  
    9. class GCN_Layer(Module):
    10.     def __init__(self,inF,outF):
    11.         super(GCN_Layer,self).__init__()
    12.         self.W1=torch.nn.Linear(in_features=inF,out_features=outF)
    13.         self.W2=torch.nn.Linear(in_features=inF,out_features=outF)
    14.     def forward(self,graph,selfLoop,features):
    15.         part1=self.W1(torch.sparse.mm(graph+selfLoop,features))
    16.         part2 = self.W2(torch.mul(torch.sparse.mm(graph,features),features))
    17.         return nn.LeakyReLU()(part1+part2)
    18.  
    19.  
    20.  
    21.     ######################
    22.     #    请你补充代码       #
    23.     ######################
    24.  
    25.  
    26. class GCN(Module):
    27.     def __init__(self, args, user_feature, item_feature, rating):
    28.         super(GCN, self).__init__()
    29.         self.args = args
    30.         self.device = args.device
    31.         self.user_feature = user_feature
    32.         self.item_feature = item_feature
    33.         self.rating = rating
    34.         self.num_user = rating['user_id'].max() + 1
    35.         self.num_item = rating['item_id'].max() + 1
    36.         # user embedding
    37.         self.user_id_embedding = nn.Embedding(user_feature['id'].max() + 1, 32)
    38.         self.user_age_embedding = nn.Embedding(user_feature['age'].max() + 1, 4)
    39.         self.user_gender_embedding = nn.Embedding(user_feature['gender'].max() + 1, 2)
    40.         self.user_occupation_embedding = nn.Embedding(user_feature['occupation'].max() + 1, 8)
    41.         self.user_location_embedding = nn.Embedding(user_feature['location'].max() + 1, 18)
    42.         # item embedding
    43.         self.item_id_embedding = nn.Embedding(item_feature['id'].max() + 1, 32)
    44.         self.item_type_embedding = nn.Embedding(item_feature['type'].max() + 1, 8)
    45.         self.item_temperature_embedding = nn.Embedding(item_feature['temperature'].max() + 1, 8)
    46.         self.item_humidity_embedding = nn.Embedding(item_feature['humidity'].max() + 1, 8)
    47.         self.item_windSpeed_embedding = nn.Embedding(item_feature['windSpeed'].max() + 1, 8)
    48.         # 自循环
    49.         self.selfLoop = self.getSelfLoop(self.num_user + self.num_item)
    50.         # 堆叠GCN层
    51.         self.GCN_Layers = torch.nn.ModuleList()
    52.         for _ in range(self.args.gcn_layers):
    53.             self.GCN_Layers.append(GCN_Layer(self.args.embedSize, self.args.embedSize))
    54.         self.graph = self.buildGraph()
    55.         self.transForm = nn.Linear(in_features=self.args.embedSize * (self.args.gcn_layers + 1),
    56.                                    out_features=self.args.embedSize)
    57.  
    58.     def getSelfLoop(self, num):
    59.         i = torch.LongTensor(
    60.             [[k for k in range(0, num)], [j for j in range(0, num)]])
    61.         val = torch.FloatTensor([1] * num)
    62.         return torch.sparse.FloatTensor(i, val).to(self.device)
    63.  
    64.     def buildGraph(self):
    65.         rating=self.rating.values
    66.         graph=sp.coo_matrix(
    67.             (rating[:,2],(rating[:,0],rating[:,1])),shape=(self.num_user,self.num_item)).tocsr()
    68.         graph=sp.bmat([[sp.csr_matrix((graph.shape[0],graph.shape[0])),graph],
    69.                        [graph.T,sp.csr_matrix((graph.shape[1],graph.shape[1]))]])
    70.  
    71.         row_sum_sqrt=sp.diags(1/(np.sqrt(graph.sum(axis=1).A.ravel())+1e-8))
    72.         col_sum_sqrt = sp.diags(1 / (np.sqrt(graph.sum(axis=0).A.ravel()) + 1e-8))
    73.         graph=row_sum_sqrt@graph@col_sum_sqrt
    74.         graph=graph.tocoo()
    75.         values=graph.data
    76.         indices=np.vstack((graph.row,graph.col))
    77.         graph=torch.sparse.FloatTensor(torch.LongTensor(indices),torch.FloatTensor(values),torch.Size(graph.shape))
    78.         return graph.to(self.device)
    79.         ######################
    80.         #    请你补充代码       #
    81.         ######################
    82.  
    83.     def getFeature(self):
    84.         # 根据用户特征获取对应的embedding
    85.         user_id = self.user_id_embedding(torch.tensor(self.user_feature['id']).to(self.device))
    86.         age = self.user_age_embedding(torch.tensor(self.user_feature['age']).to(self.device))
    87.         gender = self.user_gender_embedding(torch.tensor(self.user_feature['gender']).to(self.device))
    88.         occupation = self.user_occupation_embedding(torch.tensor(self.user_feature['occupation']).to(self.device))
    89.         location = self.user_location_embedding(torch.tensor(self.user_feature['location']).to(self.device))
    90.         user_emb = torch.cat((user_id, age, gender, occupation, location), dim=1)
    91.         # 根据天气特征获取对应的embedding
    92.         item_id = self.item_id_embedding(torch.tensor(self.item_feature['id']).to(self.device))
    93.         item_type = self.item_type_embedding(torch.tensor(self.item_feature['type']).to(self.device))
    94.         temperature = self.item_temperature_embedding(torch.tensor(self.item_feature['temperature']).to(self.device))
    95.         humidity = self.item_humidity_embedding(torch.tensor(self.item_feature['humidity']).to(self.device))
    96.         windSpeed = self.item_windSpeed_embedding(torch.tensor(self.item_feature['windSpeed']).to(self.device))
    97.         item_emb = torch.cat((item_id, item_type, temperature, humidity, windSpeed), dim=1)
    98.         # 拼接到一起
    99.         concat_emb = torch.cat([user_emb, item_emb], dim=0)
    100.         return concat_emb.to(self.device)
    101.  
    102.     def forward(self, users, items):
    103.         features=self.getFeature()
    104.         final_emb=features.clone()
    105.         for GCN_Layer in self.GCN_Layers:
    106.             features=GCN_Layer(self.graph,self.selfLoop,features)
    107.             final_emb=torch.cat((final_emb,features.clone()),dim=1)
    108.         user_emb,item_emb=torch.split(final_emb,[self.num_user,self.num_item])
    109.         user_emb=user_emb[users]
    110.         item_emb=item_emb[items]
    111.         user_emb=self.transForm(user_emb)
    112.         item_emb=self.transForm(item_emb)
    113.  
    114.         prediction=torch.mul(user_emb,item_emb).sum(1)
    115.         return prediction
    116.         ######################
    117.         #    请你补充代码       #
    118.         ######################

    mydataset类

    1. from torch.utils.data import Dataset
    2. import pandas as pd
    3.  
    4.  
    5. class MyDataset(Dataset):
    6.     def __init__(self, rating):
    7.         super(Dataset, self).__init__()
    8.         self.user = rating['user_id']
    9.         self.weather = rating['item_id']
    10.         self.rating = rating['rating']
    11.  
    12.     def __len__(self):
    13.         return len(self.rating)
    14.  
    15.     def __getitem__(self, item):
    16.         return self.user[item], self.weather[item], self.rating[item]
    17.

    utils类

    1. from torch.utils.data import Dataset
    2. import pandas as pd
    3.  
    4.  
    5. class MyDataset(Dataset):
    6.     def __init__(self, rating):
    7.         super(Dataset, self).__init__()
    8.         self.user = rating['user_id']
    9.         self.weather = rating['item_id']
    10.         self.rating = rating['rating']
    11.  
    12.     def __len__(self):
    13.         return len(self.rating)
    14.  
    15.     def __getitem__(self, item):
    16.         return self.user[item], self.weather[item], self.rating[item]
    17.

    创作不易 觉得有帮助请点赞关注收藏~~~

  • 相关阅读:
    leetcode简单题21 N.104 二叉树的最大深度 rust描述
    协程简单上手（线程切换）
    Python绘图报错解决：The factorplot function has been renamed to catplot.
    RflySim | 滤波器设计实验二
    【动手学深度学习】模型选择、欠拟合和过拟合
    手机微信里面的文件打印步骤
    通过 filesystem 的 inode 设计，理解数组与链表
    Antd Procomponent 之 proForm - 高级表单
    智能小车开发
    Linux 常用命令学习笔记
  • 原文地址：https://blog.csdn.net/jiebaoshayebuhui/article/details/127929909