def build(self, x, y, weight): with scope("x"): x = placeholder(tf.float32, [None, self.dim_x], x, "x") with scope("y"): y = placeholder(tf.float32, [None], y, "y") gx = self.gen(x) dx, dgx = self.dis(x), self.dis(gx) with scope("loss"): d_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dx) * 0.9, logits=dx)) d_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.zeros_like(dgx), logits=dgx)) d_loss = d_loss_real + d_loss_fake epsilon = 1e-10 loss_rec = tf.reduce_mean( -tf.reduce_sum(x * tf.log(epsilon + gx) + (1 - x) * tf.log(epsilon + 1 - gx), axis=1)) g_loss = weight* loss_rec \ + tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(dgx), logits=dgx)) with scope("AUC"): _, auc_dgx = tf.metrics.auc(y, tf.nn.sigmoid(dgx)) _, auc_dx = tf.metrics.auc(y, tf.nn.sigmoid(dx)) _, auc_gx = tf.metrics.auc(y, tf.reduce_mean((x - gx)**2, axis=1)) g_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="generator") d_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="discriminator") with scope('train_step'): step = tf.train.get_or_create_global_step() optimizer = tf.train.AdamOptimizer() d_step = optimizer.minimize(d_loss, step, var_list=d_vars) g_step = optimizer.minimize(g_loss, step, var_list=g_vars) return AEGAN(self, step=step, x=x, y=y, gx=gx, auc_dgx=auc_dgx, auc_gx=auc_gx, auc_dx=auc_dx, g_step=g_step, d_step=d_step, g_loss=g_loss, d_loss=d_loss)
def build(self, x, y, lr_max, mult): with tf.variable_scope("x"): x = placeholder(tf.float32, [None, self.dim_x], x, "x") with tf.variable_scope("y"): y = placeholder(tf.float32, [None], y, "y") gx = self.gen(x) dx, dgx = self.dis(x), self.dis(gx) with tf.variable_scope("loss"): a = tf.reduce_mean(tf.abs(x - dx)) b = tf.reduce_mean(tf.abs(gx - dgx)) c = tf.reduce_mean(tf.abs(x - gx)) d_vs_g = a - (b + c) / 2 # for balancing the learnign rate lr_d = sigmoid(d_vs_g, mult=mult) lr_g = (tf.constant(1.0) - lr_d) * lr_max lr_d = lr_d * lr_max # balance parameter for discriminator caring more about autoencoding real, or discriminating fake sigma = 0.5 w_fake = tf.clip_by_value( sigmoid(b * sigma - a, shift=0., mult=mult), 0., 0.9 ) # hold the discrim proportion fake aways at less than half d_loss = a - b * w_fake # weights for generator wg_fake = tf.clip_by_value(sigmoid(b - c, shift=0., mult=mult), 0., 1.0) wg_reconstruct = 1 - wg_fake g_loss = b * wg_fake + c * wg_reconstruct with tf.variable_scope("AUC"): _, auc_dgx = tf.metrics.auc(y, tf.reduce_mean((x - dgx)**2, axis=1)) _, auc_dx = tf.metrics.auc(y, tf.reduce_mean((x - dx)**2, axis=1)) _, auc_gx = tf.metrics.auc(y, tf.reduce_mean((x - gx)**2, axis=1)) with scope('down'): g_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="generator") d_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="discriminator") step = tf.train.get_or_create_global_step() d_step = tf.train.AdamOptimizer(lr_d).minimize(d_loss, step, var_list=d_vars) g_step = tf.train.AdamOptimizer(lr_g).minimize(g_loss, step, var_list=g_vars) return DAE(self, step=step, x=x, y=y, gx=gx, dgx=dgx, dx=dx, auc_dgx=auc_dgx, auc_gx=auc_gx, auc_dx=auc_dx, g_loss=g_loss, d_loss=d_loss, d_step=d_step, g_step=g_step)
def build(self, x, y, context_weight, loss, lam=0., weight_type="normal"): with scope("x"): x = placeholder(tf.float32, [None, None, None, self.channel_x], x, "x") with scope("y"): y = placeholder(tf.float32, [None], y, "y") gx = self.gen(x) dx = {k: v(x) for k, v in self.dis.items()} dgx = {k: v(gx) for k, v in self.dis.items()} #dx, dgx = self.dis(x), self.dis(gx) with scope("loss"): d_loss = [tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dx[k])*0.9, logits=dx[k])) \ + \ tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.zeros_like(dgx[k]), logits=dgx[k])) for k in dx.keys()] ### old d_loss #d_loss_real, d_loss_fake = [], [] #for k in dx.keys(): #d_loss_real.append(tf.reduce_mean( #tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(dx[k])*0.9, logits=dx[k]))) #d_loss_fake.append(tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros_like(dgx[k]), logits=dgx[k]))) #if loss=="mean": #d_loss = tf.reduce_mean(d_loss_real) + tf.reduce_mean(d_loss_fake) #elif loss=="max": #d_loss = tf.reduce_mean(d_loss_real) + tf.reduce_mean(d_loss_fake) #elif loss=="softmax": #d_loss = tf.reduce_mean(d_loss_real) + tf.reduce_mean(d_loss_fake) epsilon = 1e-10 loss_rec = tf.reduce_mean( -tf.reduce_sum(x * tf.log(epsilon + gx) + (1 - x) * tf.log(epsilon + 1 - gx), axis=1)) loss_g_fake = [ tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dgx_), logits=dgx_)) for dgx_ in dgx.values() ] lam = placeholder(tf.float32, None, lam, "lam") # only for softmax, otherwise dummy with scope("lambda"): if loss == "softmax_self_challenged": trained_l = tf.Variable(initial_value=-2., name='controlled_lambda') used_lam = tf.nn.softplus(trained_l, name='used_lambda') else: used_lam = lam if loss == "mean": gl_adv = tf.reduce_mean(loss_g_fake) g_loss = context_weight * loss_rec + gl_adv elif loss == "max": # max picks biggest loss = best discriminators feedback is used gl_adv = tf.reduce_max(loss_g_fake) g_loss = context_weight * loss_rec + gl_adv elif "softmax" in loss: # if lambda is self_learnt if used_lam == 0.: weights = tf.ones_like(loss_g_fake) else: if weight_type == 'log': weights = tf.pow(loss_g_fake, used_lam) else: weights = tf.exp(used_lam * loss_g_fake) gl_adv = weighted_arithmetic(weights, loss_g_fake) if loss == "softmax": g_loss = context_weight * loss_rec + gl_adv else: g_loss = context_weight * loss_rec + gl_adv - 0.001 * used_lam #g_loss = weight* loss_rec + tf.reduce_mean(tf.nn.softmax(loss_g_fake)*loss_g_fake) with scope("AUC"): #_, auc_dgx = tf.metrics.auc(y, tf.nn.sigmoid(tf.reduce_mean(list(dgx.values())))) #_, auc_dx = tf.metrics.auc(y, tf.nn.sigmoid(tf.reduce_mean(list(dx.values())))) _, auc_gx = tf.metrics.auc( y, tf.reduce_mean((x - gx)**2, axis=(1, 2, 3))) g_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="generator") if loss == "softmax_self_challenged": lambda_var = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="loss/lambda") g_vars.extend(lambda_var) #d_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="discriminator") d_vars = { i: tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=f"discriminator_{i}") for i in dx.keys() } with scope('train_step'): step = tf.train.get_or_create_global_step() optimizer = tf.train.AdamOptimizer() #d_step = optimizer.minimize(d_loss, step, var_list=d_vars) d_step = [ optimizer.minimize(loss, var_list=d_vars[i]) for i, loss in enumerate(d_loss) ] g_step = optimizer.minimize(g_loss, step, var_list=g_vars) return MG_GAN( self, lam=used_lam, step=step, x=x, y=y, gx=gx #, auc_dgx=auc_dgx , auc_gx=auc_gx #, auc_dx=auc_dx , g_step=g_step, d_step=d_step, gl_rec=context_weight * loss_rec, gl_lam=0.001 * used_lam, gl_adv=gl_adv, g_loss=g_loss, d_loss=d_loss, d_loss_mean=tf.reduce_mean(d_loss), d_max=tf.argmax(d_loss))
def train(anomaly_class=8): #set gpu os.environ["CUDA_VISIBLE_DEVICES"] = "0" #load data (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data() inlier = train_images[train_labels != anomaly_class] x_train = np.reshape(inlier, (len(inlier), 28 * 28)) / 255 #y_train = train_labels[train_labels!=anomaly_class] y_train = np.zeros(len(x_train), dtype=np.int8) # dummy outlier = train_images[train_labels == anomaly_class] x_test = np.reshape(np.concatenate([outlier, test_images]), (len(outlier) + len(test_images), 28 * 28)) / 255 y_test = np.concatenate( [train_labels[train_labels == anomaly_class], test_labels]) y_test = [0 if y != anomaly_class else 1 for y in y_test] x_test, y_test = unison_shfl(x_test, np.array(y_test)) path_log = "/cache/tensorboard-logdir/ae" path_ckpt = "/project/outlier_detection/ckpt" epochs = 400 batch_size = 700 dim_btlnk = 32 mult = 20 lr_max = 1e-4 trial = f"dae{anomaly_class}_b{batch_size}_btlnk{dim_btlnk}_lr_{lr_max}m{mult}" #trial="test1" dim_x = len(x_train[0]) #reset graphs and fix seeds tf.reset_default_graph() if 'sess' in globals(): sess.close() rand = RandomState(0) tf.set_random_seed(0) # data pipeline batch_fn = lambda: batch2(x_train, y_train, batch_size) x, y = pipe(batch_fn, (tf.float32, tf.float32), prefetch=4) #z = tf.random_normal((batch_size, z_dim)) # load graph dae = DAE.new(dim_x, dim_btlnk) model = DAE.build(dae, x, y, lr_max, mult) # start session, initialize variables sess = tf.InteractiveSession() saver = tf.train.Saver() wrtr = tf.summary.FileWriter(pform(path_log, trial)) #wrtr.add_graph(sess.graph) ### if load pretrained model # pretrain = "modelname" #saver.restore(sess, pform(path_ckpt, pretrain)) ### else: auc_vars = tf.get_collection(tf.GraphKeys.LOCAL_VARIABLES, scope='AUC') init = tf.group(tf.global_variables_initializer(), tf.variables_initializer(var_list=auc_vars)) sess.run(init) def log(step, wrtr=wrtr, log=tf.summary.merge([ tf.summary.scalar('g_loss', model.g_loss), tf.summary.scalar('d_loss', model.d_loss), tf.summary.image('gx400', spread_image(model.gx[:400], 20, 20, 28, 28)), tf.summary.image('dgx400', spread_image(model.dgx[:400], 20, 20, 28, 28)), tf.summary.image('dx400', spread_image(model.dx[:400], 20, 20, 28, 28)), tf.summary.scalar("AUC_dgx", model.auc_dgx), tf.summary.scalar("AUC_dx", model.auc_dx), tf.summary.scalar("AUC_gx", model.auc_gx) ]), y=y_test, x=x_test): wrtr.add_summary(sess.run(log, {model.x: x, model.y: y}), step) wrtr.flush() steps_per_epoch = len(x_train) // batch_size for epoch in tqdm(range(epochs)): for i in range(steps_per_epoch): sess.run(model.d_step) sess.run(model.g_step) # tensorboard writer log(sess.run(model["step"]) // steps_per_epoch) saver.save(sess, pform(path_ckpt, trial), write_meta_graph=False)
def train(anomaly_class, loss_type): #set gpu os.environ["CUDA_VISIBLE_DEVICES"] = "1" #load data (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data() inlier = train_images[train_labels != anomaly_class] x_train = np.reshape(inlier, (len(inlier), 28 * 28)) / 255 #y_train = train_labels[train_labels!=anomaly_class] y_train = np.zeros(len(x_train), dtype=np.int8) # dummy outlier = train_images[train_labels == anomaly_class] x_test = np.reshape(np.concatenate([outlier, test_images]), (len(outlier) + len(test_images), 28 * 28)) / 255 y_test = np.concatenate( [train_labels[train_labels == anomaly_class], test_labels]) y_test = [0 if y != anomaly_class else 1 for y in y_test] x_test, y_test = unison_shfl(x_test, np.array(y_test)) path_log = "/cache/tensorboard-logdir/ae" path_ckpt = "/project/outlier_detection/ckpt" epochs = 400 batch_size = 700 dim_btlnk = 32 dim_z = dim_btlnk dim_dense = 32 accelerate = 1e-5 context_weight = 1 trial = f"vaegan_{loss_type}_{anomaly_class}_b{batch_size}_btlnk{dim_btlnk}_d{dim_dense}_n{dim_z}_a{accelerate}" dim_x = len(x_train[0]) #reset graphs and fix seeds tf.reset_default_graph() if 'sess' in globals(): sess.close() rand = RandomState(0) tf.set_random_seed(0) # data pipeline batch_fn = lambda: batch2(x_train, y_train, batch_size, dim_z) x, y, z = pipe(batch_fn, (tf.float32, tf.float32, tf.float32), prefetch=4) # load graph aegan = VAEGAN.new(dim_x, dim_btlnk, dim_dense, dim_z, accelerate) model = VAEGAN.build(aegan, x, y, z, loss_type) # start session, initialize variables sess = tf.InteractiveSession() saver = tf.train.Saver() wrtr = tf.summary.FileWriter(pform(path_log, trial)) #wrtr.add_graph(sess.graph) ### if load pretrained model # pretrain = "modelname" #saver.restore(sess, pform(path_ckpt, pretrain)) ### else: auc_vars = tf.get_collection(tf.GraphKeys.LOCAL_VARIABLES, scope='AUC') init = tf.group(tf.global_variables_initializer(), tf.variables_initializer(var_list=auc_vars)) sess.run(init) def log( step, wrtr=wrtr, log=tf.summary. merge([ tf.summary.scalar('g_loss', model.g_loss), tf.summary.scalar('d_loss', model.d_loss), tf.summary.scalar('mu', model.m), tf.summary.scalar('lv', model.l), tf.summary.image('gzx400', spread_image(model.gzx[:400], 20, 20, 28, 28)) #, tf.summary.image('gz400', spread_image(model.gz[:400], 20,20,28,28)) , tf.summary.scalar("AUC_gzx", model.auc_gzx), tf.summary.scalar("AUC_dgzx", model.auc_dgzx), tf.summary.scalar("AUC_dx", model.auc_dx) #, tf.summary.scalar("gz_loss",model.gz_loss) , tf.summary.scalar("gzx_loss", model.gzx_loss), tf.summary.scalar("ftr_loss", model.ftr_loss), tf.summary.scalar("kl_loss", model.kl_loss), tf.summary.scalar("dx_loss", model.dx_loss) #, tf.summary.scalar("dgz_loss",model.dgz_loss) , tf.summary.scalar("dgzx_loss", model.dgzx_loss) ]), y=y_test, x=x_test): mu = sess.run(model.mu, {model.x: x}) wrtr.add_summary(sess.run(log, { model.zx: mu, model.x: x, model.y: y }), step) wrtr.flush() steps_per_epoch = len(x_train) // batch_size for epoch in tqdm(range(epochs)): for i in range(steps_per_epoch): sess.run(model.g_step) sess.run(model.d_step) # tensorboard writer #log(sess.run(model["step"])//steps_per_epoch) log(sess.run(model["step"] // steps_per_epoch)) saver.save(sess, pform(path_ckpt, trial), write_meta_graph=False)
model.lr = train[0].lr model.step = train[0].step model.errt = train[0].errt model.loss = tf.add_n([t.loss for t in train]) model.down = tf.train.AdamOptimizer(model.lr, T.beta1, T.beta2, T.epsilon) \ .minimize(model.loss, model.step, (model.embeds[1].logit, model.embeds[3].logit)) ############ # training # ############ sess = tf.InteractiveSession() tf.global_variables_initializer().run() tf.train.Saver( [v for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) if not ('embed' in v.name and 'Adam' in v.name)] ).restore(sess, pform(P.ckpt, 'm1_', 9)) saver = tf.train.Saver() model.step.assign(0).eval() def summ(step, wtr = tf.summary.FileWriter(pform(P.log, C.trial)) , summary = tf.summary.merge( ( tf.summary.scalar('step_errt', model.errt) , tf.summary.scalar('step_loss', model.loss)))): errt, loss = map(comp(np.mean, np.concatenate), zip(*chain(*( batch_run(sess, m, (m.errt_samp, m.loss_samp), s, t, batch= C.batch_valid) for m, (s, t) in zip(valid, data_valid))))) wtr.add_summary(sess.run(summary, {model.errt: errt, model.loss: loss}), step) wtr.flush()
def build(self, x, y, z, loss_type): d_scale_factor = tf.constant(0.) #tf.constant(0.25) g_scale_factor = tf.constant(0.) #tf.constant(1 - 0.75/2) with scope("x"): x = placeholder(tf.float32, [None, self.dim_x], x, "x") with scope("y"): y = placeholder(tf.float32, [None], y, "y") with scope("z"): z = placeholder(tf.float32, [None, self.dim_noise], z, "z") zx, mu, lv, hl_e = self.enc(x) gzx = self.gen(zx) #gz = self.gen(z) dx, hl_dx = self.dis(x) dgzx, hl_dgzx = self.dis(gzx) #dgz, hl_dgz = self.dis(gz) with tf.variable_scope("step"): step = tf.train.get_or_create_global_step() rate = self.accelerate * tf.to_float(step) rate_anneal = tf.tanh(rate) with scope("loss"): dx_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dx) - d_scale_factor, logits=dx)) dgzx_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.zeros_like(dgzx), logits=dgzx)) #dgz_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros_like(dgz), logits=dgz)) d_loss = dx_loss + dgzx_loss #+ dgz_loss kl_loss = tf.reduce_mean(0.5 * (tf.square(mu) + tf.exp(lv) - lv - 1.0)) gzx_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dgzx) - g_scale_factor, logits=dgzx)) if loss_type == "xtrpy": epsilon = 1e-10 ftr_loss = tf.reduce_mean( -tf.reduce_sum(x * tf.log(epsilon + gzx) + (1 - x) * tf.log(epsilon + 1 - gzx), axis=1)) g_loss = gzx_loss / 10 + ftr_loss / 5 + kl_loss * rate_anneal else: ftr_loss = tf.reduce_mean(tf.abs(x - gzx)) g_loss = gzx_loss / 2 + ftr_loss * 10 + kl_loss * rate_anneal with scope("AUC"): _, auc_gzx = tf.metrics.auc(y, tf.reduce_mean((x - gzx)**2, axis=1)) _, auc_dx = tf.metrics.auc(y, tf.nn.sigmoid(dx)) _, auc_dgzx = tf.metrics.auc(y, tf.nn.sigmoid(dgzx)) g_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="generator") g_vars.append( tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="encoder")) print(g_vars) d_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="discriminator") print(d_vars) with scope('train_step'): #optimizer = tf.train.RMSPropOptimizer() optimizer = tf.train.AdamOptimizer() d_step = optimizer.minimize(d_loss, step, var_list=d_vars) g_step = optimizer.minimize(g_loss, step, var_list=g_vars) return VAEGAN( self, step=step, x=x, y=y, z=z, zx=zx, mu=mu, lv=lv, m=tf.reduce_mean(mu), l=tf.reduce_mean(lv) #, gz=gz , gzx=gzx, auc_gzx=auc_gzx, auc_dx=auc_dx, auc_dgzx=auc_dgzx, g_step=g_step, d_step=d_step, g_loss=g_loss, d_loss=d_loss #,gz_loss=gz_loss , gzx_loss=gzx_loss, ftr_loss=ftr_loss, kl_loss=kl_loss, dx_loss=dx_loss #, dgz_loss=dgz_loss , dgzx_loss=dgzx_loss)
def train(anomaly_class=8, dataset="cifar", n_dis=1, epochs=25, dim_btlnk=32, batch_size=64, loss="mean", context_weight=1, dim_d=64, dim_g=64, extra_layers=0, gpu="0"): #set gpu os.environ["CUDA_VISIBLE_DEVICES"] = gpu path_log = f"/cache/tensorboard-logdir/{dataset}" path_ckpt = "/project/multi-discriminator-gan/ckpt" path_data = "/project/multi-discriminator-gan/data" #reset graphs and fix seeds tf.reset_default_graph() if 'sess' in globals(): sess.close() rand = RandomState(0) tf.set_random_seed(0) #load data if dataset == "ucsd1": x_train = np.load("./data/ucsd1_train_x.npz")["arr_0"] / 255 y_train = np.load("./data/ucsd1_train_y.npz")["arr_0"] x_test = np.load("./data/ucsd1_test_x.npz")["arr_0"] / 255 y_test = np.load("./data/ucsd1_test_y.npz")["arr_0"] elif dataset == "uscd2": x_train = np.load("./data/ucsd2_train_x.npz")["arr_0"] y_train = np.load("./data/ucsd2_train_y.npz")["arr_0"] x_test = np.load("./data/ucsd2_test_x.npz")["arr_0"] y_test = np.load("./data/ucsd2_test_y.npz")["arr_0"] else: if dataset == "mnist": (train_images, train_labels), ( test_images, test_labels) = tf.keras.datasets.mnist.load_data() train_images = resize_images(train_images) test_images = resize_images(test_images) else: (train_images, train_labels), ( test_images, test_labels) = tf.keras.datasets.cifar10.load_data() train_labels = np.reshape(train_labels, len(train_labels)) test_labels = np.reshape(test_labels, len(test_labels)) inlier = train_images[train_labels != anomaly_class] #data_size = prod(inlier[0].sha x_train = inlier / 255 #x_train = np.reshape(inlier, (len(inlier), data_size))/255 #y_train = train_labels[train_labels!=anomaly_class] y_train = np.zeros(len(x_train), dtype=np.int8) # dummy outlier = train_images[train_labels == anomaly_class] x_test = np.concatenate([outlier, test_images]) / 255 #x_test = np.reshape(np.concatenate([outlier, test_images]) # ,(len(outlier)+len(test_images), data_size))/255 y_test = np.concatenate( [train_labels[train_labels == anomaly_class], test_labels]) y_test = [0 if y != anomaly_class else 1 for y in y_test] x_test, y_test = unison_shfl(x_test, np.array(y_test)) img_size_x = x_train[0].shape[0] img_size_y = x_train[0].shape[1] channel = x_train[0].shape[-1] trial = f"{dataset}_{loss}_dis{n_dis}_{anomaly_class}_w{context_weight}_btlnk{dim_btlnk}_d{dim_d}_g{dim_g}e{extra_layers}" # data pipeline batch_fn = lambda: batch2(x_train, y_train, batch_size) x, y = pipe(batch_fn, (tf.float32, tf.float32), prefetch=4) #z = tf.random_normal((batch_size, z_dim)) # load graph mg_gan = MG_GAN.new(img_size_x, channel, dim_btlnk, dim_d, dim_g, n_dis, extra_layers=0) model = MG_GAN.build(mg_gan, x, y, context_weight, loss) # start session, initialize variables sess = tf.InteractiveSession() saver = tf.train.Saver() wrtr = tf.summary.FileWriter(pform(path_log, trial)) wrtr.add_graph(sess.graph) ### if load pretrained model # pretrain = "modelname" #saver.restore(sess, pform(path_ckpt, pretrain)) ### else: auc_vars = tf.get_collection(tf.GraphKeys.LOCAL_VARIABLES, scope='AUC') init = tf.group(tf.global_variables_initializer(), tf.variables_initializer(var_list=auc_vars)) sess.run(init) #if "ucsd" in dataset: summary_test = tf.summary.merge([ tf.summary.scalar('g_loss', model.g_loss), tf.summary.scalar("lambda", model.lam), tf.summary.scalar("gl_rec", model.gl_rec), tf.summary.scalar("gl_adv", model.gl_adv), tf.summary.scalar("gl_lam", model.gl_lam), tf.summary.scalar('d_loss_mean', model.d_loss_mean), tf.summary.scalar('d_max', model.d_max) #, tf.summary.scalar('d_loss', model.d_loss) , tf.summary.scalar("AUC_gx", model.auc_gx) ]) if dataset == "ucsd1": summary_images = tf.summary.merge( (tf.summary.image("gx", model.gx, max_outputs=8), tf.summary.image("x", model.x, max_outputs=8), tf.summary.image( 'gx400', spread_image(tf.concat([model.gx, model.x], axis=1), 8, 2, img_size_x, img_size_y, channel)))) else: summary_images = tf.summary.merge( (tf.summary.image("gx", model.gx, max_outputs=8), tf.summary.image( 'gx400', spread_image(model.gx[:400], 20, 20, img_size_x, img_size_y, channel)), tf.summary.image("x", model.x, max_outputs=8))) if n_dis > 1: d_wrtr = { i: tf.summary.FileWriter(pform(path_log, trial + f"d{i}")) for i in range(n_dis) } summary_discr = { i: tf.summary.scalar('d_loss_multi', model.d_loss[i]) for i in range(n_dis) } def summ(step): fetches = model.g_loss, model.lam, model.d_loss_mean, model.auc_gx results = map( np.mean, zip(*(sess.run(fetches, { model['x']: x_test[i:j], model['y']: y_test[i:j] }) for i, j in partition(len(x_test), batch_size, discard=False)))) results = list(results) wrtr.add_summary(sess.run(summary_test, dict(zip(fetches, results))), step) if dataset == "ucsd1": # bike, skateboard, grasswalk, shopping cart, car, normal, normal, grass wrtr.add_summary( sess.run( summary_images, { model.x: x_test[[990, 1851, 2140, 2500, 2780, 2880, 3380, 3580]] }), step) else: wrtr.add_summary(sess.run(summary_images, {model.x: x_test}), step) wrtr.flush() def summ_discr(step): fetches = model.d_loss results = map( np.mean, zip(*(sess.run(fetches, { model['x']: x_test[i:j], model['y']: y_test[i:j] }) for i, j in partition(len(x_test), batch_size, discard=False)))) results = list(results) if n_dis > 1: # put all losses of the discriminators in one plot for i in range(n_dis): d_wrtr[i].add_summary( sess.run(summary_discr[i], dict(zip(fetches, results))), step) #d_wrtr[i].add_summary(sess.run(summary_discr[i], dict([(fetches[i], results[i])])), step) d_wrtr[i].flush() #def log(step # , wrtr= wrtr # , log = tf.summary.merge([tf.summary.scalar('g_loss', model.g_loss) # , tf.summary.scalar('d_loss', tf.reduce_mean(model.d_loss)) # , tf.summary.scalar("lambda", model.lam) # , tf.summary.image("gx", model.gx, max_outputs=5) # , tf.summary.image('gx400', spread_image(model.gx[:400], 20,20, img_size, img_size, channel)) # #, tf.summary.scalar("AUC_dgx", model.auc_dgx) # #, tf.summary.scalar("AUC_dx", model.auc_dx) # , tf.summary.scalar("AUC_gx", model.auc_gx)]) # , y= y_test # , x= x_test): # wrtr.add_summary(sess.run(log, {model["x"]:x # , model["y"]:y}) # , step) # wrtr.flush() steps_per_epoch = len(x_train) // batch_size - 1 for epoch in tqdm(range(epochs)): for i in range(steps_per_epoch): #sess.run(model["train_step"]) sess.run(model['d_step']) sess.run(model['g_step']) # tensorboard writer #if "ucsd" in dataset: summ(sess.run(model["step"]) // steps_per_epoch) #else: # log(sess.run(model["step"])//steps_per_epoch) if n_dis > 1: summ_discr(sess.run(model["step"]) // steps_per_epoch) saver.save(sess, pform(path_ckpt, trial), write_meta_graph=False)
model.step = train[0].step model.errt = train[0].errt model.loss = tf.add_n([t.loss for t in train]) model.down = tf.train.AdamOptimizer(model.lr, T.beta1, T.beta2, T.epsilon).minimize( model.loss, model.step) ############ # training # ############ sess = tf.InteractiveSession() tf.global_variables_initializer().run() tf.train.Saver([ v for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) if not ('embed' in v.name and 'Adam' in v.name) ]).restore(sess, pform(P.ckpt, 'm1_', 9)) saver = tf.train.Saver() model.step.assign(0).eval() def summ(step, wtr=tf.summary.FileWriter(pform(P.log, C.trial)), summary=tf.summary.merge((tf.summary.scalar('step_errt', model.errt), tf.summary.scalar('step_loss', model.loss)))): errt, loss = map( comp(np.mean, np.concatenate),