def main():
nf = 256
zdim = 1024
filepath = "/workspace2/kitti/testing/image_2/007481.png"
filepath = "test/test0_2.jpg"
filepath = "test/test1_2.jpg"
filepath = "test/noise3.jpg"
filepath = "test/adversary.png"
filepath = "/workspace2/kitti/training/image_2/000003.png"
filepath = "/workspace2/kitti/testing/image_2/007597.png"
filepath = "/workspace2/kitti/testing/image_2/007662.png"
filepath = "/workspace2/kitti/testing/image_2/008001.png"
filepath = "/workspace2/kitti/testing/image_2/007618.png"
config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
sess = tf.Session(config=config)
images = tf.placeholder(tf.float32, [1, 150, 496, 3])
scdobj = scd.SCD(input=images)
rgan = eval_rgan.rgan(images=scdobj.end_points["pool5"],
z_dim=zdim,
nf=nf,
training=True)
imgsynth_from_feature = eval_imgsynth.ImageSynthesizer(rgan.rec_x_out)
scd_saver = scd.get_saver()
scd_saver.restore(sess, "/workspace/imgsynth/ssd_300_kitti/ssd_model.ckpt")
imgsynth_saver = eval_imgsynth.get_saver()
imgsynth_saver.restore(
sess, "/workspace/imgsynth/result_kitti256p_2/model.ckpt-89")
rgan_saver = eval_rgan.get_saver()
#rgan_saver.restore(sess,"models/model-99999")
rgan_saver.restore(sess, "models_doubleres_constr_x_rzx/model-80999")
image = cv2.resize(scd.imread_as_jpg(filepath), (496, 150))
image = np.expand_dims(image, 0)
reses = imgsynth_from_feature.generate_image_from_featuremap(
sess, image, images)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/single_generated.jpg", a)
def main():
filepath = "/workspace2/kitti/testing/image_2/007481.png"
filepath = "test/test0_2.jpg"
filepath = "test/test1_2.jpg"
filepath = "test/noise3.jpg"
filepath = "test/adversary.png"
filepath = "/workspace2/kitti/testing/image_2/007489.png"
filepath = "test/single_generated.jpg"
filepath = "test/valid_adv7.png"
config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
sess = tf.Session(config=config)
images = tf.placeholder(tf.float32, [1, 150, 496, 3])
scdobj = scd.SCD(input=images)
scd_saver = scd.get_saver()
scd_saver.restore(sess, "/workspace/imgsynth/ssd_300_kitti/ssd_model.ckpt")
image = cv2.resize(scd.imread_as_jpg(filepath), (496, 150))
image = np.expand_dims(image, 0)
reses = scdobj.get_image(sess, image)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/single_detected%d.jpg" % i, a)
def main():
config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
sess = tf.Session(config=config)
#define tensors and models
zb = 6
nf = 256
zdim = 1024
images = tf.placeholder(tf.float32, [2, 150, 496, 3])
z = tf.placeholder(tf.float32, [zb, zdim])
scdobj = scd.SCD(input=images)
imgsynth = eval_imgsynth.ImageSynthesizer(scdobj.end_points["pool5"])
rgan = eval_rgan.rgan(images=scdobj.end_points["pool5"],
z_dim=zdim,
nf=nf,
training=True)
imgsynth_from_feature = eval_imgsynth.ImageSynthesizer(rgan.rec_x_out,
reuse=True)
rgan_from_z = eval_rgan.rgan(latent_vec=z,
nf=nf,
z_dim=zdim,
reuse=True,
training=True)
imgsynth_from_z = eval_imgsynth.ImageSynthesizer(rgan_from_z.rec_x_p_out,
reuse=True)
#load weights
scd_saver = scd.get_saver()
scd_saver.restore(sess, "/workspace/imgsynth/ssd_300_kitti/ssd_model.ckpt")
imgsynth_saver = eval_imgsynth.get_saver()
imgsynth_saver.restore(
sess, "/workspace/imgsynth/result_kitti256p_2/model.ckpt-89")
rgan_saver = eval_rgan.get_saver()
rgan_saver.restore(sess, "models/model-99999")
co = []
image = cv2.resize(
scd.imread_as_jpg("/workspace2/kitti/testing/image_2/007482.png"),
(496, 150))
co.append(image)
image = cv2.resize(
scd.imread_as_jpg("/workspace2/kitti/testing/image_2/007481.png"),
(496, 150))
co.append(image)
#reses = imgsynth.generate_image_from_featuremap(np.expand_dims(image,0),images)
image = np.array(co)
#simply get detection result
reses = scdobj.get_image(sess, image)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/detected%d.jpg" % i, a)
#model:image=>feature, image decoder:feature=>image_hat
reses = imgsynth.generate_image_from_featuremap(sess, image, images)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/test%d.jpg" % i, a)
#model:image=>feature, gan:feature=>latent vector=>feature_hat, image decoder:feature_hat=>image_hat
reses = imgsynth_from_feature.generate_image_from_featuremap(
sess, image, images)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/test%d_2.jpg" % i, a)
#get detection result thru gan and image decoder
reses = scdobj.get_image(sess, reses)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/gan_detected%d.jpg" % i, a)
return 0
#latent vector=>feature_hat, image decoder:feature_hat=>image_hat
np.random.seed(0)
zs = []
zsp = np.random.randn(zb, zdim) + 1
zs = np.array(zsp)
reses = imgsynth_from_z.generate_image_from_featuremap(sess, zs, z)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/noise%d.jpg" % i, a)
#noise interpolation
zsb = []
for i in range(0, zb):
#zs.append(zsp[0]*float(i)/(float(zb)-1.)+zsp[1]*(1.-float(i)/(float(zb)-1.)))
zsb.append(zsp[i] * (1. - i / (zb - 1)))
zsb = np.array(zsb)
reses = imgsynth_from_z.generate_image_from_featuremap(sess, zsb, z)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/noise_interpolate%d.jpg" % i, a)
#model:images=>features, gan:features=>latent vectors=>features_hat, interpolate:features_hat=>features_interplated, image decoder:feature_interplated=>image_hat
zs = []
zsp = rgan.generate_noise_from_featuremap(sess, image, images)
for i in range(0, zb):
zs.append(zsp[0] * float(i) / zb + zsp[1] * (1 - float(i) / zb))
zs = np.array(zs)
reses = imgsynth_from_z.generate_image_from_featuremap(sess, zs, z)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/interpolate%d.jpg" % i, a)
zs = []
zsp = rgan.generate_noise_from_featuremap(sess, image, images)
for i in range(0, zb):
zs.append(zsp[0] * float(i) / zb + zsp[1] * (1 - float(i) / zb) + 3)
zs = np.array(zs)
reses = imgsynth_from_z.generate_image_from_featuremap(sess, zs, z)
for i, a in enumerate(reses):
print(i)
skimage.io.imsave("test/interpolate2%d.jpg" % i, a)
def build_model(self):
self.scdobj_real = scd.SCD(input=self.images)
self.label = self.scdobj_real.end_points["pool5"]
#self.label_resized = tf.image.resize_bilinear(self.label, (150,496))
self.label_resized = tf.image.resize_nearest_neighbor(
self.label, (self.h, self.w))
self.images_fake = self.global_generate(self.label_resized)
self.images_fake_float = tf.clip_by_value(
(self.images_fake + 1.) / 2. * 255., 0, 255)
self.scdobj_fake = scd.SCD(input=self.images_fake_float, reuse=True)
self.images_fake_uint8 = tf.cast(self.images_fake_float, tf.uint8)
self.images_real = (self.images / 255. - 0.5) / 0.5
concat_real = tf.concat([self.images_real, self.label_resized], axis=3)
concat_fake = tf.concat([self.images_fake, self.label_resized], axis=3)
self.pred_real = self.multi_discriminate(concat_real)
self.pred_fake = self.multi_discriminate(concat_fake, reuse=True)
#self.pred_real = self.multi_discriminate(self.images_real, reuse=tf.AUTO_REUSE)
#self.pred_fake = self.multi_discriminate(self.images_fake, reuse=tf.AUTO_REUSE)
#define losses
#disc losses
self.dis_cost = 0
for i in range(self.num_D):
self.dis_cost += (
mseloss(self.pred_real[i][-1],
tf.ones_like(self.pred_real[i][-1])) * 0.5 +
mseloss(self.pred_fake[i][-1],
tf.zeros_like(self.pred_fake[i][-1])))
#gen losses
self.gen_only_cost = 0
for i in range(self.num_D):
self.gen_only_cost += mseloss(self.pred_fake[i][-1],
tf.ones_like(self.pred_fake[i][-1]))
self.gan_feat_cost = 0
feat_weights = 4.0 / (self.n_layers + 1)
D_weights = 1.0 / self.num_D
for i in range(self.num_D):
for j in range(len(self.pred_fake[i]) - 1):
self.gan_feat_cost += D_weights * feat_weights * \
l1loss(self.pred_fake[i][j], self.pred_real[i][j]) * self.lambda_feat
self.vgg_feat_cost = 0
#self.vgg_feat_cost = tf.constant(0.)
#weights=[1./1.6, 1./2.3, 1./1.8, 1./2.8, 10/0.8]
weights = [1.0 / 32, 1.0 / 16, 1.0 / 8, 1.0 / 4, 1.0]
for i in range(5):
self.vgg_feat_cost += weights[i] * l1loss(
self.scdobj_real.end_points["conv%d_1" % (i + 1)],
self.scdobj_fake.end_points["conv%d_1" %
(i + 1)]) * 1. #self.lambda_feat
self.gen_cost = self.gen_only_cost + self.gan_feat_cost + self.vgg_feat_cost
"""
disc_reg = self.Discriminator_Regularizer(self.dis_x, self.x, self.dis_x_p, self.x_p)
#for more than one fake dis...
assert self.dis_cost.shape == disc_reg.shape
self.dis_cost += (self.gamma_plh/2.0)*disc_reg
"""
train_vars = tf.trainable_variables()
self.gen_params = [
v for v in train_vars if v.name.split("/")[1] == "global_generate"
]
self.dis_params = [
v for v in train_vars
if v.name.split("/")[1] == "multi_discriminate"
]
with tf.variable_scope('pix2pixhd'):
genopt = tf.train.AdamOptimizer(learning_rate=2e-4,
beta1=0.5,
beta2=0.999)
self.gen_train_op = slim.learning.create_train_op(
self.gen_cost,
genopt,
summarize_gradients=True,
variables_to_train=self.gen_params)
disopt = tf.train.AdamOptimizer(learning_rate=2e-4,
beta1=0.5,
beta2=0.999)
self.dis_train_op = slim.learning.create_train_op(
self.dis_cost,
disopt,
summarize_gradients=True,
variables_to_train=self.dis_params)
def build_model(self):
self.images_real = (self.images / 255. - 0.5) / 0.5
self.scd_real = scd.SCD(input=self.images)
self.feature_real = tf.image.resize_nearest_neighbor(
self.scd_real.end_points["pool5"], (self.ih, self.iw))
self.fmgan_real = fmgan.fmgan(x_dim=784,
z_dim=args.z_dim,
w=self.fw,
h=self.fh,
c=self.fc,
latent_dim=args.latent_dim,
nf=256,
batch_size=args.batch_size,
c_gp_x=args.c_gp_x,
lamda=args.lamda,
output_path=args.output_path,
args=args)
self.pxhdgan = p2phd.pxhdgan(x_dim=784,
z_dim=args.z_dim,
w=self.iw,
h=self.ih,
c=self.ic,
latent_dim=args.latent_dim,
nf=256,
batch_size=args.batch_size,
c_gp_x=args.c_gp_x,
lamda=args.lamda,
output_path=args.output_path,
args=args)
self.z_rec = self.fmgan_real.invert(self.feature_real)
self.feature_rec = self.fmgan_real.generate(self.z_rec)
self.images_rec = self.pxhdgan.global_generate(self.feature_rec)
self.images_out = tf.clip_by_value((self.images_rec + 1.) / 2. * 255.,
0, 255)
self.feature_fake_noise = tf.image.resize_nearest_neighbor(
self.fmgan_real.generate(self.z_noise, reuse=True),
(self.ih, self.iw))
self.images_fake_noise = self.pxhdgan.global_generate(
self.feature_fake_noise, reuse=True)
self.images_fake_noise_out = tf.clip_by_value(
(self.images_fake_noise + 1.) / 2. * 255., 0, 255)
self.scd_fake_noise = scd.SCD(input=self.images_fake_noise_out,
reuse=True)
self.feature_fake = tf.image.resize_nearest_neighbor(
self.scd_fake_noise.end_points["pool5"], (self.ih, self.iw))
self.z_rec_fake = self.fmgan_real.invert(self.feature_fake, reuse=True)
self.feature_rec_fake = tf.image.resize_nearest_neighbor(
self.fmgan_real.generate(self.z_rec_fake, reuse=True),
(self.ih, self.iw))
self.images_rec_fake = self.pxhdgan.global_generate(
self.feature_rec_fake, reuse=True)
self.images_rec_fake_out = tf.clip_by_value(
(self.images_rec_fake + 1.) / 2. * 255., 0, 255)
self.scd_rec_fake = scd.SCD(input=self.images_rec_fake_out, reuse=True)
self.images_fake = self.pxhdgan.global_generate(self.feature_real,
reuse=True)
self.images_fake_out = tf.clip_by_value(
(self.images_fake + 1.) / 2. * 255., 0, 255)
self.scd_fake = scd.SCD(input=self.images_fake_out, reuse=True)
self.images_fake_uint8 = tf.cast(self.images_fake_out, tf.uint8)
#self.images_fake_uint8 = tf.cast(self.images_fake_float,tf.uint8)
concat_images_fake_noise = tf.concat(
[self.images_fake_noise, self.feature_fake_noise], axis=3)
concat_images_rec_fake = tf.concat(
[self.images_rec_fake, self.feature_fake_noise], axis=3)
concat_images_fake = tf.concat([self.images_fake, self.feature_real],
axis=3)
concat_images_real = tf.concat([self.images_real, self.feature_real],
axis=3)
self.pred_fake_noise = self.pxhdgan.multi_discriminate(
concat_images_fake_noise)
self.pred_fake = self.pxhdgan.multi_discriminate(concat_images_fake,
reuse=True)
self.pred_rec_fake = self.pxhdgan.multi_discriminate(
concat_images_rec_fake, reuse=True)
self.pred_real = self.pxhdgan.multi_discriminate(concat_images_real,
reuse=True)
#define losses
#disc losses
def dc(preds, oz):
assert (oz == 1 or oz == 0)
loss = 0
tfoz = tf.ones_like if oz == 1 else tf.zeros_like
for p in preds:
pred = p[-1]
loss += mseloss(pred, tfoz(pred))
return loss
self.dis_cost = dc(self.pred_fake_noise, 0) + \
dc(self.pred_fake, 0) + \
dc(self.pred_rec_fake, 0) + \
dc(self.pred_real, 1) * 0.5
#gen losses
self.gen_only_cost = dc(self.pred_fake_noise, 1) + \
dc(self.pred_fake, 1) + \
dc(self.pred_rec_fake, 1)
self.gan_feat_cost = 0
feat_weights = 4.0 / (self.n_layers + 1)
D_weights = 1.0 / self.num_D
for i in range(self.num_D):
for j in range(len(self.pred_fake[i]) - 1):
self.gan_feat_cost += D_weights * feat_weights * \
(l1loss(self.pred_fake[i][j], self.pred_real[i][j]) + \
l1loss(self.pred_fake_noise[i][j], self.pred_rec_fake[i][j]))# * self.lambda_feat
self.vgg_feat_cost = 0
#weights=[1./1.6, 1./2.3, 1./1.8, 1./2.8, 10/0.8]
weights = [1.0 / 32, 1.0 / 16, 1.0 / 8, 1.0 / 4, 1.0]
for i in range(len(weights)):
self.vgg_feat_cost += weights[i] * \
(l1loss(self.scd_real.end_points["conv%d_1"%(i+1)], self.scd_fake.end_points["conv%d_1"%(i+1)]) +
l1loss(self.scd_fake_noise.end_points["conv%d_1"%(i+1)], self.scd_rec_fake.end_points["conv%d_1"%(i+1)]))
self.gen_cost = self.gen_only_cost + self.gan_feat_cost + self.vgg_feat_cost + l1loss(
self.z_noise, self.z_rec_fake) * 0.1
"""
disc_reg = self.Discriminator_Regularizer(self.dis_x, self.x, self.dis_x_p, self.x_p)
#for more than one fake dis...
assert self.dis_cost.shape == disc_reg.shape
self.dis_cost += (self.gamma_plh/2.0)*disc_reg
"""
train_vars = tf.trainable_variables()
self.gen_params = [
v for v in train_vars if v.name.split("/")[1] == "global_generate"
]
self.dis_params = [
v for v in train_vars
if v.name.split("/")[1] == "multi_discriminate"
]
with tf.variable_scope('pix2pixhd'):
genopt = tf.train.AdamOptimizer(learning_rate=2e-6,
beta1=0.5,
beta2=0.999)
self.gen_train_op = slim.learning.create_train_op(
self.gen_cost,
genopt,
summarize_gradients=True,
variables_to_train=self.gen_params)
disopt = tf.train.AdamOptimizer(learning_rate=2e-6,
beta1=0.5,
beta2=0.999)
self.dis_train_op = slim.learning.create_train_op(
self.dis_cost,
disopt,
summarize_gradients=True,
variables_to_train=self.dis_params)
path = "/workspace2/kitti/testing/image_2/007489.png"
th = 0.90
upl = 20
ra = 2
args.iterative = False
args.verbose = False
config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
sess = tf.Session(config=config)
zb = args.nsamples
nf = 256
zdim = 1024
z_tensor = tf.placeholder(tf.float32, [None, zdim])
images = tf.placeholder(tf.float32, [None, 150, 496, 3])
scdobj = scd.SCD(input=images)
rgan = eval_rgan.rgan(latent_vec=z_tensor,
images=scdobj.end_points["pool5"],
nf=nf,
z_dim=zdim,
training=True)
imgsynth = eval_imgsynth.ImageSynthesizer(rgan.rec_x_p_out)
scd_saver = scd.get_saver()
scd_saver.restore(sess, "/workspace/imgsynth/ssd_300_kitti/ssd_model.ckpt")
imgsynth_saver = eval_imgsynth.get_saver()
imgsynth_saver.restore(
sess, "/workspace/imgsynth/result_kitti256p_2/model.ckpt-89")
rgan_saver = eval_rgan.get_saver()
rgan_saver.restore(sess, "models/model-99999")