def __init__(self, opt):
BaseModel.__init__(self, opt)
def __init__(self, *args, **kwargs):
"""Initiating the Review class"""
if (args and type(args) is dict):
BaseModel.__init__(self, args[0])
else:
BaseModel.__init__(self)
def __init__(self, **kwargs):
""" constructor sends the values for the object to be created from BaseModel """
BaseModel.__init__(self, **kwargs)
def __init__(self, model_params):
BaseModel.__init__(self, model_params)
self.data_iter = DataIter(self.model_params.batch_size)
self.tar_video = tf.placeholder(
tf.float32, [None, 64, self.model_params.visual_feat_dim]) # 64
self.tar_img = tf.placeholder(tf.float32,
[None, self.model_params.word_vec_dim])
self.neg_img = tf.placeholder(tf.int32, [
self.model_params.batch_size,
])
self.y = tf.placeholder(tf.int32,
[self.model_params.batch_size, 18]) # 10
self.y_single = tf.placeholder(tf.int32,
[self.model_params.batch_size, 1])
self.l = tf.placeholder(tf.float32, [])
self.trans = tf.placeholder(tf.float32, [None, 64, 64])
self.emb_matrix = self.matrix_embed(
self.tar_video) # batch_size*(100,64)
self.emb_w = self.label_embed(self.tar_img)
self.emb_v = self.visual_embed(self.emb_matrix[0])
for i in range(1, self.model_params.batch_size):
M = self.visual_embed(self.emb_matrix[i], reuse=True)
self.emb_v = tf.concat([self.emb_v, M], axis=0)
# triplet loss
idata = []
for i in range(self.model_params.batch_size):
em_w = self.emb_w[i] / tf.norm(self.emb_w[i])
x = tf.matmul(tf.reshape(em_w, [64, 1]), tf.reshape(em_w, [1, 64]))
y = tf.concat([x[k] for k in range(64)], axis=0)
idata.append(y)
self.trans, tran2 = self.transpose(self.emb_matrix)
tran2 = tf.stop_gradient(tran2)
margin = self.model_params.margin
self.triplet_loss = self.tripletloss(idata,
self.trans / tf.norm(self.trans),
margin)
self.logits_w = self.label_classifier(self.emb_w)
self.logits_v = self.label_classifier(self.emb_v, reuse=True)
self.label_loss1 = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=self.y,
logits=self.logits_v))
self.label_loss2 = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=self.y,
logits=self.logits_w))
self.trans_loss = tf.reduce_mean(tran2 - self.trans)
self.emb_loss = 0.01 * self.label_loss1 + self.label_loss2 + 10 * self.triplet_loss + self.model_params.alpha * self.trans_loss
self.emb_v_class = self.domain_classifier(self.emb_v, self.l)
self.emb_w_class = self.domain_classifier(self.emb_w,
self.l,
reuse=True)
all_emb_v = tf.concat([
tf.ones([self.model_params.batch_size, 1]),
tf.zeros([self.model_params.batch_size, 1])
], 1)
all_emb_w = tf.concat([
tf.zeros([self.model_params.batch_size, 1]),
tf.ones([self.model_params.batch_size, 1])
], 1)
self.domain_class_loss = tf.nn.softmax_cross_entropy_with_logits(logits=self.emb_v_class, labels=all_emb_w) + \
tf.nn.softmax_cross_entropy_with_logits(logits=self.emb_w_class, labels=all_emb_v)
self.domain_class_loss = tf.reduce_mean(self.domain_class_loss)
self.t_vars = tf.trainable_variables()
self.vf1_vars = [v for v in self.t_vars if 'vf1_' in v.name]
self.vf_vars = [v for v in self.t_vars if 'vf_' in v.name]
self.le_vars = [v for v in self.t_vars if 'le_' in v.name]
self.dc_vars = [v for v in self.t_vars if 'dc_' in v.name]
self.lc_vars = [v for v in self.t_vars if 'lc_' in v.name]
self.rf_vars = [v for v in self.t_vars if 'rf_' in v.name]
def __init__(self, config):
BaseModel.__init__(self, config)
def __init__(self, opt):
"""Initialize the pix2pix class.
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
assert opt.isTrain
BaseModel.__init__(self, opt)
# specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
self.loss_names = ['G_gan', 'G_recon', 'D_real', 'D_fake']
# specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
self.visual_names = ['real_A', 'fake_B', 'real_B']
# specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>
self.model_names = ['G', 'D']
# define networks (both generator and discriminator)
self.netG = networks.define_G(opt.netG,
input_nc=opt.input_nc,
output_nc=opt.output_nc,
ngf=opt.ngf,
norm=opt.norm,
dropout_rate=opt.dropout_rate,
init_type=opt.init_type,
init_gain=opt.init_gain,
gpu_ids=self.gpu_ids,
opt=opt)
self.netD = networks.define_D(opt.netD,
input_nc=opt.input_nc + opt.output_nc,
ndf=opt.ndf,
n_layers_D=opt.n_layers_D,
norm=opt.norm,
init_type=opt.init_type,
init_gain=opt.init_gain,
gpu_ids=self.gpu_ids,
opt=opt)
# define loss functions
self.criterionGAN = GANLoss(opt.gan_mode).to(self.device)
if opt.recon_loss_type == 'l1':
self.criterionRecon = torch.nn.L1Loss()
elif opt.recon_loss_type == 'l2':
self.criterionRecon = torch.nn.MSELoss()
elif opt.recon_loss_type == 'smooth_l1':
self.criterionRecon = torch.nn.SmoothL1Loss()
else:
raise NotImplementedError(
'Unknown reconstruction loss type [%s]!' % opt.loss_type)
# initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
self.optimizer_G = torch.optim.Adam(self.netG.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(self.netD.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizers = []
self.optimizers.append(self.optimizer_G)
self.optimizers.append(self.optimizer_D)
self.eval_dataloader = create_eval_dataloader(self.opt)
block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[2048]
self.inception_model = InceptionV3([block_idx])
self.inception_model.to(self.device)
self.inception_model.eval()
if 'cityscapes' in opt.dataroot:
self.drn_model = DRNSeg('drn_d_105', 19, pretrained=False)
util.load_network(self.drn_model, opt.drn_path, verbose=False)
if len(opt.gpu_ids) > 0:
self.drn_model.to(self.device)
self.drn_model = nn.DataParallel(self.drn_model, opt.gpu_ids)
self.drn_model.eval()
self.best_fid = 1e9
self.best_mIoU = -1e9
self.fids, self.mIoUs = [], []
self.is_best = False
self.Tacts, self.Sacts = {}, {}
self.npz = np.load(opt.real_stat_path)
def __init__(self, model_params):
BaseModel.__init__(self, model_params)
self.data_iter = DataIter(self.model_params.batch_size)
self.tar_img = tf.placeholder(
tf.float32, [None, self.model_params.visual_feat_dim])
self.tar_txt = tf.placeholder(tf.float32,
[None, self.model_params.word_vec_dim])
self.pos_img = tf.placeholder(
tf.float32, [None, self.model_params.visual_feat_dim])
self.neg_img = tf.placeholder(
tf.float32, [None, self.model_params.visual_feat_dim])
self.pos_txt = tf.placeholder(tf.float32,
[None, self.model_params.word_vec_dim])
self.neg_txt = tf.placeholder(tf.float32,
[None, self.model_params.word_vec_dim])
self.y = tf.placeholder(tf.int32, [self.model_params.batch_size, 10])
self.y_single = tf.placeholder(tf.int32,
[self.model_params.batch_size, 1])
self.l = tf.placeholder(tf.float32, [])
self.emb_v = self.visual_feature_embed(self.tar_img)
self.emb_w = self.label_embed(self.tar_txt)
self.emb_v_pos = self.visual_feature_embed(self.pos_img, reuse=True)
self.emb_v_neg = self.visual_feature_embed(self.neg_img, reuse=True)
self.emb_w_pos = self.label_embed(self.pos_txt, reuse=True)
self.emb_w_neg = self.label_embed(self.neg_txt, reuse=True)
# triplet loss
margin = self.model_params.margin
alpha = self.model_params.alpha
v_loss_pos = tf.reduce_sum(tf.nn.l2_loss(self.emb_v - self.emb_w_pos))
v_loss_neg = tf.reduce_sum(tf.nn.l2_loss(self.emb_v - self.emb_w_neg))
w_loss_pos = tf.reduce_sum(tf.nn.l2_loss(self.emb_w - self.emb_v_pos))
w_loss_neg = tf.reduce_sum(tf.nn.l2_loss(self.emb_w - self.emb_v_neg))
self.triplet_loss = tf.maximum(
0., margin + alpha * v_loss_pos - v_loss_neg) + tf.maximum(
0., margin + alpha * w_loss_pos - w_loss_neg)
logits_v = self.label_classifier(self.emb_v)
logits_w = self.label_classifier(self.emb_w, reuse=True)
self.label_loss = tf.nn.softmax_cross_entropy_with_logits(labels=self.y, logits=logits_v) + \
tf.nn.softmax_cross_entropy_with_logits(labels=self.y, logits=logits_w)
self.label_loss = tf.reduce_mean(self.label_loss)
self.emb_loss = 100 * self.label_loss + self.triplet_loss
self.emb_v_class = self.domain_classifier(self.emb_v, self.l)
self.emb_w_class = self.domain_classifier(self.emb_w,
self.l,
reuse=True)
all_emb_v = tf.concat([
tf.ones([self.model_params.batch_size, 1]),
tf.zeros([self.model_params.batch_size, 1])
], 1)
all_emb_w = tf.concat([
tf.zeros([self.model_params.batch_size, 1]),
tf.ones([self.model_params.batch_size, 1])
], 1)
self.domain_class_loss = tf.nn.softmax_cross_entropy_with_logits(logits=self.emb_v_class, labels=all_emb_w) + \
tf.nn.softmax_cross_entropy_with_logits(logits=self.emb_w_class, labels=all_emb_v)
self.domain_class_loss = tf.reduce_mean(self.domain_class_loss)
self.t_vars = tf.trainable_variables()
self.vf_vars = [v for v in self.t_vars if 'vf_' in v.name]
self.le_vars = [v for v in self.t_vars if 'le_' in v.name]
self.dc_vars = [v for v in self.t_vars if 'dc_' in v.name]
self.lc_vars = [v for v in self.t_vars if 'lc_' in v.name]
def testArgs(self):
'''No arguments'''
with self.assertRaises(TypeError) as e:
BaseModel.__init__()
msg = "__init__() missing 1 required positional argument: 'self'"
self.assertEqual(str(e.exception), msg)
def __init__(self, opt): BaseModel.__init__(self, opt) # call the initialization method of BaseModel # specify the images you want to save and display. The program will call base_model.get_current_visuals to save and display these images. self.visual_names = []
def __init__(self, *args, **kwargs):
if args and type(args[0]) is dict:
BaseModel.__init__(self, args[0])
else:
BaseModel.__init__(self)
def __init__(self, *args, **kwargs):
""" initializes parent class """
if args and type(args[0]) is dict:
BaseModel.__init__(self, args[0])
else:
BaseModel.__init__(self)
def test_init_no_args(self):
"""Tests __init__ with no arguments."""
with self.assertRaises(TypeError) as e:
BaseModel.__init__()
msj = "__init__() missing 1 required positional argument: 'self'"
self.assertEqual(str(e.exception), msj)
def __init__(self, *args, **kwargs):
""" init method
"""
BaseModel.__init__(self, *args, **kwargs)
def __init__(self, data_layer):
BaseModel.__init__(self, 'archive', data_layer, {}, ItemValidator())
def __init__(self, opt):
"""Initialize the CycleGAN class.
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
assert opt.isTrain
assert opt.direction == 'AtoB'
assert opt.dataset_mode == 'unaligned'
BaseModel.__init__(self, opt)
# specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
self.loss_names = [
'D_A', 'G_A', 'G_cycle_A', 'G_idt_A', 'D_B', 'G_B', 'G_cycle_B',
'G_idt_B'
]
# specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
visual_names_A = ['real_A', 'fake_B', 'rec_A']
visual_names_B = ['real_B', 'fake_A', 'rec_B']
if self.opt.lambda_identity > 0.0: # if identity loss is used, we also visualize idt_B=G_A(B) ad idt_A=G_A(B)
visual_names_A.append('idt_B')
visual_names_B.append('idt_A')
self.visual_names = visual_names_A + visual_names_B # combine visualizations for A and B
# specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>.
self.model_names = ['G_A', 'G_B', 'D_A', 'D_B']
# define networks (both Generators and discriminators)
# The naming is different from those used in the paper.
# Code (vs. paper): G_A (G), G_B (F), D_A (D_Y), D_B (D_X)
self.netG_A = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf,
opt.netG, opt.norm, opt.dropout_rate,
opt.init_type, opt.init_gain,
self.gpu_ids)
self.netG_B = networks.define_G(opt.output_nc, opt.input_nc, opt.ngf,
opt.netG, opt.norm, opt.dropout_rate,
opt.init_type, opt.init_gain,
self.gpu_ids)
self.netD_A = networks.define_D(opt.output_nc, opt.ndf, opt.netD,
opt.n_layers_D, opt.norm,
opt.init_type, opt.init_gain,
self.gpu_ids)
self.netD_B = networks.define_D(opt.input_nc, opt.ndf, opt.netD,
opt.n_layers_D, opt.norm,
opt.init_type, opt.init_gain,
self.gpu_ids)
if opt.lambda_identity > 0.0: # only works when input and output images have the same number of channels
assert (opt.input_nc == opt.output_nc)
self.fake_A_pool = ImagePool(
opt.pool_size
) # create image buffer to store previously generated images
self.fake_B_pool = ImagePool(
opt.pool_size
) # create image buffer to store previously generated images
# define loss functions
self.criterionGAN = models.modules.loss.GANLoss(opt.gan_mode).to(
self.device) # define GAN loss.
self.criterionCycle = torch.nn.L1Loss()
self.criterionIdt = torch.nn.L1Loss()
# initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
self.optimizer_G = torch.optim.Adam(itertools.chain(
self.netG_A.parameters(), self.netG_B.parameters()),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(
self.netD_A.parameters(), self.netD_B.parameters()),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizers = []
self.optimizers.append(self.optimizer_G)
self.optimizers.append(self.optimizer_D)
self.eval_dataloader_AtoB = create_eval_dataloader(self.opt,
direction='AtoB')
self.eval_dataloader_BtoA = create_eval_dataloader(self.opt,
direction='BtoA')
block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[2048]
self.inception_model = InceptionV3([block_idx])
self.inception_model.to(self.device)
self.inception_model.eval()
if 'cityscapes' in opt.dataroot:
self.drn_model = DRNSeg('drn_d_105', 19, pretrained=False)
util.load_network(self.drn_model, opt.drn_path, verbose=False)
if len(opt.gpu_ids) > 0:
self.drn_model = nn.DataParallel(self.drn_model, opt.gpu_ids)
self.drn_model.eval()
self.best_fid_A, self.best_fid_B = 1e9, 1e9
self.best_mAP = -1e9
self.fids_A, self.fids_B = [], []
self.mAPs = []
self.is_best = False
self.npz_A = np.load(opt.real_stat_A_path)
self.npz_B = np.load(opt.real_stat_B_path)
