Upload folder using huggingface_hub

edge_aware_gnn_link.py

@@ -0,0 +1,213 @@
+import sys
+import os
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..', '..', '..')))
+
+import pickle
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torch_geometric.transforms as T
+import tqdm
+from sklearn.metrics import roc_auc_score, f1_score
+from torch_geometric import seed_everything
+from torch_geometric.loader import LinkNeighborLoader
+from torch_geometric.nn import SAGEConv, TransformerConv, GINEConv, GeneralConv, EdgeConv
+from torch.nn import Linear
+from models.edge_conv import EdgeConvConv
+from models.sage_edge_conv import SAGEEdgeConv
+from models.mlp import MLP
+import argparse
+
+class GNN(torch.nn.Module):
+	def __init__(self, hidden_channels, edge_dim, num_layers, model_type):
+		super().__init__()
+
+		self.convs = torch.nn.ModuleList()
+
+		if model_type == 'GraphSAGE':
+			self.conv = SAGEEdgeConv(hidden_channels, hidden_channels, edge_dim=edge_dim)
+		elif model_type == 'GraphTransformer':
+			self.conv = TransformerConv((-1, -1), hidden_channels, edge_dim=edge_dim)
+		elif model_type == 'GINE':
+			self.conv = GINEConv(Linear(hidden_channels, hidden_channels), edge_dim=edge_dim)
+		elif model_type == 'EdgeConv':
+			self.conv = EdgeConvConv(Linear(2 * hidden_channels + edge_dim, hidden_channels), train_eps=True,
+									 edge_dim=edge_dim)
+		elif model_type == 'GeneralConv':
+			self.conv = GeneralConv((-1, -1), hidden_channels, in_edge_channels=edge_dim)
+		else:
+			raise NotImplementedError('Model type not implemented')
+
+		for _ in range(num_layers):
+			self.convs.append(self.conv)
+
+	def forward(self, x, edge_index, edge_attr):
+		for i, conv in enumerate(self.convs):
+			x = conv(x, edge_index, edge_attr)
+			x = x.relu() if i != len(self.convs) - 1 else x
+		return x
+
+class Classifier(torch.nn.Module):
+	def __init__(self, hidden_channels):
+		super().__init__()
+		self.lin1 = Linear(2 * hidden_channels, hidden_channels)
+		self.lin2 = Linear(hidden_channels, 1)
+
+	def forward(self, x, edge_label_index):
+		# Convert node embeddings to edge-level representations:
+		edge_feat_src = x[edge_label_index[0]]
+		edge_feat_dst = x[edge_label_index[1]]
+
+		z = torch.cat([edge_feat_src, edge_feat_dst], dim=-1)
+		z = self.lin1(z).relu()
+		z = self.lin2(z)
+		return z.view(-1)
+
+class Model(torch.nn.Module):
+	def __init__(self, hidden_channels, edge_dim, num_layers, model_type):
+		super().__init__()
+		self.model_type = model_type
+		if model_type != 'MLP':
+			self.gnn = GNN(hidden_channels, edge_dim, num_layers, model_type=model_type)
+		
+		self.classifier = Classifier(hidden_channels)
+
+	def forward(self, data):
+		x = data.x
+		if self.model_type != 'MLP':
+			x = self.gnn(x, data.edge_index, data.edge_attr)
+			
+		pred = self.classifier(x, data.edge_label_index)
+		return pred, x
+
+
+if __name__ == "__main__":
+	seed_everything(66)
+
+	parser = argparse.ArgumentParser()
+	parser.add_argument('--data_type', '-dt', type=str, default='reddit', help='Data type')
+	parser.add_argument('--emb_type', '-et', type=str, default='GPT-3.5-TURBO', help='Embedding type')  # TODO: set edge dim
+	parser.add_argument('--model_type', '-mt', type=str, default='MLP', help='Model type')
+	args = parser.parse_args()
+
+	# Dataset = Children(root='.') 
+	# data = Dataset[0]   # TODO: Citation code in TAG
+	with open(f'./reddit_graph.pkl', 'rb') as f:
+		data = pickle.load(f)
+	
+	num_nodes = len(data.text_nodes)
+	num_edges = len(data.text_edges)
+ 
+	del data.text_nodes
+	del data.text_node_labels
+	del data.text_edges
+
+	# set hidden channels and edge dim for diff emb type 
+	if args.emb_type != 'None':
+		data.edge_attr = torch.load(f'./reddit_graph-openai-edge.pt').squeeze().float()
+		data.x = torch.load(f'./reddit_graph-openai-node.pt').squeeze().float()
+		if args.emb_type == 'GPT-3.5-TURBO':
+			edge_dim = 1536
+			node_dim = 1536
+		elif args.emb_type == 'Large_Bert':
+			edge_dim = 1024
+			node_dim = 1024
+		elif args.emb_type == 'BERT':
+			edge_dim = 768
+			node_dim = 768
+		else:
+			raise NotImplementedError('Embedding type not implemented')
+	else:
+		data.x = torch.load(f'./reddit_graph-openai-node.pt').squeeze().float()
+		data.edge_attr = torch.randn(num_edges, 1024).squeeze().float()
+		edge_dim = 1024
+		node_dim = 1024
+
+	print(data)
+  
+	train_data, val_data, test_data = T.RandomLinkSplit(
+		num_val=0.8,
+		num_test=0.1,
+		disjoint_train_ratio=0.3,
+		neg_sampling_ratio=1.0,
+	)(data)
+	
+	# Perform a link-level split into training, validation, and test edges:
+	edge_label_index = train_data.edge_label_index
+	edge_label = train_data.edge_label
+	train_loader = LinkNeighborLoader(
+		data=train_data,
+		num_neighbors=[20, 10],
+		edge_label_index=(edge_label_index),
+		edge_label=edge_label,
+		batch_size=1024,
+		shuffle=True,
+	)
+
+	edge_label_index = val_data.edge_label_index
+	edge_label = val_data.edge_label
+	val_loader = LinkNeighborLoader(
+		data=val_data,
+		num_neighbors=[20, 10],
+		edge_label_index=(edge_label_index),
+		edge_label=edge_label,
+		batch_size=1024,
+		shuffle=False,
+	)
+
+	edge_label_index = test_data.edge_label_index
+	edge_label = test_data.edge_label
+	test_loader = LinkNeighborLoader(
+		data=test_data,
+		num_neighbors=[20, 10],
+		edge_label_index=(edge_label_index),
+		edge_label=edge_label,
+		batch_size=1024,
+		shuffle=False,
+	)
+	
+	model = Model(hidden_channels=node_dim, edge_dim=edge_dim, num_layers=2, model_type=args.model_type)  # TODO: edge dim
+	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+	print(device)
+
+	model = model.to(device)
+	optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+	for epoch in range(1, 10):
+		total_loss = total_examples = 0
+		for sampled_data in tqdm.tqdm(train_loader):
+			optimizer.zero_grad()
+			sampled_data = sampled_data.to(device)
+			pred, x = model(sampled_data)
+			ground_truth = sampled_data.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}")
+
+		# validation
+		if epoch % 1 == 0 and epoch != 0:
+			print('Validation begins')
+			with torch.no_grad():
+				preds = []
+				ground_truths = []
+				for sampled_data in tqdm.tqdm(test_loader):
+					with torch.no_grad():
+						sampled_data = sampled_data.to(device)
+						pred = model(sampled_data)[0]
+						preds.append(pred)
+						ground_truths.append(sampled_data.edge_label)
+						positive_pred = pred[sampled_data.edge_label == 1].cpu().numpy()
+						negative_pred = pred[sampled_data.edge_label == 0].cpu().numpy()
+					pred = torch.cat(preds, dim=0).cpu().numpy()
+
+				ground_truth = torch.cat(ground_truths, dim=0).cpu().numpy()
+				y_label = np.where(pred >= 0.5, 1, 0)
+				f1 = f1_score(ground_truth, y_label)
+				print(f"F1 score: {f1:.4f}")
+				# AUC
+				auc = roc_auc_score(ground_truth, pred)
+				print(f"Validation AUC: {auc:.4f}")

edge_aware_gnn_node.py

@@ -0,0 +1,220 @@
+import os
+import pickle
+import sys
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..', '..', '..')))
+
+from models.edge_conv import EdgeConvConv
+from models.sage_edge_conv import SAGEEdgeConv
+from models.mlp import MLP
+import torch.nn.functional as F
+import numpy as np
+import torch
+import torch_geometric.transforms as T
+from torch_geometric.loader import NeighborLoader
+from torch_geometric import seed_everything
+import tqdm
+from sklearn.metrics import roc_auc_score, f1_score, accuracy_score
+from torch_geometric.loader import NeighborSampler
+from torch_geometric.nn import SAGEConv, TransformerConv, GINEConv, EdgeConv, GeneralConv
+from torch.nn import Linear
+import argparse
+
+class GNN(torch.nn.Module):
+	def __init__(self, hidden_channels, edge_dim, num_layers, model_type):
+		super().__init__()
+		self.convs = torch.nn.ModuleList()
+
+		if model_type == 'GraphSAGE':
+			self.conv = SAGEEdgeConv(hidden_channels, hidden_channels, edge_dim=edge_dim)
+		elif model_type == 'GraphTransformer':
+			self.conv = TransformerConv((-1, -1), hidden_channels, edge_dim=edge_dim)
+		elif model_type == 'GINE':
+			self.conv = GINEConv(Linear(hidden_channels, hidden_channels), edge_dim=edge_dim)
+		elif model_type == 'EdgeConv':
+			self.conv = EdgeConvConv(Linear(2 * hidden_channels + edge_dim, hidden_channels), train_eps=True,
+									 edge_dim=edge_dim)
+		elif model_type == 'GeneralConv':
+			self.conv = GeneralConv((-1, -1), hidden_channels, in_edge_channels=edge_dim)
+		else:
+			raise NotImplementedError('Model type not implemented')
+
+		for _ in range(num_layers):
+			self.convs.append(self.conv)
+
+	def forward(self, x, edge_index, edge_attr):
+		for i, conv in enumerate(self.convs):
+			x = conv(x, edge_index, edge_attr=edge_attr)
+			x = x.relu() if i != len(self.convs) - 1 else x
+		return x
+
+
+class Classifier(torch.nn.Module):
+	def __init__(self, hidden_channels, out_channels):
+		super().__init__()
+		self.lin1 = Linear(hidden_channels, hidden_channels // 4)
+		self.lin2 = Linear(hidden_channels // 4, out_channels)
+
+	def forward(self, x):
+		x = self.lin1(x).relu()
+		x = self.lin2(x)
+		return x
+
+
+class Model(torch.nn.Module):
+	def __init__(self, hidden_channels, out_channels, edge_dim, num_layers, model_type):
+		super().__init__()
+		self.model_type = model_type
+		if model_type != 'MLP':
+			self.gnn = GNN(hidden_channels, edge_dim, num_layers, model_type=model_type)
+		
+		self.classifier = Classifier(hidden_channels, out_channels)
+
+	def forward(self, data):
+		x = data.x
+		if self.model_type != 'MLP':
+			x = self.gnn(x, data.edge_index, data.edge_attr)
+		
+		pred = self.classifier(x)
+		return pred
+
+if __name__ == '__main__':
+	seed_everything(66)
+
+	parser = argparse.ArgumentParser()
+	parser.add_argument('--data_type', '-dt', type=str, default='reddit', help='Data type')
+	parser.add_argument('--emb_type', '-et', type=str, default='GPT-3.5-TURBO', help='Embedding type')  # TODO: set edge dim
+	parser.add_argument('--model_type', '-mt', type=str, default='MLP', help='Model type')
+	args = parser.parse_args()
+
+
+	# Dataset = Children(root='.') 
+	# data = Dataset[0]   # TODO: Citation code in TAG
+	with open(f'./reddit_graph.pkl', 'rb') as f:
+		data = pickle.load(f)
+	print(data)
+
+	num_nodes = len(data.text_nodes)
+	num_edges = len(data.text_edges)
+
+	# map node labels 
+	node_labels=data.node_labels.tolist()
+	label_to_int = {label: i for i, label in enumerate(set(node_labels))}
+	data.y = torch.tensor([label_to_int[label] for label in node_labels]).long()
+ 
+	# data split
+	train_ratio = 0.8
+	val_ratio = 0.1
+
+	num_train_paper = int(num_nodes * train_ratio)
+	num_val_paper = int(num_nodes * val_ratio)
+	num_test_paper = num_nodes - num_train_paper - num_val_paper
+			
+	paper_indices = torch.randperm(num_nodes)
+
+	data.train_mask = torch.zeros(num_nodes, dtype=torch.bool)
+	data.val_mask = torch.zeros(num_nodes, dtype=torch.bool)
+	data.test_mask = torch.zeros(num_nodes, dtype=torch.bool)
+
+	data.train_mask[paper_indices[:num_val_paper]] = 1
+	data.val_mask[paper_indices[num_val_paper:num_val_paper + num_val_paper ]] = 1
+	data.test_mask[paper_indices[-num_test_paper:]] = 1
+
+	data.num_classes = max(data.y) + 1
+	data.num_nodes = num_nodes
+ 
+	del data.text_nodes
+	del data.text_node_labels
+	del data.text_edges
+
+	# set hidden channels and edge dim for diff emb type 
+	
+	if args.emb_type != 'None':
+		data.x = torch.load(f'./reddit_graph-openai-node.pt').squeeze().float()
+		data.edge_attr = torch.load(f'./reddit_graph-openai-edge.pt').squeeze().float()
+		if args.emb_type == 'GPT-3.5-TURBO':
+			edge_dim = 1536
+			node_dim = 1536
+		elif args.emb_type == 'Large_Bert':
+			edge_dim = 1024
+			node_dim = 1024
+		elif args.emb_type == 'BERT':
+			edge_dim = 768
+			node_dim = 768
+		else:
+			raise NotImplementedError('Embedding type not implemented')
+	else:
+		data.x = torch.load(f'./reddit_graph-openai-node.pt').squeeze().float()
+		data.edge_attr = torch.randn(num_edges, 1024).squeeze().float()
+		edge_dim = 1024
+		node_dim = 1024
+	
+	# Make sure all attributes of data are contiguous
+	data.x = data.x.contiguous()
+	data.edge_index = data.edge_index.contiguous()
+	
+	print(data)	
+
+	# Now create the NeighborLoaders
+	train_loader = NeighborLoader(data, input_nodes=data.train_mask, num_neighbors=[10, 10], batch_size=1024, shuffle=True)
+	val_loader = NeighborLoader(data, input_nodes=data.val_mask, num_neighbors=[10, 10], batch_size=1024, shuffle=False)
+	test_loader = NeighborLoader(data, input_nodes=data.test_mask, num_neighbors=[10, 10], batch_size=1024, shuffle=False)
+
+	train_loader = NeighborLoader(data, input_nodes=data.train_mask, num_neighbors=[10, 10], batch_size=1024, shuffle=True)
+	val_loader = NeighborLoader(data, input_nodes=data.val_mask, num_neighbors=[10, 10], batch_size=1024, shuffle=False)
+	test_loader = NeighborLoader(data, input_nodes=data.test_mask, num_neighbors=[10, 10], batch_size=1024, shuffle=False)
+ 
+	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+	print(device)
+
+	model = Model(hidden_channels=node_dim, out_channels=data.num_classes, edge_dim=edge_dim, num_layers=2, model_type=args.model_type)
+	model = model.to(device)
+
+	optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+	criterion = torch.nn.CrossEntropyLoss()
+
+	for epoch in range(1, 10):
+		model.train()
+		total_examples = total_loss = 0
+
+		for batch in tqdm.tqdm(train_loader):
+			optimizer.zero_grad()
+			batch = batch.to(device)
+			batch_size = batch.batch_size
+			
+			out = model(batch)
+			loss = criterion(out, batch.y)
+			loss.backward()
+			optimizer.step()
+
+			total_examples += batch_size
+			total_loss += float(loss) * batch_size
+
+		if epoch % 1 == 0 and epoch != 0:
+			print('Validation begins')
+
+			model.eval()
+			with torch.no_grad():
+				preds = []
+				ground_truths = []
+				for batch in tqdm.tqdm(val_loader):
+					batch = batch.to(device)
+					
+					out = model(batch)
+					pred = F.softmax(out, dim=1) 
+					
+					preds.append(pred)
+					ground_truths.append(batch.y)
+				
+				pred = torch.cat(preds, dim=0).cpu().numpy()
+				ground_truth = torch.cat(ground_truths, dim=0).cpu().numpy()
+				
+				# F1 Score
+				y_pred_labels = np.argmax(pred, axis=1)  # 获得预测类别
+				f1 = f1_score(ground_truth, y_pred_labels, average='weighted')
+				print(f"F1 score: {f1:.4f}")
+				
+				# ACC
+				accuracy = accuracy_score(ground_truth, y_pred_labels)
+				print(f"Validation Accuracy: {accuracy:.4f}")

link_prediction_log/EdgeConv_GPT.txt

@@ -0,0 +1,38 @@
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], edge_attr=[676684, 1536], x=[478022, 1536])
+cuda
+Epoch: 001, Loss: 1.1276
+Validation begins
+F1 score: 0.9799
+Validation AUC: 0.9925
+Epoch: 002, Loss: 0.4067
+Validation begins
+F1 score: 0.9818
+Validation AUC: 0.9922
+Epoch: 003, Loss: 0.1547
+Validation begins
+F1 score: 0.9812
+Validation AUC: 0.9918
+Epoch: 004, Loss: 0.1403
+Validation begins
+F1 score: 0.9800
+Validation AUC: 0.9926
+Epoch: 005, Loss: 0.1717
+Validation begins
+F1 score: 0.9801
+Validation AUC: 0.9921
+Epoch: 006, Loss: 0.1315
+Validation begins
+F1 score: 0.9800
+Validation AUC: 0.9919
+Epoch: 007, Loss: 0.1300
+Validation begins
+F1 score: 0.9800
+Validation AUC: 0.9922
+Epoch: 008, Loss: 0.1417
+Validation begins
+F1 score: 0.9800
+Validation AUC: 0.9924
+Epoch: 009, Loss: 0.1294
+Validation begins
+F1 score: 0.9800
+Validation AUC: 0.9921

link_prediction_log/GINE_GPT.txt

@@ -0,0 +1,38 @@
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], edge_attr=[676684, 1536], x=[478022, 1536])
+cuda
+Epoch: 001, Loss: 0.4447
+Validation begins
+F1 score: 0.9805
+Validation AUC: 0.9961
+Epoch: 002, Loss: 0.0825
+Validation begins
+F1 score: 0.9807
+Validation AUC: 0.9961
+Epoch: 003, Loss: 0.0617
+Validation begins
+F1 score: 0.9804
+Validation AUC: 0.9960
+Epoch: 004, Loss: 0.0525
+Validation begins
+F1 score: 0.9809
+Validation AUC: 0.9962
+Epoch: 005, Loss: 0.0456
+Validation begins
+F1 score: 0.9809
+Validation AUC: 0.9961
+Epoch: 006, Loss: 0.0403
+Validation begins
+F1 score: 0.9803
+Validation AUC: 0.9957
+Epoch: 007, Loss: 0.0332
+Validation begins
+F1 score: 0.9806
+Validation AUC: 0.9957
+Epoch: 008, Loss: 0.0271
+Validation begins
+F1 score: 0.9801
+Validation AUC: 0.9960
+Epoch: 009, Loss: 0.0212
+Validation begins
+F1 score: 0.9804
+Validation AUC: 0.9952

link_prediction_log/GeneralConv_GPT.txt

@@ -0,0 +1,38 @@
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], edge_attr=[676684, 1536], x=[478022, 1536])
+cuda
+Epoch: 001, Loss: 0.1678
+Validation begins
+F1 score: 0.9809
+Validation AUC: 0.9964
+Epoch: 002, Loss: 0.0631
+Validation begins
+F1 score: 0.9809
+Validation AUC: 0.9961
+Epoch: 003, Loss: 0.0540
+Validation begins
+F1 score: 0.9802
+Validation AUC: 0.9959
+Epoch: 004, Loss: 0.0472
+Validation begins
+F1 score: 0.9795
+Validation AUC: 0.9961
+Epoch: 005, Loss: 0.0411
+Validation begins
+F1 score: 0.9798
+Validation AUC: 0.9959
+Epoch: 006, Loss: 0.0349
+Validation begins
+F1 score: 0.9803
+Validation AUC: 0.9962
+Epoch: 007, Loss: 0.0312
+Validation begins
+F1 score: 0.9801
+Validation AUC: 0.9958
+Epoch: 008, Loss: 0.0264
+Validation begins
+F1 score: 0.9804
+Validation AUC: 0.9959
+Epoch: 009, Loss: 0.0266
+Validation begins
+F1 score: 0.9799
+Validation AUC: 0.9960

link_prediction_log/GraphSAGE_GPT.txt

@@ -0,0 +1,58 @@
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], edge_attr=[676684, 1536], x=[478022, 1536])
+cuda
+Epoch: 001, Loss: 0.1693
+Validation begins
+F1 score: 0.9807
+Validation AUC: 0.9883
+Epoch: 002, Loss: 0.0656
+Validation begins
+F1 score: 0.9810
+Validation AUC: 0.9900
+Epoch: 003, Loss: 0.0556
+Validation begins
+F1 score: 0.9808
+Validation AUC: 0.9906
+Epoch: 004, Loss: 0.0473
+Validation begins
+F1 score: 0.9807
+Validation AUC: 0.9906
+Epoch: 005, Loss: 0.0397
+Validation begins
+F1 score: 0.9793
+Validation AUC: 0.9898
+Epoch: 006, Loss: 0.0337
+Validation begins
+F1 score: 0.9786
+Validation AUC: 0.9901
+Epoch: 007, Loss: 0.0291
+Validation begins
+F1 score: 0.9796
+Validation AUC: 0.9908
+Epoch: 008, Loss: 0.0247
+Validation begins
+F1 score: 0.9805
+Validation AUC: 0.9893
+Epoch: 009, Loss: 0.0262
+Validation begins
+F1 score: 0.9787
+Validation AUC: 0.9908
+Epoch: 010, Loss: 0.0218
+Validation begins
+F1 score: 0.9805
+Validation AUC: 0.9900
+Epoch: 011, Loss: 0.0176
+Validation begins
+F1 score: 0.9802
+Validation AUC: 0.9896
+Epoch: 012, Loss: 0.0143
+Validation begins
+F1 score: 0.9796
+Validation AUC: 0.9897
+Epoch: 013, Loss: 0.0121
+Validation begins
+F1 score: 0.9806
+Validation AUC: 0.9896
+Epoch: 014, Loss: 0.0094
+Validation begins
+F1 score: 0.9804
+Validation AUC: 0.9883

link_prediction_log/GraphTransformer_GPT.txt

@@ -0,0 +1,58 @@
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], edge_attr=[676684, 1536], x=[478022, 1536])
+cuda
+Epoch: 001, Loss: 0.1325
+Validation begins
+F1 score: 0.9808
+Validation AUC: 0.9921
+Epoch: 002, Loss: 0.0609
+Validation begins
+F1 score: 0.9810
+Validation AUC: 0.9944
+Epoch: 003, Loss: 0.0496
+Validation begins
+F1 score: 0.9808
+Validation AUC: 0.9944
+Epoch: 004, Loss: 0.0392
+Validation begins
+F1 score: 0.9792
+Validation AUC: 0.9942
+Epoch: 005, Loss: 0.0326
+Validation begins
+F1 score: 0.9804
+Validation AUC: 0.9934
+Epoch: 006, Loss: 0.0236
+Validation begins
+F1 score: 0.9805
+Validation AUC: 0.9935
+Epoch: 007, Loss: 0.0204
+Validation begins
+F1 score: 0.9800
+Validation AUC: 0.9900
+Epoch: 008, Loss: 0.0185
+Validation begins
+F1 score: 0.9801
+Validation AUC: 0.9915
+Epoch: 009, Loss: 0.0154
+Validation begins
+F1 score: 0.9804
+Validation AUC: 0.9917
+Epoch: 010, Loss: 0.0128
+Validation begins
+F1 score: 0.9797
+Validation AUC: 0.9911
+Epoch: 011, Loss: 0.0106
+Validation begins
+F1 score: 0.9794
+Validation AUC: 0.9903
+Epoch: 012, Loss: 0.0095
+Validation begins
+F1 score: 0.9799
+Validation AUC: 0.9878
+Epoch: 013, Loss: 0.0087
+Validation begins
+F1 score: 0.9799
+Validation AUC: 0.9894
+Epoch: 014, Loss: 0.0077
+Validation begins
+F1 score: 0.9801
+Validation AUC: 0.9898

link_prediction_log/MLP_GPT.txt

@@ -0,0 +1,38 @@
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], edge_attr=[676684, 1536], x=[478022, 1536])
+cuda
+Epoch: 001, Loss: 0.2748
+Validation begins
+F1 score: 0.9365
+Validation AUC: 0.9856
+Epoch: 002, Loss: 0.1289
+Validation begins
+F1 score: 0.9579
+Validation AUC: 0.9885
+Epoch: 003, Loss: 0.1131
+Validation begins
+F1 score: 0.9603
+Validation AUC: 0.9893
+Epoch: 004, Loss: 0.1022
+Validation begins
+F1 score: 0.9523
+Validation AUC: 0.9900
+Epoch: 005, Loss: 0.0955
+Validation begins
+F1 score: 0.9582
+Validation AUC: 0.9903
+Epoch: 006, Loss: 0.0898
+Validation begins
+F1 score: 0.9599
+Validation AUC: 0.9906
+Epoch: 007, Loss: 0.0850
+Validation begins
+F1 score: 0.9650
+Validation AUC: 0.9908
+Epoch: 008, Loss: 0.0820
+Validation begins
+F1 score: 0.9651
+Validation AUC: 0.9909
+Epoch: 009, Loss: 0.0763
+Validation begins
+F1 score: 0.9598
+Validation AUC: 0.9908

models/edge_conv.py

@@ -0,0 +1,52 @@
+"""
+edge_conv.py includes edge_attr to edge_conv
+"""
+from typing import Callable, Optional, Union
+
+import torch
+from torch import Tensor
+from torch.nn import Linear
+from torch_geometric.nn.conv import MessagePassing
+from torch_geometric.nn.dense.linear import Linear
+from torch_geometric.typing import Adj, OptPairTensor, OptTensor, Size
+
+
+class EdgeConvConv(MessagePassing):
+    def __init__(self, nn: Callable, eps: float = 0., train_eps: bool = False,
+                 edge_dim: Optional[int] = None, **kwargs):
+        kwargs.setdefault('aggr', 'add')
+        super().__init__(**kwargs)
+        self.nn = nn
+        self.initial_eps = eps
+        if train_eps:
+            self.eps = torch.nn.Parameter(torch.Tensor([eps]))
+        else:
+            self.register_buffer('eps', torch.Tensor([eps]))
+        if edge_dim is not None:
+            if hasattr(self.nn, 'in_features'):
+                in_channels = self.nn.in_features
+            else:
+                in_channels = self.nn.in_channels
+            self.lin = Linear(edge_dim, in_channels)
+        else:
+            self.lin = None
+
+    def forward(self, x: Union[Tensor, OptPairTensor], edge_index: Adj,
+                edge_attr: OptTensor = None, size: Size = None) -> Tensor:
+        """"""
+        if isinstance(x, Tensor):
+            x: OptPairTensor = (x, x)
+
+        # propagate_type: (x: OptPairTensor, edge_attr: OptTensor)
+        out = self.propagate(edge_index, x=x, edge_attr=edge_attr, size=size)
+
+        return out
+
+    def message(self, x_i: Tensor, x_j: Tensor, edge_attr: Tensor) -> Tensor:
+
+        temp = torch.cat([x_i, x_j, edge_attr], dim=1)
+
+        return self.nn(temp)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(nn={self.nn})'

models/mlp.py

@@ -0,0 +1,22 @@
+import torch
+import torch.nn.functional as F
+from torch.nn import Linear, ModuleList
+from torch_geometric.nn.dense.linear import Linear
+
+
+class MLP(torch.nn.Module):
+    def __init__(self, in_channels, hidden_channels, out_channels, num_layers=2):
+        super().__init__()
+        self.mlp = ModuleList()
+        self.mlp.append(Linear(in_channels, hidden_channels))
+        if num_layers >= 2:
+            for _ in range(num_layers - 2):
+                self.mlp.append(Linear(hidden_channels, hidden_channels))
+        self.mlp.append(Linear(hidden_channels, out_channels))
+
+    def forward(self, x):
+        for layer in self.mlp[:-1]:
+            x = layer(x)
+            x = F.relu(x)
+        x = self.mlp[-1](x)
+        return x

models/sage_edge_conv.py

@@ -0,0 +1,113 @@
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+from torch.nn import LSTM
+from torch.nn import Linear
+from torch_geometric.nn.conv import MessagePassing
+from torch_geometric.nn.dense.linear import Linear
+from torch_geometric.typing import Adj, OptPairTensor, OptTensor, Size
+from torch_geometric.utils import to_dense_batch
+from torch_scatter import scatter
+from torch_sparse import SparseTensor, matmul
+
+
+class SAGEEdgeConv(MessagePassing):
+    def __init__(
+            self,
+            in_channels: Union[int, Tuple[int, int]],
+            out_channels: int,
+            edge_dim: int,
+            aggr: str = 'mean',
+            normalize: bool = False,
+            root_weight: bool = True,
+            project: bool = False,
+            bias: bool = True,
+            **kwargs,
+    ):
+        super().__init__(aggr=aggr if aggr != 'lstm' else None, node_dim=0)
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.normalize = normalize
+        self.root_weight = root_weight
+        self.project = project
+
+        if isinstance(in_channels, int):
+            in_channels = (in_channels, in_channels)
+
+        if self.project:
+            self.lin = Linear(in_channels[0], in_channels[0], bias=True)
+
+        if self.aggr is None:
+            self.fuse = False  # No "fused" message_and_aggregate.
+            self.lstm = LSTM(in_channels[0], in_channels[0], batch_first=True)
+
+        self.lin_t = Linear(edge_dim, in_channels[0], bias=bias)
+        self.lin_l = Linear(in_channels[0], out_channels, bias=bias)
+        if self.root_weight:
+            self.lin_r = Linear(in_channels[1], out_channels, bias=False)
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        if self.project:
+            self.lin.reset_parameters()
+        if self.aggr is None:
+            self.lstm.reset_parameters()
+        self.lin_l.reset_parameters()
+        if self.root_weight:
+            self.lin_r.reset_parameters()
+
+    def forward(self, x: Union[Tensor, OptPairTensor], edge_index: Adj, edge_attr: OptTensor = None,
+                size: Size = None) -> Tensor:
+        if isinstance(x, Tensor):
+            x: OptPairTensor = (x, x)
+
+        if self.project and hasattr(self, 'lin'):
+            x = (self.lin(x[0]).relu(), x[1])
+
+        # propagate_type: (x: OptPairTensor, edge_attr: OptTensor)
+        out = self.propagate(edge_index, x=x, edge_attr=edge_attr, size=size)
+        out = self.lin_l(out)
+
+        x_r = x[1]
+        if self.root_weight and x_r is not None:
+            out += self.lin_r(x_r)
+
+        if self.normalize:
+            out = F.normalize(out, p=2., dim=-1)
+
+        return out
+
+    def message(self, x_j: Tensor, edge_attr: Tensor) -> Tensor:
+        return x_j + self.lin_t(edge_attr)
+
+    def message_and_aggregate(self, adj_t: SparseTensor,
+                              x: OptPairTensor) -> Tensor:
+        adj_t = adj_t.set_value(None, layout=None)
+        return matmul(adj_t, x[0], reduce=self.aggr)
+
+    def aggregate(self, x: Tensor, index: Tensor, ptr: Optional[Tensor] = None,
+                  dim_size: Optional[int] = None) -> Tensor:
+        if self.aggr is not None:
+            return scatter(x, index, dim=self.node_dim, dim_size=dim_size,
+                           reduce=self.aggr)
+
+        # LSTM aggregation:
+        if ptr is None and not torch.all(index[:-1] <= index[1:]):
+            raise ValueError(f"Can not utilize LSTM-style aggregation inside "
+                             f"'{self.__class__.__name__}' in case the "
+                             f"'edge_index' tensor is not sorted by columns. "
+                             f"Run 'sort_edge_index(..., sort_by_row=False)' "
+                             f"in a pre-processing step.")
+
+        x, mask = to_dense_batch(x, batch=index, batch_size=dim_size)
+        out, _ = self.lstm(x)
+        return out[:, -1]
+
+    def __repr__(self) -> str:
+        aggr = self.aggr if self.aggr is not None else 'lstm'
+        return (f'{self.__class__.__name__}({self.in_channels}, '
+                f'{self.out_channels}, aggr={aggr})')

node_classification_log/EdgeConv_GPT.txt

@@ -0,0 +1,30 @@
+Data(edge_index=[2, 676684], text_nodes=[478022], text_edges=[676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684])
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], y=[478022], train_mask=[478022], val_mask=[478022], test_mask=[478022], num_classes=3, num_nodes=478022, x=[478022, 1536], edge_attr=[676684, 1536])
+cuda
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9971
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9958
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9958
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9971
+Validation begins
+F1 score: 0.9960
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9972

node_classification_log/GINE_GPT.txt

@@ -0,0 +1,30 @@
+Data(edge_index=[2, 676684], text_nodes=[478022], text_edges=[676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684])
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], y=[478022], train_mask=[478022], val_mask=[478022], test_mask=[478022], num_classes=3, num_nodes=478022, x=[478022, 1536], edge_attr=[676684, 1536])
+cuda
+Validation begins
+F1 score: 0.9955
+Validation Accuracy: 0.9970
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9958
+Validation Accuracy: 0.9971
+Validation begins
+F1 score: 0.9961
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9960
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9961
+Validation Accuracy: 0.9969
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9967
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9972

node_classification_log/GeneralConv_GPT.txt

@@ -0,0 +1,30 @@
+Data(edge_index=[2, 676684], text_nodes=[478022], text_edges=[676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684])
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], y=[478022], train_mask=[478022], val_mask=[478022], test_mask=[478022], num_classes=3, num_nodes=478022, x=[478022, 1536], edge_attr=[676684, 1536])
+cuda
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9971
+Validation begins
+F1 score: 0.9958
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9960
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9963
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9966
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9968
+Validation begins
+F1 score: 0.9966
+Validation Accuracy: 0.9975

node_classification_log/GraphSAGE_GPT.txt

@@ -0,0 +1,30 @@
+Data(edge_index=[2, 676684], text_nodes=[478022], text_edges=[676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684])
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], y=[478022], train_mask=[478022], val_mask=[478022], test_mask=[478022], num_classes=3, num_nodes=478022, x=[478022, 1536], edge_attr=[676684, 1536])
+cuda
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9971
+Validation begins
+F1 score: 0.9957
+Validation Accuracy: 0.9971
+Validation begins
+F1 score: 0.9960
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9974
+Validation begins
+F1 score: 0.9961
+Validation Accuracy: 0.9970
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9960
+Validation Accuracy: 0.9967
+Validation begins
+F1 score: 0.9961
+Validation Accuracy: 0.9970
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9970

node_classification_log/GraphTransformer_GPT.txt

@@ -0,0 +1,30 @@
+Data(edge_index=[2, 676684], text_nodes=[478022], text_edges=[676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684])
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], y=[478022], train_mask=[478022], val_mask=[478022], test_mask=[478022], num_classes=3, num_nodes=478022, x=[478022, 1536], edge_attr=[676684, 1536])
+cuda
+Validation begins
+F1 score: 0.9958
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9959
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9961
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9958
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9963
+Validation Accuracy: 0.9973
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9972
+Validation begins
+F1 score: 0.9961
+Validation Accuracy: 0.9970
+Validation begins
+F1 score: 0.9962
+Validation Accuracy: 0.9971

node_classification_log/MLP_GPT.txt

@@ -0,0 +1,30 @@
+Data(edge_index=[2, 676684], text_nodes=[478022], text_edges=[676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684])
+Data(edge_index=[2, 676684], node_labels=[478022], edge_score_labels=[676684], edge_special_labels=[676684], y=[478022], train_mask=[478022], val_mask=[478022], test_mask=[478022], num_classes=3, num_nodes=478022, x=[478022, 1536], edge_attr=[676684, 1536])
+cuda
+Validation begins
+F1 score: 0.9532
+Validation Accuracy: 0.9687
+Validation begins
+F1 score: 0.9530
+Validation Accuracy: 0.9685
+Validation begins
+F1 score: 0.9653
+Validation Accuracy: 0.9738
+Validation begins
+F1 score: 0.9751
+Validation Accuracy: 0.9791
+Validation begins
+F1 score: 0.9787
+Validation Accuracy: 0.9815
+Validation begins
+F1 score: 0.9798
+Validation Accuracy: 0.9824
+Validation begins
+F1 score: 0.9817
+Validation Accuracy: 0.9835
+Validation begins
+F1 score: 0.9810
+Validation Accuracy: 0.9834
+Validation begins
+F1 score: 0.9817
+Validation Accuracy: 0.9839