def transform_from_internal_poly(self, content): # encode image enc_c, enc_c_layers = self.encode(content) self.normalized, self.meanC, self.sigmaC = normalize(enc_c) INTERPOLATE_NUM = settings.config["INTERPOLATE_NUM"] BATCH_SIZE = settings.config["BATCH_SIZE"] DIM = settings.config["DECODER_DIM"] STORE_SHAPE = [BATCH_SIZE] + DIM self.store_var = tf.Variable( tf.zeros(STORE_SHAPE), dtype=tf.float32, trainable=False) self.internal_sigma = tf.placeholder( tf.float32, shape=(BATCH_SIZE, INTERPOLATE_NUM, 1, 1, DIM[2])) self.internal_mean = tf.placeholder(tf.float32, shape=( BATCH_SIZE, INTERPOLATE_NUM, 1, 1, DIM[2])) self.coef_ph = tf.placeholder(tf.float32, shape=[BATCH_SIZE, INTERPOLATE_NUM]) with tf.variable_scope("transform"): self.coef = tf.get_variable("coef", shape=[BATCH_SIZE, INTERPOLATE_NUM], initializer=tf.ones_initializer()) self.coef_asgn = tf.assign(self.coef, self.coef_ph) method = "relu" if method == "relu": postive_coef = tf.nn.relu(self.coef) sum_coef = tf.reduce_sum(postive_coef, axis=1, keepdims=True) coef_poss = postive_coef / (sum_coef + 1e-7) self.regulate = tf.assign(self.coef, coef_poss) coef_poss = tf.reshape( coef_poss, shape=[BATCH_SIZE, INTERPOLATE_NUM, 1, 1, 1]) elif method =="softmax": coef = self.coef * 2 # control the gradient not to be too large coef_poss = tf.nn.softmax(coef, axis=-1) coef_poss = tf.reshape(coef_poss, shape=[BATCH_SIZE, INTERPOLATE_NUM, 1, 1, 1]) self.regulate = [] self.store_normalize = [tf.assign(self.store_var, self.normalized), self.coef.initializer] self.sigma_poly = tf.reduce_sum(self.internal_sigma*coef_poss, axis=1) self.mean_poly = tf.reduce_sum(self.internal_mean*coef_poss, axis=1) self.set_stat(self.mean_poly,self.sigma_poly) self.restored_internal = self.store_var * self.sigma_poly + self.mean_poly self.target_features = self.restored_internal self.loss_l1 = tf.reduce_sum(tf.abs(enc_c - self.target_features)) generated_adv_img = self.decode(self.target_features) generated_img = self.decode(enc_c) return generated_img, generated_adv_img
def transform_from_internal(self, content, store_var, sigma, mean): # encode image enc_c, enc_c_layers = self.encode(content) self.normalized, self.meanC, self.sigmaC = normalize(enc_c) self.store_normalize = tf.assign(store_var, self.normalized) self.set_stat(mean, sigma) self.restored_internal = store_var * sigma + mean self.target_features = self.restored_internal self.loss_l1 = tf.reduce_sum(tf.abs(enc_c - self.target_features)) generated_adv_img = self.decode( self.target_features) generated_img = self.decode(enc_c) return generated_img, generated_adv_img
def transform_from_internal(self, content, store_var, sigma, mean): content = tf.reverse(content, axis=[-1]) #style = tf.reverse(style, axis=[-1]) # preprocess image content = self.encoder.preprocess(content) #style = self.encoder.preprocess(style) # encode image enc_c, enc_c_layers = self.encoder.encode(content) self.normalized, self.meanC, self.sigmaC = normalize(enc_c) self.store_normalize = tf.assign(store_var, self.normalized) self.restored_internal = store_var * sigma + mean self.target_features = self.restored_internal self.loss_l1 = tf.reduce_sum(tf.abs(enc_c - self.target_features)) generated_adv_img = self.deocde_to_real( self.decoder.decode(self.target_features)) generated_img = self.deocde_to_real(self.decoder.decode(enc_c)) return generated_img, generated_adv_img
content_loss = tf.reduce_sum( tf.reduce_mean(tf.square(enc_gen_adv - target_features), axis=[1, 2])) # #content_loss += tf.reduce_sum(tf.reduce_mean( # tf.square(enc_gen - stn.norm_features), axis=[1, 2])) # compute the style loss style_layer_loss = [] # compute the total loss # adv_loss * adv_weight loss = content_loss + tf.reduce_sum( adv_loss * BATCH_SIZE * adv_weight) # style_weight * style_loss l2_embed = normalize(enc_gen)[0] - normalize(stn.norm_features)[0] l2_embed = tf.reduce_mean( tf.sqrt(tf.reduce_sum((l2_embed * l2_embed), axis=[1, 2, 3]))) loss = loss if data_set == "cifar10": classifier_vars = get_scope_var("model") decoder_vars = get_scope_var("decoder") # Training step global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.inverse_time_decay(LEARNING_RATE, global_step, DECAY_STEPS, LR_DECAY_RATE) #tf.train.AdamOptimizer(learning_rate).minimize( # MomentumOptimizer(learning_rate, momentum=0.9) tf.train.GradientDescentOptimizer(learning_rate) #train_op = tf.train.AdamOptimizer(learning_rate).minimize( # loss, var_list=stn_vars, global_step=global_step)
classifier = build_imagenet_model(adv_img_bgr, label, conf=1) adv_loss = -classifier.target_loss5 adv_acc = classifier.accuracy adv_acc_y = classifier.acc_y adv_acc_y_5 = classifier.acc_y_5 content_bgr = tf.reverse(content, axis=[-1]) # switch RGB to BGR classifier = build_imagenet_model(content_bgr, label, reuse=True) normal_loss = -classifier.target_loss5 norm_acc = classifier.accuracy acc_y = classifier.acc_y acc_y_5 = classifier.acc_y_5 classifier = build_imagenet_model(img_bgr, label, reuse=True) decode_acc_y = classifier.acc_y decode_acc_y_5 = classifier.acc_y_5 l2_embed_d = normalize(enc_gen_adv)[0] - normalize(stn.norm_features)[0] l2_embed = tf.sqrt(tf.reduce_sum((l2_embed_d * l2_embed_d), axis=[1, 2, 3])) # compute the content loss bar = 3000 / 64 / 128 content_loss_y = tf.reduce_sum(tf.reduce_mean(tf.square(enc_gen_adv - target_features), axis=[1, 2]), axis=-1) content_loss = tf.reduce_sum( tf.reduce_mean(tf.square(enc_gen_adv - target_features), axis=[1, 2])) # #content_loss += tf.reduce_sum(tf.reduce_mean( # tf.square(enc_gen - stn.norm_features), axis=[1, 2]))