jsp动态网站开发课程/百度后台登陆入口

论文链接：

SimGNN: A Neural Network Approachto Fast Graph Similarity Computation

个人理解：

重中之重就是理解该图：

逐步来击破这幅图吧。

数据处理:

论文中给定的例子所提供的数据是 json 格式。
读取数据：

train_graphs = glob.glob('data/train/'+'*.json')
test_graphs = glob.glob('data/test/'+'*.json')

看提供的图可得知，特征为one-hot 编码，将数据处理成需要的格式。

1、获取图节点所拥有的所有特征！

def node_mapping():nodes_id = set()graph_pairs = train_graphs + test_graphsfor graph_pair in graph_pairs:graph = json.load(open(graph_pair))nodes_id = nodes_id.union(set(graph['labels_1']))nodes_id = nodes_id.union(set(graph['labels_2']))nodes_id = sorted(nodes_id)nodes_id = {id:index for index,id in enumerate(nodes_id)}num_nodes_id = len(nodes_id)print(nodes_id,num_nodes_id)return nodes_id,num_nodes_id

l理解上述代码：
理解node_mapping()函数的作用：
例如： graph1.json：{
“labels_1”: [“A”, “B”, “C”],
“labels_2”: [“D”, “E”] } =>train_graph graph2.json:{
“labels_1”: [“C”, “F”],
“labels_2”: [“A”, “G”] } => test_graph 执行： graph_pairs = train_graphs + test_graphs 得：=> graph_pairs =
[‘graph1.json’,‘graph2.json’]

执行： for graph_pair in graph_pairs: 第一个循环：graph =
json.load(open(‘graph1.json’)) 得： #graph = {“labels_1”: [“A”, “B”,
“C”], “labels_2”: [“D”, “E”]}

nodes_id = nodes_id.union(set(graph[‘labels_1’])) # {“A”, “B”, “C”}
nodes_id = nodes_id.union(set(graph[‘labels_2’])) # {“A”, “B”, “C”,
“D”, “E”}

第二个循环：graph = json.load(open(‘graph2.json’)) 得： #graph = {“labels_1”:
[“C”, “F”], “labels_2”: [“A”, “G”]} nodes_id =
nodes_id.union(set(graph[‘labels_1’])) # {“A”, “B”, “C”, “D”, “E”,
“F”} nodes_id = nodes_id.union(set(graph[‘labels_2’])) # {“A”, “B”,
“C”, “D”, “E”, “F”, “G”}

执行： nodes_id = sorted(nodes_id) 进行排序 得： # [“A”, “B”, “C”, “D”, “E”,
“F”, “G”]

执行： nodes_id = {id:index for index,id in enumerate(nodes_id)} 进行索引的建立
得：# nodes_id = {“A”: 0, “B”: 1, “C”: 2, “D”: 3, “E”: 4, “F”: 5, “G”:
6} 简简单单理解这段代码，作用也就是完成one-hot 编码的建立

2、创建数据加载器：

def load_dataset():train_dataset = []test_dataset = []nodes_id, num_nodes_id = node_mapping()for graph_pair in train_graphs:graph = json.load(open(graph_pair))data = process_data(graph,nodes_id)train_dataset.append(data)for graph_pair in test_graphs:graph = json.load(open(graph_pair))data = process_data(graph, nodes_id)test_dataset.append(data)return train_dataset,test_dataset,num_nodes_id

其中，process_data() 函数：

def process_data(graph,nodes_id):data = dict()# 获取每个图的邻接矩阵edges_1 = graph['graph_1'] + [[y,x] for x,y in graph['graph_1']]edges_2 = graph['graph_2'] + [[y,x] for x,y in graph['graph_2']]edges_1 = torch.from_numpy(np.array(edges_1,dtype=np.int64).T).type(torch.long)edges_2 = torch.from_numpy(np.array(edges_2,dtype=np.int64).T).type(torch.long)data['edge_index_1'] = edges_1data['edge_index_2'] = edges_2feature_1 ,feature_2 = [],[]for n in graph['labels_1']:feature_1.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])for n in graph['labels_2']:feature_2.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])feature_1 = torch.FloatTensor(np.array(feature_1))feature_2 = torch.FloatTensor(np.array(feature_2))data['features_1'] = feature_1data['features_2'] = feature_2norm_ged = graph['ged'] / (0.5 * (len(graph['labels_1']) +len(graph['labels_2'])))data['norm_ged'] = norm_geddata["target"] = torch.from_numpy(np.exp(-norm_ged).reshape(1, 1)).view(-1).float().unsqueeze(0)return data

理解process_data ()函数：
理解process_data()函数的作用：
数据假设： {
“graph_1”: [[0, 1], [1, 2]], // 边的列表
“graph_2”: [[0, 2], [2, 3]],
“labels_1”: [“A”, “B”, “C”], // 图1的节点标签
“labels_2”: [“A”, “C”, “D”], // 图2的节点标签
“ged”: 2 // 图编辑距离 } 使用node_mapping()得到：nodes_id = {“A”: 0, “B”: 1, “C”: 2, “D”: 3, “E”: 4, “F”: 5, “G”: 6} 执行：edges_1 =
graph[‘graph_1’] + [[y, x] for x, y in graph[‘graph_1’]] 得： # [[0,
1], [1, 2], [1, 0], [2, 1]] 前部分是获取正向边，后边是添加反向边 执行：edges_2 =
graph[‘graph_2’] + [[y, x] for x, y in graph[‘graph_2’]] 得： # [[0,
2], [2, 3], [2, 0], [3, 2]]

执行：edges_1 = torch.from_numpy(np.array(edges_1,
dtype=np.int64).T).type(torch.long) 得：将其转换为tensor类型

第一个循环： 执行:for n in graph[‘labels_1’]: # [“A”, “B”, “C”]
执行：feature_1.append([1.0 if nodes_id[n] == i else 0.0 for i in
nodes_id.values()]) 得：

feature_1 = [

  [ A ,  B ,  C ,  D , E  ,  F ,  G ]

[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], # “A”

[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], # “B”

[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0] # “C” 第二个循环： for n in graph[‘labels_2’]: # [“A”, “C”, “D”]

feature_2.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])

feature_2 = [

[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], # “A”

[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], # “C”

[0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0] # “D”

]

执行：feature_1 = torch.FloatTensor(np.array(feature_1)) 得：将其转换为张量

计算ged： norm_ged = graph['ged'] / (0.5 * (len(graph['labels_1']) + len(graph['labels_2'])))

norm_ged = 2 / (0.5 * (3 + 3)) = 2 / 3 = 0.6667

计算目标值： data['target'] = torch.from_numpy(np.exp(-norm_ged).reshape(1,

1)).view(-1).float().unsqueeze(0)

target = torch.from_numpy(np.exp(-0.6667).reshape(1, 1)).view(-1).float().unsqueeze(0)

target = torch.tensor([[0.5134]])

理解一下ged： Graph Edit Distance ：图编辑距离 Ged 是衡量两个图之间的相似度的标识，ged越小，则越相似。 ged 是表示将一个图转变为另一个图的最小操作数（节点和边的添加、删除、替换等）。

norm_ged = GED / (0.5 * (V1 + V2 )) 其中V1和V2 是两个图的节点。

理解一下target： target = exp(-norm_ged)，很多公式都会取负指数，因为这样能够将数值限定在0到1之间。

到这就完成了数据的处理。

卷积层：

这层直接调用就行，无需过多了解。

注意力层

论文中的公式如下：

class AttentionModule(nn.Module):def __init__(self,args):super(AttentionModule,self).__init__()self.args = argsself.setup_weights()self.init_parameters()def setup_weights(self):# 创建权重矩阵（并未赋值），fiLters_3 = 32self.weight_matrix = nn.Parameter(torch.Tensor(self.args.filters_3, self.args.filters_3))def init_parameters(self):# 为权重矩阵进行赋值。nn.init.xavier_uniform_(self.weight_matrix)def forward(self, embedding):# embedding:(num_nodes=14, num_features=32)# 在每个特征维度上，取节点平均值# 执行torch.matmul(embedding, self.weight_matrix)=>[14,32]# 执行torch.mean(,dim=0) => [32,] 其实就是一行32列global_context = torch.mean(torch.matmul(embedding, self.weight_matrix), dim=0)# [32,] => [32,]transformed_global = torch.tanh(global_context)# sigmoid_scores计算每个节点与图之间的相似性得分(注意力)# sigmoid_scores:(14)# 执行：transormed_global.view(-1,1) [32,]=> [32,1]# 执行：torch.mm() =>矩阵乘法=>[14,32] × [32,1] = [14,1],# 注意：这里的实现并没有完全跟论文相同，缺少了一个转置，放在下一步实现了sigmoid_scores = torch.sigmoid(torch.mm(embedding, transformed_global.view(-1, 1)))# representation:图的嵌入(32)# 执行：torch.t(embedding) [14,32] =>[32,14]# 执行：torch.mm() [32,14] * [14,1] =>[32,1]representation = torch.mm(torch.t(embedding), sigmoid_scores)return representation

张量网络层：

张量网络层的公式如下：

class TensorNetworkModule(nn.Module):def __init__(self,args):super(TensorNetworkModule,self).__init__()self.args = argsself.setup_weights()self.init_parameters()def setup_weights(self):# tensor_neurons 表示神经元数目# 三维张量 Mself.weight_matrix = nn.Parameter(torch.Tensor(self.args.filters_3, self.args.filters_3, self.args.tensor_neurons))# 权重矩阵 Vself.weight_matrix_block = nn.Parameter(torch.Tensor(self.args.tensor_neurons,2*self.args.filters_3))# 偏置向量 bself.bias = nn.Parameter(torch.Tensor(self.args.tensor_neurons,1))def init_parameters(self):nn.init.xavier_uniform_(self.weight_matrix)nn.init.xavier_uniform_(self.weight_matrix_block)nn.init.xavier_uniform_(self.bias)def forward(self,embedding_1,embedding_2):# 这一部分实现：h1^T * M * h2# embedding_1 = [32,1] 经转置=> [1,32]# M = [32,32,16]# scoring = [1，32] * [32,512] = [1,512]scoring = torch.mm(torch.t(embedding_1),self.weight_matrix.view(self.args.filters_3,-1))# scoring = [32,16]scoring = scoring.view(self.args.filters_3,self.args.tensor_neurons) # shape=[32,16]# scoring = [16,1]scoring = torch.mm(torch.t(scoring),embedding_2) # shape = [16,1]# 就是论文中将两个嵌入向量叠加起来combined_representation = torch.cat((embedding_1,embedding_2))# V*[]block_scoring = torch.mm(self.weight_matrix_block,combined_representation)scores = F.relu(scoring + block_scoring +self.bias)return scores

理解这一部分张量网络：
根据SimGNN论文中的公式： 假设embedding_1 和 embedding_2 都为
[32,1],self.args.filters_3=32,self.args.tensor_neurons=16 可得：
self.weight_matrix = [32,32,16]
self.weight_matrix_block = [16,64]
self.bias = [16,1] 问题一：M 为啥是三维的权重矩阵呢？ 例子中的Ｍ是［32,32,16］ 表示k = 16个32*32的矩阵

定义simgnn网络模型：

class SimGNN(nn.Module):def __init__(self,args,num_nodes_id):super(SimGNN,self).__init__()self.args = argsself.num_nodes_id = num_nodes_idself.setup_layers()# 是否使用直方图def calculate_bottleneck_features(self):if self.args.histogram == True:self.feature_count = self.args.tensor_neurons + self.args.binselse:self.feature_count = self.args.tensor_neuronsdef setup_layers(self):self.calculate_bottleneck_features()self.convolution_1 = GCNConv(self.num_nodes_id,self.args.filters_1)self.convolution_2 = GCNConv(self.args.filters_1,self.args.filters_2)self.convolution_3 = GCNConv(self.args.filters_2,self.args.filters_3)self.attention = AttentionModule(self.args)self.tensor_network = TensorNetworkModule(self.args)self.fully_connected_first = nn.Linear(self.feature_count,self.args.bottle_neck_neurons)self.scoring_layer = nn.Linear(self.args.bottle_neck_neurons,1)def calculate_histogram(self,abstract_features_1, abstract_features_2):"""理解calculate_histogram函数：作用：用于计算节点特征的直方图，用于衡量图之间的相似性。"""# abstract_features_1:(num_nodes1, num_features=32)# abstract_features_2:(num_features=32, num_nodes2) 这里是完成转置了# 执行torch.mm 后得到 相似性得分矩阵。scores = torch.mm(abstract_features_1, abstract_features_2).detach()scores = scores.view(-1, 1)# 计算直方图，将得分分为 bins 个区间。# 例如 bins为 8，hist = tensor([4., 3., 1., 0., 0., 2., 1., 1.])hist = torch.histc(scores, bins=self.args.bins)  # 统计得分在每个区间的个数# hist = tensor([0.3333, 0.2500, 0.0833, 0.0000, 0.0000, 0.1667, 0.0833, 0.0833])hist = hist / torch.sum(hist)  # 归一化hist = hist.view(1, -1)return histdef convolutional_pass(self, edge_index, features):features = self.convolution_1(features, edge_index)features = F.relu(features)features = F.dropout(features, p=self.args.dropout, training=self.training)features = self.convolution_2(features, edge_index)features = F.relu(features)features = F.dropout(features, p=self.args.dropout, training=self.training)features = self.convolution_3(features, edge_index)return featuresdef forward(self, data):# 获取图 1 的邻接矩阵edge_index_1 = data["edge_index_1"]# 获取图 2 的邻接矩阵edge_index_2 = data["edge_index_2"]# 获取图 1 的特征（独热编码）features_1 = data["features_1"]  # (num_nodes1, num_features=16)features_2 = data["features_2"]  # (num_nodes2, num_features=16)# (num_nodes1, num_features=16) ——> (num_nodes1, num_features=32)abstract_features_1 = self.convolutional_pass(edge_index_1,features_1)# (num_nodes2, num_features=16) ——> (num_nodes2, num_features=32)abstract_features_2 = self.convolutional_pass(edge_index_2,features_2)# 直方图if self.args.histogram == True:hist = self.calculate_histogram(abstract_features_1, torch.t(abstract_features_2))# 池化pooled_features_1 = self.attention(abstract_features_1)  # (num_nodes1, num_features=32) ——> (num_features=32)pooled_features_2 = self.attention(abstract_features_2)  # (num_nodes2, num_features=32) ——> (num_features=32)# NTN模型scores = self.tensor_network(pooled_features_1, pooled_features_2)scores = torch.t(scores)if self.args.histogram == True:scores = torch.cat((scores, hist), dim=1).view(1, -1)scores = F.relu(self.fully_connected_first(scores))score = torch.sigmoid(self.scoring_layer(scores))return score

整体代码：

import glob,json
import numpy as np
import torch,os,math,random
import torch.nn as nn
import torch.nn.functional as F
import argparse
from tqdm import tqdm, trange
from torch import optim
from torch_geometric.nn import GCNConv
from parameter import parameter_parser,IOStream,table_printer
# 这里读取完也是json格式的文件
train_graphs = glob.glob('data/train/'+'*.json')
test_graphs = glob.glob('data/test/'+'*.json')def node_mapping():nodes_id = set()graph_pairs = train_graphs + test_graphsfor graph_pair in graph_pairs:graph = json.load(open(graph_pair))nodes_id = nodes_id.union(set(graph['labels_1']))nodes_id = nodes_id.union(set(graph['labels_2']))nodes_id = sorted(nodes_id)nodes_id = {id:index for index,id in enumerate(nodes_id)}num_nodes_id = len(nodes_id)print(nodes_id,num_nodes_id)return nodes_id,num_nodes_id"""
理解node_mapping()函数的作用：
例如：
graph1.json：{"labels_1": ["A", "B", "C"],"labels_2": ["D", "E"]
}   =>train_graph
graph2.json:{"labels_1": ["C", "F"],"labels_2": ["A", "G"]
}    => test_graph
执行：  graph_pairs = train_graphs + test_graphs 
得：=> graph_pairs = ['graph1.json','graph2.json']执行： for graph_pair in graph_pairs:
第一个循环：graph = json.load(open('graph1.json'))
得： #graph = {"labels_1": ["A", "B", "C"], "labels_2": ["D", "E"]}nodes_id = nodes_id.union(set(graph['labels_1']))  # {"A", "B", "C"}
nodes_id = nodes_id.union(set(graph['labels_2']))  # {"A", "B", "C", "D", "E"}第二个循环：graph = json.load(open('graph2.json'))
得： #graph = {"labels_1": ["C", "F"], "labels_2": ["A", "G"]}
nodes_id = nodes_id.union(set(graph['labels_1']))  # {"A", "B", "C", "D", "E", "F"}
nodes_id = nodes_id.union(set(graph['labels_2']))  # {"A", "B", "C", "D", "E", "F", "G"}执行：  nodes_id = sorted(nodes_id) 进行排序
得： # ["A", "B", "C", "D", "E", "F", "G"]执行： nodes_id = {id:index for index,id in enumerate(nodes_id)}  进行索引的建立
得：# nodes_id = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5, "G": 6}
简简单单理解这段代码，作用也就是完成one-hot 编码的建立
"""
def load_dataset():train_dataset = []test_dataset = []nodes_id, num_nodes_id = node_mapping()for graph_pair in train_graphs:graph = json.load(open(graph_pair))data = process_data(graph,nodes_id)train_dataset.append(data)for graph_pair in test_graphs:graph = json.load(open(graph_pair))data = process_data(graph, nodes_id)test_dataset.append(data)return train_dataset,test_dataset,num_nodes_iddef process_data(graph,nodes_id):data = dict()# 获取每个图的邻接矩阵edges_1 = graph['graph_1'] + [[y,x] for x,y in graph['graph_1']]edges_2 = graph['graph_2'] + [[y,x] for x,y in graph['graph_2']]edges_1 = torch.from_numpy(np.array(edges_1,dtype=np.int64).T).type(torch.long)edges_2 = torch.from_numpy(np.array(edges_2,dtype=np.int64).T).type(torch.long)data['edge_index_1'] = edges_1data['edge_index_2'] = edges_2feature_1 ,feature_2 = [],[]for n in graph['labels_1']:feature_1.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])for n in graph['labels_2']:feature_2.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])feature_1 = torch.FloatTensor(np.array(feature_1))feature_2 = torch.FloatTensor(np.array(feature_2))data['features_1'] = feature_1data['features_2'] = feature_2norm_ged = graph['ged'] / (0.5 * (len(graph['labels_1']) +len(graph['labels_2'])))data['norm_ged'] = norm_geddata["target"] = torch.from_numpy(np.exp(-norm_ged).reshape(1, 1)).view(-1).float().unsqueeze(0)return data"""理解process_data()函数的作用：数据假设：{"graph_1": [[0, 1], [1, 2]],  // 边的列表"graph_2": [[0, 2], [2, 3]],"labels_1": ["A", "B", "C"],  // 图1的节点标签"labels_2": ["A", "C", "D"],  // 图2的节点标签"ged": 2  // 图编辑距离
}
使用node_mapping()得到：nodes_id = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5, "G": 6}
执行：edges_1 = graph['graph_1'] + [[y, x] for x, y in graph['graph_1']] 
得： # [[0, 1], [1, 2], [1, 0], [2, 1]]  前部分是获取正向边，后边是添加反向边
执行：edges_2 = graph['graph_2'] + [[y, x] for x, y in graph['graph_2']] 
得： # [[0, 2], [2, 3], [2, 0], [3, 2]]执行：edges_1 = torch.from_numpy(np.array(edges_1, dtype=np.int64).T).type(torch.long)
得：将其转换为tensor类型第一个循环：
执行:for n in graph['labels_1']:  # ["A", "B", "C"]
执行：feature_1.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])
得：
# feature_1 = [[ A ,  B ,  C ,  D , E  ,  F ,  G ]
#     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],  # "A" 
#     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],  # "B" 
#     [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]   # "C" 
第二个循环：
for n in graph['labels_2']:  # ["A", "C", "D"]feature_2.append([1.0 if nodes_id[n] == i else 0.0 for i in nodes_id.values()])
# feature_2 = [
#     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],  # "A" 
#     [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],  # "C" 
#     [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]   # "D" 
# ]执行：feature_1 = torch.FloatTensor(np.array(feature_1))
得：将其转换为张量计算ged：
norm_ged = graph['ged'] / (0.5 * (len(graph['labels_1']) + len(graph['labels_2'])))
# norm_ged = 2 / (0.5 * (3 + 3)) = 2 / 3 = 0.6667计算目标值：
data['target'] = torch.from_numpy(np.exp(-norm_ged).reshape(1, 1)).view(-1).float().unsqueeze(0)
# target = torch.from_numpy(np.exp(-0.6667).reshape(1, 1)).view(-1).float().unsqueeze(0)
# target = torch.tensor([[0.5134]])理解一下ged：
Graph Edit Distance ：图编辑距离
Ged 是衡量两个图之间的相似度的标识，ged越小，则越相似。
ged 是表示将一个图转变为另一个图的最小操作数（节点和边的添加、删除、替换等）。
norm_ged = GED / (0.5 * (V1 + V2 ))  其中V1和V2 是两个图的节点。理解一下target：
target = exp(-norm_ged)，很多公式都会取负指数，因为这样能够将数值限定在0到1之间。
"""# 定义注意力模块
class AttentionModule(nn.Module):def __init__(self,args):super(AttentionModule,self).__init__()self.args = argsself.setup_weights()self.init_parameters()def setup_weights(self):# 创建权重矩阵（并未赋值），fiLters_3 = 32self.weight_matrix = nn.Parameter(torch.Tensor(self.args.filters_3, self.args.filters_3))def init_parameters(self):# 为权重矩阵进行赋值。nn.init.xavier_uniform_(self.weight_matrix)def forward(self, embedding):# embedding:(num_nodes=14, num_features=32)# 在每个特征维度上，取节点平均值# 执行torch.matmul(embedding, self.weight_matrix)=>[14,32]# 执行torch.mean(,dim=0) => [32,] 其实就是一行32列global_context = torch.mean(torch.matmul(embedding, self.weight_matrix), dim=0)# [32,] => [32,]transformed_global = torch.tanh(global_context)# sigmoid_scores计算每个节点与图之间的相似性得分(注意力)# sigmoid_scores:(14)# 执行：transormed_global.view(-1,1) [32,]=> [32,1]# 执行：torch.mm() =>矩阵乘法=>[14,32] × [32,1] = [14,1],# 注意：这里的实现并没有完全跟论文相同，缺少了一个转置，放在下一步实现了sigmoid_scores = torch.sigmoid(torch.mm(embedding, transformed_global.view(-1, 1)))# representation:图的嵌入(32)# 执行：torch.t(embedding) [14,32] =>[32,14]# 执行：torch.mm() [32,14] * [14,1] =>[32,1]representation = torch.mm(torch.t(embedding), sigmoid_scores)return representation
"""
理解attention函数：
根据simgnn论文可得知："""
class TensorNetworkModule(nn.Module):def __init__(self,args):super(TensorNetworkModule,self).__init__()self.args = argsself.setup_weights()self.init_parameters()def setup_weights(self):# tensor_neurons 表示神经元数目# 三维张量 Mself.weight_matrix = nn.Parameter(torch.Tensor(self.args.filters_3, self.args.filters_3, self.args.tensor_neurons))# 权重矩阵 Vself.weight_matrix_block = nn.Parameter(torch.Tensor(self.args.tensor_neurons,2*self.args.filters_3))# 偏置向量 bself.bias = nn.Parameter(torch.Tensor(self.args.tensor_neurons,1))def init_parameters(self):nn.init.xavier_uniform_(self.weight_matrix)nn.init.xavier_uniform_(self.weight_matrix_block)nn.init.xavier_uniform_(self.bias)def forward(self,embedding_1,embedding_2):# 这一部分实现：h1^T * M * h2# embedding_1 = [32,1] 经转置=> [1,32]# M = [32,32,16]# scoring = [1，32] * [32,512] = [1,512]scoring = torch.mm(torch.t(embedding_1),self.weight_matrix.view(self.args.filters_3,-1))# scoring = [32,16]scoring = scoring.view(self.args.filters_3,self.args.tensor_neurons) # shape=[32,16]# scoring = [16,1]scoring = torch.mm(torch.t(scoring),embedding_2) # shape = [16,1]# 就是论文中将两个嵌入向量叠加起来combined_representation = torch.cat((embedding_1,embedding_2))# V*[]block_scoring = torch.mm(self.weight_matrix_block,combined_representation)scores = F.relu(scoring + block_scoring +self.bias)return scores"""
理解这一部分张量网络：
根据SimGNN论文中的公式：
假设embedding_1 和 embedding_2 都为 [32,1],self.args.filters_3=32,self.args.tensor_neurons=16
可得： self.weight_matrix = [32,32,16]self.weight_matrix_block = [16,64]self.bias = [16,1]
问题一：M 为啥是三维的权重矩阵呢？
例子中的Ｍ是［32,32,16］ 表示k = 16个32*32的矩阵
"""
class SimGNN(nn.Module):def __init__(self,args,num_nodes_id):super(SimGNN,self).__init__()self.args = argsself.num_nodes_id = num_nodes_idself.setup_layers()# 是否使用直方图def calculate_bottleneck_features(self):if self.args.histogram == True:self.feature_count = self.args.tensor_neurons + self.args.binselse:self.feature_count = self.args.tensor_neuronsdef setup_layers(self):self.calculate_bottleneck_features()self.convolution_1 = GCNConv(self.num_nodes_id,self.args.filters_1)self.convolution_2 = GCNConv(self.args.filters_1,self.args.filters_2)self.convolution_3 = GCNConv(self.args.filters_2,self.args.filters_3)self.attention = AttentionModule(self.args)self.tensor_network = TensorNetworkModule(self.args)self.fully_connected_first = nn.Linear(self.feature_count,self.args.bottle_neck_neurons)self.scoring_layer = nn.Linear(self.args.bottle_neck_neurons,1)def calculate_histogram(self,abstract_features_1, abstract_features_2):"""理解calculate_histogram函数：作用：用于计算节点特征的直方图，用于衡量图之间的相似性。"""# abstract_features_1:(num_nodes1, num_features=32)# abstract_features_2:(num_features=32, num_nodes2) 这里是完成转置了# 执行torch.mm 后得到 相似性得分矩阵。scores = torch.mm(abstract_features_1, abstract_features_2).detach()scores = scores.view(-1, 1)# 计算直方图，将得分分为 bins 个区间。# 例如 bins为 8，hist = tensor([4., 3., 1., 0., 0., 2., 1., 1.])hist = torch.histc(scores, bins=self.args.bins)  # 统计得分在每个区间的个数# hist = tensor([0.3333, 0.2500, 0.0833, 0.0000, 0.0000, 0.1667, 0.0833, 0.0833])hist = hist / torch.sum(hist)  # 归一化hist = hist.view(1, -1)return histdef convolutional_pass(self, edge_index, features):features = self.convolution_1(features, edge_index)features = F.relu(features)features = F.dropout(features, p=self.args.dropout, training=self.training)features = self.convolution_2(features, edge_index)features = F.relu(features)features = F.dropout(features, p=self.args.dropout, training=self.training)features = self.convolution_3(features, edge_index)return featuresdef forward(self, data):# 获取图 1 的邻接矩阵edge_index_1 = data["edge_index_1"]# 获取图 2 的邻接矩阵edge_index_2 = data["edge_index_2"]# 获取图 1 的特征（独热编码）features_1 = data["features_1"]  # (num_nodes1, num_features=16)features_2 = data["features_2"]  # (num_nodes2, num_features=16)# (num_nodes1, num_features=16) ——> (num_nodes1, num_features=32)abstract_features_1 = self.convolutional_pass(edge_index_1,features_1)# (num_nodes2, num_features=16) ——> (num_nodes2, num_features=32)abstract_features_2 = self.convolutional_pass(edge_index_2,features_2)# 直方图if self.args.histogram == True:hist = self.calculate_histogram(abstract_features_1, torch.t(abstract_features_2))# 池化pooled_features_1 = self.attention(abstract_features_1)  # (num_nodes1, num_features=32) ——> (num_features=32)pooled_features_2 = self.attention(abstract_features_2)  # (num_nodes2, num_features=32) ——> (num_features=32)# NTN模型scores = self.tensor_network(pooled_features_1, pooled_features_2)scores = torch.t(scores)if self.args.histogram == True:scores = torch.cat((scores, hist), dim=1).view(1, -1)scores = F.relu(self.fully_connected_first(scores))score = torch.sigmoid(self.scoring_layer(scores))return score
def exp_init():"""实验初始化"""if not os.path.exists('outputs'):os.mkdir('outputs')if not os.path.exists('outputs/' + args.exp_name):os.mkdir('outputs/' + args.exp_name)# 跟踪执行脚本，windows下使用copy命令，且使用双引号os.system(f"copy main.py outputs\\{args.exp_name}\\main.py.backup")os.system(f"copy data.py outputs\\{args.exp_name}\\data.py.backup")os.system(f"copy model.py outputs\\{args.exp_name}\\model.py.backup")os.system(f"copy parameter.py outputs\\{args.exp_name}\\parameter.py.backup")def train(args, IO, train_dataset, num_nodes_id):# 使用GPU or CPUdevice = torch.device('cpu' if args.gpu_index < 0 else 'cuda:{}'.format(args.gpu_index))if args.gpu_index < 0:IO.cprint('Using CPU')else:IO.cprint('Using GPU: {}'.format(args.gpu_index))torch.cuda.manual_seed(args.seed)  # 设置PyTorch GPU随机种子# 加载模型及参数量统计model = SimGNN(args, num_nodes_id).to(device)IO.cprint(str(model))total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)IO.cprint('Model Parameter: {}'.format(total_params))# 优化器optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)IO.cprint('Using Adam')epochs = trange(args.epochs, leave=True, desc="Epoch")for epoch in epochs:random.shuffle(train_dataset)train_batches = []for graph in range(0, len(train_dataset), 16):train_batches.append(train_dataset[graph:graph + 16])loss_epoch = 0 # 一个epoch，所有样本损失for index, batch in tqdm(enumerate(train_batches), total=len(train_batches), desc="Train_Batches"):optimizer.zero_grad()loss_batch = 0 # 一个batch，样本损失for data in batch:# 数据变成GPU支持的数据类型data["edge_index_1"], data["edge_index_2"] = data["edge_index_1"].to(device), data["edge_index_2"].to(device)data["features_1"], data["features_2"] = data["features_1"].to(device), data["features_2"].to(device)prediction = model(data)loss_batch = loss_batch + F.mse_loss(data["target"], prediction.cpu())loss_epoch = loss_epoch + loss_batch.item()loss_batch.backward()optimizer.step()IO.cprint('Epoch #{}, Train_Loss: {:.6f}'.format(epoch, loss_epoch/len(train_dataset)))torch.save(model, 'outputs/%s/model.pth' % args.exp_name)IO.cprint('The current best model is saved in: {}'.format('******** outputs/%s/model.pth *********' % args.exp_name))def test(args, IO, test_dataset):"""测试模型"""device = torch.device('cpu' if args.gpu_index < 0 else 'cuda:{}'.format(args.gpu_index))# 输出内容保存在之前的训练日志里IO.cprint('********** TEST START **********')IO.cprint('Reload Best Model')IO.cprint('The current best model is saved in: {}'.format('******** outputs/%s/model.pth *********' % args.exp_name))model = torch.load('outputs/%s/model.pth' % args.exp_name).to(device)#model = model.eval()  # 创建一个新的评估模式的模型对象，不覆盖原模型ground_truth = [] # 存放data["norm_ged"]scores = [] # 存放模型预测与ground_truth的损失for data in test_dataset:data["edge_index_1"], data["edge_index_2"] = data["edge_index_1"].to(device), data["edge_index_2"].to(device)data["features_1"], data["features_2"] = data["features_1"].to(device), data["features_2"].to(device)prediction = model(data)scores.append((-math.log(prediction.item()) - data["norm_ged"]) ** 2) # MSELossground_truth.append(data["norm_ged"])model_error = np.mean(scores)norm_ged_mean = np.mean(ground_truth)baseline_error = np.mean([(gt - norm_ged_mean) ** 2 for gt in ground_truth])IO.cprint('Baseline_Error: {:.6f}, Model_Test_Error: {:.6f}'.format(baseline_error, model_error))args = parameter_parser()
random.seed(args.seed)  # 设置Python随机种子
torch.manual_seed(args.seed)  # 设置PyTorch随机种子
exp_init()IO = IOStream('outputs/' + args.exp_name + '/run.log')
IO.cprint(str(table_printer(args)))  # 参数可视化train_dataset, test_dataset, num_nodes_id = load_dataset()train(args, IO, train_dataset, num_nodes_id)
test(args, IO, test_dataset)

感谢B站的各位老师，不过训练部分的代码还没看，明天吧！