def get_loss_fn(self): if self.task_name in [ 'udc', 'atis_slot', 'atis_intent', 'mrda', 'swda' ]: return F.softmax_with_cross_entropy elif self.task_name == 'dstc2': return nn.BCEWithLogitsLoss(reduction='sum')
def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0, loss_weight=1.0): """ Initialize the GANLoss class. Args: gan_mode (str): the type of GAN objective. It currently supports vanilla, lsgan, and wgangp. target_real_label (bool): label for a real image target_fake_label (bool): label of a fake image Note: Do not use sigmoid as the last layer of Discriminator. LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss. """ super(GANLoss, self).__init__() # when loss weight less than zero return None if loss_weight <= 0: return None self.target_real_label = target_real_label self.target_fake_label = target_fake_label self.loss_weight = loss_weight self.gan_mode = gan_mode if gan_mode == 'lsgan': self.loss = nn.MSELoss() elif gan_mode == 'vanilla': self.loss = nn.BCEWithLogitsLoss() elif gan_mode in ['wgan', 'wgangp', 'hinge', 'logistic']: self.loss = None else: raise NotImplementedError('gan mode %s not implemented' % gan_mode)
def __init__(self, reduction='mean', loss_weight=1.0): # when loss weight less than zero return None if loss_weight <= 0: return None self._bce_loss = nn.BCEWithLogitsLoss(reduction=reduction) self.loss_weight = loss_weight self.reduction = reduction
def __init__(self, vocab_size, gen_weight, disc_weight): super(ElectraPretrainingCriterion, self).__init__() self.vocab_size = vocab_size self.gen_weight = gen_weight self.disc_weight = disc_weight self.gen_loss_fct = nn.CrossEntropyLoss(reduction='none') self.disc_loss_fct = nn.BCEWithLogitsLoss(reduction='none')
def __init__(self, model_config, compound_encoder): super(SupervisedModel, self).__init__() self.task_num = model_config['task_num'] self.compound_encoder = compound_encoder self.linear = nn.Linear(compound_encoder.graph_dim, self.task_num) self.criterion = nn.BCEWithLogitsLoss(reduction='none')
def __init__(self, model_config, compound_encoder): super(GeoPredModel, self).__init__() self.compound_encoder = compound_encoder self.hidden_size = model_config['hidden_size'] self.dropout_rate = model_config['dropout_rate'] self.act = model_config['act'] self.pretrain_tasks = model_config['pretrain_tasks'] # context mask if 'Cm' in self.pretrain_tasks: self.Cm_vocab = model_config['Cm_vocab'] self.Cm_linear = nn.Linear(compound_encoder.embed_dim, self.Cm_vocab + 3) self.Cm_loss = nn.CrossEntropyLoss() # functinal group self.Fg_linear = nn.Linear(compound_encoder.embed_dim, model_config['Fg_size']) # 494 self.Fg_loss = nn.BCEWithLogitsLoss() # bond angle with regression if 'Bar' in self.pretrain_tasks: self.Bar_mlp = MLP(2, hidden_size=self.hidden_size, act=self.act, in_size=compound_encoder.embed_dim * 3, out_size=1, dropout_rate=self.dropout_rate) self.Bar_loss = nn.SmoothL1Loss() # bond length with regression if 'Blr' in self.pretrain_tasks: self.Blr_mlp = MLP(2, hidden_size=self.hidden_size, act=self.act, in_size=compound_encoder.embed_dim * 2, out_size=1, dropout_rate=self.dropout_rate) self.Blr_loss = nn.SmoothL1Loss() # atom distance with classification if 'Adc' in self.pretrain_tasks: self.Adc_vocab = model_config['Adc_vocab'] self.Adc_mlp = MLP(2, hidden_size=self.hidden_size, in_size=self.compound_encoder.embed_dim * 2, act=self.act, out_size=self.Adc_vocab + 3, dropout_rate=self.dropout_rate) self.Adc_loss = nn.CrossEntropyLoss() print('[GeoPredModel] pretrain_tasks:%s' % str(self.pretrain_tasks))
def __init__(self, cfg): """Initialize the CycleGAN class. Parameters: opt (config)-- stores all the experiment flags; needs to be a subclass of Dict """ super(UGATITModel, self).__init__(cfg) # define networks (both Generators and discriminators) # The naming is different from those used in the paper. self.nets['genA2B'] = build_generator(cfg.model.generator) self.nets['genB2A'] = build_generator(cfg.model.generator) init_weights(self.nets['genA2B']) init_weights(self.nets['genB2A']) if self.is_train: # define discriminators self.nets['disGA'] = build_discriminator(cfg.model.discriminator_g) self.nets['disGB'] = build_discriminator(cfg.model.discriminator_g) self.nets['disLA'] = build_discriminator(cfg.model.discriminator_l) self.nets['disLB'] = build_discriminator(cfg.model.discriminator_l) init_weights(self.nets['disGA']) init_weights(self.nets['disGB']) init_weights(self.nets['disLA']) init_weights(self.nets['disLB']) if self.is_train: # define loss functions self.BCE_loss = nn.BCEWithLogitsLoss() self.L1_loss = nn.L1Loss() self.MSE_loss = nn.MSELoss() self.build_lr_scheduler() self.optimizers['optimizer_G'] = build_optimizer( cfg.optimizer, self.lr_scheduler, parameter_list=self.nets['genA2B'].parameters() + self.nets['genB2A'].parameters()) self.optimizers['optimizer_D'] = build_optimizer( cfg.optimizer, self.lr_scheduler, parameter_list=self.nets['disGA'].parameters() + self.nets['disGB'].parameters() + self.nets['disLA'].parameters() + self.nets['disLB'].parameters()) self.Rho_clipper = RhoClipper(0, 1)
def __init__(self, vocab, hidden_size, latent_size, embedding): super(JTNNDecoder, self).__init__() self.hidden_size = hidden_size self.vocab_size = vocab.size() self.vocab = vocab self.embedding = embedding latent_size = int(latent_size) self.W_z = nn.Linear(2 * hidden_size, hidden_size) self.U_r = nn.Linear(hidden_size, hidden_size, bias_attr=False) self.W_r = nn.Linear(hidden_size, hidden_size) self.W_h = nn.Linear(2 * hidden_size, hidden_size) self.W = nn.Linear(hidden_size + latent_size, hidden_size) self.U = nn.Linear(hidden_size + latent_size, hidden_size) self.U_i = nn.Linear(2 * hidden_size, hidden_size) self.W_o = nn.Linear(hidden_size, self.vocab_size) self.U_o = nn.Linear(hidden_size, 1) self.pred_loss = nn.CrossEntropyLoss(reduction='sum') self.stop_loss = nn.BCEWithLogitsLoss(reduction='sum')
def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0): """ Initialize the GANLoss class. Parameters: gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp. target_real_label (bool) - - label for a real image target_fake_label (bool) - - label of a fake image Note: Do not use sigmoid as the last layer of Discriminator. LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss. """ super(GANLoss, self).__init__() self.target_real_label = target_real_label self.target_fake_label = target_fake_label self.gan_mode = gan_mode if gan_mode == 'lsgan': self.loss = nn.MSELoss() elif gan_mode == 'vanilla': self.loss = nn.BCEWithLogitsLoss() elif gan_mode in ['wgangp']: self.loss = None else: raise NotImplementedError('gan mode %s not implemented' % gan_mode)
def __init__(self, ): super(BCELossForDuIE, self).__init__() self.criterion = nn.BCEWithLogitsLoss(reduction='none')
def run(args): print('Load data...') # get the data file path and name data_path = args.data_path + args.dataset + '/' # initializen distributed env if args.is_parallel == 1: dist.init_parallel_env() for fold in range(args.N_runs): print('><<><><><><><><><><><><><><><><><><><><><><><><><<><><><><><>') train_file = 'BindingDB_values_mixed_' + 'train_' + args.index + '_filter.csv' val_file = 'BindingDB_values_mixed_' + 'val_' + args.index + '_filter.csv' test_file = 'BindingDB_values_mixed_' + 'test_' + args.index + '_filter.csv' # load the data train_data = pd.read_csv(data_path + train_file) val_data = pd.read_csv(data_path + val_file) test_data = pd.read_csv(data_path + test_file) LEN_train = len(train_data) # load the mixed data if args.is_mixed: mixed_data_file = 'BindingDB_values_mixed_' + 'train_' + args.mixed_index + '_filter.csv' mixed_data = pd.read_csv(data_path + mixed_data_file) LEN_mixed0 = len(mixed_data) mixed_data_file1 = 'BindingDB_values_mixed_' + 'train_' + args.mixed_index1 + '_filter.csv' mixed_data1 = pd.read_csv(data_path + mixed_data_file1) # get the group qid_doc_map_train = group_by(train_data, 'groupID') query_idx_train = qid_doc_map_train.keys() train_keys = np.array(list(query_idx_train)) if args.is_mixed: id_doc_map_mixed = group_by(mixed_data, 'groupID') query_idx_mixed = id_doc_map_mixed.keys() mixed_keys = np.array(list(query_idx_mixed)) id_doc_map_mixed1 = group_by(mixed_data1, 'groupID') query_idx_mixed1 = id_doc_map_mixed1.keys() mixed_keys1 = np.array(list(query_idx_mixed1)) qid_doc_map_val = group_by(val_data, 'groupID') query_idx_val = qid_doc_map_val.keys() val_keys = np.array(list(query_idx_val)) qid_doc_map_test = group_by(test_data, 'groupID') query_idx_test = qid_doc_map_test.keys() test_keys = np.array(list(query_idx_test)) # get the true scores of train and mixed dataset true_scores = [ train_data.iloc[:, -1].values[qid_doc_map_train[qid]] for qid in query_idx_train ] if args.is_mixed: true_scores_mixed = [ mixed_data.iloc[:, -1].values[id_doc_map_mixed[qid]] for qid in query_idx_mixed ] true_scores_mixed1 = [ mixed_data1.iloc[:, -1].values[id_doc_map_mixed1[qid]] for qid in query_idx_mixed1 ] ###### get val/test dataloader val_index = [] for qid in val_keys: val_index.append(qid_doc_map_val[qid]) val_dataset = Data_test(val_index, val_data) val_dataloader = paddle.io.DataLoader(val_dataset, batch_size=args.test_batch_size, shuffle=False) test_index = [] for qid in test_keys: test_index.append(qid_doc_map_test[qid]) test_dataset = Data_test(test_index, test_data) test_dataloader = paddle.io.DataLoader(test_dataset, batch_size=args.test_batch_size, shuffle=False) if args.is_mixed: # concatenate the data train_data = train_data.append(mixed_data).append(mixed_data1) train_data = train_data.reset_index(drop=True) # Load model model = Model() if args.is_parallel == 1: model_parallel = paddle.DataParallel(model) else: model_parallel = model # define optimizer clip = nn.ClipGradByValue(min=-1, max=1) optimizer = paddle.optimizer.Adam(learning_rate=args.learning_rate, parameters=model.parameters(), grad_clip=clip) print('start to train the model...') for epoch in range(args.N_epoch): ##################### resampling the pairs for each epoch ##################### train_x1_index, train_x2_index, train_scores, Y_train = sample_pairs( true_scores, K=args.sampling_N_train, eps=args.filter_threshold, seed=epoch) if args.is_mixed: mixed_x1_index, mixed_x2_index, mixed_scores, Y_mixed = sample_pairs( true_scores_mixed, K=args.sampling_N_mixed, eps=args.filter_threshold, seed=epoch) mixed_x1_index1, mixed_x2_index1, mixed_scores1, Y_mixed1 = sample_pairs( true_scores_mixed1, K=args.sampling_N_mixed1, eps=args.filter_threshold, seed=epoch) # mixed all pairs from train and mixed dataset temp = LEN_train temp1 = LEN_mixed0 mixed_x1_index = [i + temp for i in mixed_x1_index] mixed_x2_index = [i + temp for i in mixed_x2_index] mixed_x1_index1 = [i + temp + temp1 for i in mixed_x1_index1] mixed_x2_index1 = [i + temp + temp1 for i in mixed_x2_index1] rain_x1_index = train_x1_index + mixed_x1_index + mixed_x1_index1 train_x2_index = train_x2_index + mixed_x2_index + mixed_x2_index1 Y_train = np.concatenate((Y_train, Y_mixed, Y_mixed1)) ##################### resampling the pairs for each epoch ##################### # get dataloader train_dataset = Data_Encoder_flow(train_x1_index, train_x2_index, Y_train, train_data) if args.is_parallel: train_batch_sampler = paddle.io.DistributedBatchSampler( train_dataset, batch_size=args.train_batch_size, shuffle=False) train_dataloader = paddle.io.DataLoader( train_dataset, batch_sampler=train_batch_sampler) else: train_dataloader = paddle.io.DataLoader( train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=23) LOSS = [] model.train() model_parallel.train() start_time = time.time() for batch_id, data in enumerate(train_dataloader()): batch_d1 = data[0] batch_t1 = data[1] batch_d2 = data[2] batch_t2 = data[3] batch_y = data[4] ###### define loss and optimization function loss_ = nn.BCEWithLogitsLoss() optimizer.clear_grad() res = model_parallel(batch_d1, batch_t1, batch_d2, batch_t2) batch_y.stop_gradient = False loss = loss_(res.squeeze(1), batch_y) loss.backward() optimizer.step() if batch_id % 100 == 0: print('batch {} loss {}'.format(batch_id, loss.numpy())) LOSS.append(float(loss.cpu().detach().numpy())) end_time = time.time() print('take time {}'.format(end_time - start_time)) print('epoch {}: loss: {} '.format(epoch, np.mean(LOSS))) # test print('val......') val_average_CI, val_weighted_CI = model_eval(model, val_dataloader) if epoch == 0: best_average_CI = val_weighted_CI test_average_CI, test_weighted_CI = model_eval( model, test_dataloader) # save the best epoch paddle.save(model.state_dict(), args.save_direct + 'train_model_best' + str(fold)) with open( args.save_direct + "best_results" + str(fold) + ".txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( '##############################################' + '\n') if (epoch != 0) & (val_weighted_CI >= best_average_CI): best_average_CI = val_weighted_CI test_average_CI, test_weighted_CI = model_eval( model, test_dataloader) # save the best epoch paddle.save(model.state_dict(), args.save_direct + 'train_model_best' + str(fold)) with open( args.save_direct + "best_results" + str(fold) + ".txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( '##############################################' + '\n') print( '###############################################################')
z = F.sigmoid(W_z(z_input)) r_1 = paddle.reshape(W_r(x), shape=[-1, 1, hidden_size]) r_2 = U_r(h_nei) r = F.sigmoid(r_1 + r_2) gated_h = r * h_nei sum_gated_h = paddle.sum(gated_h, axis=1) h_input = paddle.concat([x, sum_gated_h], axis=1) pre_h = F.tanh(W_h(h_input)) new_h = (1.0 - z) * sum_h + z * pre_h return new_h pred_loss = nn.CrossEntropyLoss(reduction='sum') stop_loss = nn.BCEWithLogitsLoss(reduction='sum') latent_size = 28 hidden_size = 450 MAX_NB = 15 embedding = nn.Embedding(531, hidden_size) W_z = nn.Linear(2 * hidden_size, hidden_size) U_r = nn.Linear(hidden_size, hidden_size, bias_attr=False) W_r = nn.Linear(hidden_size, hidden_size) W_h = nn.Linear(2 * hidden_size, hidden_size) W = nn.Linear(hidden_size + latent_size, hidden_size) # Stop Prediction Weights U = nn.Linear(hidden_size + latent_size, hidden_size) U_i = nn.Linear(2 * hidden_size, hidden_size) # Output Weights W_o = nn.Linear(hidden_size, 531) U_o = nn.Linear(hidden_size, 1)
def run(args): # initializen distributed env if args.is_parallel == 1: dist.init_parallel_env() data_path = args.data_path + args.dataset + '/' print('><<><><><><><><><><><><><><><><><><><><><><><><><<><><><><><>') train_file = 'BindingDB_values_mixed_' + 'train_' + args.index + '_filter.csv' val_file = 'BindingDB_values_mixed_' + 'val_' + args.index + '_filter.csv' test_file = 'BindingDB_values_mixed_' + 'test_' + args.index + '_filter.csv' # load the data r_train = pd.read_csv(data_path + train_file) r_train = r_train.reset_index(drop=True) r_val = pd.read_csv(data_path + val_file) r_val = r_val.reset_index(drop=True) r_test = pd.read_csv(data_path + test_file) r_test = r_test.reset_index(drop=True) # load the mixed data if args.is_mixed: mixed_data_file = 'BindingDB_values_mixed_' + 'train_' + args.mixed_index + '_filter.csv' r_mixed = pd.read_csv(data_path + mixed_data_file) r_mixed = r_mixed.reset_index(drop=True) mixed_data_file1 = 'BindingDB_values_mixed_' + 'train_' + args.mixed_index1 + '_filter.csv' r_mixed1 = pd.read_csv(data_path + mixed_data_file1) r_mixed1 = r_mixed1.reset_index(drop=True) print('Load data...') r_train = load_customised_BindingDB(r_train, groupID='groupID') r_val = load_customised_BindingDB(r_val, groupID='groupID') # r_train = load_customised_BindingDB(r_train,groupID='targetID') # r_val = load_customised_BindingDB(r_val,groupID='targetID') r_test = load_customised_BindingDB(r_test, groupID='groupID') LEN_train = len(r_train) print('number of train samples are {}'.format(len(r_train))) print('number of val samples are {}'.format(len(r_val))) print('number of test samples are {}'.format(len(r_test))) if args.is_mixed: r_mixed = load_customised_BindingDB(r_mixed) r_mixed1 = load_customised_BindingDB(r_mixed1) LEN_mixed0 = len(r_mixed) print('number of mixed samples are {}'.format(len(r_mixed))) print('number of mixed samples are {}'.format(len(r_mixed1))) print('Load done.\n') ###### get the protein group and index for train/val/test qid_doc_map_train = group_by(r_train, 0) query_idx_train = qid_doc_map_train.keys() train_keys = np.array(list(query_idx_train)) if args.is_mixed: id_doc_map_mixed = group_by(r_mixed, 0) query_idx_mixed = id_doc_map_mixed.keys() mixed_keys = np.array(list(query_idx_mixed)) id_doc_map_mixed1 = group_by(r_mixed1, 0) query_idx_mixed1 = id_doc_map_mixed1.keys() mixed_keys1 = np.array(list(query_idx_mixed1)) qid_doc_map_val = group_by(r_val, 0) query_idx_val = qid_doc_map_val.keys() val_keys = np.array(list(query_idx_val)) qid_doc_map_test = group_by(r_test, 0) query_idx_test = qid_doc_map_test.keys() test_keys = np.array(list(query_idx_test)) ###### get the protein group and index for train/val/test # get the true scores of train true_scores = [ r_train[qid_doc_map_train[qid], 1] for qid in query_idx_train ] if args.is_mixed: true_scores_mixed = [ r_mixed[id_doc_map_mixed[qid], 1] for qid in query_idx_mixed ] true_scores_mixed1 = [ r_mixed1[id_doc_map_mixed1[qid], 1] for qid in query_idx_mixed1 ] ###### get val/test dataloader val_index = [] for qid in val_keys: val_index.append(qid_doc_map_val[qid]) val_dataset = Data_test(val_index, r_val) val_dataloader = paddle.io.DataLoader(val_dataset, batch_size=args.test_batch_size, shuffle=False) test_index = [] for qid in test_keys: test_index.append(qid_doc_map_test[qid]) test_dataset = Data_test(test_index, r_test) test_dataloader = paddle.io.DataLoader(test_dataset, batch_size=args.test_batch_size, shuffle=False) if args.is_mixed: # concatenate the data r_train = np.concatenate((r_train, r_mixed, r_mixed1)) del r_mixed del r_mixed1 for fold in range(args.N_runs): # Load model model_config = json.load(open(args.model_config_path, 'r')) model = MolTransModel(model_config) len_SMILES = model_config['drug_max_seq'] len_target = model_config['target_max_seq'] if args.is_parallel == 1: model_parallel = paddle.DataParallel(model) else: model_parallel = model # define the optimizer clip = nn.ClipGradByValue(min=-1, max=1) optimizer = paddle.optimizer.AdamW( parameters=model_parallel.parameters(), weight_decay=0.01, learning_rate=args.learning_rate, grad_clip=clip) print('start to train the model...') for epoch in range(args.N_epoch): ##################### resampling the pairs for each epoch ##################### train_x1_index, train_x2_index, train_scores, Y_train = sample_pairs( true_scores, K=args.sampling_N_train, eps=args.filter_threshold, seed=epoch) print('Number of training dataset is {}'.format( len(train_x1_index))) if args.is_mixed: mixed_x1_index, mixed_x2_index, mixed_scores, Y_mixed = sample_pairs( true_scores_mixed, K=args.sampling_N_mixed, eps=args.filter_threshold, seed=epoch) mixed_x1_index1, mixed_x2_index1, mixed_scores1, Y_mixed1 = sample_pairs( true_scores_mixed1, K=args.sampling_N_mixed1, eps=args.filter_threshold, seed=epoch) print('Number of mixed dataset is {}'.format( len(mixed_x1_index))) print('Number of mixed dataset is {}'.format( len(mixed_x1_index1))) # mixed all pairs from train and mixed dataset temp = LEN_train temp1 = LEN_mixed0 mixed_x1_index = [i + temp for i in mixed_x1_index] mixed_x2_index = [i + temp for i in mixed_x2_index] mixed_x1_index1 = [i + temp + temp1 for i in mixed_x1_index1] mixed_x2_index1 = [i + temp + temp1 for i in mixed_x2_index1] train_x1_index = train_x1_index + mixed_x1_index + mixed_x1_index1 train_x2_index = train_x2_index + mixed_x2_index + mixed_x2_index1 Y_train = np.concatenate((Y_train, Y_mixed, Y_mixed1)) train_dataset = Data_Encoder_flow(train_x1_index, train_x2_index, Y_train, r_train) if args.is_parallel: train_batch_sampler = paddle.io.DistributedBatchSampler( train_dataset, batch_size=args.train_batch_size, shuffle=True) train_dataloader = paddle.io.DataLoader( train_dataset, batch_sampler=train_batch_sampler) else: train_dataloader = paddle.io.DataLoader( train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=23) ##################### resampling the pairs for each epoch ##################### print('***************train') LOSS = [] model.train() model_parallel.train() start_time = time.time() for batch_id, data in enumerate(train_dataloader()): batch_x1 = data[0] batch_x2 = data[1] batch_y = data[2] ###### define loss and optimization function loss_ = nn.BCEWithLogitsLoss() # split to smiles and protein batch_x1_smiles = batch_x1[:, 0:len_SMILES].astype('int64') batch_x1_protein = batch_x1[:, len_SMILES:len_SMILES + len_target].astype('int64') batch_x1_smiles_mask = batch_x1[:, len_SMILES + len_target:len_SMILES + len_target + len_SMILES].astype('int64') batch_x1_protein_mask = batch_x1[:, len_SMILES + len_target + len_SMILES:].astype('int64') batch_x2_smiles = batch_x2[:, 0:len_SMILES].astype('int64') batch_x2_protein = batch_x2[:, len_SMILES:len_SMILES + len_target].astype('int64') batch_x2_smiles_mask = batch_x2[:, len_SMILES + len_target:len_SMILES + len_target + len_SMILES].astype('int64') batch_x2_protein_mask = batch_x2[:, len_SMILES + len_target + len_SMILES:].astype('int64') optimizer.clear_grad() res = model_parallel(batch_x1_smiles, batch_x1_protein, batch_x2_smiles, batch_x2_protein, batch_x1_smiles_mask, batch_x1_protein_mask, batch_x2_smiles_mask, batch_x2_protein_mask) loss = loss_(res.squeeze(1), batch_y) loss.backward() optimizer.step() # scheduler.step() if batch_id % 100 == 0: print('batch {} loss {}'.format(batch_id, loss.numpy())) LOSS.append(loss.numpy()) end_time = time.time() print('take time {}'.format(end_time - start_time)) print('epoch {}: loss: {} '.format(epoch, np.mean(LOSS))) # test print('***************test') val_average_CI, val_weighted_CI = model_eval( model, val_dataloader, len_SMILES, len_target) if epoch == 0: best_average_CI = val_weighted_CI test_average_CI, test_weighted_CI = model_eval( model, test_dataloader, len_SMILES, len_target) # save the best epoch paddle.save(model.state_dict(), args.save_direct + 'train_model_best' + str(fold)) with open( args.save_direct + "best_results" + str(fold) + ".txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( '##############################################' + '\n') if (epoch != 0) & (val_weighted_CI >= best_average_CI): best_average_CI = val_weighted_CI test_average_CI, test_weighted_CI = model_eval( model, test_dataloader, len_SMILES, len_target) # save the best epoch paddle.save(model.state_dict(), args.save_direct + 'train_model_best' + str(fold)) with open( args.save_direct + "best_results" + str(fold) + ".txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( '##############################################' + '\n') print( '###############################################################')
def run(args): # initializen distributed env if args.is_parallel == 1: dist.init_parallel_env() data_path = args.data_path + args.dataset + '/' CVs = ['CV1', 'CV2', 'CV3', 'CV4', 'CV5'] for CV in CVs: print('><<><><><><><><><><><><><><><><><><><><><><><><><<><><><><><>') print('start {}'.format(CV)) ##################### load the data ############################ train_file = CV + '_' + args.dataset + '_' + args.split + '_' + 'train' + '.csv' val_file = CV + '_' + args.dataset + '_' + args.split + '_' + 'val' + '.csv' test = 'test_' + args.dataset + '_' + args.split + '.csv' print('Load data...') r_train = pd.read_csv(data_path + CV + '/' + train_file) r_train = r_train.reset_index(drop=True) r_val = pd.read_csv(data_path + CV + '/' + val_file) r_val = r_val.reset_index(drop=True) r_test = pd.read_csv(data_path + test) r_test = r_test.reset_index(drop=True) if args.is_mixed: # load the mixed data if args.dataset == 'DAVIS': mixed_dataset = 'KIBA' if args.dataset == 'KIBA': mixed_dataset = 'DAVIS' # load the mixed data mixed_data_file = mixed_dataset + '_mixed_train_unseenP_seenD.csv' mixed_data = pd.read_csv(data_path + mixed_data_file) mixed_data = mixed_data.reset_index(drop=True) # remove the repeated protein sequence val_t = r_val['Target Sequence'].unique() mixed_t = mixed_data['Target Sequence'].unique() filter1 = list((set(val_t).intersection(set(mixed_t)))) mixed_data = mixed_data[~mixed_data['Target Sequence'].isin(filter1 )] mixed_data = mixed_data.reset_index(drop=True) r_train = load_customised_Davis(r_train) r_val = load_customised_Davis(r_val) r_test = load_customised_Davis(r_test) if args.is_mixed: r_mixed = load_customised_Davis(mixed_data) LEN_train = len(r_train) print('number of train samples are {}'.format(len(r_train))) print('number of validation samples are {}'.format(len(r_val))) print('number of test samples are {}'.format(len(r_test))) if args.is_mixed: r_mixed = load_customised_Davis(mixed_data) print('number of mixed samples are {}'.format(len(r_mixed))) print('Load done.\n') if args.is_mixed: # concatenate the data r_train = np.concatenate((r_train, r_mixed)) ###### get the protein group and index for train/val/test qid_doc_map_train = group_by(r_train, 0) query_idx_train = qid_doc_map_train.keys() train_keys = np.array(list(query_idx_train)) if args.is_mixed: id_doc_map_mixed = group_by(r_mixed, 0) query_idx_mixed = id_doc_map_mixed.keys() mixed_keys = np.array(list(query_idx_mixed)) qid_doc_map_val = group_by(r_val, 0) query_idx_val = qid_doc_map_val.keys() val_keys = np.array(list(query_idx_val)) qid_doc_map_test = group_by(r_test, 0) query_idx_test = qid_doc_map_test.keys() test_keys = np.array(list(query_idx_test)) ###### get the protein group and index for train/val/test # get the true scores of train true_scores = [ r_train[qid_doc_map_train[qid], 1] for qid in query_idx_train ] if args.is_mixed: true_scores_mixed = [ r_mixed[id_doc_map_mixed[qid], 1] for qid in query_idx_mixed ] ###### get val/test dataloader val_index = [] for qid in val_keys: val_index.append(qid_doc_map_val[qid]) val_dataset = Data_test(val_index, r_val) val_dataloader = paddle.io.DataLoader(val_dataset, batch_size=args.test_batch_size, shuffle=True) test_index = [] for qid in test_keys: test_index.append(qid_doc_map_test[qid]) test_dataset = Data_test(test_index, r_test) test_dataloader = paddle.io.DataLoader(test_dataset, batch_size=args.test_batch_size, shuffle=True) # Load model model_config = json.load(open(args.model_config_path, 'r')) model = MolTransModel(model_config) len_SMILES = model_config['drug_max_seq'] len_target = model_config['target_max_seq'] if args.is_parallel == 1: model_parallel = paddle.DataParallel(model) else: model_parallel = model # define the optimizer optimizer = paddle.optimizer.AdamW( parameters=model_parallel.parameters(), weight_decay=0.01, learning_rate=args.learning_rate) print('start to train the model...') for epoch in range(args.N_epoch): ##################### resampling the pairs for each epoch ##################### train_x1_index, train_x2_index, train_scores, Y_train = sample_pairs( true_scores, K=args.sampling_N_train, eps=args.filter_threshold, seed=epoch) if args.is_mixed: mixed_x1_index, mixed_x2_index, mixed_scores, Y_mixed = sample_pairs( true_scores_mixed, K=args.sampling_N_mixed, eps=args.filter_threshold, seed=epoch) # mixed all pairs from train and mixed dataset temp = LEN_train mixed_x1_index = [i + temp for i in mixed_x1_index] mixed_x2_index = [i + temp for i in mixed_x2_index] train_x1_index = train_x1_index + mixed_x1_index train_x2_index = train_x2_index + mixed_x2_index Y_train = np.concatenate((Y_train, Y_mixed)) train_dataset = Data_Encoder_flow(train_x1_index, train_x2_index, Y_train, r_train) if args.is_parallel: train_batch_sampler = paddle.io.DistributedBatchSampler( train_dataset, batch_size=args.train_batch_size, shuffle=True) train_dataloader = paddle.io.DataLoader( train_dataset, batch_sampler=train_batch_sampler) else: train_dataloader = paddle.io.DataLoader( train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=23) ##################### resampling the pairs for each epoch ##################### print('***************train') LOSS = [] model.train() model_parallel.train() start_time = time.time() for batch_id, data in enumerate(train_dataloader()): batch_x1 = data[0] batch_x2 = data[1] batch_y = data[2] ###### define loss and optimization function loss_ = nn.BCEWithLogitsLoss() # split to smiles and protein batch_x1_smiles = batch_x1[:, 0:len_SMILES].astype('int64') batch_x1_protein = batch_x1[:, len_SMILES:len_SMILES + len_target].astype('int64') batch_x1_smiles_mask = batch_x1[:, len_SMILES + len_target:len_SMILES + len_target + len_SMILES].astype('int64') batch_x1_protein_mask = batch_x1[:, len_SMILES + len_target + len_SMILES:].astype('int64') batch_x2_smiles = batch_x2[:, 0:len_SMILES].astype('int64') batch_x2_protein = batch_x2[:, len_SMILES:len_SMILES + len_target].astype('int64') batch_x2_smiles_mask = batch_x2[:, len_SMILES + len_target:len_SMILES + len_target + len_SMILES].astype('int64') batch_x2_protein_mask = batch_x2[:, len_SMILES + len_target + len_SMILES:].astype('int64') optimizer.clear_grad() res = model_parallel(batch_x1_smiles, batch_x1_protein, batch_x2_smiles, batch_x2_protein, batch_x1_smiles_mask, batch_x1_protein_mask, batch_x2_smiles_mask, batch_x2_protein_mask) loss = loss_(res.squeeze(1), batch_y) loss.backward() optimizer.step() # scheduler.step() if batch_id % 100 == 0: print('batch {} loss {}'.format(batch_id, loss.numpy())) LOSS.append(loss.numpy()) end_time = time.time() print('take time {}'.format(end_time - start_time)) print('epoch {}: loss: {} '.format(epoch, np.mean(LOSS))) # validation print('***************validation') val_average_CI, val_weighted_CI, val_overall_CI = model_eval( model, val_dataloader, len_SMILES, len_target) # test print('***************test') test_average_CI, test_weighted_CI, test_overall_CI = model_eval( model, test_dataloader, len_SMILES, len_target) if epoch == 0: best_average_CI = val_average_CI # save the best epoch paddle.save(model.state_dict(), args.save_direct + CV + '_' + 'train_model_best') with open(args.save_direct + CV + '_' + "best_results.txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "val overall CI is {}".format(val_overall_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( "test overall CI is {}".format(test_overall_CI) + '\n') text_file.write( '##############################################' + '\n') if (epoch != 0) & (val_average_CI >= best_average_CI): best_average_CI = val_average_CI # save the best epoch paddle.save(model.state_dict(), args.save_direct + CV + '_' + 'train_model_best') with open(args.save_direct + CV + '_' + "best_results.txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "val overall CI is {}".format(val_overall_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( "test overall CI is {}".format(test_overall_CI) + '\n') text_file.write( '##############################################' + '\n') print( '###############################################################')
def run(args): # initializen distributed env if args.is_parallel == 1: dist.init_parallel_env() CVs = ['CV1', 'CV2', 'CV3', 'CV4', 'CV5'] data_path = args.data_path + args.dataset + '/' for CV in CVs: print('><<><><><><><><><><><><><><><><><><><><><><><><><<><><><><><>') print('start {}'.format(CV)) ##################### load the data ############################ train_file = CV + '_' + args.dataset + '_' + args.split + '_' + 'train' + '.csv' val_file = CV + '_' + args.dataset + '_' + args.split + '_' + 'val' + '.csv' test = 'test_' + args.dataset + '_' + args.split + '.csv' # mixed_data_file = 'DAVIS_mixed_train_unseenP_seenD.csv' # load the data train_data = pd.read_csv(data_path + CV + '/' + train_file) train_data = train_data.reset_index(drop=True) val_data = pd.read_csv(data_path + CV + '/' + val_file) val_data = val_data.reset_index(drop=True) test_data = pd.read_csv(data_path + test) test_data = test_data.reset_index(drop=True) if args.is_mixed: # load the mixed data if args.dataset == 'DAVIS': mixed_dataset = 'KIBA' if args.dataset == 'KIBA': mixed_dataset = 'DAVIS' mixed_data_file = mixed_dataset + '_mixed_train_unseenP_seenD.csv' mixed_data = pd.read_csv(data_path + mixed_data_file) mixed_data = mixed_data.reset_index(drop=True) # remove the repeated protein sequence train_t = train_data['Target Sequence'].unique() val_t = val_data['Target Sequence'].unique() test_t = test_data['Target Sequence'].unique() mixed_t = mixed_data['Target Sequence'].unique() filter1 = list((set(val_t).intersection(set(mixed_t)))) mixed_data = mixed_data[~mixed_data['Target Sequence'].isin(filter1 )] # concatenate the data train_data_ALL = train_data.append(mixed_data) train_data_ALL = train_data_ALL.reset_index(drop=True) # get the group qid_doc_map_train = group_by(train_data, 'Target ID') query_idx_train = qid_doc_map_train.keys() train_keys = np.array(list(query_idx_train)) qid_doc_map_val = group_by(val_data, 'Target ID') query_idx_val = qid_doc_map_val.keys() val_keys = np.array(list(query_idx_val)) qid_doc_map_mixed = group_by(mixed_data, 'Target ID') query_idx_mixed = qid_doc_map_mixed.keys() mixed_keys = np.array(list(query_idx_mixed)) qid_doc_map_test = group_by(test_data, 'Target ID') query_idx_test = qid_doc_map_test.keys() test_keys = np.array(list(query_idx_test)) ###### get the protein group and index for train/val/test # get the true scores of train true_scores = [ train_data['Label'].values[qid_doc_map_train[qid]] for qid in query_idx_train ] if args.is_mixed: true_scores_mixed = [ mixed_data['Label'].values[qid_doc_map_mixed[qid]] for qid in query_idx_mixed ] ###### get val/test dataloader val_index = [] for qid in val_keys: val_index.append(qid_doc_map_val[qid]) val_dataset = Data_test(val_index, val_data) val_dataloader = paddle.io.DataLoader(val_dataset, batch_size=args.test_batch_size, shuffle=True) test_index = [] for qid in test_keys: test_index.append(qid_doc_map_test[qid]) test_dataset = Data_test(test_index, test_data) test_dataloader = paddle.io.DataLoader(test_dataset, batch_size=args.test_batch_size, shuffle=True) # Load model model = Model() if args.is_parallel == 1: model_parallel = paddle.DataParallel(model) else: args.model_parallel = model # define optimizer optimizer = paddle.optimizer.Adam(learning_rate=args.learning_rate, parameters=model.parameters()) print('start to train the model...') for epoch in range(args.N_epoch): ##################### resampling the pairs for each epoch ##################### train_x1_index, train_x2_index, train_scores, Y_train = sample_pairs( true_scores, K=args.sampling_N_train, eps=args.filter_threshold, seed=epoch) if args.is_mixed: mixed_x1_index, mixed_x2_index, mixed_scores, Y_mixed = sample_pairs( true_scores_mixed, K=args.sampling_N_mixed, eps=args.filter_threshold, seed=epoch) ##################### resampling the pairs for each epoch ##################### # mixed all pairs from train and mixed dataset len_train = len(train_x1_index) temp = len(train_data) if args.is_mixed: mixed_x1_index = [i + temp for i in mixed_x1_index] mixed_x2_index = [i + temp for i in mixed_x2_index] train_x1_index = train_x1_index + mixed_x1_index train_x2_index = train_x2_index + mixed_x2_index Y_train_data = np.concatenate((Y_train, Y_mixed)) # get dataloader train_dataset = Data_Encoder_flow(train_x1_index, train_x2_index, Y_train_data, train_data_ALL) if args.is_parallel: train_batch_sampler = paddle.io.DistributedBatchSampler( train_dataset, batch_size=args.train_batch_size, shuffle=True) train_dataloader = paddle.io.DataLoader( train_dataset, batch_sampler=train_batch_sampler) else: train_dataloader = paddle.io.DataLoader( train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=23) LOSS = [] model.train() model_parallel.train() start_time = time.time() for batch_id, data in enumerate(train_dataloader()): batch_d1 = data[0] batch_t1 = data[1] batch_d2 = data[2] batch_t2 = data[3] batch_y = data[4] ###### define loss and optimization function loss_ = nn.BCEWithLogitsLoss() optimizer.clear_grad() res = model_parallel(batch_d1, batch_t1, batch_d2, batch_t2) loss = loss_(res.squeeze(1), batch_y) loss.backward() optimizer.step() if batch_id % 100 == 0: print('batch {} loss {}'.format(batch_id, loss.numpy())) LOSS.append(loss.numpy()) end_time = time.time() print('take time {}'.format(end_time - start_time)) print('epoch {}: loss: {} '.format(epoch, np.mean(LOSS))) # validation print('validation......') val_average_CI, val_weighted_CI = model_eval(model, val_dataloader) # test print('test......') test_average_CI, test_weighted_CI = model_eval( model, test_dataloader) if epoch == 0: best_average_CI = val_average_CI # save the best epoch paddle.save(model.state_dict(), args.save_direct + CV + '_' + 'train_model_best') with open(args.save_direct + CV + '_' + "best_results.txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( '##############################################' + '\n') if (epoch != 0) & (val_average_CI >= best_average_CI): best_average_CI = val_average_CI # save the best epoch paddle.save(model.state_dict(), args.save_direct + CV + '_' + 'train_model_best') with open(args.save_direct + CV + '_' + "best_results.txt", "w") as text_file: text_file.write( 'epoch {}: loss: {} '.format(epoch, np.mean(LOSS)) + '\n') text_file.write( "val Average CI is {}".format(val_average_CI) + '\n') text_file.write( "val weighted CI is {}".format(val_weighted_CI) + '\n') text_file.write( "test Average CI is {}".format(test_average_CI) + '\n') text_file.write( "test weighted CI is {}".format(test_weighted_CI) + '\n') text_file.write( '##############################################' + '\n') print( '###############################################################')
def __init__( self, num_classes, width=1.0, strides=[8, 16, 32], in_channels=[256, 512, 1024], act="silu", depthwise=False, iou_loss=None, yolo_loss=None, nms_cfg=None, prior_prob=0.01, is_train=False, ): """ Args: act (str): activation type of conv. Defalut value: "silu". depthwise (bool): whether apply depthwise conv in conv branch. Defalut value: False. """ super().__init__() self.n_anchors = 1 # self.is_train = is_train self.num_classes = num_classes self.decode_in_inference = True # for deploy, set to False self.cls_convs = nn.LayerList() self.reg_convs = nn.LayerList() self.cls_preds = nn.LayerList() self.reg_preds = nn.LayerList() self.obj_preds = nn.LayerList() self.stems = nn.LayerList() Conv = DWConv if depthwise else BaseConv self.prior_prob = prior_prob # 类别分支最后的卷积。设置偏移的初始值使得各类别预测概率初始值为self.prior_prob (根据激活函数是sigmoid()时推导出,和RetinaNet中一样) bias_init_value = -math.log((1 - self.prior_prob) / self.prior_prob) for i in range(len(in_channels)): self.stems.append( BaseConv( in_channels=int(in_channels[i] * width), out_channels=int(256 * width), ksize=1, stride=1, act=act, )) self.cls_convs.append( nn.Sequential(*[ Conv( in_channels=int(256 * width), out_channels=int(256 * width), ksize=3, stride=1, act=act, ), Conv( in_channels=int(256 * width), out_channels=int(256 * width), ksize=3, stride=1, act=act, ), ])) self.reg_convs.append( nn.Sequential(*[ Conv( in_channels=int(256 * width), out_channels=int(256 * width), ksize=3, stride=1, act=act, ), Conv( in_channels=int(256 * width), out_channels=int(256 * width), ksize=3, stride=1, act=act, ), ])) battr1 = ParamAttr( initializer=Constant(bias_init_value), regularizer=L2Decay(0.) ) # 不可以加正则化的参数:norm层(比如bn层、affine_channel层、gn层)的scale、offset;卷积层的偏移参数。 cls_pred_conv = nn.Conv2D(in_channels=int(256 * width), out_channels=self.n_anchors * self.num_classes, kernel_size=1, stride=1, padding=0, bias_attr=battr1) self.cls_preds.append(cls_pred_conv) battr2 = ParamAttr( initializer=Constant(bias_init_value), regularizer=L2Decay(0.) ) # 不可以加正则化的参数:norm层(比如bn层、affine_channel层、gn层)的scale、offset;卷积层的偏移参数。 reg_pred_conv = nn.Conv2D(in_channels=int(256 * width), out_channels=4, kernel_size=1, stride=1, padding=0, bias_attr=battr2) self.reg_preds.append(reg_pred_conv) self.obj_preds.append( nn.Conv2D( in_channels=int(256 * width), out_channels=self.n_anchors * 1, kernel_size=1, stride=1, padding=0, )) self.use_l1 = False self.l1_loss = nn.L1Loss(reduction="none") self.bcewithlog_loss = nn.BCEWithLogitsLoss(reduction="none") self.iou_loss = iou_loss self.strides = strides self.grids = [paddle.zeros((1, ))] * len(in_channels) self.yolo_loss = yolo_loss self.nms_cfg = nms_cfg