def run(is_train, hidden, data_name, random_state, use_cuda, save_path): if is_train is False and save_path is None: raise RuntimeError("There is no file for test.") device = "cpu" if use_cuda: device = "cuda" # Load Train data train_data = load_data(data_name=data_name, train=True, random_state=random_state) dim_features = train_data[0].shape[1] num_labels = max(train_data[2]).item() + 1 model = GCN(dim_features, hidden, num_labels) # Train Phase if is_train: print("---Training Start---") train(model, train_data, device, save_path) print("---Training Done--- \n") if save_path is not None: # Load model model.load_state_dict(torch.load(save_path)) # Test Phase print("---Test Start---") test_data = load_data(data_name=data_name, train=False, random_state=42) print("Test Accuracy: %2.2f %%" % get_acc(model, test_data, device)) print("---Test Done--- \n")
def main(): from pre_process import preprocess feature, a_hat, labels = preprocess() print("loaded") selected, unselected = depart(len(labels), 1 - Config.test_ratio) labels_selected = labels[selected] labels_unselected = labels[unselected] feature = torch.from_numpy(feature).float().cuda() tensor_selected = torch.tensor(labels_selected).long().cuda() a_hat = torch.tensor(a_hat).float().cuda() net = GCN(a_hat, feature.shape[1], Config.num_classes, Config.hidden_size, Config.n_hidden_layer).cuda() print(net) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=Config.lr) net.train() for e in range(Config.num_epochs): optimizer.zero_grad() output = net(feature) loss = criterion(output[selected], tensor_selected) loss.backward() optimizer.step() trained_accuracy = evaluate(output[selected], labels_selected) untrained_accuracy = evaluate(output[unselected], labels_unselected) print( "[Epoch %d]: trained acc: %.7f, untrained acc: %.7f, loss: %.7f" % (e, trained_accuracy, untrained_accuracy, loss.detach().cpu().numpy()))
def gen_model(args): if args.use_labels: model = GCN( in_feats + n_classes, args.n_hidden, n_classes, args.n_layers, F.relu, args.dropout, args.use_linear ) else: model = GCN(in_feats, args.n_hidden, n_classes, args.n_layers, F.relu, args.dropout, args.use_linear) return model
def test_memorize_minibatch(self): for db_name in self.db_names: db_info = get_db_info(db_name) train_data, val_data, _ = get_train_val_test_datasets( dataset_name=db_name, train_test_split='use_full_train', encoders=dict(CATEGORICAL='CategoricalOrdinalEnc', SCALAR='ScalarRobustScalerEnc', DATETIME='DatetimeScalarEnc', LATLONG='LatLongScalarEnc', TEXT='TextSummaryScalarEnc'), ) train_loader = get_dataloader( dataset=train_data, batch_size=256, sampler_class_name='SequentialSampler', num_workers=0, max_nodes_per_graph=False) writer = DummyWriter() model = GCN(writer, db_info=db_info, hidden_dim=256, n_init_layers=3, activation_class_name='SELU', activation_class_kwargs={}, loss_class_kwargs={}, loss_class_name='CrossEntropyLoss', p_dropout=0.0, drop_whole_embeddings=True, n_layers=3, readout_class_name='AvgPooling', readout_kwargs={}) if torch.cuda.is_available(): model.cuda() model.device = torch.device('cuda:0') else: model.device = torch.device('cpu') model.train() optimizer = AdamW(model.parameters(), lr=0.001, weight_decay=0.0) bdgl, features, label = next(iter(train_loader)) recursive_to((bdgl, features, label), model.device) for _ in tqdm(range(200)): optimizer.zero_grad() output = model(bdgl, features) loss = model.loss_fxn(output, label) if loss < 1e-4: break loss.backward() optimizer.step() else: tqdm.write(f'Loss: {loss}') self.fail("Didn't memorize minibatch")
def main(): # Load data start = time.time() N, _adj, _feats, _labels, train_adj, train_feats, train_nodes, val_nodes, test_nodes, y_train, y_val, y_test, val_mask, test_mask = utils.load_data(args.dataset) print('Loaded data in {:.2f} seconds!'.format(time.time() - start)) # Prepare Train Data start = time.time() _, parts = utils.partition_graph(train_adj, train_nodes, args.num_clusters_train) parts = [np.array(pt) for pt in parts] train_features, train_support, y_train = utils.preprocess_multicluster(train_adj, parts, train_feats, y_train, args.num_clusters_train, args.batch_size) print('Train Data pre-processed in {:.2f} seconds!'.format(time.time() - start)) # Prepare Test Data if args.test == 1: y_test, test_mask = y_val, val_mask start = time.time() _, test_features, test_support, y_test, test_mask = utils.preprocess(_adj, _feats, y_test, np.arange(N), args.num_clusters_test, test_mask) print('Test Data pre-processed in {:.2f} seconds!'.format(time.time() - start)) # Shuffle Batches batch_idxs = list(range(len(train_features))) # model model = GCN(fan_in=_in, fan_out=_out, layers=args.layers, dropout=args.dropout, normalize=True, bias=False).float() model.cuda() # Loss Function criterion = torch.nn.CrossEntropyLoss() # Optimization Algorithm optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) # Learning Rate Schedule scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=args.lr, steps_per_epoch=int(args.num_clusters_train/args.batch_size), epochs=args.epochs+1, anneal_strategy='linear') model.train() # Train for epoch in range(args.epochs + 1): np.random.shuffle(batch_idxs) avg_loss = 0 start = time.time() for batch in batch_idxs: loss = train(model.cuda(), criterion, optimizer, train_features[batch], train_support[batch], y_train[batch], dataset=args.dataset) if args.lr_scheduler == 1: scheduler.step() avg_loss += loss.item() # Write Train stats to tensorboard writer.add_scalar('time/train', time.time() - start, epoch) writer.add_scalar('loss/train', avg_loss/len(train_features), epoch) if args.test == 1: # Test on cpu f1 = test(model.cpu(), test_features, test_support, y_test, test_mask, device='cpu') print('f1: {:.4f}'.format(f1))
def train(config): # Set random seed tf.random.set_seed(config.seed) np.random.seed(config.seed) # Load dataset adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data( config.dataset ) # Feature preprocessing norm_feat = preprocess_features(features) sparse_norm_feat = sparse_matrix_to_sparse_tensor(norm_feat) if config.model.name == "gcn": support = [preprocess_adj(adj)] num_supports = 1 elif config.model.name == "gcn_cheby": support = chebyshev_polynomials(adj, config.model.max_degree) num_supports = 1 + config.model.max_degree else: raise ValueError("Invalid argument for model: {0}".format(config.model.name)) model = GCN( input_dim=sparse_norm_feat.shape, output_dim=y_train.shape[1], supports=support, num_features_nonzero=tuple(sparse_norm_feat.values.shape.as_list()), config=config.model, ) train_generator = dataset_generator(sparse_norm_feat, y_train, train_mask) val_generator = dataset_generator(sparse_norm_feat, y_val, val_mask) # Train history = model.fit_generator( train_generator, steps_per_epoch=1, epochs=config.training.epochs, verbose=2, validation_data=val_generator, validation_steps=1, ) # Evaluate test_loss, test_acc = model.test_on_batch( sparse_norm_feat, np.column_stack((y_test, test_mask)) ) print("Test set results: cost= {:.5f}, accuracy={:.5f}".format(test_loss, test_acc))
def main(): config = get_args() dataset = Data(config) num_features = dataset.features.shape[1] num_classes = dataset.labels.max().item() + 1 model = GCN(config=config, num_features=num_features, num_classes=num_classes) solver = Solver(config, model, dataset) if torch.cuda.is_available(): model = model.to('cuda') criterion, best_model = solver.train() solver.test(criterion, best_model)
def gen_model(in_feats, n_classes, args): norm = args.norm use_attn_dst = not args.no_attn_dst if args.use_labels: in_feats_ = in_feats + n_classes else: in_feats_ = in_feats if args.model == "gcn": model = GCN(in_feats_, args.n_hidden, n_classes, args.n_layers, F.relu, args.dropout, args.use_linear) if args.model == "gcn-ha": model = GCNHA( in_feats_, n_classes, K=args.K, n_hidden=args.n_hidden, n_layers=args.n_layers, n_heads=args.n_heads, activation=F.relu, dropout=args.dropout, input_drop=args.input_drop, attn_drop=args.attn_drop, ) if args.model == "gat": model = GAT( in_feats_, n_classes, n_hidden=args.n_hidden, n_layers=args.n_layers, n_heads=args.n_heads, activation=F.relu, dropout=args.dropout, input_drop=args.input_drop, attn_drop=args.attn_drop, edge_drop=args.edge_drop, use_attn_dst=use_attn_dst, use_symmetric_norm=(norm == "sym"), ) if args.model == "gat-ha": model = GATHA( in_feats_, n_classes, K=args.K, n_hidden=args.n_hidden, n_layers=args.n_layers, n_heads=args.n_heads, activation=F.relu, dropout=args.dropout, input_drop=args.input_drop, edge_drop=args.edge_drop, attn_drop=args.attn_drop, use_attn_dst=use_attn_dst, norm=norm, ) return model
def build_model(model_name, num_layers, mlp_layers, hidden_dim, num_classes, dropout_rate, num_heads, learn_eps, sparse): """Create gnn model and initialize parameters weights.""" # Convert hidden_dim to integers for i in range(len(hidden_dim)): hidden_dim[i] = int(hidden_dim[i]) # Only GCN, GAT and GIN are available. if model_name == 'gcn': model = GCN( num_layers=num_layers, hidden_dim=hidden_dim, num_classes=num_classes, dropout_rate=dropout_rate, sparse=sparse, bias=True) elif model_name == 'gat': model = GAT( num_layers=num_layers, hidden_dim=hidden_dim, num_classes=num_classes, dropout_rate=dropout_rate, num_heads=num_heads, sparse=sparse) elif model_name == 'gin': model = GIN( num_layers=num_layers, mlp_layers=mlp_layers, hidden_dim=hidden_dim, num_classes=num_classes, dropout_rate=dropout_rate, learn_eps=learn_eps, sparse=sparse) return model
def train(self): """ Trains the model based on configurations specified in __init__ """ # Model and optimizer model = GCN(nfeat=self.features.shape[1], nhid=self.hidden, nclass=self.labels.max().item() + 1, dropout=self.dropout) optimizer = optim.Adam(model.parameters(), lr=self.lr, weight_decay=self.weight_decay) # Train model for _ in range(self.epochs): train(model, self.features, self.adj, self.idx_train, self.labels, optimizer) return model
def run(n_trials=100): start_time = time.time() # Load data adj, features, labels, idx_train, idx_test = load_data() epochs = 200 lr = 0.01 weight_decay = 5e-4 hidden = 16 dropout = 0.5 for i in range(n_trials): # Model and optimizer model = GCN(nfeat=features.shape[1], nhid=hidden, nclass=labels.max().item() + 1, dropout=dropout) optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay) # Train model for _ in range(epochs): train(model, features, adj, idx_train, labels, optimizer) done_training_time = time.time() # Testing metrics = test(model, features, adj, idx_test, labels) params = model.state_dict() for k in params: params[k] = params[k].reshape(-1).data.tolist() final_results = {**params, **metrics} done_testing_time = time.time() # Cache to file records_filename = "records.csv" write_results_to_file(records_filename, final_results) # report_progress(i, start_time, done_training_time, # done_testing_time, end_time) end_time = time.time() speed = n_trials / (end_time - start_time) print(f"{n_trials} tasks completed in {end_time - start_time}.") print(f"{round(speed, 3)} tasks/second for non-parallel implementation.")
def main(dataset, times): adj, features, labels, idx_train, idx_val, idx_test = load_data(dataset) features = features.to(device) adj = adj.to(device) labels = labels.to(device) idx_train = idx_train.to(device) idx_val = idx_val.to(device) idx_test = idx_test.to(device) nclass = labels.max().item() + 1 acc_lst = list() for seed in random.sample(range(0, 100000), times): np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed(seed) # Model and optimizer # weight_decay 权值衰减,防止过拟合,调节模型复杂度对损失函数的影响 model = GCN(nfeat=features.shape[1], nhid=args.hidden, nclass=nclass, dropout=args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) model.to(device) # Train model t_total = time.time() for epoch in range(args.epochs): train(epoch, model, optimizer, adj, features, labels, idx_train, idx_val) print(f"Total time elapsed: {time.time() - t_total:.4f}s") # Testing acc_lst.append(test(model, adj, features, labels, idx_test)) print(acc_lst) print(np.mean(acc_lst))
def build_model(model_name, num_layers, hidden_dim, num_classes, dropout_rate): """Create gnn model and initialize parameters weights.""" # Convert hidden_dim to integers for i in range(len(hidden_dim)): hidden_dim[i] = int(hidden_dim[i]) # Only gcn available now if model_name == 'gcn': model = GCN(num_layers=num_layers, hidden_dim=hidden_dim, num_classes=num_classes, dropout_rate=dropout_rate, bias=True) elif model_name == 'gat': raise NotImplementedError return model
def __init__(self, nfeat, hidden_sizes, nclass, nnodes, lambda_, device): super(BaseMeta, self).__init__() self.hidden_sizes = hidden_sizes self.nfeat = nfeat self.nclass = nclass self.lambda_ = lambda_ self.device = device self.gcn = GCN(nfeat=nfeat, nhid=hidden_sizes[0], nclass=nclass).to(self.device) self.nnodes = nnodes self.adj_changes = Parameter(torch.FloatTensor(nnodes, nnodes)).to(self.device) self.adj_changes.data.fill_(0)
def main(): data_generator = DataGenerator(args) meta_model = GCN(nfeat=args.in_f_d, nhid=args.hidden, nclass=args.nclasses, dropout=args.dropout).to(device) proto_model = GCN_Proto(args, nfeat=args.hidden, dropout=args.dropout).to(device) structure_model = GCN_Structure(args, nfeat=args.hidden, nhid=args.structure_dim, dropout=args.dropout).to( device) if args.train: meta_optimiser = torch.optim.Adam( list(meta_model.parameters()) + list(proto_model.parameters()) + list(structure_model.parameters()), lr=args.meta_lr, weight_decay=args.weight_decay) train(args, meta_model, meta_optimiser, proto_model, structure_model, metatrain_iterations=args.metatrain_iterations, data_generator=data_generator, fit_function=meta_gradient_step, fit_function_kwargs={'train': True, 'inner_train_steps': args.inner_train_steps, 'inner_lr': args.inner_lr, 'batch_n': args.batch_n, 'device': device}) else: if args.test_load_epoch > 0: meta_model.load_state_dict( torch.load(args.logdir + '/' + exp_string + '/' + 'model_epoch_{}'.format(args.test_load_epoch))) proto_model.load_state_dict( torch.load( args.logdir + '/' + exp_string + '/' + 'proto_model_epoch_{}'.format(args.test_load_epoch))) structure_model.load_state_dict( torch.load( args.logdir + '/' + exp_string + '/' + 'structure_model_epoch_{}'.format( args.test_load_epoch))) meta_optimiser = torch.optim.Adam(list(meta_model.parameters()) + list(proto_model.parameters()), lr=args.meta_lr, weight_decay=args.weight_decay) evaluate(args, meta_model, meta_optimiser, proto_model, structure_model, data_generator=data_generator, fit_function=meta_gradient_step, fit_function_kwargs={'train': False, 'inner_train_steps': args.inner_train_steps, 'inner_lr': args.inner_lr_test, 'batch_n': args.test_sample_g_n, 'device': device})
def main(args): start_time_str = time.strftime("_%m_%d_%H_%M_%S", time.localtime()) log_path = os.path.join(args.log_dir, args.model + start_time_str) if not os.path.exists(log_path): os.mkdir(log_path) logging.basicConfig(filename=os.path.join(log_path, 'log_file'), filemode='w', format='| %(asctime)s |\n%(message)s', datefmt='%b %d %H:%M:%S', level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(sys.stdout)) logging.info(args) # load data if args.model in ['EGNN', 'ECConv', 'GTEA-ST']: data = Dataset(data_dir=args.data_dir, batch_size=args.batch_size, use_static=True) else: data = Dataset(data_dir=args.data_dir, batch_size=args.batch_size) g = data.g # features = torch.FloatTensor(data.features) # labels = torch.LongTensor(data.labels) train_loader = data.train_loader val_loader = data.val_loader test_loader = data.test_loader num_nodes = data.num_nodes node_in_dim = args.node_in_dim num_edges = data.num_edges edge_in_dim = data.edge_in_dim edge_timestep_len = data.edge_timestep_len num_train_samples = data.num_train_samples num_val_samples = data.num_val_samples num_test_samples = data.num_test_samples logging.info("""----Data statistics------' #Nodes %d #Edges %d #Node_feat %d #Edge_feat %d #Edge_timestep %d #Train samples %d #Val samples %d #Test samples %d""" % (num_nodes, num_edges, node_in_dim, edge_in_dim, edge_timestep_len, num_train_samples, num_val_samples, num_test_samples)) device = torch.device("cuda:"+str(args.gpu) if torch.cuda.is_available() and args.gpu >=0 else "cpu") infer_device = device if args.infer_gpu else torch.device('cpu') # g = g.to(device) # create model if args.model == 'GCN': model = GCN(num_nodes=num_nodes, in_feats=node_in_dim, n_hidden=args.node_hidden_dim, n_layers=args.num_layers, activation=F.relu, dropout=args.dropout) elif args.model == 'GraphSAGE': model = GraphSAGE(num_nodes=num_nodes, in_feats=node_in_dim, n_hidden=args.node_hidden_dim, n_layers=args.num_layers, activation=F.relu, dropout=args.dropout) elif args.model == 'GAT': model = GAT(num_nodes=num_nodes, in_dim=node_in_dim, hidden_dim=args.node_hidden_dim, num_layers=args.num_layers, num_heads=args.num_heads) elif args.model == 'ECConv': model = ECConv(num_nodes=num_nodes, node_in_dim=node_in_dim, edge_in_dim=edge_in_dim, hidden_dim=args.node_hidden_dim, num_layers=args.num_layers, drop_prob=args.dropout, device=device) elif args.model == 'EGNN': model = EGNN(num_nodes=num_nodes, node_in_dim=node_in_dim, edge_in_dim=edge_in_dim, hidden_dim=args.node_hidden_dim, num_layers=args.num_layers, drop_prob=args.dropout, device=device) elif args.model == 'GTEA-ST': model = GTEAST(num_nodes=num_nodes, node_in_dim=node_in_dim, edge_in_dim=edge_in_dim, node_hidden_dim=args.node_hidden_dim, num_layers=args.num_layers, drop_prob=args.dropout, device=device) elif args.model == 'TGAT': model = TGAT(num_nodes=num_nodes, node_in_dim=node_in_dim, node_hidden_dim=args.node_hidden_dim, edge_in_dim=edge_in_dim-1, time_hidden_dim=args.time_hidden_dim, num_class=0, num_layers=args.num_layers, num_heads=args.num_heads, device=device, drop_prob=args.dropout) elif args.model == 'GTEA-LSTM': model = GTEALSTM(num_nodes=num_nodes, node_in_dim=node_in_dim, node_hidden_dim=args.node_hidden_dim, edge_in_dim=edge_in_dim, num_class=0, num_layers=args.num_layers, num_time_layers=args.num_lstm_layers, bidirectional=args.bidirectional, device=device, drop_prob=args.dropout) elif args.model == 'GTEA-LSTM+T2V': model = GTEALSTMT2V(num_nodes=num_nodes, node_in_dim=node_in_dim, node_hidden_dim=args.node_hidden_dim, edge_in_dim=edge_in_dim-1, time_hidden_dim=args.time_hidden_dim, num_class=0, num_layers=args.num_layers, num_time_layers=args.num_lstm_layers, bidirectional=args.bidirectional, device=device, drop_prob=args.dropout) elif args.model == 'GTEA-Trans': model = GTEATrans(num_nodes=num_nodes, node_in_dim=node_in_dim, node_hidden_dim=args.node_hidden_dim, edge_in_dim=edge_in_dim, num_class=0, num_layers=args.num_layers, num_heads=args.num_heads, num_time_layers=args.num_lstm_layers, device=device, drop_prob=args.dropout) elif args.model == 'GTEA-Trans+T2V': model = GTEATransT2V(num_nodes=num_nodes, node_in_dim=node_in_dim, node_hidden_dim=args.node_hidden_dim, edge_in_dim=edge_in_dim-1, time_hidden_dim=args.time_hidden_dim, num_class=0, num_layers=args.num_layers, num_heads=args.num_heads, num_time_layers=args.num_lstm_layers, device=device, drop_prob=args.dropout) else: logging.info('Model {} not found.'.format(args.model)) exit(0) # send model to device model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) checkpoint_path = os.path.join(log_path, str(args.model) + '_checkpoint.pt') trainer = Trainer(g=g, model=model, optimizer=optimizer, epochs=args.epochs, train_loader=train_loader, val_loader=val_loader, test_loader=test_loader, patience=args.patience, batch_size=args.batch_size, num_neighbors=args.num_neighbors, num_layers=args.num_layers, num_workers=args.num_workers, device=device, infer_device=infer_device, log_path=log_path, checkpoint_path=checkpoint_path) logging.info('Start training') best_val_result, test_result = trainer.train() # recording the result line = [start_time_str[1:]] + [args.model] + ['K=' + str(args.use_K)] + \ [str(x) for x in best_val_result] + [str(x) for x in test_result] + [str(args)] line = ','.join(line) + '\n' with open(os.path.join(args.log_dir, str(args.model) + '_result.csv'), 'a') as f: f.write(line)
mean_time_list = [] total_time_list = [] # repeat multiple runs for i in range(args.repeat): t_total = time.time() # Load data adj_train, adj_val, adj_test, features, labels, idx_train, idx_val, \ idx_test = load_data(args.dataset, args.label_rate, inductive, loop, norm) # Model and optimizer if args.model == 'GCN': model = GCN(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout, node_dropout=args.node_dropout, edge_dropout=args.edge_dropout) elif args.model == 'GCN1': model = GCN1(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout, edge_dropout=args.edge_dropout) elif args.model == 'GCN_Linear': model = GCN_Linear(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout) elif args.model == 'Linear_GCN': model = Linear_GCN(nfeat=features.shape[1],
tf.sparse_placeholder(tf.float32), 'features': tf.sparse_placeholder(tf.float32, shape=tf.constant(features[2], dtype=tf.int64)), 'labels': tf.placeholder(tf.float32, shape=(None, y_train.shape[1])), 'labels_mask': tf.placeholder(tf.int32), 'dropout': tf.placeholder_with_default(0., shape=()), 'num_features_nonzero': tf.placeholder(tf.int32) # helper variable for sparse dropout } # Create model model = GCN(placeholders, input_dim=features[2][1], logging=True) # Initialize session sess = tf.Session() def construct_feed_dict(features, support_, labels, labels_mask, placeholders): """Construct feed dictionary.""" feed_dict = dict() feed_dict.update({placeholders['labels']: labels}) feed_dict.update({placeholders['labels_mask']: labels_mask}) feed_dict.update({placeholders['features']: features}) feed_dict.update({placeholders['support']: support_}) feed_dict.update({placeholders['num_features_nonzero']: features[1].shape}) return feed_dict
model_ts = GCNLink(nfeat=nfeat, nhid=args.hidden, nout=args.embed_dim, dropout=args.dropout) model_cluster = GCNClusterNet(nfeat=nfeat, nhid=args.hidden, nout=args.embed_dim, dropout=args.dropout, K=args.K, cluster_temp=args.clustertemp) #keep a couple of initializations here so that the random seeding lines up #with results reported in the paper -- removing these is essentially equivalent to #changing the seed _ = GCN(nfeat, args.hidden, args.embed_dim, args.dropout) _ = nn.Parameter(torch.rand(K, args.embed_dim)) #uses GCNs to predict the cluster membership of each node model_gcn = GCNDeep(nfeat=nfeat, nhid=args.hidden, nout=args.K, dropout=args.dropout, nlayers=2) #uses GCNs to predict the probability that each node appears in the solution model_gcn_x = GCNDeepSigmoid(nfeat=nfeat, nhid=args.hidden, nout=1, dropout=args.dropout, nlayers=2)
dataset_test = MyDataset(dataset, file_list_test, and_or=and_or, args=args) dataloader_train = DataLoader(dataset_train, batch_size=args.batch_size, shuffle=True, num_workers=args.dataloader_workers) dataloader_test = DataLoader(dataset_test, batch_size=1, shuffle=False, num_workers=args.dataloader_workers) print('Number of training samples:', len(dataset_train)) # Model and optimizer model = GCN(input_size=args.features, hidden_size=args.hidden_size, output_size=args.embedding_size, dropout=args.dropout, indep_weights=indep_weights) mlp = MLP(input_size=2 * args.embedding_size, hidden_size=args.hidden_size_mlp, output_size=2, dropout=args.dropout) optimizer = optim.Adam(itertools.chain(model.parameters(), mlp.parameters()), lr=args.lr, weight_decay=args.weight_decay) creterion = torch.nn.TripletMarginLoss(margin=args.margin, p=2) CE = torch.nn.CrossEntropyLoss() loss_list = deque(maxlen=100) loss_list_CE = deque(maxlen=100)
args = parser.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) # Load feature vectors and labels of original graph features, labels = load_data('pubmed') model = GCN(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, alpha=args.alpha) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) if args.cuda: model.cuda() features = features.cuda() labels = labels.cuda() features, labels = Variable(features), Variable(labels) def train(epoch, features, adj, labels, idx_train, idx_val):
# processed_adj = np.dot(d_inv,adj) # processed_adj = np.dot(adj,d_inv) # adj = sp.csr_matrix(processed_adj) # adj = sparse_mx_to_torch_sparse_tensor(adj) # adj = torch.from_numpy(adj).float() def accuracy(output, labels): preds = output.max(1)[1].type_as(labels) correct = preds.eq(labels).double() correct = correct.sum() return correct / len(labels) # model creation and loss seting model = GCN(nfeat=1, nhid=256, nclass=10).to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) ###Training Part start_time = time.time() for epoch in range(num_epochs): for i, (adj, features, masks, batch_labels) in tqdm(enumerate(train_loader)): # input = feature[1].view(784,1) features = features.to(device) batch_labels = batch_labels.to(device) adj = adj.to(device) t = time.time()
def train_step(model_file): # Set random seed seed = 123 np.random.seed(seed) tf.set_random_seed(seed) dirname = FLAGS.dataset + model_file + '/' print(dirname) # Load data namelist_path = FLAGS.dataset + 'sub_list_new.txt' adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data( FLAGS.hemisphere, namelist=namelist_path, MPM=True) # neighbor_mask = 50*np.load( FLAGS.modeldir+'neighbor_mask_{}.npy'.format(FLAGS.hemisphere)) namelist = [ str(name).replace("\n", "") for name in open(namelist_path, 'r').readlines() ] # mpm = np.max(np.load( FLAGS.modeldir+'MPM_{}.npy'.format(FLAGS.hemisphere))[:,:210], axis=1) # train_mask = np.array([False]*len(mpm)) # train_mask[mpm>0.5] = True # Some preprocessing adj = sparse_to_tuple(adj) for i in range(len(features)): features[i] = preprocess_features(features[i]) support = chebyshev_polynomials(adj, FLAGS.max_degree) num_supports = 1 + FLAGS.max_degree # Define placeholders/ placeholders = { 'support': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)], 'features': tf.sparse_placeholder(tf.float32, shape=tf.constant(features[0].shape, dtype=tf.float64)), 'labels': tf.placeholder(tf.float32, shape=(None, y_train.shape[1])), 'labels_mask': tf.placeholder(tf.int32), 'dropout': tf.placeholder_with_default(FLAGS.dropout, shape=()), 'num_features_nonzero': tf.placeholder(tf.int32), # helper variable for sparse dropout 'gradient_adj': [tf.sparse_placeholder(tf.float32)], 'gradient': tf.placeholder(tf.bool) } # Create model model_name = 'model_{}'.format(FLAGS.hemisphere) print('model name:', model_name) model = GCN(placeholders, input_dim=features[0].shape[1], layer_num=FLAGS.layer_num, logging=True, name=model_name) # Initialize session sess = tf.Session() # Init variables sess.run(tf.global_variables_initializer()) # Define model evaluation function def evaluate(features, support, labels, mask, adj, gradient, placeholders): t_test = time.time() feed_dict_val = construct_feed_dict(features, support, labels, mask, adj, gradient, placeholders) outs_val = sess.run([model.loss, model.dice, model.outputs], feed_dict=feed_dict_val) return outs_val[0], outs_val[1], outs_val[2], (time.time() - t_test) def dynamic_learning_rate(epoch): # learning_rate = FLAGS.basic_learning_rate * 10**(-3 * epoch/FLAGS.epochs) learning_rate = FLAGS.basic_learning_rate * (1 - epoch / FLAGS.epochs) return learning_rate # def dynamic_training_mask(mpm, epoch): # if (epoch/FLAGS.epochs)>0.5: # train_mask = [True]*len(mpm) # else: # thr = 65-130*epoch/FLAGS.epochs # train_mask = np.array([False]*len(mpm)) # train_mask[mpm>thr] = True # return train_mask cost_train, acc_train, dc_train = [], [], [] cost_val, acc_val, dc_val = [], [], [] # Train model print('length', len(features)) for epoch in range(FLAGS.epochs): numlist = np.arange(0, FLAGS.train_num, 1) np.random.shuffle(numlist) FLAGS.learning_rate = dynamic_learning_rate(epoch) # train_mask = dynamic_training_mask(mpm, epoch) print('_____leaning rate', FLAGS.learning_rate, 'epoch:', epoch) for i in numlist: t = time.time() print('training sample: ', i) # Construct feed dictionary feed_dict = construct_feed_dict(features[i], support, y_train, train_mask, adj, False, placeholders) # Training step outs = sess.run([model.opt_op, model.loss, model.dice], feed_dict=feed_dict) cost_train.append(outs[1]) dice_train.append(outs[2]) # Validation validnum = np.random.randint(FLAGS.validate_num) + FLAGS.train_num cost_val, dice_val, _, tt = evaluate(features[validnum], support, y_val, val_mask, adj, False, placeholders) cost_val.append(cost_val) dc_val.append(dice_val) # Print results print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(outs[1]), "train_dice=", "{:.3f}".format(outs[2]), "val_loss=", "{:.5f}".format(cost_val), "val_dice=", "{:.3f}".format(dice_val), "time=", "{:.5f}".format(tt)) # if epoch > FLAGS.early_stopping and cost_val[-1] > np.mean(cost_val[-(FLAGS.early_stopping+1):-1]): # print("Early stopping...") # break model.save(sess=sess, path=dirname) np.savetxt(dirname + 'cost_val.txt', cost_val, fmt='%9.5f', delimiter=',') np.savetxt(dirname + 'cost_train.txt', cost_train, fmt='%9.5f', delimiter=',') np.savetxt(dirname + 'dc_val.txt', dc_val, fmt='%9.5f', delimiter=',') np.savetxt(dirname + 'dc_train.txt', dc_train, fmt='%9.5f', delimiter=',') print("Optimization Finished!") # model.load(sess) # testave = [] # # Testing # for i in range(len(features)): # test_cost, test_acc, test_dice, prediction, test_duration = evaluate(features[i], support, y_test, test_mask, neighbor_mask, placeholders) # print("Test set results:", "cost=", "{:.5f}".format(test_cost), # "accuracy=", "{:.3f}_{:.3f}".format(test_acc, test_dice), "time=", "{:.5f}".format(test_duration)) # if i>=FLAGS.train_num: # testave.append(test_dice) # # print(prediction.shape) # path = dirname+'{}.npy'.format(namelist[i]) # np.save(path, prediction) # np.savetxt(dirname+'dc_test.txt', testave, fmt='%7.4f', delimiter=',') # print('average_test_dice:', np.array(testave).mean()) # Testing and resting # #load data # f = open('/DATA/232/lma/data/HCP_test/sub_list.txt','r') # namelist = [str(int(name)) for name in f.readlines()] # feature_path_list = [] # for name in namelist: # feature_path_list.append('/DATA/232/lma/data/HCP_test/{}/{}_{}_probtrackx_omatrix2/finger_print_fiber.npz'.format(name, name, FLAGS.hemisphere)) # adj, features2, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data(FLAGS.hemisphere,pathlist= feature_path_list) # # Some preprocessing # for i in range(len(features2)): # features2[i] = preprocess_features(features2[i]) # # prediction # testave = [] # for i in range(len(features2)): # test_cost, test_acc, test_dice, prediction, test_duration = evaluate(features2[i], support, y_test, test_mask, neighbor_mask,placeholders) # print("Test set results:", "cost=", "{:.5f}".format(test_cost), # "accuracy=", "{:.5f}".format(test_dice), "time=", "{:.5f}".format(test_duration)) # testave.append(test_dice) # # print(prediction.shape) # path = dirname+'test_{}.npy'.format(namelist[i]) # np.save(path, prediction) # print('average_test/retest_acc:', np.array(testave).mean()) # #Resesting # f = open('/DATA/232/lma/data/HCP_retest/sub_list.txt','r') # namelist = [str(int(name)) for name in f.readlines()] # feature_path_list = [] # for name in namelist: # feature_path_list.append('/DATA/232/lma/data/HCP_retest/{}/{}_{}_probtrackx_omatrix2/finger_print_fiber.npz'.format(name, name, FLAGS.hemisphere)) # adj, features3, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data(FLAGS.hemisphere, pathlist= feature_path_list) # # Some preprocessing # for i in range(len(features3)): # features3[i] = preprocess_features(features3[i]) # #prediction # testave = [] # for i in range(len(features3)): # test_cost, test_acc, test_dice, prediction, test_duration = evaluate(features3[i], support, y_test, test_mask, neighbor_mask, placeholders) # print("Test set results:", "cost=", "{:.5f}".format(test_cost), # "accuracy=", "{:.5f}".format(test_dice), "time=", "{:.5f}".format(test_duration)) # testave.append(test_dice) # # print(prediction.shape) # path = dirname+'retest_{}.npy'.format(namelist[i]) # np.save(path, prediction) # print('average_test/retest_acc:', np.array(testave).mean()) return None
import sklearn.metrics as metrics from os.path import expanduser import gzip import pickle import pathlib import tensorflow as tf; os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' print('tf version:', tf.__version__) assert tf.__version__.startswith('2.') if __name__ == '__main__': filedir = os.path.dirname(__file__) model_dir = f'{filedir}/../trained_models/{args.problem}/TRIG-GCN' model = GCN( output_dim=2) model.load_weights(f'{model_dir}/model.ckpt') ####### data ####### for data_dir in ['test_small', 'test_medium']: data_path = f'{filedir}/../datasets/{args.problem}/{data_dir}' data_files = list(pathlib.Path(data_path).glob('sample_*.pkl')) data_files = [str(data_file) for data_file in data_files][:100] os.makedirs(f'{filedir}/../ret_model', exist_ok=True) logfile = f'{filedir}/../ret_model/{args.problem}_{data_dir}_TRIG_GCN.txt' nsamples = len(data_files) log(f'test dataset: <{data_path}>, number of instances: {nsamples}', logfile) log(f'log write to: <{logfile}>', logfile) t1 = time.time()
dataloader_test = DataLoader(dataset_test, batch_size=1, shuffle=False, num_workers=args.dataloader_workers) print('Number of training samples:', len(dataset_train)) sys.stdout.flush() # Model and optimizer # a dummy example to determine the dimension of input data adj0, features0, labels0, idx_train0, idx_val0, idx_test0, add_children0, or_children0 = load_data( '0', dataset, and_or=and_or, override_path=ds_path) model = GCN( nfeat=features0.shape[1], nhid=args.hidden, # nclass=labels.max().item() + 1, nclass=100, nhidlayers=args.hidden_layers, dropout=args.dropout, indep_weights=indep_weights) mlp = MLP(dropout=args.dropout) optimizer = optim.Adam(itertools.chain(model.parameters(), mlp.parameters()), lr=args.lr, weight_decay=args.weight_decay) creterion = torch.nn.TripletMarginLoss(margin=args.margin, p=2) CE = torch.nn.CrossEntropyLoss() loss_list = RunningAvg(window_size=200) loss_list_CE = RunningAvg(window_size=200) acc_list = RunningAvg(window_size=200) loss_by_iter = []
args = parser.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() np.random.seed(args.seed) torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) # Load data adj, features, labels, idx_train, idx_val, idx_test = load_data() # Model and optimizer model = GCN(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout, nnz=adj._nnz()) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) gamma = 0 eta = 10**-6 #should be decreasing with epochs print('!!!!!!!!!!!!CHECK!!!!!!!!!!!!') print('save (location) of plots') print('Gamma:', gamma) print('Eta:', eta) print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') if args.cuda:
def execute(params, budget=None, max_epoch=243, device='cpu', seed=42): np.random.seed(seed) torch.manual_seed(seed) if device == "cuda": torch.cuda.manual_seed(seed) # Load data if params['dataset'] == "cora": adj, features, labels, idx_train, idx_val, idx_test = load_data( dataset=params['dataset'], train_percent=0.052) if params['dataset'] == "citeseer": adj, features, labels, idx_train, idx_val, idx_test = load_citeseer( train_percent=0.036) # Model and optimizer model = GCN(nfeat=features.shape[1], nhid=params['hidden'], nclass=labels.max().item() + 1, dropout=params['dropout']) optimizer = optim.Adam(model.parameters(), lr=params['lr'], weight_decay=params['weight_decay']) if device == "cuda": model.cuda() features = features.cuda() adj = adj.cuda() labels = labels.cuda() idx_train = idx_train.cuda() idx_val = idx_val.cuda() idx_test = idx_test.cuda() # train model if device == "cuda": start = torch.cuda.Event(enable_timing=True) end = torch.cuda.Event(enable_timing=True) start.record() else: t1 = time.time_ns() model.train() num_epoch = int(budget) if budget != None else max_epoch for epoch in range(num_epoch): optimizer.zero_grad() output = model(features, adj) loss_train = F.nll_loss(output[idx_train], labels[idx_train]) acc_train = accuracy(output[idx_train], labels[idx_train]) loss_train.backward() optimizer.step() # evaluation model.eval() output = model(features, adj) loss_val = F.nll_loss(output[idx_val], labels[idx_val]) acc_val = accuracy(output[idx_val], labels[idx_val]) if device == "cuda": end.record() torch.cuda.synchronize() total_time = start.elapsed_time(end) / 1e3 sys.stdout.flush() acc_val = acc_val.item() else: t2 = time.time_ns() total_time = (t2 - t1) / 1e9 print() print( f"dataset={params['dataset']}, num_epoch={num_epoch}, device={next(model.parameters()).device}" ) print("Validation results:", "loss= {:.4f}".format(loss_val.item()), "accuracy= {:.4f}".format(acc_val)) print("Total training time: {:.4f} sec".format(total_time)) return 1 - acc_val
random.seed(42) np.random.seed(42) torch.manual_seed(42) if use_gpu: torch.cuda.manual_seed(42) model, optimizer = None, None best_acc = 0 # Define the model and optimizer if (opt.model == 'basic'): print("| Constructing basic GCN model...") model = GCN( nfeat = features.shape[1], nhid = opt.num_hidden, nclass = labels.max().item() + 1, dropout = opt.dropout, init = opt.init_type ) else: raise NotImplementedError if (opt.optimizer == 'sgd'): optimizer = optim.SGD( model.parameters(), lr = opt.lr, weight_decay = opt.weight_decay, momentum = 0.9 ) elif (opt.optimizer == 'adam'): optimizer = optim.Adam(
def train_k_fold(model_name, support, placeholders, is_pool=False, is_skip_connection=True, locality1=1, locality2=2, locality_sizes=None): """model_name: name of model (using option defined for FLAGS.model in top locality1 & locality2: values of k for 2 GC blocks of gcn_cheby(simple gcn model) locality_sizes: locality sizes included in each GC block for res_gcn_cheby(our proposed model) """ # Create model logging = False if model_name == 'res_gcn_cheby': model = ResGCN(placeholders, input_dim=num_features_selected, logging=logging, locality_sizes=locality_sizes, is_pool=is_pool, is_skip_connection=is_skip_connection) elif model_name == 'gcn': model = GCN(placeholders, input_dim=num_features_selected, logging=logging) elif model_name == 'gcn_cheby': locality = [locality1, locality2] # locality sizes of different blocks model = GCN(placeholders, input_dim=num_features_selected, logging=logging, is_simple=True, is_skip_connection=is_skip_connection, locality=locality) elif model_name == 'dense': model = MLP(placeholders, input_dim=num_features_selected, logging=logging) else: raise ValueError('Invalid argument for model: ' + str(model_name)) # Define model evaluation function def evaluate(features, support, labels, mask, placeholders): t_test = time.time() feed_dict_val = construct_feed_dict(features, support, labels, mask, placeholders) outs_val = sess.run([model.loss, model.accuracy, merged_summary], feed_dict=feed_dict_val) return outs_val[0], outs_val[1], outs_val[2], (time.time() - t_test) ##...........change to dense_features num_nodes = dense_features.shape[0] num_folds = 10 fold_size = int(num_nodes / num_folds) # list of results including accuracy, auc, confusion matrix train_accuracy = [] val_accuracy = [] test_accuracy = [] test_confusion_matrices = [] test_auc = [] # index of fold for validation set and test set val_part = 0 test_part = 1 # storing number of epochs of each fold num_epochs = [] # shape of features print('whole features shape: ', dense_features.shape) # Num_folds cross validation for fold in range(num_folds): print('Starting fold {}'.format(fold + 1)) # rotating folds of val and test val_part = (val_part + 1) % 10 test_part = (test_part + 1) % 10 # defining train, val and test mask train_mask = np.ones((num_nodes, ), dtype=np.bool) val_mask = np.zeros((num_nodes, ), dtype=np.bool) test_mask = np.zeros((num_nodes, ), dtype=np.bool) train_mask[val_part * fold_size:min((val_part + 1) * fold_size, num_nodes)] = 0 train_mask[test_part * fold_size:min((test_part + 1) * fold_size, num_nodes)] = 0 val_mask[val_part * fold_size:min((val_part + 1) * fold_size, num_nodes)] = 1 test_mask[test_part * fold_size:min((test_part + 1) * fold_size, num_nodes)] = 1 # defining train, val and test labels y_train = np.zeros(one_hot_labels.shape) y_val = np.zeros(one_hot_labels.shape) y_test = np.zeros(one_hot_labels.shape) y_train[train_mask, :] = one_hot_labels[train_mask, :] y_val[val_mask, :] = one_hot_labels[val_mask, :] y_test[test_mask, :] = one_hot_labels[test_mask, :] # number of samples in each set print('# of training samples: ', np.sum(train_mask)) print('# of validation samples: ', np.sum(val_mask)) print('# of testing samples: ', np.sum(test_mask)) tmp_labels = [item + 1 for item in all_labels] train_labels = train_mask * tmp_labels val_labels = val_mask * tmp_labels test_labels = test_mask * tmp_labels # distribution of train, val and test set over classes train_class = [ train_labels.tolist().count(i) for i in range(1, num_class + 1) ] print('train class distribution:', train_class) val_class = [ val_labels.tolist().count(i) for i in range(1, num_class + 1) ] print('val class distribution:', val_class) test_class = [ test_labels.tolist().count(i) for i in range(1, num_class + 1) ] print('test class distribution:', test_class) # saving initial boolean masks for later use init_train_mask = train_mask init_val_mask = val_mask init_test_mask = test_mask # changing mask for having weighted loss train_mask = node_weights * train_mask val_mask = node_weights * val_mask test_mask = node_weights * test_mask labeled_ind = [i for i in range(num_nodes) if train_mask[i]] # feature selection features_selected = feature_selection(dense_features, all_labels, labeled_ind, num_features_selected) features_selected = sparse_to_tuple(sp.coo_matrix(features_selected)) # Initialize session config = tf.ConfigProto(device_count={'GPU': 1}) sess = tf.Session(config=config) # Session with GPU # config = tf.ConfigProto() # config.gpu_options.allow_growth = True # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9) # sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) # Initialize variables sess.run(tf.global_variables_initializer()) # loss and accuracy scalar curves if model_name == 'res_gcn_cheby': l1 = locality_sizes[0] l2 = locality_sizes[1] else: l1 = locality1 l2 = locality2 tf.summary.scalar(name='{}_{}_loss_fold_{}'.format(l1, l2, fold + 1), tensor=model.loss) tf.summary.scalar(name='{}_{}_accuracy_fold_{}'.format( l1, l2, fold + 1), tensor=model.accuracy) merged_summary = tf.summary.merge_all() # defining train, test and val writers in /tmp/model_name/ path train_writer = tf.summary.FileWriter( logdir='/tmp/' + model_name + '_{}_{}/train_fold_{}/'.format(l1, l2, fold + 1)) test_writer = tf.summary.FileWriter( logdir='/tmp/' + model_name + '_{}_{}/test_fold_{}/'.format(l1, l2, fold + 1)) val_writer = tf.summary.FileWriter( logdir='/tmp/' + model_name + '_{}_{}/val_fold_{}/'.format(l1, l2, fold + 1)) # Train model cost_val = [] train_results = [] for epoch in range(FLAGS.epochs): t = time.time() # Construct feed dictionary for training feed_dict = construct_feed_dict(features_selected, support, y_train, train_mask, placeholders) feed_dict.update({placeholders['dropout']: FLAGS.dropout}) # Training step train_results = sess.run( [model.opt_op, model.loss, model.accuracy, merged_summary], feed_dict=feed_dict) train_writer.add_summary(train_results[-1], epoch) # Evaluation on val set val_cost, val_acc, val_summary, duration = evaluate( features_selected, support, y_val, val_mask, placeholders) cost_val.append(val_cost) val_writer.add_summary(val_summary, epoch) # Evaluation on test set test_cost, test_acc, test_summary, test_duration = evaluate( features_selected, support, y_test, test_mask, placeholders) test_writer.add_summary(test_summary, epoch) # Print results of train, val and test print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(train_results[1]), "train_acc=", "{:.5f}".format(train_results[2]), "val_loss=", "{:.5f}".format(val_cost), "val_acc=", "{:.5f}".format(val_acc), "time=", "{:.5f}".format(time.time() - t)) print("Test set results:", "test_loss=", "{:.5f}".format(test_cost), "test_accuracy=", "{:.5f}".format(test_acc)) # Check val loss for early stopping if epoch > max(FLAGS.early_stopping, FLAGS.start_stopping) and cost_val[-1] > np.mean( cost_val[-(FLAGS.early_stopping + 1):-1]): print("Early stopping on epoch {}...".format(epoch + 1)) break num_epochs.append(epoch) print("Optimization Finished!") # Collecting final results of train, test & val train_accuracy.append(train_results[2]) val_accuracy.append(val_acc) test_accuracy.append(test_acc) # Visualizing layers' embedding # if model_name == 'res_gcn_cheby': # path = '/tmp/' + model_name + '_{}_{}'.format(l1, l2) + '/layers/' + \ # 'fold_{}/'.format(fold) # layer_writer = tf.summary.FileWriter(logdir=path) # write_meta_data_labels(all_labels, path) # visualize_node_embeddings_resgcn(features, support, placeholders, sess, model, layer_writer, FLAGS.is_pool, # path, len(locality_sizes)) # layer_writer.close() # activations = get_activations(features, support, placeholders, sess, model) # l1_act = activations[0][1] # l2_act = activations[1][1] # graph_visualize(adj, dense_features, all_labels, 15, l1_act) # graph_visualize(adj, dense_features, all_labels, 15, l2_act) # Confusion matrix on test set feed_dict = dict() feed_dict.update({placeholders['features']: features_selected}) ##...........Feature_modi feed_dict.update({ placeholders['support'][i]: support[i] for i in range(len(support)) }) feed_dict.update( {placeholders['num_features_nonzero']: features_selected[1].shape}) ##...........Feature_modi model_outputs = sess.run(model.outputs, feed_dict=feed_dict) prediction = np.argmax(model_outputs, axis=1)[init_test_mask] confusion_mat = confusion_matrix( y_true=np.asarray(all_labels)[init_test_mask], y_pred=prediction, labels=[i for i in range(num_class)]) test_confusion_matrices.append(confusion_mat) print('Confusion matrix of test set:') print(confusion_mat) # Roc auc score on test set # auc = roc_auc_score(y_true=one_hot_labels[init_test_mask, :], y_score=model_outputs[init_test_mask, :]) # test_auc.append(auc) # print('Test auc: {:.4f}'.format(auc)) print('--------') # Closing writers train_writer.close() test_writer.close() val_writer.close() sess.close() if model_name == 'gcn_cheby': print('Results of k1={} k2={}'.format(locality1, locality2)) elif model_name == 'gcn': print('Results of re-parametrization model') elif model_name == 'res_gcn_cheby': print('Results of res_gcn with localities of: ', locality_sizes) else: print('Results of 3 layer dense neural network') print('Average number of epochs: {:.3f}'.format(np.mean(num_epochs))) print('Accuracy on {} folds'.format(num_folds)) print('train:', train_accuracy) print('val', val_accuracy) print('test', test_accuracy) print() # print('Test auc on {} folds'.format(num_folds)) # print(test_auc) # print() # # test_avg_auc = np.mean(test_auc) # print('Average test auc on {} folds'.format(num_folds)) # print(test_avg_auc, '±', np.std(test_auc)) return train_accuracy, val_accuracy, test_accuracy
node_heat_map = np.array(node_heat_map[:mol.GetNumAtoms()]).reshape(-1, 1) pos_node_heat_map = MinMaxScaler(feature_range=(0, 1)).fit_transform( node_heat_map * (node_heat_map >= 0)).reshape(-1, ) neg_node_heat_map = MinMaxScaler(feature_range=(-1, 0)).fit_transform( node_heat_map * (node_heat_map < 0)).reshape(-1, ) return pos_node_heat_map + neg_node_heat_map dataset = load_bbbp(hp.N) random.Random(hp.shuffle_seed).shuffle(dataset) split_idx = int(np.floor(len(dataset) * hp.train_frac)) test_dataset = dataset[split_idx:] loader = DataLoader(test_dataset, batch_size=1, shuffle=False) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = GCN(hp.H_0, hp.H_1, hp.H_2, hp.H_3).to(device) model.load_state_dict(torch.load('gcn_state_dict.pt')) model.eval() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) print(model) model.train() total_loss = 0 for data in tqdm(loader): # breakpoint() data = data.to(device) optimizer.zero_grad() out = model(data) loss = F.binary_cross_entropy(out, data.y) loss.backward()