Download annotations/annotation_42/HTML/unsupervised_TU/HTML.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 14.8 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_42/HTML/unsupervised_TU/HTML.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_42/HTML/unsupervised_TU/HTML.py
-
curl -L -o HTML.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_42/HTML/unsupervised_TU/HTML.py
14.8 kB
| import os.path as osp | |
| import torch | |
| from torch.autograd import Variable | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| import numpy as np | |
| import json | |
| # from core.encoders import * | |
| # from torch_geometric.datasets import TUDataset | |
| from aug import TUDataset_aug as TUDataset | |
| from torch_geometric.data import DataLoader | |
| import sys | |
| import json | |
| from torch import optim | |
| from cortex_DIM.nn_modules.mi_networks import MIFCNet, MI1x1ConvNet | |
| from losses import * | |
| from gin import Encoder | |
| from evaluate_embedding import evaluate_embedding | |
| from model import * | |
| from arguments import arg_parse | |
| from torch_geometric.transforms import Constant | |
| import pdb | |
| import networkx as nx | |
| from wl_test import WL_test, WL_simlar | |
| from subiso import get_w | |
| import datetime | |
| from copy import deepcopy | |
| class GcnInfomax(nn.Module): | |
| def __init__(self, hidden_dim, num_gc_layers, alpha=0.5, beta=1., gamma=.1): | |
| super(GcnInfomax, self).__init__() | |
| self.alpha = alpha | |
| self.beta = beta | |
| self.gamma = gamma | |
| self.prior = args.prior | |
| self.embedding_dim = mi_units = hidden_dim * num_gc_layers | |
| self.encoder = Encoder(dataset_num_features, hidden_dim, num_gc_layers) | |
| self.local_d = FF(self.embedding_dim) | |
| self.global_d = FF(self.embedding_dim) | |
| # self.local_d = MI1x1ConvNet(self.embedding_dim, mi_units) | |
| # self.global_d = MIFCNet(self.embedding_dim, mi_units) | |
| if self.prior: | |
| self.prior_d = PriorDiscriminator(self.embedding_dim) | |
| self.init_emb() | |
| def init_emb(self): | |
| initrange = -1.5 / self.embedding_dim | |
| for m in self.modules(): | |
| if isinstance(m, nn.Linear): | |
| torch.nn.init.xavier_uniform_(m.weight.data) | |
| if m.bias is not None: | |
| m.bias.data.fill_(0.0) | |
| def forward(self, x, edge_index, batch, num_graphs): | |
| # batch_size = data.num_graphs | |
| if x is None: | |
| x = torch.ones(batch.shape[0]).to(device) | |
| y, M = self.encoder(x, edge_index, batch) | |
| g_enc = self.global_d(y) | |
| l_enc = self.local_d(M) | |
| mode = 'fd' | |
| measure = 'JSD' | |
| local_global_loss = local_global_loss_(l_enc, g_enc, edge_index, batch, measure) | |
| if self.prior: | |
| prior = torch.rand_like(y) | |
| term_a = torch.log(self.prior_d(prior)).mean() | |
| term_b = torch.log(1.0 - self.prior_d(y)).mean() | |
| PRIOR = - (term_a + term_b) * self.gamma | |
| else: | |
| PRIOR = 0 | |
| return local_global_loss + PRIOR | |
| class simclr(nn.Module): | |
| def __init__(self, hidden_dim, num_gc_layers, alpha=0.5, beta=1., gamma=.1, tau: float = 0.5): | |
| super(simclr, self).__init__() | |
| self.alpha = alpha | |
| self.beta = beta | |
| self.gamma = gamma | |
| self.prior = args.prior | |
| self.tau: float = tau | |
| self.embedding_dim = mi_units = hidden_dim * num_gc_layers | |
| self.encoder = Encoder(dataset_num_features, hidden_dim, num_gc_layers) | |
| self.proj_head = nn.Sequential(nn.Linear(self.embedding_dim, self.embedding_dim), nn.ReLU(inplace=True), | |
| nn.Linear(self.embedding_dim, self.embedding_dim)) | |
| # iso simlar prediction | |
| self.proj_iso_head = nn.Sequential(nn.Linear(self.embedding_dim * 2, self.embedding_dim * 2), | |
| nn.ReLU(inplace=True), | |
| nn.Linear(self.embedding_dim * 2, 1), nn.Sigmoid()) | |
| # subiso | |
| self.fc1 = nn.Linear(hidden_dim, hidden_dim) | |
| self.fc2 = nn.Linear(hidden_dim, hidden_dim) | |
| self.fc3 = nn.Sequential(nn.Linear(1, 1), nn.Sigmoid()) | |
| self.init_emb() | |
| def init_emb(self): | |
| initrange = -1.5 / self.embedding_dim | |
| for m in self.modules(): | |
| if isinstance(m, nn.Linear): | |
| torch.nn.init.xavier_uniform_(m.weight.data) | |
| if m.bias is not None: | |
| m.bias.data.fill_(0.0) | |
| def forward(self, x, edge_index, batch, num_graphs): | |
| # batch_size = data.num_graphs | |
| if x is None: | |
| x = torch.ones(batch.shape[0]).to(device) | |
| y, M, f_e = self.encoder(x, edge_index, batch) | |
| y = self.proj_head(y) | |
| return y, M, f_e | |
| def loss_cal(self, x, x_aug): | |
| T = 0.2 | |
| batch_size, _ = x.size() | |
| x_abs = x.norm(dim=1) | |
| x_aug_abs = x_aug.norm(dim=1) | |
| sim_matrix = torch.einsum('ik,jk->ij', x, x_aug) / torch.einsum('i,j->ij', x_abs, x_aug_abs) | |
| sim_matrix = torch.exp(sim_matrix / T) | |
| pos_sim = sim_matrix[range(batch_size), range(batch_size)] | |
| loss = pos_sim / (sim_matrix.sum(dim=1) - pos_sim) | |
| loss = - torch.log(loss).mean() | |
| return loss | |
| # predict isomorphism head | |
| def iso_proj(self, x, edge_index, batch, x_aug, edge_index_aug, batch_aug): | |
| if x is None: | |
| x = torch.ones(batch.shape[0]).to(device) | |
| if x_aug is None: | |
| x_aug = torch.ones(batch.shape[0]).to(device) | |
| y, M, _ = self.encoder(x, edge_index, batch) | |
| y_aug, M_aug, _ = self.encoder(x_aug, edge_index_aug, batch_aug) | |
| y_comb = torch.cat((y, y_aug), dim=1) | |
| output = self.proj_iso_head(y_comb) | |
| return output | |
| def projection(self, z: torch.Tensor) -> torch.Tensor: | |
| z = F.elu(self.fc1(z)) | |
| return self.fc2(z) | |
| def sim(self, z1: torch.Tensor, z2: torch.Tensor): | |
| z1 = F.normalize(z1) | |
| z2 = F.normalize(z2) | |
| return torch.mm(z1, z2.t()) | |
| def subiso(self, z): | |
| z = self.projection(z) | |
| cos_sim = self.sim(z, z) | |
| cos_sim = torch.unsqueeze(cos_sim, 2) | |
| cos_sim = self.fc3(cos_sim) | |
| return torch.squeeze(cos_sim, 2) | |
| import random | |
| def setup_seed(seed): | |
| torch.manual_seed(seed) | |
| torch.cuda.manual_seed_all(seed) | |
| torch.backends.cudnn.deterministic = True | |
| np.random.seed(seed) | |
| random.seed(seed) | |
| if __name__ == '__main__': | |
| args = arg_parse() | |
| setup_seed(args.seed) | |
| accuracies = {'val': [], 'test': []} | |
| epochs = 20 | |
| log_interval = 10 | |
| batch_size = 128 | |
| # batch_size = 512 | |
| lr = args.lr | |
| DS = args.DS | |
| path = osp.join(osp.dirname(osp.realpath(__file__)), '.', 'data', DS) | |
| # kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=None) | |
| dataset = TUDataset(path, name=DS, aug=args.aug).shuffle() | |
| dataset_eval = TUDataset(path, name=DS, aug='none').shuffle() | |
| print(len(dataset)) | |
| print(dataset.get_num_feature()) | |
| try: | |
| dataset_num_features = dataset.get_num_feature() | |
| except: | |
| dataset_num_features = 1 | |
| dataloader = DataLoader(dataset, batch_size=batch_size) | |
| dataloader_eval = DataLoader(dataset_eval, batch_size=batch_size) | |
| device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') | |
| model = simclr(args.hidden_dim, args.num_gc_layers).to(device) | |
| # print(model) | |
| optimizer = torch.optim.Adam(model.parameters(), lr=lr) | |
| CELoss = nn.CrossEntropyLoss(reduction="mean") | |
| MSEloss = nn.MSELoss(reduction='mean') | |
| print('================') | |
| print('lr: {}'.format(lr)) | |
| print('num_features: {}'.format(dataset_num_features)) | |
| print('hidden_dim: {}'.format(args.hidden_dim)) | |
| print('num_gc_layers: {}'.format(args.num_gc_layers)) | |
| print('================') | |
| model.eval() | |
| emb, y = model.encoder.get_embeddings(dataloader_eval) | |
| # print(emb.shape, y.shape) | |
| """ | |
| acc_val, acc = evaluate_embedding(emb, y) | |
| accuracies['val'].append(acc_val) | |
| accuracies['test'].append(acc) | |
| """ | |
| for epoch in range(1, epochs + 1): | |
| loss_all = 0 | |
| model.train() | |
| for data in dataloader: | |
| data, data_aug = data | |
| data_copy = deepcopy(data) | |
| optimizer.zero_grad() | |
| node_num, _ = data.x.size() | |
| data = data.to(device) | |
| x, M, f_e = model(data.x, data.edge_index, data.batch, data.num_graphs) | |
| if args.aug == 'dnodes' or args.aug == 'subgraph' or args.aug == 'random2' or args.aug == 'random3' or args.aug == 'random4': | |
| edge_idx = data_aug.edge_index.numpy() | |
| _, edge_num = edge_idx.shape | |
| idx_not_missing = [n for n in range(node_num) if (n in edge_idx[0] or n in edge_idx[1])] | |
| node_num_aug = len(idx_not_missing) | |
| data_aug.x = data_aug.x[idx_not_missing] | |
| data_aug.batch = data.batch[idx_not_missing] | |
| idx_dict = {idx_not_missing[n]: n for n in range(node_num_aug)} | |
| edge_idx = [[idx_dict[edge_idx[0, n]], idx_dict[edge_idx[1, n]]] for n in range(edge_num) if | |
| not edge_idx[0, n] == edge_idx[1, n]] | |
| data_aug.edge_index = torch.tensor(edge_idx).transpose_(0, 1) | |
| data_aug = data_aug.to(device) | |
| ''' | |
| print(data.edge_index) | |
| print(data.edge_index.size()) | |
| print(data_aug.edge_index) | |
| print(data_aug.edge_index.size()) | |
| print(data.x.size()) | |
| print(data_aug.x.size()) | |
| print(data.batch.size()) | |
| print(data_aug.batch.size()) | |
| pdb.set_trace() | |
| ''' | |
| x_aug, M_aug, f_e_aug = model(data_aug.x, data_aug.edge_index, data_aug.batch, data_aug.num_graphs) | |
| loss = model.loss_cal(x, x_aug) | |
| log = "" | |
| # add isomorphism logic | |
| if args.iso_logic: | |
| log += "_wlsimlar_" + str(args.a) | |
| if args.aug == 'dnodes' or args.aug == 'subgraph' or args.aug == 'random2' or args.aug == 'random3' or args.aug == 'random4': | |
| edge_idx_ori = data_copy.edge_index.cpu().numpy() | |
| _, edge_num_ori = edge_idx_ori.shape | |
| idx_ori = [n for n in range(node_num)] | |
| node_num_ori = len(idx_ori) | |
| edge_idx_ori = [[edge_idx_ori[0, n], edge_idx_ori[1, n]] for n in range(edge_num_ori) if | |
| not edge_idx_ori[0, n] == edge_idx_ori[1, n]] | |
| data_copy.edge_index = torch.tensor(edge_idx_ori).transpose_(0, 1) | |
| data_copy = data_copy.to(device) | |
| # 1.get isomorphism label | |
| graphs = [] | |
| graphs_aug = [] | |
| graph_iso_label = [] | |
| edge_list = data_copy.edge_index.cpu().numpy().tolist() | |
| edge_list_aug = data_aug.edge_index.cpu().numpy().tolist() | |
| for i in range(data_copy.num_graphs): | |
| node_list = torch.nonzero(data_copy.batch == i).squeeze(1).cpu().numpy().tolist() | |
| node_list_aug = torch.nonzero(data_aug.batch == i).squeeze(1).cpu().numpy().tolist() | |
| graph = nx.DiGraph() | |
| graph.add_nodes_from(node_list) | |
| edges = [] | |
| for node in node_list: | |
| index = torch.nonzero(data_copy.edge_index[0] == node).squeeze(1).cpu().numpy().tolist() | |
| edges += [(edge_list[0][i], edge_list[1][i]) for i in index] | |
| graph.add_edges_from(edges) | |
| for node in node_list: | |
| graph.nodes[node]['label'] = str(graph.degree(node)) | |
| graphs.append(graph) | |
| graph_aug = nx.DiGraph() | |
| graph_aug.add_nodes_from(node_list_aug) | |
| edges_aug = [] | |
| for node_aug in node_list_aug: | |
| index_aug = torch.nonzero(data_aug.edge_index[0] == node_aug).squeeze(1).cpu().numpy().tolist() | |
| edges_aug += [(edge_list_aug[0][i], edge_list_aug[1][i]) for i in index_aug] | |
| graph_aug.add_edges_from(edges_aug) | |
| for node_aug in node_list_aug: | |
| graph_aug.nodes[node_aug]['label'] = str(graph_aug.degree(node_aug)) | |
| graphs_aug.append(graph_aug) | |
| node_labels = nx.get_node_attributes(graph, 'label') | |
| node_labels_aug = nx.get_node_attributes(graph_aug, 'label') | |
| if graph_aug.number_of_nodes() == 0: | |
| graph_iso_label.append(0) | |
| continue | |
| graph_iso_label.append(WL_simlar(node_labels, node_labels_aug, graph, graph_aug)) | |
| graph_iso_label = torch.tensor(graph_iso_label).to(device) | |
| # 2.make prediction use simclr | |
| graph_iso_pre = model.iso_proj(data_copy.x, data_copy.edge_index, data_copy.batch, data_aug.x, | |
| data_aug.edge_index, data_aug.batch) | |
| graph_iso_pre = torch.squeeze(graph_iso_pre, 1) | |
| # 3.loss | |
| loss_iso = MSEloss(graph_iso_pre, graph_iso_label) | |
| loss+= args.a * loss_iso | |
| if args.subiso_logic: | |
| log += "_subiso_" + str(args.b) | |
| weight = get_w(data) | |
| mse_loss = 0 | |
| for i in range(data.num_graphs): | |
| node_list = torch.nonzero(data.batch == i).squeeze(1) | |
| node_embedding = f_e[node_list[0]:node_list[-1] + 1] | |
| cos_sim = model.subiso(node_embedding) | |
| cos_sim = cos_sim / cos_sim.sum(1, keepdim=True) | |
| mse_loss += MSEloss(weight[i], cos_sim) | |
| loss_subiso = mse_loss / data.num_graphs | |
| loss += args.b * loss_subiso | |
| loss_all += loss.item() | |
| loss.backward() | |
| optimizer.step() | |
| print('{}: Epoch {}, Loss {}'.format(datetime.datetime.now(), epoch, loss_all/len(dataloader))) | |
| if epoch % log_interval == 0: | |
| model.eval() | |
| emb, y = model.encoder.get_embeddings(dataloader_eval) | |
| acc_val, acc = evaluate_embedding(emb, y) | |
| accuracies['val'].append(acc_val) | |
| accuracies['test'].append(acc) | |
| tpe = ('local' if args.local else '') + ('prior' if args.prior else '') | |
| with open('logs/log_' + args.DS + '_' + args.aug + log, 'a+') as f: | |
| s = json.dumps(accuracies) | |
| f.write('{},{},{},{},{},{},{}\n'.format(args.DS, tpe, args.num_gc_layers, epochs, log_interval, lr, s)) | |
| f.write('\n') | |