def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
q_units = net_conf.inference_num_units
q_layers = net_conf.inference_num_layers
p_units = net_conf.prediction_num_units
p_layers = net_conf.prediction_num_layers
latent_dim = net_conf.latent_dim
beta = net_conf.regularize_const
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
epoch = train_conf.epoch
batch_len = train_conf.batch_length
batchsize = train_conf.batchsize
data_dim = 128
save_dir = train_conf.save_dir
if not os.path.exists(save_dir):
os.mkdir(save_dir)
save_file = os.path.join(save_dir, "model.ckpt")
# data preparation
train_data = read_target(train_conf.train_dir, data_dim)
train_num = train_data.shape[1]
train_len = train_data.shape[0]
if train_conf.test:
test_data = read_target(train_conf.test_dir)
test_len = test_data.shape[0]
test_num = test_data.shape[1]
np.random.seed(seed)
tf.reset_default_graph()
tf.set_random_seed(seed)
global_step = tf.Variable(0, name="global_step", trainable=False)
x = tf.placeholder(tf.float32, [batch_len, batchsize, data_dim])
z_mean, z_log_var = inference(x, q_units, q_layers, latent_dim)
y = generation(x, z_mean, z_log_var, p_units, p_layers, data_dim)
with tf.name_scope('loss'):
recon_loss = tf.reduce_mean(-tf.reduce_sum(x*tf.log(y), axis=2))
latent_loss = -tf.reduce_mean(tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=1))
loss = recon_loss + beta * latent_loss
train_step = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss, global_step=global_step)
gpuConfig = tf.ConfigProto(
gpu_options=tf.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
ckpt = tf.train.get_checkpoint_state(save_dir)
latest_model = ckpt.model_checkpoint_path
saver.restore(sess, latest_model)
error_log = []
for itr in range(epoch):
batch_idx = np.random.permutation(train_num)[:batchsize]
start_pos = np.random.randint(train_len - batch_len)
batch = train_data[start_pos:start_pos+batch_len, batch_idx, :]
feed_dict = {x: batch}
_, latent, recon, total, step = sess.run([train_step,
latent_loss,
recon_loss,
loss,
global_step],
feed_dict=feed_dict)
error_log.append([step, latent, recon, total])
print "step:{} latent:{}, recon:{}, total:{}".format(step, latent, recon, total)
if train_conf.test and itr % train_conf.test_interval == 0:
batch_idx = np.random.permutation(test_num)[:batchsize]
start_pos = np.random.randint(test_len - batch_len)
batch = test_data[start_pos:start_pos+batch_len, batch_idx, :]
feed_dict = {x: batch}
latent, recon, total = sess.run([latent_loss,
recon_loss,
loss],
feed_dict=feed_dict)
print "-------test--------"
print "step:{} latent:{}, recon:{}, total:{}".format(step, latent, recon, total)
print "-------------------"
if step % train_conf.log_interval == 0:
saver.save(sess, save_file, global_step=global_step)
error_log = np.array(error_log)
old_error_log = np.loadtxt("error.log")
np.savetxt("error.log", np.r_[old_error_log, error_log])
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
batchsize = 1
epoch = train_conf.epoch
save_dir = train_conf.save_dir
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, L_filenames = read_sequential_target(
L_data_dir, True)
print len(L_filenames)
B_fw, B_bw, B_bin, B_len, B_filenames = read_sequential_target(
B_data_dir, True)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, L_filenames_u = read_sequential_target(
L_data_dir_test, True)
print len(L_filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u, B_filenames_u = read_sequential_target(
B_data_dir_test, True)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(
V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
tf.reset_default_graph()
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
L_enc_final_state = encoder(placeholders["L_bw"],
placeholders["L_len"],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_encoder")
VB_input = tf.concat([placeholders["V_bw"], placeholders["B_bw"]], axis=2)
VB_enc_final_state = encoder(VB_input,
placeholders["V_len"],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_encoder")
##### sharing #####
L_shared = fc(L_enc_final_state,
SHARE_DIM,
activation_fn=None,
scope="L_share")
VB_shared = fc(VB_enc_final_state,
SHARE_DIM,
activation_fn=None,
scope="VB_share")
gpuConfig = tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
for i in range(B_shape[1]):
feed_dict = {
placeholders["L_fw"]: L_fw[:, i:i + 1, :],
placeholders["B_fw"]: B_fw[:, i:i + 1, :],
placeholders["V_fw"]: V_fw[:, i:i + 1, :],
placeholders["L_bw"]: L_bw[:, i:i + 1, :],
placeholders["B_bw"]: B_bw[:, i:i + 1, :],
placeholders["V_bw"]: V_bw[:, i:i + 1, :],
placeholders["B_bin"]: B_bin[:, i:i + 1, :],
placeholders["L_len"]: L_len[i:i + 1],
placeholders["V_len"]: V_len[i:i + 1]
}
L_enc, VB_enc = sess.run([L_shared, VB_shared], feed_dict=feed_dict)
save_latent(L_enc, L_filenames[i])
save_latent(VB_enc, B_filenames[i])
print B_filenames[i]
if train_conf.test:
for i in range(B_shape_u[1]):
feed_dict = {
placeholders["L_fw"]: L_fw_u[:, i:i + 1, :],
placeholders["B_fw"]: B_fw_u[:, i:i + 1, :],
placeholders["V_fw"]: V_fw_u[:, i:i + 1, :],
placeholders["L_bw"]: L_bw_u[:, i:i + 1, :],
placeholders["B_bw"]: B_bw_u[:, i:i + 1, :],
placeholders["V_bw"]: V_bw_u[:, i:i + 1, :],
placeholders["B_bin"]: B_bin_u[:, i:i + 1, :],
placeholders["L_len"]: L_len_u[i:i + 1],
placeholders["V_len"]: V_len_u[i:i + 1]
}
L_enc, VB_enc = sess.run([L_shared, VB_shared],
feed_dict=feed_dict)
save_latent(L_enc, L_filenames_u[i])
save_latent(VB_enc, B_filenames_u[i])
print B_filenames_u[i]
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
batchsize = 1
save_dir = train_conf.save_dir
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, L_filenames = read_sequential_target(
L_data_dir, True)
print len(L_filenames)
B_fw, B_bw, B_bin, B_len, B_filenames = read_sequential_target(
B_data_dir, True)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, L_filenames_u = read_sequential_target(
L_data_dir_test, True)
print len(L_filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u, B_filenames_u = read_sequential_target(
B_data_dir_test, True)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(
V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
tf.reset_default_graph()
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
VB_input = tf.concat([placeholders["V_bw"], placeholders["B_bw"]], axis=2)
VB_enc_final_state = encoder(VB_input,
placeholders["V_len"],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_encoder")
##### sharing #####
VB_shared = fc(VB_enc_final_state,
SHARE_DIM,
activation_fn=None,
scope="VB_share")
L_dec_init_state = fc(VB_shared,
L_num_units * L_num_layers * 2,
activation_fn=None,
scope="L_postshare")
##### decoding #####
L_output = L_decoder(placeholders["L_fw"][0],
L_dec_init_state,
length=L_shape[0],
out_dim=L_shape[2],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_decoder")
L_output = tf.contrib.seq2seq.hardmax(L_output)
gpuConfig = tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
for i in range(B_shape[1]):
feed_dict = {
placeholders["L_fw"]: L_fw[:, i:i + 1, :],
placeholders["B_fw"]: B_fw[:, i:i + 1, :],
placeholders["V_fw"]: V_fw[:, i:i + 1, :],
placeholders["L_bw"]: L_bw[:, i:i + 1, :],
placeholders["B_bw"]: B_bw[:, i:i + 1, :],
placeholders["V_bw"]: V_bw[:, i:i + 1, :],
placeholders["B_bin"]: B_bin[:, i:i + 1, :],
placeholders["L_len"]: L_len[i:i + 1],
placeholders["V_len"]: V_len[i:i + 1]
}
result = sess.run([L_output], feed_dict=feed_dict)
r = result[0][:, 0, :].argmax(axis=1)
t = L_fw[1:, i, :].argmax(axis=1)
print(r == t).all()
if train_conf.test:
print "test!!!!!!!!!!!!!!!!"
for i in range(B_shape_u[1]):
feed_dict = {
placeholders["L_fw"]: L_fw_u[:, i:i + 1, :],
placeholders["B_fw"]: B_fw_u[:, i:i + 1, :],
placeholders["V_fw"]: V_fw_u[:, i:i + 1, :],
placeholders["L_bw"]: L_bw_u[:, i:i + 1, :],
placeholders["B_bw"]: B_bw_u[:, i:i + 1, :],
placeholders["V_bw"]: V_bw_u[:, i:i + 1, :],
placeholders["B_bin"]: B_bin_u[:, i:i + 1, :],
placeholders["L_len"]: L_len_u[i:i + 1],
placeholders["V_len"]: V_len_u[i:i + 1]
}
result = sess.run([L_output], feed_dict=feed_dict)
result = result[0][:, 0, :].argmax(axis=1)
target = L_fw_u[1:, i, :].argmax(axis=1)
print(result == target).all()
def main():
encoder_conf = open("./encoder.json", "r")
encoder_layers = json.load(encoder_conf)
decoder_conf = open("./decoder.json", "r")
decoder_layers = json.load(decoder_conf)
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
q_units = net_conf.inference_num_units
q_layers = net_conf.inference_num_layers
p_units = net_conf.prediction_num_units
p_layers = net_conf.prediction_num_layers
latent_dim = net_conf.latent_dim
beta = net_conf.regularize_const
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
epoch = train_conf.epoch
save_dir = train_conf.save_dir + "/"
save_file = os.path.join(save_dir, "model.ckpt")
data_file = train_conf.data_file
if not os.path.exists(data_file):
if not os.path.exists(os.path.dirname(data_file)):
os.mkdir(os.path.dirname(data_file))
import wget
url = "http://www.cs.toronto.edu/~nitish/unsupervised_video/mnist_test_seq.npy"
wget.download(url, out=data_file)
data = np.load(data_file)
data = (data / 255.) * 0.9 + 0.05
train_data = data[:, :8000, :, :]
test_data = data[:, 8000:, :, :]
data_len = train_data.shape[0]
batchsize = train_conf.batchsize
height = train_data.shape[2]
width = train_data.shape[3]
n_channel = 1
np.random.seed(seed)
tf.compat.v1.reset_default_graph()
tf.compat.v1.set_random_seed(seed)
global_step = tf.Variable(0, name="global_step", trainable=False)
x = tf.compat.v1.placeholder(
tf.float32, [data_len, batchsize, height, width, n_channel])
reshaped_x = tf.reshape(x, [-1, height, width, n_channel])
with tf.compat.v1.variable_scope("encoder", reuse=False):
h = image_processor(reshaped_x, encoder_layers)
h = tf.reshape(h, [data_len, batchsize, -1])
z_post_mean, z_post_log_var = inference(h, q_units, q_layers, latent_dim)
z_prior_mean = tf.zeros(z_post_mean.get_shape().as_list(), tf.float32)
z_prior_log_var = tf.ones(z_post_log_var.get_shape().as_list(), tf.float32)
is_train = tf.compat.v1.placeholder(tf.bool)
z_mean = tf.cond(pred=is_train,
true_fn=lambda: z_post_mean,
false_fn=lambda: z_prior_mean)
z_log_var = tf.cond(pred=is_train,
true_fn=lambda: z_post_log_var,
false_fn=lambda: z_prior_log_var)
g = generation(h, z_mean, z_log_var, p_units, p_layers,
int(h.get_shape()[2]))
g = tf.reshape(g, [-1, int(h.get_shape()[2])])
with tf.compat.v1.variable_scope("decoder", reuse=False):
reshaped_y = image_processor(g, decoder_layers)
y = tf.reshape(reshaped_y, x.get_shape().as_list())
with tf.compat.v1.name_scope('loss'):
# mse is ok? not cross entropy?
recon_loss = tf.reduce_mean(input_tensor=tf.square(x - y))
latent_loss = -tf.reduce_mean(input_tensor=1 + z_log_var -
tf.square(z_mean) - tf.exp(z_log_var))
# what is the appropriate beta...
loss = recon_loss + beta * latent_loss
train_step = tf.compat.v1.train.AdamOptimizer(
learning_rate=0.001).minimize(loss, global_step=global_step)
gpuConfig = tf.compat.v1.ConfigProto(gpu_options=tf.compat.v1.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.compat.v1.Session(config=gpuConfig)
sess.run(tf.compat.v1.global_variables_initializer())
saver = tf.compat.v1.train.Saver(tf.compat.v1.global_variables())
ckpt = tf.train.get_checkpoint_state(save_dir)
latest_model = ckpt.model_checkpoint_path
saver.restore(sess, latest_model)
error_log = []
for itr in range(epoch):
batch_idx = np.random.permutation(8000)[:batchsize]
batch = train_data[:, batch_idx, :, :]
batch = np.reshape(batch, list(batch.shape) + [1])
feed_dict = {is_train: True, x: batch}
_, latent, recon, total, step = sess.run(
[train_step, latent_loss, recon_loss, loss, global_step],
feed_dict=feed_dict)
error_log.append([step, latent, recon, total])
print("step:{} latent:{}, recon:{}, total:{}".format(
step, latent, recon, total))
if train_conf.test and (step + 1) % train_conf.test_interval == 0:
batch_idx = np.random.permutation(2000)[:batchsize]
batch = test_data[:, batch_idx, :, :]
batch = np.reshape(batch, list(batch.shape) + [1])
feed_dict = {is_train: False, x: batch}
latent, recon, total = sess.run([latent_loss, recon_loss, loss],
feed_dict=feed_dict)
print("test.")
print("step:{} latent:{}, recon:{}, total:{}".format(
step, latent, recon, total))
if step % train_conf.log_interval == 0:
saver.save(sess, save_file, global_step=global_step)
error_log = np.array(error_log)
old_error_log = np.loadtxt("error.log")
np.savetxt("error.log", np.r_[old_error_log, error_log])
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
batchsize = 1
save_dir = train_conf.save_dir
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, L_filenames = read_sequential_target(L_data_dir, True)
print len(L_filenames)
B_fw, B_bw, B_bin, B_len, B_filenames = read_sequential_target(B_data_dir, True)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, L_filenames_u = read_sequential_target(L_data_dir_test, True)
print len(L_filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u, B_filenames_u = read_sequential_target(B_data_dir_test, True)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
L_enc_final_state = encoder(placeholders["L_bw"],
placeholders["L_len"],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_encoder")
##### sharing #####
L_shared = fc(L_enc_final_state, SHARE_DIM,
activation_fn=None, scope="L_share")
VB_dec_init_state = fc(L_shared, VB_num_units*VB_num_layers*2,
activation_fn=None, scope="VB_postshare")
##### decoding #####
B_output = VB_decoder(placeholders["V_fw"],
placeholders["B_fw"][0],
VB_dec_init_state,
length=B_shape[0],
out_dim=B_shape[2],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_decoder")
gpuConfig = tf.ConfigProto(
gpu_options=tf.GPUOptions(allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
for i in range(B_shape[1]):
feed_dict = {placeholders["L_fw"]: L_fw[:, i:i+1, :],
placeholders["B_fw"]: B_fw[:, i:i+1, :],
placeholders["V_fw"]: V_fw[:, i:i+1, :],
placeholders["L_bw"]: L_bw[:, i:i+1, :],
placeholders["B_bw"]: B_bw[:, i:i+1, :],
placeholders["V_bw"]: V_bw[:, i:i+1, :],
placeholders["B_bin"]: B_bin[:, i:i+1, :],
placeholders["L_len"]: L_len[i:i+1],
placeholders["V_len"]: V_len[i:i+1]}
result = sess.run(B_output, feed_dict=feed_dict)
save_latent(np.transpose(result, (1,0,2)), B_filenames[i], "generation")
if train_conf.test:
for i in range(B_shape_u[1]):
feed_dict = {placeholders["L_fw"]: L_fw_u[:, i:i+1, :],
placeholders["B_fw"]: B_fw_u[:, i:i+1, :],
placeholders["V_fw"]: V_fw_u[:, i:i+1, :],
placeholders["L_bw"]: L_bw_u[:, i:i+1, :],
placeholders["B_bw"]: B_bw_u[:, i:i+1, :],
placeholders["V_bw"]: V_bw_u[:, i:i+1, :],
placeholders["B_bin"]: B_bin_u[:, i:i+1, :],
placeholders["L_len"]: L_len_u[i:i+1],
placeholders["V_len"]: V_len_u[i:i+1]}
result = sess.run(B_output, feed_dict=feed_dict)
save_latent(np.transpose(result, (1,0,2)), B_filenames_u[i], "generation")
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
batchsize = 1
epoch = train_conf.epoch
save_dir = train_conf.save_dir
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, L_filenames = read_sequential_target(L_data_dir, True)
print len(L_filenames)
B_fw, B_bw, B_bin, B_len, B_filenames = read_sequential_target(B_data_dir, True)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, L_filenames_u = read_sequential_target(L_data_dir_test, True)
print len(L_filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u, B_filenames_u = read_sequential_target(B_data_dir_test, True)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
tf.reset_default_graph()
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
L_enc_final_state = encoder(placeholders["L_bw"],
placeholders["L_len"],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_encoder")
VB_input = tf.concat([placeholders["V_bw"],
placeholders["B_bw"]],
axis=2)
VB_enc_final_state = encoder(VB_input,
placeholders["V_len"],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_encoder")
##### sharing #####
L_shared = fc(L_enc_final_state, SHARE_DIM,
activation_fn=None, scope="L_share")
VB_shared = fc(VB_enc_final_state, SHARE_DIM,
activation_fn=None, scope="VB_share")
gpuConfig = tf.ConfigProto(
gpu_options=tf.GPUOptions(allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
for i in range(B_shape[1]):
feed_dict = {placeholders["L_fw"]: L_fw[:, i:i+1, :],
placeholders["B_fw"]: B_fw[:, i:i+1, :],
placeholders["V_fw"]: V_fw[:, i:i+1, :],
placeholders["L_bw"]: L_bw[:, i:i+1, :],
placeholders["B_bw"]: B_bw[:, i:i+1, :],
placeholders["V_bw"]: V_bw[:, i:i+1, :],
placeholders["B_bin"]: B_bin[:, i:i+1, :],
placeholders["L_len"]: L_len[i:i+1],
placeholders["V_len"]: V_len[i:i+1]}
L_enc, VB_enc = sess.run([L_shared, VB_shared],
feed_dict=feed_dict)
save_latent(L_enc, L_filenames[i])
save_latent(VB_enc, B_filenames[i])
print B_filenames[i]
if train_conf.test:
for i in range(B_shape_u[1]):
feed_dict = {placeholders["L_fw"]: L_fw_u[:, i:i+1, :],
placeholders["B_fw"]: B_fw_u[:, i:i+1, :],
placeholders["V_fw"]: V_fw_u[:, i:i+1, :],
placeholders["L_bw"]: L_bw_u[:, i:i+1, :],
placeholders["B_bw"]: B_bw_u[:, i:i+1, :],
placeholders["V_bw"]: V_bw_u[:, i:i+1, :],
placeholders["B_bin"]: B_bin_u[:, i:i+1, :],
placeholders["L_len"]: L_len_u[i:i+1],
placeholders["V_len"]: V_len_u[i:i+1]}
L_enc, VB_enc = sess.run([L_shared, VB_shared],
feed_dict=feed_dict)
save_latent(L_enc, L_filenames_u[i])
save_latent(VB_enc, B_filenames_u[i])
print B_filenames_u[i]
def main():
encoder_conf = open("./encoder.json", "r")
encoder_layers = json.load(encoder_conf)
decoder_conf = open("./decoder.json", "r")
decoder_layers = json.load(decoder_conf)
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
q_units = net_conf.inference_num_units
q_layers = net_conf.inference_num_layers
p_units = net_conf.prediction_num_units
p_layers = net_conf.prediction_num_layers
latent_dim = net_conf.latent_dim
beta = net_conf.regularize_const
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
epoch = train_conf.epoch
save_dir = train_conf.save_dir
if not os.path.exists(os.path.dirname(save_dir)):
os.mkdir(os.path.dirname(save_dir))
data_file = train_conf.data_file
if not os.path.exists(data_file):
if not os.path.exists(os.path.dirname(data_file)):
os.mkdir(os.path.dirname(data_file))
import wget
url = "http://www.cs.toronto.edu/~nitish/unsupervised_video/mnist_test_seq.npy"
wget.download(url, out=data_file)
data = np.load(data_file)
data = (data / 255.) * 0.9 + 0.05
train_data = data[:, :8000, :, :]
test_data = data[:, 8000:, :, :]
data_len = train_data.shape[0]
batchsize = 1
height = train_data.shape[2]
width = train_data.shape[3]
n_channel = 1
np.random.seed(seed)
tf.reset_default_graph()
tf.set_random_seed(seed)
x = tf.placeholder(tf.float32,
[data_len, batchsize, height, width, n_channel])
reshaped_x = tf.reshape(x, [-1, height, width, n_channel])
with tf.variable_scope("encoder", reuse=False):
h = image_processor(reshaped_x, encoder_layers)
h = tf.reshape(h, [data_len, batchsize, -1])
z_post_mean, z_post_log_var = inference(h, q_units, q_layers, latent_dim)
z_prior_mean = tf.zeros(z_post_mean.get_shape().as_list(), tf.float32)
z_prior_log_var = tf.ones(z_post_log_var.get_shape().as_list(), tf.float32)
is_train = tf.placeholder(tf.bool)
z_mean = tf.cond(is_train, lambda: z_post_mean, lambda: z_prior_mean)
z_log_var = tf.cond(is_train, lambda: z_post_log_var,
lambda: z_prior_log_var)
g = generation(h, z_mean, z_log_var, p_units, p_layers,
int(h.get_shape()[2]))
g = tf.reshape(g, [-1, int(h.get_shape()[2])])
with tf.variable_scope("decoder", reuse=False):
reshaped_y = image_processor(g, decoder_layers)
y = tf.reshape(reshaped_y, x.get_shape().as_list())
with tf.name_scope('loss'):
# mse is ok? not cross entropy?
recon_loss = tf.reduce_mean(tf.square(x - y))
latent_loss = -tf.reduce_mean(1 + z_log_var - tf.square(z_mean) -
tf.exp(z_log_var))
# what is the appropriate beta...
loss = recon_loss + beta * latent_loss
train_step = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
gpuConfig = tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
error_log = []
for i in range(train_data.shape[1]):
print "train {}".format(i)
batch = train_data[:, i:i + 1, :, :]
batch = np.reshape(batch, list(batch.shape) + [1])
feed_dict = {is_train: True, x: batch}
outputs = sess.run(y, feed_dict=feed_dict)
save_as_images(outputs, i, "train")
for i in range(test_data.shape[1]):
print "test {}".format(i)
batch = test_data[:, i:i + 1, :, :]
batch = np.reshape(batch, list(batch.shape) + [1])
feed_dict = {is_train: True, x: batch}
outputs = sess.run(y, feed_dict=feed_dict)
save_as_images(outputs, i, "test")
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
batchsize = train_conf.batchsize
epoch = train_conf.epoch
save_dir = train_conf.save_dir
if not os.path.exists(os.path.dirname(save_dir)):
os.mkdir(os.path.dirname(save_dir))
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, filenames = read_sequential_target(L_data_dir, True)
print len(filenames)
B_fw, B_bw, B_bin, B_len = read_sequential_target(B_data_dir)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, filenames_u = read_sequential_target(L_data_dir_test, True)
print len(filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u = read_sequential_target(B_data_dir_test)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
np.random.seed(seed)
tf.reset_default_graph()
tf.set_random_seed(seed)
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
L_enc_final_state = encoder(placeholders["L_bw"],
placeholders["L_len"],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_encoder")
VB_input = tf.concat([placeholders["V_bw"],
placeholders["B_bw"]],
axis=2)
VB_enc_final_state = encoder(VB_input,
placeholders["V_len"],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_encoder")
##### sharing #####
L_shared = fc(L_enc_final_state, SHARE_DIM,
activation_fn=None, scope="L_share")
VB_shared = fc(VB_enc_final_state, SHARE_DIM,
activation_fn=None, scope="VB_share")
L_dec_init_state = fc(L_shared, L_num_units*L_num_layers*2,
activation_fn=None, scope="L_postshare")
VB_dec_init_state = fc(VB_shared, VB_num_units*VB_num_layers*2,
activation_fn=None, scope="VB_postshare")
##### decoding #####
L_output = L_decoder(placeholders["L_fw"][0],
L_dec_init_state,
length=L_shape[0],
out_dim=L_shape[2],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_decoder")
B_output = VB_decoder(placeholders["V_fw"],
placeholders["B_fw"][0],
VB_dec_init_state,
length=B_shape[0],
out_dim=B_shape[2],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_decoder")
with tf.name_scope('loss'):
L_output = L_output # no need to multiply binary array
B_output = B_output * placeholders["B_bin"][1:]
L_loss = tf.reduce_mean(-tf.reduce_sum(placeholders["L_fw"][1:]*tf.log(L_output),
reduction_indices=[2]))
B_loss = tf.reduce_mean(tf.square(B_output-placeholders["B_fw"][1:]))
share_loss = aligned_discriminative_loss(L_shared, VB_shared)
loss = net_conf.L_weight*L_loss + net_conf.B_weight*B_loss + net_conf.S_weight*share_loss
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_step = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
gpuConfig = tf.ConfigProto(
gpu_options=tf.GPUOptions(allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
previous = time.time()
for step in range(epoch):
batch_idx = np.random.permutation(B_shape[1])[:batchsize]
feed_dict = {placeholders["L_fw"]: L_fw[:, batch_idx, :],
placeholders["B_fw"]: B_fw[:, batch_idx, :],
placeholders["V_fw"]: V_fw[:, batch_idx, :],
placeholders["L_bw"]: L_bw[:, batch_idx, :],
placeholders["B_bw"]: B_bw[:, batch_idx, :],
placeholders["V_bw"]: V_bw[:, batch_idx, :],
placeholders["B_bin"]: B_bin[:, batch_idx, :],
placeholders["L_len"]: L_len[batch_idx],
placeholders["V_len"]: V_len[batch_idx]}
_, l, b, s, t = sess.run([train_step,
L_loss,
B_loss,
share_loss,
loss],
feed_dict=feed_dict)
print "step:{} total:{}, language:{}, behavior:{}, share:{}".format(step, t, l, b, s)
if train_conf.test and (step+1) % train_conf.test_interval == 0:
batch_idx = np.random.permutation(B_shape_u[1])[:batchsize]
feed_dict = {placeholders["L_fw"]: L_fw_u[:, batch_idx, :],
placeholders["B_fw"]: B_fw_u[:, batch_idx, :],
placeholders["V_fw"]: V_fw_u[:, batch_idx, :],
placeholders["L_bw"]: L_bw_u[:, batch_idx, :],
placeholders["B_bw"]: B_bw_u[:, batch_idx, :],
placeholders["V_bw"]: V_bw_u[:, batch_idx, :],
placeholders["B_bin"]: B_bin_u[:, batch_idx, :],
placeholders["L_len"]: L_len_u[batch_idx],
placeholders["V_len"]: V_len_u[batch_idx]}
l, b, s, t = sess.run([L_loss, B_loss, share_loss, loss],
feed_dict=feed_dict)
print "test"
print "step:{} total:{}, language:{}, behavior:{}, share:{}".format(step, t, l, b, s)
if (step + 1) % train_conf.log_interval == 0:
saver.save(sess, save_dir)
past = time.time()
print past-previous
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
batchsize = 1
save_dir = train_conf.save_dir
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, L_filenames = read_sequential_target(
L_data_dir, True)
print len(L_filenames)
B_fw, B_bw, B_bin, B_len, B_filenames = read_sequential_target(
B_data_dir, True)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, L_filenames_u = read_sequential_target(
L_data_dir_test, True)
print len(L_filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u, B_filenames_u = read_sequential_target(
B_data_dir_test, True)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(
V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
L_enc_final_state = encoder(placeholders["L_bw"],
placeholders["L_len"],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_encoder")
##### sharing #####
L_shared = fc(L_enc_final_state,
SHARE_DIM,
activation_fn=None,
scope="L_share")
VB_dec_init_state = fc(L_shared,
VB_num_units * VB_num_layers * 2,
activation_fn=None,
scope="VB_postshare")
##### decoding #####
B_output = VB_decoder(placeholders["V_fw"],
placeholders["B_fw"][0],
VB_dec_init_state,
length=B_shape[0],
out_dim=B_shape[2],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_decoder")
gpuConfig = tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
for i in range(B_shape[1]):
feed_dict = {
placeholders["L_fw"]: L_fw[:, i:i + 1, :],
placeholders["B_fw"]: B_fw[:, i:i + 1, :],
placeholders["V_fw"]: V_fw[:, i:i + 1, :],
placeholders["L_bw"]: L_bw[:, i:i + 1, :],
placeholders["B_bw"]: B_bw[:, i:i + 1, :],
placeholders["V_bw"]: V_bw[:, i:i + 1, :],
placeholders["B_bin"]: B_bin[:, i:i + 1, :],
placeholders["L_len"]: L_len[i:i + 1],
placeholders["V_len"]: V_len[i:i + 1]
}
result = sess.run(B_output, feed_dict=feed_dict)
save_latent(np.transpose(result, (1, 0, 2)), B_filenames[i],
"generation")
if train_conf.test:
for i in range(B_shape_u[1]):
feed_dict = {
placeholders["L_fw"]: L_fw_u[:, i:i + 1, :],
placeholders["B_fw"]: B_fw_u[:, i:i + 1, :],
placeholders["V_fw"]: V_fw_u[:, i:i + 1, :],
placeholders["L_bw"]: L_bw_u[:, i:i + 1, :],
placeholders["B_bw"]: B_bw_u[:, i:i + 1, :],
placeholders["V_bw"]: V_bw_u[:, i:i + 1, :],
placeholders["B_bin"]: B_bin_u[:, i:i + 1, :],
placeholders["L_len"]: L_len_u[i:i + 1],
placeholders["V_len"]: V_len_u[i:i + 1]
}
result = sess.run(B_output, feed_dict=feed_dict)
save_latent(np.transpose(result, (1, 0, 2)), B_filenames_u[i],
"generation")
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
seed = train_conf.seed
batchsize = train_conf.batchsize
epoch = train_conf.epoch
save_dir = train_conf.save_dir
if not os.path.exists(os.path.dirname(save_dir)):
os.mkdir(os.path.dirname(save_dir))
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, filenames = read_sequential_target(
L_data_dir, True)
print len(filenames)
B_fw, B_bw, B_bin, B_len = read_sequential_target(B_data_dir)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, filenames_u = read_sequential_target(
L_data_dir_test, True)
print len(filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u = read_sequential_target(
B_data_dir_test)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(
V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
np.random.seed(seed)
tf.reset_default_graph()
tf.set_random_seed(seed)
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
L_enc_final_state = encoder(placeholders["L_bw"],
placeholders["L_len"],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_encoder")
VB_input = tf.concat([placeholders["V_bw"], placeholders["B_bw"]], axis=2)
VB_enc_final_state = encoder(VB_input,
placeholders["V_len"],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_encoder")
##### sharing #####
L_shared = fc(L_enc_final_state,
SHARE_DIM,
activation_fn=None,
scope="L_share")
VB_shared = fc(VB_enc_final_state,
SHARE_DIM,
activation_fn=None,
scope="VB_share")
L_dec_init_state = fc(L_shared,
L_num_units * L_num_layers * 2,
activation_fn=None,
scope="L_postshare")
VB_dec_init_state = fc(VB_shared,
VB_num_units * VB_num_layers * 2,
activation_fn=None,
scope="VB_postshare")
##### decoding #####
L_output = L_decoder(placeholders["L_fw"][0],
L_dec_init_state,
length=L_shape[0],
out_dim=L_shape[2],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_decoder")
B_output = VB_decoder(placeholders["V_fw"],
placeholders["B_fw"][0],
VB_dec_init_state,
length=B_shape[0],
out_dim=B_shape[2],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_decoder")
with tf.name_scope('loss'):
L_output = L_output # no need to multiply binary array
B_output = B_output * placeholders["B_bin"][1:]
L_loss = tf.reduce_mean(-tf.reduce_sum(placeholders["L_fw"][1:] *
tf.log(L_output),
reduction_indices=[2]))
B_loss = tf.reduce_mean(tf.square(B_output - placeholders["B_fw"][1:]))
share_loss = aligned_discriminative_loss(L_shared, VB_shared)
loss = net_conf.L_weight * L_loss + net_conf.B_weight * B_loss + net_conf.S_weight * share_loss
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_step = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
gpuConfig = tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
previous = time.time()
for step in range(epoch):
batch_idx = np.random.permutation(B_shape[1])[:batchsize]
feed_dict = {
placeholders["L_fw"]: L_fw[:, batch_idx, :],
placeholders["B_fw"]: B_fw[:, batch_idx, :],
placeholders["V_fw"]: V_fw[:, batch_idx, :],
placeholders["L_bw"]: L_bw[:, batch_idx, :],
placeholders["B_bw"]: B_bw[:, batch_idx, :],
placeholders["V_bw"]: V_bw[:, batch_idx, :],
placeholders["B_bin"]: B_bin[:, batch_idx, :],
placeholders["L_len"]: L_len[batch_idx],
placeholders["V_len"]: V_len[batch_idx]
}
_, l, b, s, t = sess.run(
[train_step, L_loss, B_loss, share_loss, loss],
feed_dict=feed_dict)
print "step:{} total:{}, language:{}, behavior:{}, share:{}".format(
step, t, l, b, s)
if train_conf.test and (step + 1) % train_conf.test_interval == 0:
batch_idx = np.random.permutation(B_shape_u[1])[:batchsize]
feed_dict = {
placeholders["L_fw"]: L_fw_u[:, batch_idx, :],
placeholders["B_fw"]: B_fw_u[:, batch_idx, :],
placeholders["V_fw"]: V_fw_u[:, batch_idx, :],
placeholders["L_bw"]: L_bw_u[:, batch_idx, :],
placeholders["B_bw"]: B_bw_u[:, batch_idx, :],
placeholders["V_bw"]: V_bw_u[:, batch_idx, :],
placeholders["B_bin"]: B_bin_u[:, batch_idx, :],
placeholders["L_len"]: L_len_u[batch_idx],
placeholders["V_len"]: V_len_u[batch_idx]
}
l, b, s, t = sess.run([L_loss, B_loss, share_loss, loss],
feed_dict=feed_dict)
print "test"
print "step:{} total:{}, language:{}, behavior:{}, share:{}".format(
step, t, l, b, s)
if (step + 1) % train_conf.log_interval == 0:
saver.save(sess, save_dir)
past = time.time()
print past - previous
def main():
net_conf = NetConfig()
net_conf.set_conf("./net_conf.txt")
L_num_units = net_conf.L_num_units
L_num_layers = net_conf.L_num_layers
VB_num_units = net_conf.VB_num_units
VB_num_layers = net_conf.VB_num_layers
SHARE_DIM = net_conf.S_dim
train_conf = TrainConfig()
train_conf.set_conf("./train_conf.txt")
batchsize = 1
save_dir = train_conf.save_dir
L_data_dir = train_conf.L_dir
B_data_dir = train_conf.B_dir
V_data_dir = train_conf.V_dir
L_fw, L_bw, L_bin, L_len, L_filenames = read_sequential_target(L_data_dir, True)
print len(L_filenames)
B_fw, B_bw, B_bin, B_len, B_filenames = read_sequential_target(B_data_dir, True)
V_fw, V_bw, V_bin, V_len = read_sequential_target(V_data_dir)
L_shape = L_fw.shape
B_shape = B_fw.shape
V_shape = V_fw.shape
if train_conf.test:
L_data_dir_test = train_conf.L_dir_test
B_data_dir_test = train_conf.B_dir_test
V_data_dir_test = train_conf.V_dir_test
L_fw_u, L_bw_u, L_bin_u, L_len_u, L_filenames_u = read_sequential_target(L_data_dir_test, True)
print len(L_filenames_u)
B_fw_u, B_bw_u, B_bin_u, B_len_u, B_filenames_u = read_sequential_target(B_data_dir_test, True)
V_fw_u, V_bw_u, V_bin_u, V_len_u = read_sequential_target(V_data_dir_test)
L_shape_u = L_fw_u.shape
B_shape_u = B_fw_u.shape
V_shape_u = V_fw_u.shape
tf.reset_default_graph()
placeholders = make_placeholders(L_shape, B_shape, V_shape, batchsize)
##### encoding #####
VB_input = tf.concat([placeholders["V_bw"],
placeholders["B_bw"]],
axis=2)
VB_enc_final_state = encoder(VB_input,
placeholders["V_len"],
n_units=VB_num_units,
n_layers=VB_num_layers,
scope="VB_encoder")
##### sharing #####
VB_shared = fc(VB_enc_final_state, SHARE_DIM,
activation_fn=None, scope="VB_share")
L_dec_init_state = fc(VB_shared, L_num_units*L_num_layers*2,
activation_fn=None, scope="L_postshare")
##### decoding #####
L_output = L_decoder(placeholders["L_fw"][0],
L_dec_init_state,
length=L_shape[0],
out_dim=L_shape[2],
n_units=L_num_units,
n_layers=L_num_layers,
scope="L_decoder")
L_output = tf.contrib.seq2seq.hardmax(L_output)
gpuConfig = tf.ConfigProto(
gpu_options=tf.GPUOptions(allow_growth=True,
per_process_gpu_memory_fraction=train_conf.gpu_use_rate),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
saver.restore(sess, save_dir)
for i in range(B_shape[1]):
feed_dict = {placeholders["L_fw"]: L_fw[:, i:i+1, :],
placeholders["B_fw"]: B_fw[:, i:i+1, :],
placeholders["V_fw"]: V_fw[:, i:i+1, :],
placeholders["L_bw"]: L_bw[:, i:i+1, :],
placeholders["B_bw"]: B_bw[:, i:i+1, :],
placeholders["V_bw"]: V_bw[:, i:i+1, :],
placeholders["B_bin"]: B_bin[:, i:i+1, :],
placeholders["L_len"]: L_len[i:i+1],
placeholders["V_len"]: V_len[i:i+1]}
result = sess.run([L_output], feed_dict=feed_dict)
r = result[0][:,0,:].argmax(axis=1)
t = L_fw[1:,i,:].argmax(axis=1)
print (r == t).all()
if train_conf.test:
print "test!!!!!!!!!!!!!!!!"
for i in range(B_shape_u[1]):
feed_dict = {placeholders["L_fw"]: L_fw_u[:, i:i+1, :],
placeholders["B_fw"]: B_fw_u[:, i:i+1, :],
placeholders["V_fw"]: V_fw_u[:, i:i+1, :],
placeholders["L_bw"]: L_bw_u[:, i:i+1, :],
placeholders["B_bw"]: B_bw_u[:, i:i+1, :],
placeholders["V_bw"]: V_bw_u[:, i:i+1, :],
placeholders["B_bin"]: B_bin_u[:, i:i+1, :],
placeholders["L_len"]: L_len_u[i:i+1],
placeholders["V_len"]: V_len_u[i:i+1]}
result = sess.run([L_output], feed_dict=feed_dict)
result = result[0][:,0,:].argmax(axis=1)
target = L_fw_u[1:,i,:].argmax(axis=1)
print (result == target).all()
