def build_loss(self, seg_layer, lab_holder):
lab_reform = tf.expand_dims(lab_holder, -1)
lab_reform = tf.image.resize_images(seg_layer,
tf.shape(lab_reform)[1:3])
lab_reform = tf.squeeze(lab_reform)
seg_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=seg_layer,
labels=lab_reform))
var_s = M.get_trainable_vars('SegLayer')
var_m = M.get_trainable_vars('MergingLayer')
train_step = tf.train.AdamOptimizer(0.0001).minimize(seg_loss,
var_list=var_s)
train_step2 = tf.train.AdamOptimizer(1e-5).minimize(
seg_loss, var_list=self.net_body.var)
train_step3 = tf.train.AdamOptimizer(0.0001).minimize(seg_loss,
var_list=var_m)
upds = M.get_update_ops()
with tf.control_dependencies(upds +
[train_step, train_step2, train_step3]):
train_op = tf.no_op()
self.loss = seg_loss
self.train_op = train_op
def build_loss(self,seg_layer,stream_list,inst_layer,lab_holder,mask_holder,coord_holder,inst_holder):
with tf.variable_scope('coord_loss'):
coords_reshape = tf.constant(self.coords[:,:,::-1],tf.float32)
coords_reshape = tf.expand_dims(coords_reshape,0)
offset = coord_holder - tf.tile(coords_reshape,[tf.shape(coord_holder)[0],1,1,3])
coord_loss = self.coord_loss(stream_list,offset,mask_holder)
with tf.variable_scope('inst_loss'):
inst_loss = tf.reduce_mean(tf.square(inst_layer - inst_holder))
var_m = M.get_trainable_vars('inst_part/MergingLayer')
var_c = M.get_trainable_vars('inst_part/stream')
var_i = M.get_trainable_vars('inst_part/inst_layer')
var_net = M.get_trainable_vars('inst_part/WideRes')
with tf.variable_scope('overall_loss'):
overall_loss = 5*coord_loss + inst_loss
train_step = tf.train.AdamOptimizer(0.0001).minimize(overall_loss,var_list=var_m) # merging layer
train_step2 = tf.train.AdamOptimizer(1e-5).minimize(overall_loss,var_list=var_net) # main body
train_step4 = tf.train.AdamOptimizer(0.0001).minimize(10*coord_loss,var_list=var_c) # coord streams
train_step5 = tf.train.AdamOptimizer(0.0001).minimize(inst_loss,var_list=var_i) # instant prediction
with tf.control_dependencies([train_step,train_step2,train_step4,train_step5]):
train_op = tf.no_op()
self.crd_loss = coord_loss
self.inst_loss = inst_loss
self.train_op = train_op
def build_graph():
envholder = tf.placeholder(tf.float32, [None, 128])
envholder2 = tf.placeholder(tf.float32, [None, 128])
reward_holder = tf.placeholder(tf.float32, [None, 1])
actholder = tf.placeholder(tf.float32, [None, 1])
terminated_holder = tf.placeholder(tf.float32, [None, 1])
#policy gradient
#S_0 for actor_1
a_eval = actor(envholder, 'a1')
#S_1 for actor_1
a_real = actor(envholder2, 'a2')
#combine actor with env
env_act1 = tf.concat([envholder, a_eval], axis=-1) #S_0
env_act2 = tf.concat([envholder2, a_real], axis=-1) #S_1
env_act3 = tf.concat([envholder, actholder], axis=-1)
#DQN
c_eval = crit(env_act1, 'c1') #S_0
c_real = crit(env_act2, 'c2') #S_1
c_real2 = crit(env_act1, 'c2', True)
c_eval2 = crit(env_act3, 'c1', True)
var_a1 = M.get_trainable_vars('a1')
var_a2 = M.get_trainable_vars('a2')
var_c1 = M.get_trainable_vars('c1')
var_c2 = M.get_trainable_vars('c2')
q_target = EPS * c_real * terminated_holder + reward_holder
c_loss = tf.reduce_mean(tf.square(c_eval2 - q_target))
a_loss = -tf.reduce_mean(c_real2)
train_c = tf.train.RMSPropOptimizer(0.0025).minimize(c_loss,
var_list=var_c1)
train_a = tf.train.RMSPropOptimizer(0.0005).minimize(
a_loss, var_list=var_a1) #maximize c_real2 , env_act1
assign_a = soft_assign(var_a2, var_a1, 0.5)
assign_c = soft_assign(var_c2, var_c1, 0.5)
assign_a0 = assign(var_a2, var_a1)
assign_c0 = assign(var_c2, var_c1)
return [
envholder, envholder2, reward_holder, actholder, terminated_holder
], a_eval, [c_loss, a_loss], [train_c,
train_a], [assign_c,
assign_a], [assign_c0,
assign_a0], a_eval
def build_loss(self):
with tf.variable_scope('mask_loss'):
lab_reform = tf.expand_dims(self.mask_holder,-1)
lab_reform = tf.image.resize_images(seg_layer,tf.shape(lab_reform)[1:3])
lab_reform = tf.squeeze(lab_reform)
mask_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.mask_out,labels=lab_reform))
train_mask0 = tf.train.AdamOptimizer(0.0001).minimize(mask_loss,var_list=M.get_trainable_vars('bg_fg/SegLayer'))
train_mask1 = tf.train.AdamOptimizer(1e-5).minimize(mask_loss,var_list=M.get_trainable_vars('bg_fg/WideRes'))
with tf.variable_scope('seg_loss'):
lab_reform = tf.expand_dims(self.seg_holder,-1)
lab_reform = tf.image.resize_images(self.seg_out,tf.shape(lab_reform)[1:3])
lab_reform = tf.squeeze(lab_reform)
seg_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.seg_out,labels=lab_reform))
train_seg0 = tf.train.AdamOptimizer(0.0001).minimize(seg_loss,var_list=M.get_trainable_vars('seg_part/SegLayer')+M.get_trainable_vars('seg_part/MergingLayer'))
train_seg1 = tf.train.AdamOptimizer(1e-5).minimize(seg_loss,var_list=M.get_trainable_vars('seg_part/WideRes'))
def __init__(self, class_num):
inp_holder = tf.placeholder(tf.float32, [None, 460, 460, 3])
lab_holder = tf.placeholder(tf.int32, [None, 460, 460])
mask_holder = tf.placeholder(tf.float32, [None, 460, 460])
mask = tf.expand_dims(mask_holder, -1)
c_ = tf.concat([inp_holder, mask], -1)
merged_layer = self.merging_layer(c_)
self.net_body = seg_main_body(merged_layer)
seg_layer = self.segmentation_layer(self.net_body.feature_layer, 12,
class_num)
self.build_loss(seg_layer, lab_holder)
self.saver = tf.train.Saver()
self.sess = tf.Session()
M.loadSess('./savings_seg/',
self.sess,
init=True,
var_list=M.get_trainable_vars('seg_part/WideRes'))
self.inp_holder = inp_holder
self.lab_holder = lab_holder
self.seg_layer = seg_layer
self.mask_holder = mask_holder
def build_loss(self,seg_layer,lab_holder):
lab_reform = tf.expand_dims(lab_holder, -1) # 460 x 460 x 1
seg_layer = tf.image.resize_images(seg_layer, tf.shape(lab_reform)[1:3]) # 460 x 460 x 2
lab_reform = tf.squeeze(lab_reform, axis=3) # 460 x 460 x 2
seg_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=seg_layer,labels=lab_reform))
var_s = M.get_trainable_vars('bg_fg/SegLayer')
var_net = M.get_trainable_vars('bg_fg/WideRes')
train_step = tf.train.AdamOptimizer(0.0001).minimize(seg_loss,var_list=var_s)
train_step2 = tf.train.AdamOptimizer(1e-6).minimize(seg_loss,var_list=var_net)
upds = M.get_update_ops()
with tf.control_dependencies(upds+[train_step,train_step2]):
train_op = tf.no_op()
self.loss = seg_loss
self.train_op = train_op
def build_loss(self,seg_layer,lab_holder):
lab_reform = tf.expand_dims(lab_holder,-1)
lab_reform = tf.image.resize_images(seg_layer,tf.shape(lab_reform)[1:3])
lab_reform = tf.squeeze(lab_reform)
seg_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=seg_layer,labels=lab_reform))
var_s = M.get_trainable_vars('SegLayer')
self.loss = seg_loss
def build_graph(train=True):
with tf.name_scope('inp'):
imgholder = tf.placeholder(tf.float32, [None, 256, 256, 3])
with tf.name_scope('gnd'):
gndholder = tf.placeholder(tf.float32, [None, 256, 256, 1])
x_fake = gen(imgholder, train=train)
d_fake = dis(x_fake, imgholder, train=train)
d_real = dis(gndholder, imgholder, reuse=True, train=train)
g_loss_L1 = tf.reduce_mean(tf.abs(x_fake - gndholder))
g_loss_lg = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake,
labels=tf.ones_like(d_fake)))
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=d_real,
labels=tf.ones_like(d_real)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake,
labels=tf.zeros_like(d_fake)))
varg = M.get_trainable_vars('gen')
vard = M.get_trainable_vars('dis')
updg = M.get_update_ops('gen')
updd = M.get_update_ops('dis')
with tf.name_scope('optimizer'):
train_d = tf.train.AdamOptimizer(0.001, beta1=0.5).minimize(
d_loss_real + d_loss_fake, var_list=vard)
train_g = tf.train.AdamOptimizer(0.001, beta1=0.5).minimize(
g_loss_lg + g_loss_L1 * 10, var_list=varg)
return [imgholder, gndholder], [
g_loss_L1 + g_loss_lg, d_loss_fake + d_loss_real
], [updg, updd], [train_g,
train_d], x_fake, [g_loss_lg, d_loss_fake + d_loss_real]
def __init__(self):
inp_holder = tf.placeholder(tf.float32,[None,460,460,3])
lab_holder = tf.placeholder(tf.int32,[None,460,460])
self.net_body = seg_main_body(inp_holder)
seg_layer = self.segmentation_layer(self.net_body.feature_layer,12)
self.build_loss(seg_layer,lab_holder)
self.saver = tf.train.Saver()
self.sess = tf.Session()
M.loadSess('./savings_bgfg/',self.sess,init=True,var_list=M.get_trainable_vars('bg_fg/WideRes'))
self.inp_holder = inp_holder
self.lab_holder = lab_holder
self.seg_layer = seg_layer
def build_graph():
envHolder = tf.placeholder(tf.float32, [None, 4])
actionHolder = tf.placeholder(tf.float32, [None, 2])
scoreHolder = tf.placeholder(tf.float32, [None])
output = main_structure(envHolder, 'output')
# action_out have the same value as next_score
action_out = tf.reduce_sum(output * actionHolder, axis=1)
action = tf.argmax(output, axis=1)
next_score = tf.reduce_max(output, axis=1)
loss = tf.reduce_mean(tf.square(scoreHolder - action_out))
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss)
var_o = M.get_trainable_vars('output')
return output, envHolder, actionHolder, scoreHolder, action, action_out, next_score, train_step, loss, var_o
def __init__(self, class_num):
self.size = 460
self.class_num = 20
# build placeholders
inp_holder = tf.placeholder(tf.float32,[None,size,size,3],name='image_holder')
seg_holder = tf.placeholder(tf.float32,[None,size,size,class_num],name='segment_holder')
mask_holder = tf.placeholder(tf.float32,[None,size,size],name='mask_holder')
coord_holder = tf.placeholder(tf.float32,[None,size,size,6],name='coordinate_holder')
inst_holder = tf.placeholder(tf.float32,[None,class_num],name='instance_holder')
# construct input (4 -> 3 with 1x1 conv)
merged_layer = self.merging_layer(inp_holder,seg_holder,mask_holder)
# build network
self.get_coord(size)
self.net_body = seg_main_body(merged_layer)
stream_list = self.get_stream_list(self.net_body.feature_maps)
inst_pred = self.inst_layer(self.net_body.feature_layer,stream_list[-1],class_num)
self.build_loss(seg_layer,stream_list,inst_pred,lab_holder,mask_holder,coord_holder,inst_holder)
# build saver and session
self.saver = tf.train.Saver()
self.sess = tf.Session()
# self.writer = tf.summary.FileWriter('./logs/',self.sess.graph)
M.loadSess('./savings_inst_model/',self.sess,init=True,var_list=M.get_trainable_vars('inst_part/WideRes'))
# set class variables
# holders
self.inp_holder = inp_holder
self.lab_holder = lab_holder
self.mask_holder = mask_holder
self.coord_holder = coord_holder
self.inst_holder = inst_holder
# layers
self.coord_layer = stream_list[-1]
self.inst_layer = inst_pred
img = (img/127.5 - 1.0)
img = cv2.resize(img,(122,144))
M2 = np.float32([[1,0,11],[0,1,0]])
img = cv2.warpAffine(img,M2,(144,144))
img = img[8:136,8:136]
data2.append(img)
return data,data2
build_total_graph()
with tf.Session() as sess:
print('Writing log file...')
saver = tf.train.Saver()
# writer = tf.summary.FileWriter('./logs/',sess.graph)
data,data2 = get_data()
M.loadSess('./model/',sess)
M.loadSess(modpath='./modelres/Epoc0Iter20999.ckpt',sess=sess,var_list=M.get_trainable_vars('MainModel'))
alltensor = [totalLoss,dis_loss,train_d,train_g,updd,updg]
gentensor = [profHolder,x_fake,gtHolder]
for iteration in range(100000):
train_batch = random.sample(data,BSIZE)
p2_batch = random.sample(data2,BSIZE)
p_batch = [i[0] for i in train_batch]
l_batch = [i[1] for i in train_batch]
r_batch = [i[2] for i in train_batch]
n_batch = [i[3] for i in train_batch]
m_batch = [i[4] for i in train_batch]
gt_batch = [i[5] for i in train_batch]
z_batch = np.random.uniform(size=[BSIZE,ZDIM],low=-1.0,high=1.0)
feeddict = {profHolder:p_batch, gtHolder:gt_batch, leHolder:l_batch, reHolder:r_batch, mthHolder:m_batch, nseHolder:n_batch, zHolder:z_batch, domainHolder:np.zeros([BSIZE])}
g_loss, d_loss, _, _, _, _ = sess.run(alltensor, feed_dict=feeddict)
feeddict2 = {domainHolder:np.ones([BSIZE]), profHolder:p2_batch}
class network():
def __init__(self,class_num):
img_holder = tf.placeholder(tf.float32,[None,460,460,3])
with tf.variable_scope('bg_fg'):
net_bgfg = network_bg_fg(img_holder)
with tf.variable_scope('seg_part'):
net_seg = network_seg(class_num,img_holder,tf.nn.softmax(tf.image.resize_images(net_bgfg.seg_layer,[460,460]),1)[:,:,:,1])
with tf.variable_scope('inst_part'):
net_inst = network_inst(class_num,img_holder
tf.nn.softmax(tf.image.resize_images(net_bgfg.seg_layer,[460,460]),1)[:,:,:,1],
tf.image.resize_images(net_seg.seg_layer,[460,460]))
self.network_bg_fg = network_bg_fg
self.network_seg = network_seg
self.network_inst = network_inst
self.img_holder = img_holder
self.mask_holder = network_bg_fg.lab_holder
self.seg_holder = network_seg.lab_holder
self.coord_holder = network_inst.coord_holder
self.inst_holder = network_inst.inst_holder
self.mask_out = network_bg_fg.seg_layer
self.seg_out = network_seg.seg_layer
self.inst_num_out = network_inst.inst_layer
self.coord_out = network_inst.coord_layer
self.build_loss()
self.sess = tf.Session()
M.loadSess('./savings_bgfg/',sess=self.sess,init=True,var_list=M.get_all_vars('bg_fg'))
M.loadSess('./savings_seg/',sess=self.sess,var_list=M.get_all_vars('seg_part'))
M.loadSess('./savings_inst/',sess=self.sess,var_list=M.get_all_vars('inst_part'))
def build_loss(self):
with tf.variable_scope('mask_loss'):
lab_reform = tf.expand_dims(self.mask_holder,-1)
lab_reform = tf.image.resize_images(seg_layer,tf.shape(lab_reform)[1:3])
lab_reform = tf.squeeze(lab_reform)
mask_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.mask_out,labels=lab_reform))
train_mask0 = tf.train.AdamOptimizer(0.0001).minimize(mask_loss,var_list=M.get_trainable_vars('bg_fg/SegLayer'))
train_mask1 = tf.train.AdamOptimizer(1e-5).minimize(mask_loss,var_list=M.get_trainable_vars('bg_fg/WideRes'))
with tf.variable_scope('seg_loss'):
lab_reform = tf.expand_dims(self.seg_holder,-1)
lab_reform = tf.image.resize_images(self.seg_out,tf.shape(lab_reform)[1:3])
lab_reform = tf.squeeze(lab_reform)
seg_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.seg_out,labels=lab_reform))
train_seg0 = tf.train.AdamOptimizer(0.0001).minimize(seg_loss,var_list=M.get_trainable_vars('seg_part/SegLayer')+M.get_trainable_vars('seg_part/MergingLayer'))
train_seg1 = tf.train.AdamOptimizer(1e-5).minimize(seg_loss,var_list=M.get_trainable_vars('seg_part/WideRes'))
with tf.variable_scope('inst_loss'):
train_inst0 = tf.train.AdamOptimizer(0.0001).minimize(self.network_inst.overall_loss,var_list=M.get_trainable_vars('inst_part/MergingLayer')) # merging layer
train_inst1 = tf.train.AdamOptimizer(1e-5).minimize(self.network_inst.overall_loss,var_list=M.get_trainable_vars('inst_part/WideRes')) # main body
train_inst2 = tf.train.AdamOptimizer(0.0001).minimize(10*self.network_inst.coord_loss,var_list=M.get_trainable_vars('inst_part/stream')) # coord streams
train_inst3 = tf.train.AdamOptimizer(0.0001).minimize(self.network_inst.inst_loss,var_list=M.get_trainable_vars('inst_part/inst_layer')) # instant prediction
upd_ops = M.get_update_ops()
with tf.control_dependencies(upd_ops+[train_mask0,train_mask1,train_seg1,train_seg0,train_inst0,train_inst1,train_inst2,train_inst3]):
train_op = tf.no_op()
self.mask_loss = mask_loss
self.seg_loss = seg_loss
self.inst_loss = self.network_inst.inst_loss
self.coord_loss = self.network_inst.coord_loss
self.train_op = train_op
cropped = item[0]
coord = item[1]
lb = get_lb(coord,crds)
lbs.append([cropped,lb])
# x,y,w,h =
# cv2.rectangle(img,())
return lbs
reader = datareader2.reader(height=240,width=320,scale_range=[0.05,1.2])
b0,b1,c0,c1 = netpart.model_out
start_time = time.time()
MAXITER = 100000
with tf.Session() as sess:
saver = tf.train.Saver()
M.loadSess('./model/',sess,init=True,var_list=M.get_trainable_vars('MSRPN'))
for i in range(MAXITER):
img,coord = reader.get_img()
buff_out = sess.run([b0,b1,c0,c1],feed_dict={netpart.inpholder:[img]})
bs,cs = buff_out[:2],buff_out[2:]
lbs = crop(img,bs,cs,coord)
train_imgs = [k[0] for k in lbs]
train_labs = [k[1] for k in lbs]
# for item in lbs:
# cv2.imshow('ad',item[0])
# print(item[1])
# cv2.waitKey(0)
ls,ac,_ = sess.run([net_veri.loss,net_veri.accuracy,net_veri.ts],
feed_dict={net_veri.inputholder:train_imgs,net_veri.labelholder:train_labs})
if i%10==0:
t2 = time.time()
logits=disfalse))
tf.summary.scalar('lossG', lossG)
with tf.name_scope('lossD'):
lossD1 = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.ones(
[BSIZE], dtype=tf.int64),
logits=distrue))
lossD2 = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.zeros(
[BSIZE], dtype=tf.int64),
logits=disfalse))
lossD = 0.5 * (lossD1 + lossD2)
tf.summary.scalar('lossD', lossD)
#run update_ops for updating the batch_norm
VARD = M.get_trainable_vars('Discriminator')
VARG = M.get_trainable_vars('Generator')
UPDD = M.get_update_ops('Discriminator')
UPDG = M.get_update_ops('Generator')
with tf.name_scope('opti'):
with tf.name_scope('optiG'):
trainG = tf.train.AdamOptimizer(learning_rate=LR,
beta1=BETA).minimize(lossG,
var_list=VARG)
with tf.name_scope('optiD'):
trainD = tf.train.AdamOptimizer(learning_rate=LR,
beta1=BETA).minimize(lossD,
var_list=VARD)
with tf.control_dependencies([trainG, trainD]):
trainAll = tf.no_op(name='train')
def build_total_graph():
global totalLoss, dis_loss, train_d, train_g, train_e, updd, updg, upde, profHolder, gtHolder, leHolder, reHolder, mthHolder, nseHolder, domainHolder, zHolder, clsHolder, x_fake, losscollection
with tf.name_scope('ProfileImg'):
profHolder = tf.placeholder(tf.float32, [None, 128, 128, 3])
with tf.name_scope('GTIMG'):
gtHolder = tf.placeholder(tf.float32, [None, 128, 128, 3])
with tf.name_scope('LEIMG'):
leHolder = tf.placeholder(tf.float32, [None, 40, 40, 3])
with tf.name_scope('REIMG'):
reHolder = tf.placeholder(tf.float32, [None, 40, 40, 3])
with tf.name_scope('MTHIMG'):
mthHolder = tf.placeholder(tf.float32, [None, 32, 48, 3])
with tf.name_scope('NSEIMG'):
nseHolder = tf.placeholder(tf.float32, [None, 32, 40, 3])
with tf.name_scope('Z'):
zHolder = tf.placeholder(tf.float32, [None, ZDIM])
with tf.name_scope('domain'):
domainHolder = tf.placeholder(tf.int32, [None])
with tf.name_scope('CLASS'):
clsHolder = tf.placeholder(tf.int32, [None])
nse = localpath_nse(nseHolder)
mth = localpath_mth(mthHolder)
le = localpath_le(leHolder)
re = localpath_re(reHolder)
fusion = fusion_locals(le, re, nse, mth)
x_fake, domainlayer = globalpath(profHolder, zHolder, fusion)
d_fake, c_fake = discriminator(x_fake)
d_real, c_real = discriminator(gtHolder, reuse=True)
f_fake = lcnn(x_fake)
f_real = lcnn(gtHolder, reuse=True)
with tf.name_scope('pixel_loss'):
pix_loss = tf.reduce_mean(tf.abs(gtHolder - x_fake))
with tf.name_scope('sym_loss'):
x_left, x_right = tf.split(x_fake, 2, axis=2)
sym_loss = tf.reduce_mean(tf.abs(x_left - x_right))
with tf.name_scope('dis_loss'):
dis_true = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=d_real,
labels=tf.ones([BSIZE,
1])))
dis_false = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake,
labels=tf.zeros([BSIZE,
1])))
dis_loss = dis_true + dis_false
with tf.name_scope('gen_loss'):
gen_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake,
labels=tf.ones([BSIZE,
1])))
with tf.name_scope('ip_loss'):
ip_loss = tf.reduce_mean(tf.abs(f_real - f_fake))
with tf.name_scope('tv_loss'):
tv_loss = tf.reduce_mean(
tf.image.total_variation(x_fake)) / (128.0 * 128.0)
with tf.name_scope('domain_loss'):
domain_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=domainlayer, labels=domainHolder))
with tf.name_scope('cls_loss'):
cls_loss_real = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=c_real,
labels=clsHolder))
# cls_loss_fake = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=c_fake,labels=clsHolder))
vard = M.get_trainable_vars('dis')
varg = M.get_trainable_vars('local_le') \
+ M.get_trainable_vars('local_re') \
+ M.get_trainable_vars('local_mth') \
+ M.get_trainable_vars('local_nse')\
+ M.get_trainable_vars('global_path')\
+ M.get_trainable_vars('fusion_node')
updd = M.get_update_ops('dis')
updg = M.get_update_ops('local_le') \
+ M.get_update_ops('local_re') \
+ M.get_update_ops('local_mth') \
+ M.get_update_ops('local_nse')\
+ M.get_update_ops('global_path')\
+ M.get_update_ops('fusion_node')
upde = M.get_update_ops('global_path')[:18]
losscollection = [
pix_loss, sym_loss, gen_loss, ip_loss, tv_loss, domain_loss, dis_loss
]
with tf.name_scope('Optimizer'):
totalLoss = (pix_loss * 0.3 + sym_loss * 0.07 + 0.001 * gen_loss +
0.003 * ip_loss + 0.0001 * tv_loss + 0.1 * domain_loss)
train_d = tf.train.AdamOptimizer(0.0001).minimize(dis_loss +
cls_loss_real,
var_list=vard)
train_g = tf.train.AdamOptimizer(0.0001).minimize(totalLoss,
var_list=varg)
train_e = tf.train.AdamOptimizer(0.0001).minimize(domain_loss)
data2.append(img)
print('data2 length:', len(data2))
return data2
build_total_graph()
with tf.Session() as sess:
print('Writing log file...')
saver = tf.train.Saver()
reader = data_reader()
# writer = tf.summary.FileWriter('./logs/',sess.graph)
# data2 = get_data2()
M.loadSess('./model/', sess, init=True)
M.loadSess(modpath='/home/psl/7T/chengyu/modelres/Epoc0Iter20999.ckpt',
sess=sess,
var_list=M.get_trainable_vars('MainModel'))
alltensor = [totalLoss, dis_loss, train_d, train_g, updd, updg]
gentensor = [profHolder, x_fake, gtHolder]
for iteration in range(100000):
train_batch = reader.get_batch(BSIZE)
# p2_batch = random.sample(data2,BSIZE)
p_batch = [i[0] for i in train_batch]
l_batch = [i[1] for i in train_batch]
r_batch = [i[2] for i in train_batch]
n_batch = [i[3] for i in train_batch]
m_batch = [i[4] for i in train_batch]
gt_batch = [i[5] for i in train_batch]
lb_batch = [i[6] for i in train_batch]
z_batch = np.random.uniform(size=[BSIZE, ZDIM], low=-1.0, high=1.0)
feeddict = {
profHolder: p_batch,
lbs.append([cropped, lb])
# x,y,w,h =
# cv2.rectangle(img,())
return lbs
reader = datareader2.reader(scale_range=[0.05, 1.2])
b0, b1, b2, c0, c1, c2 = netpart.model_out
start_time = time.time()
with tf.Session() as sess:
saver = tf.train.Saver()
M.loadSess('./model/',
sess,
init=True,
var_list=M.get_trainable_vars('MSRPN'))
for i in range(MAXITER):
img, coord = reader.get_img()
buff_out = sess.run([b0, b1, b2, c0, c1, c2],
feed_dict={netpart.inpholder: [img]})
bs, cs = buff_out[:3], buff_out[3:]
lbs = crop(img, bs, cs, coord)
train_imgs = [k[0] for k in lbs]
train_labs = [k[1] for k in lbs]
# for item in lbs:
# cv2.imshow('ad',item[0])
# print(item[1])
# cv2.waitKey(0)
ls, ac, _ = sess.run([net_veri.loss, net_veri.accuracy, net_veri.ts],
feed_dict={
net_veri.inputholder: train_imgs,
