def main(opt): train_dataset = BADataset(opt.dataroot, opt.L, True, False, False) train_dataloader = BADataloader(train_dataset, batch_size=opt.batchSize, \ shuffle=True, num_workers=opt.workers, drop_last=True) valid_dataset = BADataset(opt.dataroot, opt.L, False, True, False) valid_dataloader = BADataloader(valid_dataset, batch_size=opt.batchSize, \ shuffle=True, num_workers=opt.workers, drop_last=True) test_dataset = BADataset(opt.dataroot, opt.L, False, False, True) test_dataloader = BADataloader(test_dataset, batch_size=opt.batchSize, \ shuffle=True, num_workers=opt.workers, drop_last=True) all_dataset = BADataset(opt.dataroot, opt.L, False, False, False) all_dataloader = BADataloader(all_dataset, batch_size=opt.batchSize, \ shuffle=False, num_workers=opt.workers, drop_last=False) opt.n_edge_types = train_dataset.n_edge_types opt.n_node = train_dataset.n_node opt.n_existing_node = all_node_num net = GCN(opt, kernel_size=2, n_blocks=1, state_dim_bottleneck=opt.state_dim, annotation_dim_bottleneck=opt.annotation_dim) net.double() print(net) criterion = nn.CosineSimilarity(dim=1, eps=1e-6) if opt.cuda: net.cuda() criterion.cuda() optimizer = optim.Adam(net.parameters(), lr=opt.lr) early_stopping = EarlyStopping(patience=opt.patience, verbose=True) os.makedirs(OutputDir, exist_ok=True) train_loss_ls = [] valid_loss_ls = [] test_loss_ls = [] for epoch in range(0, opt.niter): train_loss = train(epoch, train_dataloader, net, criterion, optimizer, opt) valid_loss = valid(valid_dataloader, net, criterion, opt) test_loss = test(test_dataloader, net, criterion, opt) train_loss_ls.append(train_loss) valid_loss_ls.append(valid_loss) test_loss_ls.append(test_loss) early_stopping(valid_loss, net, OutputDir) if early_stopping.early_stop: print("Early stopping") break df = pd.DataFrame({'epoch':[i for i in range(1, len(train_loss_ls)+1)], 'train_loss': train_loss_ls, 'valid_loss': valid_loss_ls, 'test_loss': test_loss_ls}) df.to_csv(OutputDir + '/loss.csv', index=False) net.load_state_dict(torch.load(OutputDir + '/checkpoint.pt')) inference(all_dataloader, net, criterion, opt, OutputDir)
def save_output(root_dir, output_dir): # dataset dataset = save_predict_dataset(root_dir) #model model = GCN(4, 512) if use_gpu: model = model.cuda() #model = torch.nn.DataParallel(model).cuda() model.load_state_dict(torch.load(os.path.join(save_dir, model_name))) model.train(False) for n in range(int(len(dataset) / (6 * 9))): #test full_output = np.zeros((4, 2848, 4288), dtype='float32') #(C, H, W) title = '' for idx in range(6 * 9 * n, 6 * 9 * (n + 1)): image, name = dataset[idx] r = int((idx % (6 * 9)) / 9) #row c = (idx % (6 * 9)) % 9 #column title = name if use_gpu: image = image.cuda() image = Variable(image, volatile=True) #forward output = model(image.unsqueeze(0)) output = F.sigmoid(output) output = output[0] if c < 8: if r == 5: full_output[:, r * 512:r * 512 + 512 - 224, c * 512:c * 512 + 512] = output.cpu().data.numpy()[:, :-224, :] else: full_output[:, r * 512:r * 512 + 512, c * 512:c * 512 + 512] = output.cpu().data.numpy() for i, d in enumerate(['MA', 'EX', 'HE', 'SE']): if not os.path.exists(os.path.join(output_dir, d)): os.makedirs(os.path.join(output_dir, d)) im = np.expand_dims(full_output[i], axis=0).transpose(1, 2, 0) im = full_output[i] * 255 im = np.uint8(im) im = Image.fromarray(im) im.save(os.path.join(output_dir, d, title + '.jpg'))
np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) # Load data adj, features, labels, idx_train, idx_val, idx_test = load_citeseer() # Model and optimizer model = GCN(input_size=features.shape[1], hidden_size=args.hidden, n_classes=labels.max().item() + 1) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) 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() criterion = nn.CrossEntropyLoss() def train(epoch): t = time.time() model.train() optimizer.zero_grad() output = model(features, adj)
print() time_elapsed = time.time() - since print('Training complete in {:.0f}m {:.0f}s'.format( time_elapsed // 60, time_elapsed % 60)) print('Best F1 score: {:.4f}'.format(best_f1)) # load best model weights model.load_state_dict(best_model_wts) return model if __name__ == '__main__': # dataset dataloaders = make_dataloaders(batch_size=batch_size) #model model = GCN(4, 512) if use_gpu: model = model.cuda() #model = torch.nn.DataParallel(model).cuda() model.load_state_dict(torch.load(os.path.join(save_dir, 'gcn_v5.pth'))) #training optimizer = optim.Adam(model.parameters(), lr=lr) scheduler = ReduceLROnPlateau(optimizer, 'min', verbose=True) model = train_model(model, num_epochs, dataloaders, optimizer, scheduler) #save save_model(model, save_dir, model_name)
idx_test = range(500, 1500) idx_train = torch.LongTensor(idx_train) idx_val = torch.LongTensor(idx_val) idx_test = torch.LongTensor(idx_test) # Model and optimizer model = GCN(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) # 数据写入cuda,便于后续加速 if args.cuda: model.cuda() # . cuda()会分配到显存里(如果gpu可用) features = features.cuda() adj = adj.cuda() labels = labels.cuda() idx_train = idx_train.cuda() idx_val = idx_val.cuda() idx_test = idx_test.cuda() def train(epoch): t = time.time() # 返回当前时间 model.train() optimizer.zero_grad() # optimizer.zero_grad()意思是把梯度置零,也就是把loss关于weight的导数变成0. # pytorch中每一轮batch需要设置optimizer.zero_gra output = model(features, adj)
def run_statistic(threshold): ''' evaluate on small images result ''' # dataset dataset = IDRiD_sub1_dataset(data_dir) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=4) #print('Data: %d'%(len(dataset))) #model model = GCN(4, 512) if use_gpu: model = model.cuda() #model = torch.nn.DataParallel(model).cuda() model.load_state_dict(torch.load(os.path.join(save_dir, model_name))) model.train(False) for i in range(4): y_pred_list = [] y_true_list = [] for idx, data in enumerate(dataloader): images, masks, names = data if use_gpu: images = images.cuda() masks = masks.cuda() images, masks = Variable(images, volatile=True), Variable(masks, volatile=True) #forward outputs = model(images) # statistics outputs = F.sigmoid( outputs).cpu().data #remenber to apply sigmoid befor usage masks = masks.cpu().data #for i in range(len(outputs)): y_pred = outputs[i] y_true = masks[i] y_pred = y_pred.numpy().flatten() y_pred = np.where(y_pred > threshold, 1, 0) y_true = y_true.numpy().flatten() y_pred_list.append(y_pred) y_true_list.append(y_true) #verbose if idx % 5 == 0 and idx != 0: print('\r{:.2f}%'.format(100 * idx / len(dataloader)), end='\r') #print() type_list = ['MA', 'EX', 'HE', 'SE'] precision, recall, f1, _ = precision_recall_fscore_support( np.array(y_true_list).flatten(), np.array(y_pred_list).flatten(), average='binary') print( '{} \nThreshold: {:.2f}\nPrecision: {:.4f}\nRecall: {:.4f}\nF1: {:.4f}' .format(type_list[i], threshold, precision, recall, f1))
def show_image_sample(): # dataset dataset = IDRiD_sub1_dataset(data_dir) #model model = GCN(4, 512) if use_gpu: model = model.cuda() #model = torch.nn.DataParallel(model).cuda() model.load_state_dict(torch.load(os.path.join(save_dir, model_name))) model.train(False) for n in range(12): #test full_image = np.zeros((3, 2848, 4288), dtype='float32') full_mask = np.zeros((4, 2848, 4288), dtype='float32') full_output = np.zeros((4, 2848, 4288), dtype='float32') #(C, H, W) title = '' for idx in range(9 * 6 * n, 9 * 6 * (n + 1)): image, mask, name = dataset[idx] n = int(idx / (6 * 9)) #image index r = int((idx % (6 * 9)) / 9) #row c = (idx % (6 * 9)) % 9 #column title = name[:-8] if use_gpu: image = image.cuda() mask = mask.cuda() image, mask = Variable(image, volatile=True), Variable(mask, volatile=True) #forward output = model(image.unsqueeze(0)) output = F.sigmoid(output) output = output[0] if c < 8: if r == 5: full_output[:, r * 512:r * 512 + 512 - 224, c * 512:c * 512 + 512] = output.cpu().data.numpy()[:, :-224, :] full_mask[:, r * 512:r * 512 + 512 - 224, c * 512:c * 512 + 512] = mask.cpu().data.numpy()[:, :-224, :] full_image[:, r * 512:r * 512 + 512 - 224, c * 512:c * 512 + 512] = image.cpu().data.numpy()[:, :-224, :] else: full_output[:, r * 512:r * 512 + 512, c * 512:c * 512 + 512] = output.cpu().data.numpy() full_mask[:, r * 512:r * 512 + 512, c * 512:c * 512 + 512] = mask.cpu().data.numpy() full_image[:, r * 512:r * 512 + 512, c * 512:c * 512 + 512] = image.cpu().data.numpy() full_image = full_image.transpose(1, 2, 0) MA = full_output[0] EX = full_output[1] HE = full_output[2] SE = full_output[3] plt.figure() plt.axis('off') plt.suptitle(title) plt.subplot(331) plt.title('image') fig = plt.imshow(full_image) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(332) plt.title('ground truth MA') fig = plt.imshow(full_mask[0]) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(333) plt.title('ground truth EX') fig = plt.imshow(full_mask[1]) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(334) plt.title('ground truth HE') fig = plt.imshow(full_mask[2]) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(335) plt.title('ground truth SE') fig = plt.imshow(full_mask[3]) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(336) plt.title('predict MA') fig = plt.imshow(MA) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(337) plt.title('predict EX') fig = plt.imshow(EX) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(338) plt.title('predict HE') fig = plt.imshow(HE) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.subplot(339) plt.title('predict SE') fig = plt.imshow(SE) fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False) plt.show()
def main(files_home): starttime = datetime.now() print('start test model ', starttime) number = args.number f = open(os.path.join(files_home, files_name['node_index']), 'rb') node2index = cPickle.load(f) f_train = os.path.join(files_home, files_name['train_file']) f_test = os.path.join(files_home, files_name['test_file']) ### # testset = Sample_Set_Test(f_test,f_train, node2index) # testloader = DataLoader(testset, batch_size=32, shuffle=False) node_count = len(node2index) node_dim = 128 n_repr = 128 gcn = GCN(node_count, node_dim, n_repr, dropout=args.dropout) lp = Link_Prediction(n_repr, dropout=args.dropout) if args.cuda == True: gcn.cuda() lp = nn.DataParallel(lp) lp.cuda() init_input = torch.LongTensor([j for j in range(0, node_count)]).cuda() dis2gene_test_true, dis2gene_test_all = get_rank_test_samples( f_train, f_test) f = open(files_home + '/networks/adj_matrix_%d_full' % (number), 'rb') full_adj_matrix = cPickle.load(f) full_adj_matrix = sparse_mx_to_torch_sparse_tensor(full_adj_matrix).cuda() for epoch in tqdm(range(0, args.epochs)): if epoch % 9 != 0 and epoch < args.epochs - 5: continue gcn.load_state_dict( torch.load(files_home + '/networks/GCN_%d_%d.pth' % (number, epoch))) lp.load_state_dict( torch.load(files_home + '/networks/Link_Prediction_%d_%d.pth' % (number, epoch))) gcn.eval() feature_matrix = gcn(init_input, full_adj_matrix) # test_link(testloader, feature_matrix, lp) if 0: print('use gcn to prediction') ap, prec, recall, f1score = test_priorization_gcn( dis2gene_test_true, dis2gene_test_all, feature_matrix, lp) else: print('use gcn and word2ver to prediction') ap, prec, recall, f1score = test_priorization_word_gcn( dis2gene_test_true, dis2gene_test_all, feature_matrix, lp) print('Performance for number=%d epoch=%d' % (number, epoch)) print('AP: ', ap) print('Prec: ', prec) print('Recall: ', recall) print('F1score: ', f1score) endtime = datetime.now() print('finish test model! run spend ', endtime - starttime)
import numpy as np import torch import torch.nn.functional as F from model import GCN as GCN from graph import build_graph_skeleton as build_graph from dataLoader import cropCUB as CUB CD = True G = build_graph() net = GCN(2048, [1024, 512], 200) if CD: net = net.cuda(0) batch_size = 8 start_epoch = 0 if True: ckpt = torch.load('/Disk5/junqi/CUB/early_skeleton_93.ckpt') net.load_state_dict(ckpt['net_state_dict']) start_epoch = ckpt['epoch'] + 1 datas = CUB() dataLoader = torch.utils.data.DataLoader(datas, batch_size=batch_size, shuffle=True, num_workers=4) optimizer = torch.optim.SGD(net.parameters(), lr=1e-2, momentum=0.9, weight_decay=1e-4)
import pickle import torch from graph import build_graph_skeleton as build_graph from model import GCN as GCN testset = CUB('test', False) dataloader = torch.utils.data.DataLoader(testset, batch_size=8, shuffle=False, num_workers=4) net = GCN(2048, [1024, 512], 200) G = build_graph() ckpt = torch.load('/Disk5/junqi/CUB/early_skeleton_104.ckpt') net.load_state_dict(ckpt['net_state_dict']) net = net.cuda() net = torch.nn.DataParallel(net) creterion = torch.nn.CrossEntropyLoss() test_correct = 0 test_loss = 0 total = 0 net.eval() pre, lab = [], [] for i, (inputs, mask, labels) in enumerate(dataloader): if i % 10 == 0 and i > 0: print('test {}/{}, acc: {:.3f}, loss: {:.3f}'.format( i, len(dataloader), float(test_correct) / total, test_loss / total))
def train_classification_gcn(self, Adj, features, nfeats, labels, nclasses, train_mask, val_mask, test_mask, args): model = GCN(in_channels=nfeats, hidden_channels=args.hidden, out_channels=nclasses, num_layers=args.nlayers, dropout=args.dropout2, dropout_adj=args.dropout_adj2, Adj=Adj, sparse=args.sparse) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.w_decay) bad_counter = 0 best_val = 0 best_model = None best_loss = 0 best_train_loss = 0 if torch.cuda.is_available(): model = model.cuda() train_mask = train_mask.cuda() val_mask = val_mask.cuda() test_mask = test_mask.cuda() features = features.cuda() labels = labels.cuda() for epoch in range(1, args.epochs + 1): model.train() loss, accu = self.get_loss_fixed_adj(model, train_mask, features, labels) optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 10 == 0: model.eval() val_loss, accu = self.get_loss_fixed_adj( model, val_mask, features, labels) if accu > best_val: bad_counter = 0 best_val = accu best_model = copy.deepcopy(model) best_loss = val_loss best_train_loss = loss else: bad_counter += 1 if bad_counter >= args.patience: break print("Val Loss {:.4f}, Val Accuracy {:.4f}".format( best_loss, best_val)) best_model.eval() test_loss, test_accu = self.get_loss_fixed_adj(best_model, test_mask, features, labels) print("Test Loss {:.4f}, Test Accuracy {:.4f}".format( test_loss, test_accu)) return best_val, test_accu, best_model
embeddings, freeze_embeddings=True) gcn_model = GCN(nFeat, nHid, nComm) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=args.learning_rate, weight_decay=5e-4) gcn_optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, gcn_model.parameters()), lr=args.learning_rate, weight_decay=5e-4) if args.use_cuda: model.cuda() gcn_model.cuda() X_train = X_train.cuda() X_test = X_test.cuda() Y_train = Y_train.cuda() Y_test = Y_test.cuda() epoch_loss = [] epoch_accuracy = [] train_accuracy = [] epochs = [] correct = 0 try: for epoch in range(1, args.num_epochs + 1): optimizer.zero_grad()
def main(args): device = torch.device('cuda' if args.cuda else 'cpu') adj, features, labels, idx_train, idx_val, idx_test = load_data( args.dataset) if args.model == 'gcn': model = GCN(nfeat=features.size(1), nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout) print('Model: GCN') elif args.model == 'gat': model = GAT(nfeat=features.size(1), nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout, alpha=args.alpha, nheads=args.n_heads) print('Model: GAT') elif args.model == 'spgcn': model = SpGCN(nfeat=features.size(1), nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout) print('Model: SpGCN') elif args.model == 'spgat': model = SpGAT(nfeat=features.size(1), nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout, alpha=args.alpha, nheads=args.n_heads) print('Model: SpGAT') optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) if args.cuda: adj = adj.cuda() features = features.cuda() labels = labels.cuda() idx_train = idx_train.cuda() idx_val = idx_val.cuda() idx_test = idx_test.cuda() model.cuda() print(device) def train(epoch): model.train() 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() if not args.fastmode: 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]) # print('Epoch: {:04d}'.format(epoch + 1), # 'loss_train: {:.4f}'.format(loss_train.item()), # 'acc_train: {:.4f}'.format(acc_train.item()), # 'loss_val: {:.4f}'.format(loss_val.item()), # 'acc_val: {:.4f}'.format(acc_val.item())) pbar.set_description( '| epoch: {:4d} | loss_train: {:.4f} | acc_train: {:.4f} |' ' loss_val: {:.4f} | acc_val: {:.4f}'.format( epoch + 1, loss_train.item(), acc_train.item(), loss_val.item(), acc_val.item())) return loss_train.item(), loss_val.item() def test(): model.eval() output = model(features, adj) loss_test = F.nll_loss(output[idx_test], labels[idx_test]) acc_test = accuracy(output[idx_test], labels[idx_test]) print("Test set results:", "loss= {:.4f}".format(loss_test.item()), "accuracy= {:.4f}".format(acc_test.item())) losses = {} pbar = tqdm(range(args.epochs)) for epoch in pbar: loss_train, loss_val = train(epoch) if epoch % 10 == 0: if len(losses) == 0: losses['train'] = [loss_train] losses['val'] = [loss_val] else: losses['train'].append(loss_train) losses['val'].append(loss_val) f, ax = plt.subplots() train_loss = ax.plot(losses['train'], label='Train Loss') val_loss = ax.plot(losses['val'], label='Validation Loss') ax.legend() ax.set_xlabel('Epoch / 10') ax.set_ylabel('Loss') plt.savefig('results/loss_{}_{}.png'.format(args.model, args.dataset), dpi=300) print('Optimization Finished!') test()