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
