def main(): read_f = file("./data/train_data", "rb") train_generator = cPickle.load(read_f) read_f.close() read_f = file("./data/emb", "rb") embedding_matrix, _, _ = cPickle.load(read_f) read_f.close() test_generator = DataGenerator("test", args.batch_size) model = Network(args.embedding_size, args.embedding_dimension, embedding_matrix, args.hidden_dimension).cuda() best_model = Network(args.embedding_size, args.embedding_dimension, embedding_matrix, args.hidden_dimension).cuda() optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.l2_reg) best_result = 0.0 for echo in range(args.epoch_num): info = "[" + echo * ">" + " " * (args.epoch_num - echo) + "]" sys.stderr.write(info + "\r") cost1, cost2, cost, total_num = 0.0, 0.0, 0.0, 0 for data in train_generator.generate_data(shuffle=True): zp_rep, npc_rep, np_rep, feature = model.forward(data, dropout=args.dropout) output = model.generate_score(zp_rep, npc_rep, np_rep, feature) optimizer.zero_grad() dis1 = output[data['wid']] - output[data['cid']] + args.margin dis2 = output[data['uwid']] - args.wrong_bound dis3 = args.correct_bound - output[data['ucid']] triplet_loss = torch.sum(dis1 * (dis1 > 0).cuda().float()) + torch.sum( dis2 * (dis2 > 0).cuda().float()) + torch.sum(dis3 * (dis3 > 0).cuda().float()) cos_sim_sum = torch.sum(1 - F.cosine_similarity(np_rep[data['cid1']], np_rep[data['cid2']])) sim_w = 0.5 num = data["result"].shape[0] total_loss = triplet_loss + sim_w * cos_sim_sum total_loss.backward() cost += total_loss.item() * num cost1 += triplet_loss.item() * num cost2 += cos_sim_sum.item() * num total_num += num optimizer.step() train_re = evaluate_train(train_generator, model) dev_re, dev_cost = evaluate_dev(train_generator, model, args.margin) if dev_re > best_result: best_result = dev_re net_copy(best_model, model) test_re = evaluate_test(test_generator, model) print 'Epoch %s; Train Cost: %.4f, %.4f, %.4f; Train Result: %.4f; Dev Result: %.4f, %.4f; Test Result: %.4f' % ( echo, cost / total_num, cost1 / total_num, cost2 / total_num, train_re, dev_re, dev_cost, test_re) print >> sys.stderr torch.save(best_model, "./models/model") re = evaluate_test(test_generator, best_model) print "Performance on Test: F", re
def test(): import torch.optim as optim import numpy as np net = Network(128) opt = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) updater = Updater(net, opt) x = torch.Tensor([[0.4, 0.3], [0.5, 0.9]]) t = torch.Tensor([[0.7, 0.1, 0.12], [1.4, -0.4, 0.45]]) mc = np.array([2, 2, 1]) sc = np.array([0, -1, 0]) print(net(x).data.numpy() * mc + sc) for i in range(10000): loss = updater.step(x, t) if i % 1000 + 1 == 1000: print("iter {} : {}".format(i + 1, loss)) print(net(x).data.numpy() * mc + sc)
def main(): ## Network initialize ## net = Network(classes=2, arch=args.arch) # defalt number of classes 2 #net.load_state_dict(torch.load('./model/cs_globalmean/model_10.pth')) #print('Load model successfully') ## define loss function (criterion) and optimizer ## criterion = nn.CosineEmbeddingLoss().cuda() optimizer = torch.optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay = 1e-4) ## Data loading ## traindir = os.path.join(args.train_data, 'train') valpdir = os.path.join(args.test_data, 'pocket') valldir = os.path.join(args.test_data, 'ligand') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) num_classes = len([name for name in os.listdir(traindir)]) - 1 print("num_classes = '{}'".format(num_classes)) train_data = datasets.ImageFolder( ## train/tdata, fdata traindir, transforms.Compose([ transforms.ToTensor(), ## (height x width, channel),(0-255) -> (channel x height x width),(0.0-1.0) normalize, ## GRB の正規化 ])) train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=args.batch_size, shuffle=False, num_workers=args.workers) val_pdata = datasets.ImageFolder( ## val/pocket valpdir, transforms.Compose([ transforms.ToTensor(), normalize, ])) val_ploader = torch.utils.data.DataLoader(dataset=val_pdata, batch_size=20, # batch-size for test shuffle=False, num_workers=args.workers) val_ldata = datasets.ImageFolder( ## val/ligand valldir, transforms.Compose([ transforms.ToTensor(), normalize, ])) val_lloader = torch.utils.data.DataLoader(dataset=val_ldata, batch_size=20, # batch-size for test shuffle=False, num_workers=args.workers) ## Train ## print(('Start training: lr %f, batch size %d, classes %d'%(args.lr, args.batch_size, num_classes))) steps = args.start_epoch iter_per_epoch = args.batch_size//40 imgs = [] lbls = [] image_list = [] label_list = [] for i, (images, labels) in enumerate(train_loader): imgs.append(images) lbls.append(labels) shuffle_list = [i*40 for i in range(iter_per_epoch*len(imgs))] random.shuffle(shuffle_list) list_length = iter_per_epoch*len(imgs) for i in range(list_length): s = shuffle_list[i]//args.batch_size f = shuffle_list[i]%args.batch_size image_list.append(imgs[s][f:f+40]) label_list.append(lbls[s][f:f+40]) init_numdict = {} numlist = [] for i in range(list_length): if label_list[i][0].tolist()==0: numlist.append(i) for i in range(int(list_length/2)): init_numdict[i] = numlist[i] for epoch in range(args.start_epoch, args.epochs): #if (epoch+1)%(int(list_length/2)-1)==0 and epoch>args.start_epoch: if epoch%1==0 and epoch>19: path = modelpath + 'model_' + str(epoch) + '.pth' torch.save(net.state_dict(), path) print('>>>>>Save model successfully<<<<<') loss = 0 sum_loss = 0 if (epoch+1)%(int(list_length/2)-1)==0 and epoch>0: image_list, init_numdict = shuffle_fpair(image_list, label_list, list_length, init_numdict, 1) print('Shuffle mode >>>> 1') else: image_list, init_numdict = shuffle_fpair(image_list, label_list, list_length, init_numdict, 0) print('Shuffle mode >>>> 0') image_list, label_list, init_numdict = shuffle_set(image_list, label_list, list_length, init_numdict) for i , (images, lables) in enumerate(zip(image_list, label_list)): images = Variable(image_list[i]) labels = Variable(label_list[i]) # Forward + Backward + Optimize label = torch.tensor([labels[0]]) label = label*2-1 optimizer.zero_grad() output_lig, output_poc = net(images, 'train', 'max', 'max') sim = cos(output_lig, output_poc) loss += criterion(output_lig, output_poc, label.type_as(output_lig)) if (i+1)%(iter_per_epoch)==0 and i>0: loss /= iter_per_epoch ## calculate loss average sum_loss += loss print('Epoch: %2d, iter: %2d, Loss: %.4f' %(epoch, i+1, loss)) if (i+1)==list_length: print('>>>Epoch: %2d, Train_Loss: %.4f' %(epoch, sum_loss/list_length*iter_per_epoch)) sum_loss = 0 #test(net, val_ploader, val_lloader, epoch) loss.backward() optimizer.step() loss = 0
word_index = tokenizer.word_index nb_words = min(max_features, len(word_index)) embedding_matrix = np.random.normal(emb_mean, emb_std, (nb_words, embed_size)) for word, i in word_index.items(): if i >= max_features: continue embedding_vector = embeddings_index.get(word) if embedding_vector is not None: embedding_matrix[i] = embedding_vector filter_sizes = [1, 2, 3, 5] num_filters = 36 net = Network(embedding_matrix, max_features, embed_size, maxlen, num_filters, filter_sizes) for m in net.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') optimizer = torch.optim.Adam(net.parameters(), lr=0.0001) # optimize all cnn parameters loss_func = nn.CrossEntropyLoss() #train print('training') batch_size = 512 lenth = train_X.shape[0] for step in range(int(lenth / batch_size)): dx = train_X[batch_size * step:batch_size * (step + 1)] dy = np.array([ train_y[batch_size * step:batch_size * (step + 1)] ]) # gives batch data, normalize x when iterate train_loader dx = torch.LongTensor(dx) dy = torch.LongTensor(dy) dy = dy.squeeze(0)
train_indices, val_indices = indices[split:], indices[:split] train_sampler = SubsetRandomSampler(train_indices) valid_sampler = SubsetRandomSampler(val_indices) train_loader = torch.utils.data.DataLoader(dataset, batch_size=32, sampler=train_sampler) valid_loader = torch.utils.data.DataLoader(dataset, batch_size=32, sampler=valid_sampler) model = Network() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() train_iter = iter(train_loader) for e in range(num_epoch): try: inputs, _ = next(train_iter) except StopIteration: train_iter = iter(train_loader) inputs, _ = next(train_iter) #inputs = inputs.to(device) lr_batch = torch.zeros(32, 3, 8, 8, dtype=torch.float) hr_batch = torch.zeros(32, 3, 32, 32, dtype=torch.float) labels = torch.zeros(32, 3, 32, 32, dtype=torch.float)