def test(activation_type=model.USE_RELU):
model_, params = model.load_model(activation_type=activation_type)
X = model_['input']
Y_hat = tf.nn.sigmoid(model_['out'], name='pred')
Y = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='true_value')
loss = tf.reduce_sum(
tf.nn.sigmoid_cross_entropy_with_logits(logits=model_['out'],
labels=Y))
saver = tf.train.Saver()
test_queue = tf.train.string_input_producer([Config.TFRECORD_TEST])
with tf.Session() as sess:
# initialize all variables
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
if activation_type == model.USE_RELU:
saver.restore(sess, Config.NORMAL_MODEL_PATH)
else:
saver.restore(sess, Config.LEAKY_MODEL_PATH)
# Create a coordinator and run all QueueRunner objects
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
img_test, label_test = read_and_decode(test_queue)
t_loss, t_acc = 0, 0
for i in range(20):
image, label = sess.run([img_test, label_test])
l, y, y_hat = sess.run([loss, Y, Y_hat],
feed_dict={
X: image,
Y: label
})
t_acc += int((y_hat >= 0.5) == y)
t_loss += l
t_acc = t_acc / 21
t_loss = t_loss / 21
# Stop the threads
coord.request_stop()
# Wait for threads to stop
coord.join(threads)
print("Test Accuracy: {}\tTest Loss: {}".format(round(t_acc, 5),
round(t_loss, 5)))
import tensorflow as tf import numpy as np from PIL import Image import graph import params import util train_dir = 'saved_model/' data_record = ["dataset/fly_train.tfrecords", "dataset/fly_test.tfrecords"] p = params.Params() batch_train = util.read_and_decode(p, data_record[0]) batch_test = util.read_and_decode(p, data_record[1]) img_L = tf.placeholder(tf.float32, [p.batch_size, p.target_h, p.target_w, 3]) img_R = tf.placeholder(tf.float32, [p.batch_size, p.target_h, p.target_w, 3]) disp = tf.placeholder(tf.float32, [p.batch_size, p.target_h, p.target_w, 1]) phase = tf.placeholder(tf.bool) pred = graph.GCNet(img_L, img_R, phase, p.max_disparity) # loss = tf.reduce_mean(tf.losses.mean_squared_error(pred, gt)) loss = tf.losses.absolute_difference(pred, disp) learning_rate = 0.001 optimizer = tf.train.RMSPropOptimizer(learning_rate=learning_rate)
def build_graph(self, data_dir, batch_size, mode):
"""Builds the VAE-GAN network.
Args:
data_dir: Locations of input data.
batch_size: Batch size of input data.
mode: Mode of the graph (TRAINING, EVAL, or PREDICT)
Returns:
The tensors used in training the model.
"""
tensors = GraphReferences()
assert batch_size > 0
self.batch_size = batch_size
if mode is PREDICT_EMBED_IN:
# Input embeddings to send through decoder/generator network.
tensors.embeddings = tf.placeholder(tf.float32,
shape=(None,
EMBEDDING_DIMENSION),
name='input')
elif mode is PREDICT_IMAGE_IN:
tensors.prediction_image = tf.placeholder(tf.string,
shape=(None, ),
name='input')
tensors.image = tf.map_fn(self.process_image,
tensors.prediction_image,
dtype=tf.float32)
if mode in (TRAIN, EVAL):
mode_string = 'train'
if mode is EVAL:
mode_string = 'validation'
tensors.image = util.read_and_decode(data_dir, batch_size,
mode_string,
self.resized_image_size,
self.crop_image_dimension,
self.center_crop)
tensors.image = tf.reshape(
tensors.image,
[-1, self.resized_image_size, self.resized_image_size, 3])
tf.summary.image('original_images', tensors.image, 1)
tensors.embeddings, y_mean, y_stddev = self.encode(tensors.image)
if mode is PREDICT_IMAGE_IN:
tensors.image = tf.reshape(
tensors.image,
[-1, self.resized_image_size, self.resized_image_size, 3])
tensors.embeddings, y_mean, _ = self.encode(tensors.image, False)
tensors.predictions = tensors.embeddings
return tensors
decoded_images = self.decode(tensors.embeddings)
if mode is TRAIN:
tf.summary.image('decoded_images', decoded_images, 1)
if mode is PREDICT_EMBED_IN:
decoded_images = self.decode(tensors.embeddings, False, True)
output_images = (decoded_images + 1.0) / 2.0
output_img = tf.image.convert_image_dtype(output_images,
dtype=tf.uint8,
saturate=True)[0]
output_data = tf.image.encode_png(output_img)
output = tf.encode_base64(output_data)
tensors.predictions = output
return tensors
tensors.dis_fake = self.discriminate(decoded_images, self.dropout)
tensors.dis_real = self.discriminate(tensors.image,
self.dropout,
reuse=True)
tensors.cost_encoder = self.loss_encoder(tensors.image, decoded_images,
y_mean, y_stddev)
tensors.cost_generator = self.loss_generator(tensors.dis_fake)
tensors.cost_discriminator = self.loss_discriminator(
tensors.dis_real, tensors.dis_fake)
if mode in (TRAIN, EVAL):
tf.summary.scalar('cost_encoder', tensors.cost_encoder)
tf.summary.scalar('cost_generator', tensors.cost_generator)
tf.summary.scalar('cost_discriminator', tensors.cost_discriminator)
tf.summary.tensor_summary('disc_fake', tensors.dis_fake)
tf.summary.tensor_summary('disc_real', tensors.dis_real)
tf.summary.scalar('mean_disc_fake',
tf.reduce_mean(tensors.dis_fake))
tf.summary.scalar('mean_disc_real',
tf.reduce_mean(tensors.dis_real))
# Cost of Decoder/Generator is VAE network cost and cost of generator
# being detected by the discriminator.
enc_weight = 1
gen_weight = 1
tensors.cost_balance = (enc_weight * tensors.cost_encoder +
gen_weight * tensors.cost_generator)
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
t_vars = tf.trainable_variables()
with tf.variable_scope(tf.get_variable_scope(), reuse=None):
encoder_vars = [
var for var in t_vars if var.name.startswith('enc_')
]
generator_vars = [
var for var in t_vars if var.name.startswith('gen_')
]
discriminator_vars = [
var for var in t_vars if var.name.startswith('disc_')
]
vae_vars = encoder_vars + generator_vars
# Create optimizers for each network.
tensors.encoder_optimizer = tf.train.AdamOptimizer(
learning_rate=self.learning_rate,
beta1=self.beta1).minimize(tensors.cost_encoder,
var_list=vae_vars,
global_step=tensors.global_step)
tensors.generator_optimizer = tf.train.AdamOptimizer(
learning_rate=self.learning_rate,
beta1=self.beta1).minimize(tensors.cost_balance,
var_list=vae_vars,
global_step=tensors.global_step)
tensors.discriminator_optimizer = tf.train.AdamOptimizer(
learning_rate=self.learning_rate,
beta1=self.beta1).minimize(tensors.cost_discriminator,
var_list=discriminator_vars,
global_step=tensors.global_step)
return tensors
def train(n_iter=20, activation_type=model.USE_RELU):
"""
Train Model for given iterations and based on different activation function.
@params
n_iter: Number of Epochs
activation_type: Type of Activation Used. Possible Values => model.USE_RELU or model.USE_LEAKY_RELU
@returns
hist: A dictionary of training history of the form ->
{
'train': {
'loss': [loss_1, loss_2,... n_iter],
'acc': [acc_1, acc_2,... n_iter]
},
'dev': {
'loss': [loss_d_1, loss_d_2,... n_iter],
'acc': [acc_d_1, acc_d_2,... n_iter]
}
}
"""
tf.set_random_seed(2)
model_, params = model.load_model(activation_type=activation_type)
X = model_['input']
Y_hat = tf.nn.sigmoid(model_['out'], name='pred')
Y = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='true_value')
loss = tf.reduce_sum(
tf.nn.sigmoid_cross_entropy_with_logits(logits=model_['out'],
labels=Y))
train_step = tf.train.GradientDescentOptimizer(1e-3).minimize(loss)
hist = {'train': {'loss': [], 'acc': []}, 'dev': {'loss': [], 'acc': []}}
saver = tf.train.Saver()
train_queue = tf.train.string_input_producer([Config.TFRECORD_TRAIN],
num_epochs=(n_iter + 1) * 157,
shuffle=True)
dev_queue = tf.train.string_input_producer([Config.TFRECORD_DEV],
num_epochs=(n_iter + 1) * 20,
shuffle=True)
with tf.Session() as sess:
# initialize all variables
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
# Create a coordinator and run all QueueRunner objects
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
img_train, label_train = read_and_decode(train_queue)
img_dev, label_dev = read_and_decode(dev_queue)
for i in range(n_iter):
t_loss, t_acc, d_loss, d_acc = 0, 0, 0, 0
for j in range(150):
img, label = sess.run([img_train, label_train])
_, l, y_hat, y = sess.run([train_step, loss, Y_hat, Y],
feed_dict={
X: img,
Y: label
})
t_loss += l
t_acc += int((y_hat >= 0.5) == y)
hist['train']['loss'].append(t_loss / 150)
hist['train']['acc'].append(t_acc / 150)
for j in range(15):
img, label = sess.run([img_dev, label_dev])
l, y_hat, y = sess.run([loss, Y_hat, Y],
feed_dict={
X: img,
Y: label
})
d_loss += l
d_acc += int((y_hat >= 0.5) == y)
hist['dev']['loss'].append(d_loss / 15)
hist['dev']['acc'].append(d_acc / 15)
print('\nEpoch: {}-----------------'.format(i))
print('Loss: {}\tAcc: {}'.format(
round(hist['train']['loss'][-1], 5),
round(hist['train']['acc'][-1], 5)))
print('ValLoss: {}\tVal Acc: {}'.format(
round(hist['dev']['loss'][-1], 5),
round(hist['dev']['acc'][-1], 5)))
# Override old model with every 10th model
if i % 10 == 0:
if activation_type == model.USE_RELU:
saver.save(sess, Config.NORMAL_MODEL_PATH)
else:
saver.save(sess, Config.LEAKY_MODEL_PATH)
# Save the Last Model
if activation_type == model.USE_RELU:
saver.save(sess, Config.NORMAL_MODEL_PATH)
else:
saver.save(sess, Config.LEAKY_MODEL_PATH)
print('Final Model Saved!!')
# Stop the threads
coord.request_stop()
# Wait for threads to stop
coord.join(threads)
return hist
strides=1,
trainable=phase)(logits)
return k.models.Model(inputs=[input_l, input_r], outputs=distrib)
def keras_asl(tgt, pred):
return tf.losses.absolute_difference(pred, tgt)
if __name__ == '__main__':
import util
import params
train_dir = 'saved_model/'
data_record = ["dataset/fly_train.tfrecords", "dataset/fly_test.tfrecords"]
p = params.Params()
train_img_l_b, train_img_r_b, train_d_b = util.read_and_decode(
p, data_record[0])
test_img_l_b, test_img_r_b, test_d_b = util.read_and_decode(
p, data_record[1])
model = build_model(train_img_l_b, train_img_r_b)
opt = k.optimizers.RMSprop()
model.compile(optimizer=opt, loss=keras_asl, target_tensors=[train_d_b])
print(model.summary())
print(type(train_img_r_b))
# model.fit(epochs=10, verbose=1,steps_per_epoch=)