这里写目录标题

• 异构图？
• 处理数据：

  异构图？

  异构图：就是指节点与边类型不同的图。

  连接预测：目的是预测图中两个节点之间是否存在一条边，或者是预测两个节点之间，在未来可能形成的连接。

  eg：

  节点：

  研究人员A、研究人员B、研究人员C

  论文P1、论文P2

  机构I1

  边关系：

  研究人员A 写作 论文P1

  研究人员B 写作 论文P1

  研究人员C 写作 论文P2

  论文P1 隶属于 机构I1

  例如呢，我们想预测 在未来 A 与Ｂ　是否会合作写作论文呢？

  或者是预测　Ｂ会不会加入机构l1呢？

  处理数据：

  代码展示，其中包括我其中遇到的困惑。

  """
  MoviesLens数据集：描述了MoviesLens的评分以及标记活动。
  该数据集包括600多个用户对9000多部电影的10万个评分。
  使用该数据集生成两种节点类型： 分别保存电影  和 用户的数据，
  以及一种连接用户和电影的边缘类型，表示用户是否对特定电影进行了评级关系。
  最后，链接预测任务 尝试预测缺失的评分，可以用于向用户推荐新电影。
  """
  import torch
  import os
  import pandas as pd
  from torch_geometric.data import HeteroData
  import torch_geometric.transforms as T
  # 电影
  movies_path = './data/ml-latest-small/movies.csv'
  # 评分
  ratings_path = './data/ml-latest-small/ratings.csv'
  # 在处理数据之前肯定得先知道csv中的数据格式
  # print('movies.csv')
  # print('movies.csv:')
  # print('===========')
  # print(pd.read_csv(movies_path)[["movieId", "genres"]].head(10))
  # print()
  # print('ratings.csv:')
  # print('============')
  # print(pd.read_csv(ratings_path)[["userId", "movieId"]].head(10))
  # 加载数据,movieId 作为索引列
  movies_df = pd.read_csv(movies_path,index_col='movieId')
  # data = {
  #     'movieId': [1, 2, 3],
  #     'title': ['Toy Story', 'Jumanji', 'Grumpier Old Men'],
  #     'genres': ['Adventure|Animation|Children|Comedy|Fantasy',
  #                'Adventure|Children|Fantasy',
  #                'Comedy|Romance']
  # }
  # 执行下方这行代码，作用就是按照 | 进行分割，且使用one-hot 编码
  # 输出：   Adventure  Animation  Children  Comedy  Fantasy  Romance
  # 0          1          1         1       1        1        0
  # 1          1          0         1       0        1        0
  # 2          0          0         0       1        0        1
  genres = movies_df['genres'].str.get_dummies('|')
  # print(genres[["Action", "Adventure", "Drama", "Horror"]].head())
  # (9742, 20) 9742部电影，20种体裁
  # print(genres.values.shape)
  # 将genres作为电影的输入特征
  movie_feat = torch.from_numpy(genres.values).to(torch.float)
  assert movie_feat.size() == (9742,20)
  # 同理对评分进行处理
  ratings_df = pd.read_csv(ratings_path)
  # 提取出每个用户的id
  """
  ratings_data = {
      'userId': [10, 20, 10, 30, 20, 40, 30, 50],
      'movieId': [101, 101, 102, 103, 104, 105, 106, 107],
      'rating': [3.5, 4.0, 2.5, 5.0, 4.0, 3.0, 4.5, 2.0]
  }
  """
  # unique_user_id = ([10, 20, 30, 40, 50])
  unique_user_id = ratings_df['userId'].unique()
  # 创建映射表
  """
   userId  mappedID
  0      10         0
  1      20         1
  2      30         2
  3      40         3
  4      50         4
  """
  unique_user_id = pd.DataFrame(data={
      'userId': unique_user_id,
      'mappedID':pd.RangeIndex(len(unique_user_id))
  })
  # 同理，对电影进行相同处理
  unique_movie_id = ratings_df['movieId'].unique()
  unique_movie_id = pd.DataFrame(data={
      'movieId':unique_movie_id,
      'mappedID':pd.RangeIndex(len(unique_movie_id))
  })
  # 获取user和movie的原始Id和映射ID
  # 下方这代码，不就是将评分表种的原始id与获取的映射id进行映射而已吗
  ratings_user_id = pd.merge(ratings_df['userId'],unique_user_id,
                             left_on='userId',right_on='userId',how='left')
  ratings_user_id = torch.from_numpy(ratings_user_id['mappedID'].values)
  ratings_movie_id = pd.merge(ratings_df['movieId'], unique_movie_id,
                              left_on='movieId', right_on='movieId', how='left')
  ratings_movie_id = torch.from_numpy(ratings_movie_id['mappedID'].values)
  # 构造’edge_index'
  # 在这里，你肯定会有这个疑惑？
  # 为啥能那么刚好，例如用户id为0的，刚好就是评论10号电影呢？
  # 其实在一开始，所有的数据都是安排好的
  #  'userId': [1, 2, 1, 3, 2, 4, 3, 5],
  #    'movieId': [101, 101, 102, 103, 104, 105, 106, 107],
  #    'rating': [3.5, 4.0, 2.5, 5.0, 4.0, 3.0, 4.5, 2.0]
  # 是不是一一对应呢？只是将userid和movieid转变为对应的mappedid而已
  # 例如：userid:[0, 1, 0, 2, 1, 3, 2, 4]
  #      movieid:[0, 0, 1, 2, 3, 4, 5, 6]
  edge_index_user_to_movie = torch.stack([ratings_user_id,ratings_movie_id],dim=0)
  assert edge_index_user_to_movie.size() == (2,100836)
  """
  tensor([[   0,    0,    0,  ...,  609,  609,  609],
          [   0,    1,    2,  ..., 3121, 1392, 2873]])
  """
  # print(edge_index_user_to_movie)
  # 到现在，完成了数据的处理
  # 初始化HeterData 对象。
  data = HeteroData()
  # 保存节点索引
  data['user'].node_id = torch.arange(len(unique_user_id))
  data['movie'].node_id = torch.arange(len(movies_df))
  # 添加节点特征和边索引
  data['movie'].x = movie_feat  # 电影的体裁作为节点特征，因为每个电影可能会有多个体裁
  data['user','rates','movie'].edge_index =edge_index_user_to_movie
  # 添加反向边，使得GNN能够在两个方向上传递消息,那不就是成为无向图咯
  data = T.ToUndirected()(data)
  print(data)
  assert data.node_types == ["user", "movie"]
  assert data.edge_types == [("user", "rates", "movie"),
                             ("movie", "rev_rates", "user")]
  assert data["user"].num_nodes == 610
  assert data["user"].num_features == 0
  assert data["movie"].num_nodes == 9742
  assert data["movie"].num_features == 20
  assert data["user", "rates", "movie"].num_edges == 100836
  assert data["movie", "rev_rates", "user"].num_edges == 100836