异构图上的连接预测二

对整个大图进行transform处理

详细描述过程都在代码中体现。

transform = T.RandomLinkSplit(
    num_val=0.1, # 10%的 边 作为验证集，
    num_test=0.1, # 10%的 边 作为测试集
    disjoint_train_ratio=0.3, #训练集中 30%的边将不会出现在验证集和测试集中。
    neg_sampling_ratio=2.0, # 负采样比例为2.0，就是说生成的负样本数量是正样本数量的两倍，
                            # 什么是负样本呢？ 就是图中不存在的边。
    add_negative_train_samples=False,  # 是否为训练集添加负样本呢？
    edge_types=("user", "rates", "movie"),# 指定边的类型，user到movie，关系是rates，即用户对电影的评分。
    rev_edge_types=("movie", "rev_rates", "user"),  # 同上，只不过反了，即电影被用户评分。
)
#
train_data, val_data, test_data = transform(data)
# print("Training data:")
# print("==============")
# print(train_data)
# print()
# print("Validation data:")
# print("================")
# print(val_data)
# print()
# print("Testing data:")
# print("================")
# print(test_data)
#
# print(train_data["user", "rates", "movie"].edge_label)
# print(train_data["user", "rates", "movie"].edge_label_index)

assert train_data["user", "rates", "movie"].num_edges == 56469
assert train_data["user", "rates", "movie"].edge_label_index.size(1) == 24201
assert train_data["movie", "rev_rates", "user"].num_edges == 56469

# 没有负采样边（标签都为1）
assert train_data["user", "rates", "movie"].edge_label.min() == 1
assert train_data["user", "rates", "movie"].edge_label.max() == 1

assert val_data["user", "rates", "movie"].num_edges == 80670
assert val_data["user", "rates", "movie"].edge_label_index.size(1) == 30249
assert val_data["movie", "rev_rates", "user"].num_edges == 80670

# 负采样边比例为2
assert val_data["user", "rates", "movie"].edge_label.long().bincount().tolist() == [20166, 10083]
"""
训练边:验证边:测试边=0.8:0.1:0.1，总共100836
100836*0.8=80670
训练边中：消息传递:监督=0.7:0.3，训练边一共80670，其中消息边为80670 * 0.7=56469(edge_index)；监督边24201
验证边和测试边正样本（标签为1）各自为100836 * 0.1 ≈10083，由于有负采样，所以edge_label都为10083 * 3 =30249 
 (user, rates, movie)={
    edge_index=[2, 56469],
    edge_label=[24201],
    edge_label_index=[2, 24201],
  },
  理解下：
  edge_index=[2, 56469] 为啥这里有56469条边，而edge_label=[24201] 只有24201条边的标签呢？
  训练边中：消息传递:监督=0.7:0.3，训练边一共80670，其中消息边为80670 * 0.7=56469(edge_index)；监督边24201
  因为edge_index包括了图中所有的边，而edge_label是用于监督的，在训练集中，占了80%，其中30%用于监督。
  什么？不理解监督什么意思吗？？简单来说了你预测了一个东西，而且事先是知道该东西是啥玩意，即已知标签，将预测与标签进行对比。

"""

# 获取需要的边标签索引和边标签
edge_label_index = train_data['user','rates','movie'].edge_label_index # 标签对应的索引，那不就是监督边的索引吗？
edge_label = train_data['user','rates','movie'].edge_label # 标签，监督边

获取批次子图

# 1-hop ,采样20个邻居，2-hop采样10个邻居
train_loader = LinkNeighborLoader(
    # 这里其实相当于在整个图中取出多个子图
    data=train_data,
    num_neighbors=[20, 10],
    neg_sampling_ratio=2.0,
    edge_label_index=(('user','rates','movie'), edge_label_index),
    edge_label=edge_label,
    batch_size=128, # 该批次选择了128个初始节点
    shuffle=True,

    # 128个节点，然后第一层都挑选20个一阶节点，第二层挑选10个二阶节点。
    # 因为neg_sampling_ration = 2,也就是负样本的数量将是正样本的两本，那么总的数量就是128 *2 + 128 = 384
)

# 一个采样数据
sampled_data = next(iter(train_loader))

print("Sampled mini-batch:")
print("===================")
# print(sampled_data)

assert sampled_data["user", "rates", "movie"].edge_label_index.size(1) == 3 * 128
assert sampled_data["user", "rates", "movie"].edge_label.min() == 0
assert sampled_data["user", "rates", "movie"].edge_label.max() == 1

定义GNN网络

在这里应该注意到这是GNN网络，用于处理同构图的。也就是边和节点类型都一样的图。

class GNN(nn.Module):
    def __init__(self,hidden_channels):
        super(GNN,self).__init__()
        # 对子图进行处理咯，例如吧，电影的特征20，   输出为64，
        self.conv1 = SAGEConv(hidden_channels,hidden_channels)
        self.conv2 = SAGEConv(hidden_channels,hidden_channels)
        # x 的类型被注释为tensor，edge_index 的类型也是tensor，而->tensor 用于指示forward方法的返回类型是tensor
    def forward(self,x: Tensor, edge_index:Tensor)->Tensor:
        x = F.relu(self.conv1(x,edge_index))
        x = self.conv2(x,edge_index)
        return x

定义分类器：

你说分类器干嘛的？
假设数据：
x_user = [
[0.1, 0.2, 0.3], # 用户1的嵌入向量
[0.4, 0.5, 0.6], # 用户2的嵌入向量
[0.7, 0.8, 0.9] # 用户3的嵌入向量
]
x_movie = [
[0.1, 0.2, 0.3], # 电影A的嵌入向量
[0.4, 0.5, 0.6], # 电影B的嵌入向量
[0.7, 0.8, 0.9] # 电影C的嵌入向量
]
edge_label_index = [
[0, 1, 2], # 用户的节点ID
[0, 1, 2] # 对应电影的节点ID
]
(0.1 * 0.1) + (0.2 * 0.2) + (0.3 * 0.3) = 0.01 + 0.04 + 0.09 = 0.14
(0.4 * 0.4) + (0.5 * 0.5) + (0.6 * 0.6) = 0.16 + 0.25 + 0.36 = 0.77
(0.7 * 0.7) + (0.8 * 0.8) + (0.9 * 0.9) = 0.49 + 0.64 + 0.81 = 1.94
pred:tensor([0.14, 0.77, 1.94])
用于预测用户对电影的评分。
分类器通过点积操作计算用户和电影嵌入向量的相似度，从而预测用户对电影的评分。

class Classifier(nn.Module):
    def forward(self,x_user:Tensor,x_movie:Tensor,edge_label_index:Tensor)->Tensor:
        # 将节点嵌入转换为边表示：
        edge_feat_user = x_user[edge_label_index[0]]
        edge_feat_movie = x_movie[edge_label_index[1]]

        return (edge_feat_user * edge_feat_movie).sum(dim=-1)

整合模型。

class Model(nn.Module):
    def __init__(self,hidden_channels):
        super().__init__()
        # 电影的特征维度是20
        self.movie_lin = nn.Linear(in_features=20,out_features=hidden_channels)
        # embedding操作，为用户生成向量，
        self.user_emb = nn.Embedding(data['user'].num_nodes,hidden_channels)
        # embedding操作，为电影生成向量，
        self.movie_emb = nn.Embedding(data['movie'].num_nodes,hidden_channels)

        self.gnn = GNN(hidden_channels)
        # 将同构图转变为异构图。
        self.gnn = to_hetero(self.gnn,metadata=data.metadata())
        self.classifer = Classifier()

    def forward(self,data:HeteroData)->Tensor:
        x_dict = {
            'user':self.user_emb(data['user'].node_id),
            # 其实可以不用相加的，但相加的话，可能学习效果会更好，
            # self.movie_lin(data['movie'].x) x其实是电影特征=>[128,20] =>[128,64]
            # self.movie_emb(data['movie'].node_id) [128,64]
            'movie':self.movie_lin(data['movie'].x) +self.movie_emb(data['movie'].node_id)
        }
        # model 初始化时已经调用了self.gnn = to_hetero(self.gnn,metadata=data.metadata()) 将其变为异构图gnn吗，能够对异构图进行处理
        x_dict = self.gnn(x_dict, data.edge_index_dict)

        pred = self.classifer(
            x_dict["user"],
            x_dict["movie"],
            data["user", "rates", "movie"].edge_label_index,
        )
        return pred

开始训练：

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f'运行在{device}上')
model = Model(hidden_channels=64).to(device)
optimizer = torch.optim.Adam(model.parameters(),lr=0.001)
for epoch in range(1,6):
    total_loss = total_examples = 0
    for sampled_data in tqdm.tqdm(train_loader):
        sampled_data =sampled_data.to(device)
        # 梯度清零
        optimizer.zero_grad()
        # 运行
        pred = model(sampled_data)
        # 真实值
        ground_truth = sampled_data['user','rates','movie'].edge_label
        loss = F.binary_cross_entropy_with_logits(pred,ground_truth)
        loss.backward()
        optimizer.step()
        total_loss += float(loss) * pred.numel()
        total_examples += pred.numel()
    print(f"Epoch: {epoch:03d}, Loss: {total_loss / total_examples:.4f}")