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)
