def sg_ctc(tensor, opt):
r"""Computes the CTC (Connectionist Temporal Classification) Loss between `tensor` and `target`.
Args:
tensor: A 3-D `float Tensor`.
opt:
target: A `Tensor` with the same length in the first dimension as the `tensor`. Labels. ( Dense tensor )
name: A `string`. A name to display in the tensor board web UI.
Returns:
A 1-D `Tensor` with the same length in the first dimension of the `tensor`.
For example,
```
tensor = [[[2., -1., 3.], [3., 1., -2.]], [[1., -1., 2.], [3., 1., -2.]]]
target = [[2., 1.], [2., 3.]]
tensor.sg_ctc(target=target) => [ 4.45940781 2.43091154]
```
"""
assert opt.target is not None, 'target is mandatory.'
# default sequence length
shape = tf.shape(tensor)
opt += tf.sg_opt(seq_len=tf.ones((shape[0],), dtype=tf.sg_intx) * shape[1], merge=True)
# ctc loss
out = tf.nn.ctc_loss(opt.target.sg_to_sparse(), tensor, opt.seq_len,
ctc_merge_repeated=opt.merge, time_major=False)
out = tf.identity(out, 'ctc')
# add summary
tf.sg_summary_loss(out, name=opt.name)
return out
def sg_ctc(tensor, opt):
assert opt.target is not None, 'target is mandatory.'
# default sequence length
shape = tf.shape(tensor)
opt += tf.sg_opt(seq_len=tf.ones((shape[0],), dtype=tf.sg_intx) * shape[1])
# ctc loss
out = tf.nn.ctc_loss(tensor, opt.target.sg_to_sparse(), opt.seq_len, time_major=False)
out = tf.identity(out, 'ctc')
# add summary
tf.sg_summary_loss(out)
return out
def trainIt():
data = prepareData()
x = data['train'][0]
# x = data['train']
z = tf.random_normal((batch_size, rand_dim))
gen = generator(z)
disc_real = discriminator(x)
disc_fake = discriminator(gen)
loss_d_r = disc_real.sg_mse(target=data['train'][1], name='disc_real')
# loss_d_r = disc_real.sg_mse(target = tf.ones(batch_size), name = 'disc_real')
loss_d_f = disc_fake.sg_mse(target=tf.zeros(batch_size), name='disc_fake')
loss_d = (loss_d_r + loss_d_f) / 2
loss_g = disc_fake.sg_mse(target=tf.ones(batch_size), name='gen')
# train_disc = tf.sg_optim(loss_d, lr=0.01, name = 'train_disc', category = 'discriminator') # discriminator train ops
train_disc = tf.sg_optim(loss_d_r,
lr=0.01,
name='train_disc',
category='discriminator')
train_gen = tf.sg_optim(loss_g, lr=0.01,
category='generator') # generator train ops
@tf.sg_train_func
def alt_train(sess, opt):
if sess.run(tf.sg_global_step()) % 1 == 0:
l_disc = sess.run([loss_d_r,
train_disc])[0] # training discriminator
else:
l_disc = sess.run(loss_d)
# l_gen = sess.run([loss_g, train_gen])[0] # training generator
# print np.mean(l_gen)
return np.mean(l_disc) #+ np.mean(l_gen)
alt_train(log_interval=10,
max_ep=25,
ep_size=(1100 + 690) / batch_size,
early_stop=False,
save_dir='asset/train/gan',
save_interval=10)
def sg_ctc(tensor, opt):
r"""Returns softmax cross entropy loss between `tensor` and `target`.
Args:
tensor: A `Tensor`. Logits. Unscaled log probabilities.
target: A `Tensor` with the same length in the first dimension as the `tensor`. Labels. ( Dense tensor )
Returns:
A 1-D `Tensor` with the same shape as `tensor`.
For example,
```
tensor = [[[2, -1, 3], [3, 1, -2]]]
target = [[2, 1]]
tensor.sg_ce(target=target, one_hot=True) => [ 31.32656264 64.13284527]
```
"""
assert opt.target is not None, 'target is mandatory.'
# default sequence length
shape = tf.shape(tensor)
opt += tf.sg_opt(seq_len=tf.ones((shape[0], ), dtype=tf.sg_intx) *
shape[1])
# ctc loss
out = tf.nn.ctc_loss(tensor,
opt.target.sg_to_sparse(),
opt.seq_len,
time_major=False)
out = tf.identity(out, 'ctc')
# add summary
tf.sg_summary_loss(out)
return out
return disc, cat, con
#
# inputs
#
# MNIST input tensor ( with QueueRunner )
data = tf.sg_data.Mnist(batch_size=batch_size)
# input images and label
x = data.train.image
y = data.train.label
# labels for discriminator
y_real = tf.ones(batch_size)
y_fake = tf.zeros(batch_size)
# discriminator labels ( half 1s, half 0s )
y_disc = tf.concat(0, [y, y * 0])
# categorical latent variable
z_cat = tf.multinomial(
tf.ones((batch_size, cat_dim), dtype=tf.sg_floatx) / cat_dim,
1).sg_squeeze().sg_int()
# continuous latent variable
z_con = tf.random_normal((batch_size, con_dim))
# random latent variable dimension
z_rand = tf.random_normal((batch_size, rand_dim))
# latent variable
z = tf.concat(1, [z_cat.sg_one_hot(depth=cat_dim), z_con, z_rand])
# inputs
#
# MNIST input tensor ( with QueueRunner )
data = tf.sg_data.Mnist(batch_size=batch_size)
# input images
x = data.train.image
# corrupted image
x_small = tf.image.resize_bicubic(x, (14, 14))
x_nearest = tf.image.resize_images(x_small, (28, 28),
tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# generator labels ( all ones )
y = tf.ones(batch_size, dtype=tf.sg_floatx)
# discriminator labels ( half 1s, half 0s )
y_disc = tf.concat([y, y * 0], 0)
#
# create generator
#
# I've used ESPCN scheme
# http://www.cv-foundation.org/openaccess/content_cvpr_2016/papers/Shi_Real-Time_Single_Image_CVPR_2016_paper.pdf
#
# generator network
with tf.sg_context(name='generator', act='relu', bn=True):
gen = (x_small.sg_conv(dim=32).sg_conv().sg_conv(
dim=4, act='sigmoid', bn=False).sg_periodic_shuffle(factor=2))
batch_size = 32 # batch size num_category = 10 # category variable number num_cont = 2 # continuous variable number num_dim = 30 # total latent dimension ( category + continuous + noise ) # # inputs # # input tensor ( with QueueRunner ) data = TimeSeriesData(batch_size=batch_size) x = data.X # generator labels ( all ones ) y = tf.ones(batch_size, dtype=tf.sg_floatx) # discriminator labels ( half 1s, half 0s ) y_disc = tf.concat(0, [y, y * 0]) # # create generator # # random class number z_cat = tf.multinomial(tf.ones((batch_size, num_category), dtype=tf.sg_floatx) / num_category, 1).sg_squeeze() # random seed = random categorical variable + random uniform z = z_cat.sg_one_hot(depth=num_category).sg_concat(target=tf.random_uniform((batch_size, num_dim-num_category)))
# # hyper parameters # batch_size = 32 # batch size # # inputs # # input tensor ( with QueueRunner ) data = SpectrumData(batch_size=batch_size) x = data.X # labels for discriminator y_real = tf.ones(batch_size) y_fake = tf.zeros(batch_size) # continuous latent variable z_con = tf.random_uniform((batch_size, con_dim)) # random latent variable dimension z_rand = tf.random_uniform((batch_size, rand_dim)) # latent variable z = tf.concat([z_con, z_rand], 1) # # Computational graph # # generator gen = generator(z)
num_dim = 30 # total latent dimension ( category + continuous + noise )
#
# inputs
#
# target_number
target_num = tf.placeholder(dtype=tf.sg_intx, shape=batch_size)
# target continuous variable # 1
target_cval_1 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size)
# target continuous variable # 2
target_cval_2 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size)
# category variables
z = (tf.ones(batch_size, dtype=tf.sg_intx) * target_num).sg_one_hot(depth=num_category)
# continuous variables
z = z.sg_concat(target=[target_cval_1.sg_expand_dims(), target_cval_2.sg_expand_dims()])
# random seed = categorical variable + continuous variable + random uniform
z = z.sg_concat(target=tf.random_uniform((batch_size, num_dim-num_cont-num_category)))
#
# create generator
#
# generator network
with tf.sg_context(name='generator', size=(4, 1), stride=(2, 1), act='relu', bn=True):
gen = (z.sg_dense(dim=1024)
#
# inputs
#
# MNIST input tensor ( with QueueRunner )
data = tf.sg_data.Mnist(batch_size=batch_size)
# input images
x = data.train.image
# corrupted image
x_small = tf.image.resize_bicubic(x, (14, 14))
x_nearest = tf.image.resize_images(x_small, (28, 28), tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# generator labels ( all ones )
y = tf.ones(batch_size, dtype=tf.sg_floatx)
# discriminator labels ( half 1s, half 0s )
y_disc = tf.concat(0, [y, y * 0])
#
# create generator
#
# I've used ESPCN scheme
# http://www.cv-foundation.org/openaccess/content_cvpr_2016/papers/Shi_Real-Time_Single_Image_CVPR_2016_paper.pdf
#
# generator network
with tf.sg_context(name='generator', act='relu', bn=True):
gen = (x_small
.sg_conv(dim=32)
num_category = 10 # total categorical factor num_cont = 2 # total continuous factor num_dim = 50 # total latent dimension # # inputs # # MNIST input tensor ( with QueueRunner ) data = tf.sg_data.Mnist(batch_size=batch_size) # input images x = data.train.image # generator labels ( all ones ) y = tf.ones(batch_size, dtype=tf.sg_floatx) # discriminator labels ( half 1s, half 0s ) y_disc = tf.concat(0, [y, y * 0]) # # create generator # # random class number z_cat = tf.multinomial(tf.ones((batch_size, num_category), dtype=tf.sg_floatx) / num_category, 1).sg_squeeze().sg_int() # random seed = random categorical variable + random uniform z = z_cat.sg_one_hot(depth=num_category).sg_concat(target=tf.random_uniform((batch_size, num_dim - num_category))) # random continuous variable
# set log level to debug
tf.sg_verbosity(10)
#
# inputs
#
# MNIST input tensor ( with QueueRunner )
data = tf.sg_data.Mnist(batch_size=32)
# input images
x = data.train.image
# generator labels ( all ones )
y = tf.ones(data.batch_size, dtype=tf.sg_floatx)
# discriminator labels ( half 1s, half 0s )
y_disc = tf.concat(0, [y, y * 0])
#
# create generator
#
# random uniform seed
z = tf.random_uniform((data.batch_size, 100))
with tf.sg_context(name='generator', size=4, stride=2, act='relu', bn=True):
# generator network
gen = (z.sg_dense(dim=1024).sg_dense(dim=7 * 7 * 128).sg_reshape(
return res # # inputs # # target_number target_num = tf.placeholder(dtype=tf.sg_intx, shape=batch_size) # target continuous variable # 1 target_cval_1 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size) # target continuous variable # 2 target_cval_2 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size) # category variables z = (tf.ones(batch_size, dtype=tf.sg_intx) * target_num).sg_one_hot(depth=cat_dim) # continuous variables z = z.sg_concat(target=[target_cval_1.sg_expand_dims(), target_cval_2.sg_expand_dims()]) # random seed = categorical variable + continuous variable + random normal z = z.sg_concat(target=tf.random_normal((batch_size, rand_dim))) # generator gen = generator(z).sg_squeeze() # # run generator # def run_generator(num, x1, x2, fig_name='sample.png'):
return disc, cat, con # # inputs # # MNIST input tensor ( with QueueRunner ) data = tf.sg_data.Mnist(batch_size=batch_size) # input images and label x = data.train.image y = data.train.label # labels for discriminator y_real = tf.ones(batch_size) y_fake = tf.zeros(batch_size) # discriminator labels ( half 1s, half 0s ) y_disc = tf.concat(axis=0, values=[y, y * 0]) # categorical latent variable z_cat = tf.multinomial(tf.ones((batch_size, cat_dim), dtype=tf.sg_floatx) / cat_dim, 1).sg_squeeze().sg_int() # continuous latent variable z_con = tf.random_normal((batch_size, con_dim)) # random latent variable dimension z_rand = tf.random_normal((batch_size, rand_dim)) # latent variable z = tf.concat(axis=1, values=[z_cat.sg_one_hot(depth=cat_dim), z_con, z_rand])
return res
#
# inputs
#
# target_number
target_num = tf.placeholder(dtype=tf.sg_intx, shape=batch_size)
# target continuous variable # 1
target_cval_1 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size)
# target continuous variable # 2
target_cval_2 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size)
# category variables
z = (tf.ones(batch_size, dtype=tf.sg_intx) *
target_num).sg_one_hot(depth=cat_dim)
# continuous variables
z = z.sg_concat(
target=[target_cval_1.sg_expand_dims(),
target_cval_2.sg_expand_dims()])
# random seed = categorical variable + continuous variable + random normal
z = z.sg_concat(target=tf.random_normal((batch_size, rand_dim)))
# generator
gen = generator(z).sg_squeeze()
#
self.train = tf.sg_opt()
# convert to tensor queue
self.train.image, self.train.label = \
_data_to_tensor([x.astype('float32'), label.astype('int32')], batch_size, name='train')
# calc total batch count
self.train.num_batch = label.shape[0] // batch_size
# MNIST input tensor ( with QueueRunner )
data = Mnist(batch_size=batch_size)
# input images
x = data.train.image
# generator labels ( all ones )
y = tf.ones(batch_size, dtype=tf.sg_floatx)
# discriminator labels ( half 1s, half 0s )
y_disc = tf.concat([y, y * 0], 0)
#
# create generator
#
# random class number
z_cat = tf.multinomial(
tf.ones((batch_size, num_category), dtype=tf.sg_floatx) / num_category,
1).sg_squeeze().sg_int()
# random seed = random categorical variable + random uniform
z = z_cat.sg_one_hot(depth=num_category).sg_concat(
target=tf.random_uniform((batch_size, num_dim - num_category)))
# random continuous variable
z_cont = z[:, num_category:num_category + num_cont]
# category label
num_dim = 50 # total latent dimension # # inputs # # target_number target_num = tf.placeholder(dtype=tf.sg_intx, shape=batch_size) # target continuous variable # 1 target_cval_1 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size) # target continuous variable # 2 target_cval_2 = tf.placeholder(dtype=tf.sg_floatx, shape=batch_size) # category variables z = (tf.ones(batch_size, dtype=tf.sg_intx) * target_num).sg_one_hot(depth=num_category) # continuous variables z = z.sg_concat(target=[target_cval_1.sg_expand_dims(), target_cval_2.sg_expand_dims()]) # random seed = categorical variable + continuous variable + random uniform z = z.sg_concat(target=tf.random_uniform((batch_size, num_dim-num_cont-num_category-1))) # # create generator # # generator network # with tf.sg_context(name='generator', stride=2, act='relu', bn=True): # gen = (z.sg_dense(dim=1024)
