def train(args):
device = torch.device(
'cpu' if args.gpu_idx < 0 else 'cuda:{}'.format(args.gpu_idx))
outdir = args.path_model
indir = os.path.join(args.path_model, args.path_dataset)
learning_rate = args.lr
batch_size = args.batch_size
# Data Loading
HMP, Nf, Ng, idx_train, idx_val = load_data(path=indir,
id_cluster=args.id_cluster,
split=args.rate_split)
ds_loader_train, ds_loader_val = data_loader(
HMP,
Nf,
Ng,
idx_train,
idx_val,
BatchSize=args.batch_size,
sampling=args.sampling_strategy)
nfeatures = int(Nf.shape[1] / 3)
# Create model
net = Net(nfeatures)
net.to(device)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
weight_decay=args.weight_decay,
momentum=args.momentum)
scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[], gamma=0.1)
if not os.path.exists(outdir):
os.makedirs(outdir)
log_filename = os.path.join(outdir,
'log_trainC{}.txt'.format(args.id_cluster))
model_filename = os.path.join(
outdir, 'model_cluster{}.pth'.format(args.id_cluster))
args_filename = os.path.join(outdir,
'args_cluster{}.pth'.format(args.id_cluster))
# Training
print("Training...")
'''
if os.path.exists(model_filename):
response = input('A training instance ({}) already exists, overwrite? (y/n) '.format(model_filename))
if response == 'y' or response == 'Y':
if os.path.exists(log_filename):
os.remove(log_filename)
if os.path.exists(model_filename):
os.remove(model_filename)
else:
print('Training exit.')
sys.exit()'''
if os.path.exists(model_filename):
raise ValueError(
'A training instance already exists: {}'.format(model_filename))
# LOG
LOG_file = open(log_filename, 'w')
log_write(LOG_file, str(args))
log_write(
LOG_file, 'data size = {}, train size = {}, val size = {}'.format(
HMP.shape[0], np.sum(idx_train), np.sum(idx_val)))
log_write(LOG_file, '***************************\n')
train_batch_num = len(ds_loader_train)
val_batch_num = len(ds_loader_val)
min_error = 180
epoch_best = -1
bad_counter = 0
for epoch in range(args.max_epochs):
loss_cnt = 0
err_cnt = 0
cnt = 0
# update learning rate
scheduler.step()
learning_rate = optimizer.param_groups[0]['lr']
log_write(LOG_file, 'EPOCH #{}'.format(str(epoch + 1)))
log_write(LOG_file,
'lr = {}, batch size = {}'.format(learning_rate, batch_size))
net.train()
for i, inputs in enumerate(ds_loader_train):
x, y, label = inputs
x = x.to(device)
y = y.to(device)
label = label.to(device)
optimizer.zero_grad()
# forward backward
output = net(x, y)
loss = compute_loss(output,
label,
loss_type=args.normal_loss,
normalize=args.normalize_output)
loss.backward()
optimizer.step()
cnt += x.size(0)
loss_cnt += loss.item()
err = torch.abs(cos_angle(output, label)).detach().cpu().numpy()
err = np.rad2deg(np.arccos(err))
err_cnt += np.sum(err)
train_loss = loss_cnt / train_batch_num
train_err = err_cnt / cnt
# validate
net.eval()
loss_cnt = 0
err_cnt = 0
cnt = 0
for i, inputs in enumerate(ds_loader_val):
x, y, label = inputs
x = x.to(device)
y = y.to(device)
label = label.to(device)
# forward
with torch.no_grad():
output = net(x, y)
loss = compute_loss(output,
label,
loss_type=args.normal_loss,
normalize=args.normalize_output)
loss_cnt += loss.item()
cnt += x.size(0)
err = torch.abs(cos_angle(output, label)).detach().cpu().numpy()
err = np.rad2deg(np.arccos(err))
err_cnt += np.sum(err)
val_loss = loss_cnt / val_batch_num
val_err = err_cnt / cnt
# log
log_write(
LOG_file,
'train loss = {}, train error = {}'.format(train_loss, train_err))
log_write(LOG_file,
'val loss = {}, val error = {}'.format(val_loss, val_err))
if min_error > val_err:
min_error = val_err
epoch_best = epoch + 1
bad_counter = 0
log_write(LOG_file,
'Current best epoch #{} saved in file: {}'.format(
epoch_best, model_filename),
show_info=False)
torch.save(net.state_dict(), model_filename)
else:
bad_counter += 1
if bad_counter >= args.patience:
break
parser.add_argument('--target', default='mnist', type=str, metavar='N')
parser.add_argument('--fix_three', default=True, type=bool, metavar='N')
# self.source = 'mnist'
# self.target = 'svnh'
args = parser.parse_args()
args.model_name = args.mode+'/'+args.source + '2' + args.target + '.pth.tar'
args.device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
# args=argument()
net_G=model.Feature().to(args.device)
net_D1=model.Predictor().to(args.device)
net_D2=model.Predictor().to(args.device)
if args.fix_three==False:
net_G = usps.Feature().to(args.device)
net_D1 = usps.Predictor().to(args.device)
net_D2 = usps.Predictor().to(args.device)
# if os.path.exists(args.model_name):
# print('loading....')
# ckp = torch.load(args.model_name,map_location=args.device)
# net_G.load_state_dict(ckp['G_state_dict'])
# net_D1.load_state_dict(ckp['C1_state_dict'])
# net_D2.load_state_dict(ckp['C2_state_dict'])
data_loader=data_loader(args=args)
source_trainset, source_testset = get_data(args.source)
target_trainset,target_test=get_data(args.target)
train(args,source_trainset,target_trainset,target_test)
# test(args,target_test)
def main(args, device):
logger = create_logger(args.train_test_mode, args.save_dir)
if logger is not None:
debug, info = logger.debug, logger.info
debug('Command line')
debug(f'python {" ".join(sys.argv)}')
debug('Args')
debug(args)
chem1, chem2, cell_line, synergies = data_loader(args.drug1_chemicals, args.drug2_chemicals,
args.cell_line_gex, args.comb_data_name)
print(chem1.shape)
print(chem1.max())
print(chem1.min())
print(chem2.shape)
print(chem2.max())
print(chem2.min())
print(cell_line.shape)
architecture = pd.read_csv('architecture.txt')
layers = {}
layers['DSN'] = list(map(int, architecture['DSN_1'][0].split('-'))) # layers of Drug Synergy Network 1
layers['SPN'] = list(map(int, architecture['SPN'][0].split('-'))) # layers of Synergy Prediction Network
# mm = MatchMaker(layers['DSN'], layers['SPN'], chem1.shape[1], cell_line.shape[1],
# args.in_drop, args.dropout)
# mm.to(device)
if args.train_test_mode == 'train':
#TODO remove features where there is no variation
train_dataset = MMDataset(cell_line, chem1, chem2, synergies, args.train_ind, train=True)
chem_scaler, cell_scaler = train_dataset.normalize()
train_dataset.calculate_weight()
valid_dataset = MMDataset(cell_line, chem1, chem2, synergies, args.val_ind)
valid_dataset.normalize(chem_scaler, cell_scaler)
debug(f'Train set: {len(train_dataset)}')
debug(f'Validation set: {len(valid_dataset)}')
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=0)
valid_loader = DataLoader(valid_dataset, batch_size=128, shuffle=True, num_workers=0)
drug_dim = train_dataset.chem1.shape[1]
cell_dim = train_dataset.cells.shape[1]
mm = MatchMaker(layers['DSN'], layers['SPN'], drug_dim, cell_dim, args.in_drop, args.dropout)
debug(mm)
mm.to(device)
start = datetime.datetime.now()
debug(f'Training starts at {start}')
train(mm, train_loader, valid_loader, logger, args.epoch,
args.patience, args.model_name, args.save_dir, device)
debug(f'Train time {datetime.datetime.now()-start}')
mm.load_state_dict(torch.load(os.path.join(args.save_dir, args.model_name)))
mm.eval()
test_dataset = MMDataset(cell_line, chem1, chem2, synergies, args.test_ind)
test_dataset.normalize(chem_scaler, cell_scaler)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=0)
debug(f'Test set: {len(test_dataset)}')
all_preds = predict(mm, test_loader, device)
mse_value = performance_metrics.mse(test_dataset.synergies, all_preds, debug)
spearman_value = performance_metrics.spearman(test_dataset.synergies, all_preds, debug)
pearson_value = performance_metrics.pearson(test_dataset.synergies, all_preds, debug)
df = pd.DataFrame()
df['preds'] = all_preds
df['loewe'] = test_dataset.synergies
df.to_csv(os.path.join(args.save_dir, 'mm-pytorch-preds.csv'), index=False)
info(f"Pearson correlation: {pearson_value}")
info(f"Spearman correlation: {spearman_value}")
info(f"Mean squared error: {mse_value}")
def main(opts):
# Create the data loader
# loader = sunnerData.DataLoader(sunnerData.ImageDataset(
# root=[[opts.path]],
# transforms=transforms.Compose([
# sunnertransforms.Resize((1024, 1024)),
# sunnertransforms.ToTensor(),
# sunnertransforms.ToFloat(),
# #sunnertransforms.Transpose(sunnertransforms.BHWC2BCHW),
# sunnertransforms.Normalize(),
# ])),
# batch_size=opts.batch_size,
# shuffle=True,
# )
loader = data_loader(opts.path)
device = fluid.CUDAPlace(0) if opts.device == 'GPU' else fluid.CPUPlace(0)
with fluid.dygraph.guard(device):
# Create the model
start_epoch = 0
G = StyleGenerator()
D = StyleDiscriminator()
# Load the pre-trained weight
if os.path.exists(opts.resume):
INFO("Load the pre-trained weight!")
#state = fluid.dygraph.load_dygraph(opts.resume)
state = load_checkpoint(opts.resume)
G.load_dict(state['G'])
D.load_dict(state['D'])
start_epoch = state['start_epoch']
else:
INFO(
"Pre-trained weight cannot load successfully, train from scratch!"
)
# # Multi-GPU support
# if torch.cuda.device_count() > 1:
# INFO("Multiple GPU:" + str(torch.cuda.device_count()) + "\t GPUs")
# G = nn.DataParallel(G)
# D = nn.DataParallel(D)
scheduler_D = exponential_decay(learning_rate=0.00001,
decay_steps=1000,
decay_rate=0.99)
scheduler_G = exponential_decay(learning_rate=0.00001,
decay_steps=1000,
decay_rate=0.99)
optim_D = optim.Adam(parameter_list=D.parameters(),
learning_rate=scheduler_D)
optim_G = optim.Adam(parameter_list=G.parameters(),
learning_rate=scheduler_G)
# Train
fix_z = np.random.randn(opts.batch_size, 512)
fix_z = dygraph.to_variable(fix_z)
softplus = SoftPlus()
Loss_D_list = [0.0]
Loss_G_list = [0.0]
D.train()
G.train()
for ep in range(start_epoch, opts.epoch):
bar = tqdm(loader())
loss_D_list = []
loss_G_list = []
for i, data in enumerate(bar):
# =======================================================================================================
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
# =======================================================================================================
# Compute adversarial loss toward discriminator
real_img = np.array([item for item in data],
dtype='float32').reshape(
(-1, 3, 1024, 1024))
D.clear_gradients()
real_img = dygraph.to_variable(real_img)
real_logit = D(real_img)
z = np.float32(np.random.randn(real_img.shape[0], 512))
fake_img = G(dygraph.to_variable(z))
fake_logit = D(fake_img)
d_loss = layers.mean(softplus(fake_logit))
d_loss = d_loss + layers.mean(softplus(-real_logit))
if opts.r1_gamma != 0.0:
r1_penalty = R1Penalty(real_img, D)
d_loss = d_loss + r1_penalty * (opts.r1_gamma * 0.5)
if opts.r2_gamma != 0.0:
r2_penalty = R2Penalty(fake_img, D)
d_loss = d_loss + r2_penalty * (opts.r2_gamma * 0.5)
loss_D_list.append(d_loss.numpy())
# Update discriminator
d_loss.backward()
optim_D.minimize(d_loss)
# =======================================================================================================
# (2) Update G network: maximize log(D(G(z)))
# =======================================================================================================
if i % CRITIC_ITER == 0:
G.clear_gradients()
fake_logit = D(fake_img.detach())
g_loss = layers.mean(softplus(-fake_logit))
#print("g_loss",g_loss)
loss_G_list.append(g_loss.numpy())
# Update generator
g_loss.backward()
optim_G.minimize(g_loss)
# Output training stats
bar.set_description("Epoch {} [{}, {}] [G]: {} [D]: {}".format(
ep, i + 1, 52000, loss_G_list[-1], loss_D_list[-1]))
# Save the result
Loss_G_list.append(np.mean(loss_G_list))
Loss_D_list.append(np.mean(loss_D_list))
# Check how the generator is doing by saving G's output on fixed_noise
G.eval()
#fake_img = G(fix_z).detach().cpu()
fake_img = G(fix_z).numpy().squeeze()
log(f"fake_img.shape: {fake_img.shape}")
save_image(fake_img,
os.path.join(opts.det, 'images',
str(ep) + '.png'))
G.train()
# Save model
# print("type:",type(G.state_dict()).__name__)
# print("type:",type(D.state_dict()).__name__)
states = {
'G': G.state_dict(),
'D': D.state_dict(),
'Loss_G': Loss_G_list,
'Loss_D': Loss_D_list,
'start_epoch': ep,
}
#dygraph.save_dygraph(state, os.path.join(opts.det, 'models', 'latest'))
save_checkpoint(states,
os.path.join(opts.det, 'models', 'latest.pp'))
# scheduler_D.step()
# scheduler_G.step()
# Plot the total loss curve
Loss_D_list = Loss_D_list[1:]
Loss_G_list = Loss_G_list[1:]
plotLossCurve(opts, Loss_D_list, Loss_G_list)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batch-size', default=50, type=int)
parser.add_argument('--dropout', default=0.5, type=float)
parser.add_argument('--epoch', default=20, type=int)
parser.add_argument('--learning-rate', default=0.1, type=float)
parser.add_argument("--mode",
default="non-static",
help="available models: rand, static, non-static")
parser.add_argument('--num-feature-maps', default=100, type=int)
parser.add_argument("--pretrained-word-vectors",
default="fasttext",
help="available models: fasttext, Word2Vec")
parser.add_argument("--save-word-vectors",
action='store_true',
default=False,
help='save trained word vectors')
parser.add_argument("--predict",
action='store_true',
default=False,
help='classify your sentence')
args = parser.parse_args()
# load data
print("Load data...\n")
texts, labels = dataset.load_data()
print("Tokenizing...\n")
tokenized_texts, word2idx, max_len = dataset.tokenize(texts)
input_ids = dataset.encode(tokenized_texts, word2idx, max_len)
train_inputs, val_inputs, train_labels, val_labels = train_test_split(
input_ids, labels, test_size=0.1, random_state=42)
print("Creating Dataloader...\n")
train_dataloader, val_dataloader = dataset.data_loader(
train_inputs,
val_inputs,
train_labels,
val_labels,
batch_size=args.batch_size)
if args.mode == 'rand':
# CNN-rand: Word vectors are randomly initialized.
train.set_seed(42)
cnn_model, optimizer = model.initilize_model(
vocab_size=len(word2idx),
embed_dim=300,
learning_rate=args.learning_rate,
dropout=args.dropout)
train.train(cnn_model,
optimizer,
train_dataloader,
val_dataloader,
epochs=args.epoch)
elif args.mode == 'static':
# CNN-static: fastText pretrained word vectors are used and freezed during training.
train.set_seed(42)
embeddings = pretrained_vectors.get_embeddings(
word2idx, args.pretrained_word_vectors)
cnn_model, optimizer = model.initilize_model(
pretrained_embedding=embeddings,
freeze_embedding=True,
learning_rate=args.learning_rate,
dropout=args.dropout)
train.train(cnn_model,
optimizer,
train_dataloader,
val_dataloader,
epochs=args.epoch)
else:
# CNN-non-static: fastText pretrained word vectors are fine-tuned during training.
train.set_seed(42)
embeddings = pretrained_vectors.get_embeddings(
word2idx, args.pretrained_word_vectors)
cnn_model, optimizer = model.initilize_model(
pretrained_embedding=embeddings,
freeze_embedding=False,
learning_rate=args.learning_rate,
dropout=args.dropout)
train.train(cnn_model,
optimizer,
train_dataloader,
val_dataloader,
epochs=args.epoch)
if args.save_word_vectors == True:
save_embeddings.write_embeddings(
'trained_embeddings_{}.txt'.format(args.mode),
cnn_model.embedding.weight.data, word2idx)
if args.predict == True:
x = input('영어 텍스트를 입력하세요! : ')
x = str(x)
train.predict(x, cnn_model, word2idx)
while True:
conti = input('계속하시겠습니까? (y/n) : ')
if conti == 'y':
x1 = input('영어 텍스트를 입력하세요! : ')
x1 = str(x1)
train.predict(x1, cnn_model, word2idx)
else:
break