def train_mnist_single_machine(num_epochs,
use_fake_data=False,
device=None,
manual_op_exec=False):
"""Train a ConvNet on MNIST.
Args:
num_epochs: int. Number of passes to make over the training set.
use_fake_data: bool. If True, generate a synthetic dataset.
device: string or None. The covariance and inverse update ops are run on
this device. If empty or None, the default device will be used.
(Default: None)
manual_op_exec: bool, If `True` then `minimize_loss_single_machine_manual`
is called for training which handles inverse and covariance computation.
This is shown only for illustrative purpose. Otherwise
`minimize_loss_single_machine` is called which relies on
`PeriodicInvCovUpdateOpt` for op placement and execution.
Returns:
accuracy of model on the final minibatch of training data.
"""
from tensorflow.data import Iterator
# Load a dataset.
print ("Loading MNIST into memory.")
tf.logging.info("Loading MNIST into memory.")
iter_train_handle, output_types, output_shapes = mnist.load_mnist_as_iterator(num_epochs,
args.batch_size,
train=True,
use_fake_data=use_fake_data,
flatten_images=False)
iter_val_handle, _, _ = mnist.load_mnist_as_iterator(10000*num_epochs, # This just ensures this doesn't cause early termination
10000,
train=False,
use_fake_data=use_fake_data,
flatten_images=False)
handle = tf.placeholder(tf.string, shape=[])
iterator = Iterator.from_string_handle(
handle, output_types, output_shapes)
next_batch = iterator.get_next()
(examples, labels) = next_batch
# Build a ConvNet.
layer_collection = kfac.LayerCollection()
loss, accuracy = build_model(
examples, labels, num_labels=10, layer_collection=layer_collection,
register_layers_manually=_USE_MANUAL_REG)
if not _USE_MANUAL_REG:
layer_collection.auto_register_layers()
# Without setting allow_soft_placement=True there will be problems when
# the optimizer tries to place certain ops like "mod" on the GPU (which isn't
# supported).
config = tf.ConfigProto(allow_soft_placement=True)
# Fit model.
return minimize_loss_single_machine(handle, iter_train_handle, iter_val_handle,
loss, accuracy, layer_collection, device=device, session_config=config)
def loaddata(self):
"""
loads data queue pipelines for train,test,val which can be switched during run time.
"""
#change image to float
scale = (1.0 / 255.0)
#mean centering
mean = np.load("DataCollection/Pong-v0/mean.npy")
# making multi threaded pipelines from tfrecords using feedable iterators to switch queues during run time
filenames = glob.glob('DataCollection/Pong-v0/'+'train'+'/*.tfrecords')
datasettrain = tf.data.TFRecordDataset(filenames)
filenames = glob.glob('DataCollection/Pong-v0/' + 'val' + '/*.tfrecords')
datasetval = tf.data.TFRecordDataset(filenames)
filenames = glob.glob('DataCollection/Pong-v0/' + 'test' + '/*.tfrecords')
datasettest = tf.data.TFRecordDataset(filenames)
#restore image and action data and shape
datasettrain = datasettrain.map(map_func= self.parse_function, num_parallel_calls= 4)
#to iterate over dataset for multiple epochs
datasettrain = datasettrain.repeat()
#shuffling and creating a queue buffer
datasettrain = datasettrain.shuffle(buffer_size=1000) # specify queue size buffer
#making batches
datasettrain = datasettrain.batch(32)
#string handle for train
iter_train_handle = datasettrain.make_one_shot_iterator().string_handle()
datasetval = datasetval.map(map_func=self.parse_function, num_parallel_calls=4)
datasetval = datasetval.repeat()
datasetval = datasetval.shuffle(buffer_size=1000) # specify queue size buffer
datasetval = datasetval.batch(32)
# string handle for val
iter_val_handle = datasetval.make_one_shot_iterator().string_handle()
datasettest = datasettest.map(map_func=self.parse_function, num_parallel_calls=4)
datasettest = datasettest.repeat()
datasettest = datasettest.shuffle(buffer_size=1000) # specify queue size buffer
datasettest = datasettest.batch(32)
# string handle for test
iter_test_handle = datasettest.make_one_shot_iterator().string_handle()
#handle to indicate which queue we want to switch to or iterate over
handle = tf.placeholder(tf.string, shape=[])
iterator = Iterator.from_string_handle(handle, datasettrain.output_types, datasettrain.output_shapes)
#get data tensors
s_t_batch, a_t_batch, x_t_1_batch = iterator.get_next()
mean_const = tf.constant(mean, dtype=tf.float32)
#mean centering and convert to float
s_t_batch = (s_t_batch - tf.tile(mean_const, [1, 1, 4])) * scale
x_t_1_batch = (x_t_1_batch - mean_const) * scale
self.s_t_batch = s_t_batch
self.a_t_batch = a_t_batch
self.x_t_1_batch = x_t_1_batch
self.iter_train_handle = iter_train_handle
self.iter_val_handle = iter_val_handle
self.iter_test_handle = iter_test_handle
self.handle = handle
import tensorflow as tf
from tensorflow.data import Dataset, Iterator
dataset_train = Dataset.range(10)
dataset_val = Dataset.range(90, 100)
iter_train_handle = dataset_train.make_one_shot_iterator().string_handle()
iter_val_handle = dataset_val.make_one_shot_iterator().string_handle()
handle = tf.placeholder(tf.string, shape=[])
iterator = Iterator.from_string_handle(handle, dataset_train.output_types,
dataset_train.output_shapes)
next_batch = iterator.get_next()
with tf.train.MonitoredTrainingSession() as sess:
handle_train, handle_val = sess.run([iter_train_handle, iter_val_handle])
for step in range(10):
print('train', sess.run(next_batch, feed_dict={handle: handle_train}))
if step % 3 == 0:
print('val', sess.run(next_batch, feed_dict={handle: handle_val}))
def training():
batch_size = 10
noise_type = 'gaussian'
noise_proportion = 0.2
noise_mean = 0
noise_std = 1
noise_lam = 1
noise_std_range = [1,5]
noise_lam_range = [1,5]
loss_type = 'l2_loss'
study_rate = 1e-5
current_dir = Path('.')
train_true,__,test_true=load_data(dataset='mias',
DIR=current_dir)
train_true = train_true.repeat().batch(batch_size)
train_true = train_true.prefetch(buffer_size =
tf.data.experimental.AUTOTUNE)
test_true = test_true.repeat().batch(batch_size)
test_true = test_true.prefetch(buffer_size =
tf.data.experimental.AUTOTUNE)
iter_train_handle = train_true.make_one_shot_iterator().string_handle()
iter_val_handle = test_true.make_one_shot_iterator().string_handle()
handle = tf.placeholder(tf.string, shape=[])
iterator = Iterator.from_string_handle(handle,
train_true.output_types,
train_true.output_shapes)
next_batch = iterator.get_next()
noise_args = {'proportion':noise_proportion}
if noise_type == 'random':
noise_fn = random_noise
noise_args['std_range'] = noise_std_range
noise_args['lam_range'] = noise_lam_range
elif noise_type == 'poisson':
noise_fn = poisson_noise
noise_args['lam'] = noise_lam
else:
noise_fn = gaussian_noise
noise_args['mean'] = noise_mean
noise_args['std'] = noise_std
true_img = tf.placeholder(tf.uint8,
shape=[batch_size, 64, 64, 1])
noised_img = noise_fn(**noise_args,
image=true_img)
model_input = tf.cast(noised_img,
dtype=tf.float32)
denoised_img = QAE.build_QAE(model_input)
if loss_type == 'l2_loss':
train_loss = l2_loss(
tf.cast(true_img,
dtype=tf.float32),
denoised_img)
# val_loss = l2_loss(
# tf.cast(test_true_img,
# dtype=tf.float32),
# test_denoised_img)
total_train_loss = train_loss
optimizer = tf.train.AdamOptimizer(\
learning_rate=study_rate).minimize(
total_train_loss)
tf.summary.scalar('train_l2_loss',train_loss)
# tf.summary.scalar('val_l2_loss',val_loss)
tf.summary.scalar('total_train_loss',
total_train_loss)
merged_summary = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(
current_dir/'train_data')
init_vars = tf.group(
tf.global_variables_initializer(),
tf.local_variables_initializer())
saver = tf.train.Saver()
with tf.Session().as_default() as sess:
global_step = tf.train.get_global_step()
handle_train, handle_val = sess.run(
[iter_train_handle, iter_val_handle])
sess.run(init_vars)
for step in range(500):
train_true_img = sess.run(next_batch,
feed_dict={handle: handle_train})
test_true_img = sess.run(next_batch,
feed_dict={handle: handle_val})
_ = sess.run(optimizer,
feed_dict={true_img:train_true_img})
t_summ = sess.run(merged_summary,
feed_dict={true_img:train_true_img})
t_loss = sess.run(total_train_loss,
feed_dict={true_img:train_true_img})
train_writer.add_summary(t_summ,step)
print('Iter:{}, Training Loss {}'.format(
step, t_loss))
if step%20 == 0:
fig,axes =
print('done')