Reputation: 384
I have a deep learning model where I have to input images of size say 100X100. The data i have is
train images - x_train (530,100,100)
,
train labels - y_train (530,4)
,
test images - x_test(89,100,100)
,
test labels - y_test(89,4)
.
The dataset mnist is read using -
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
and it generates something like this-
Datasets(train=tensorflow.contrib.learn.python.learn.datasets.mnist.DataSet object at 0x7fd64cae76a0,
validation=tensorflow.contrib.learn.python.learn.datasets.mnist.DataSet object at 0x7fd64cae7be0,
test=tensorflow.contrib.learn.python.learn.datasets.mnist.DataSet object at 0x7fd64cae7400)
I have to transform my data in this same format so as this works with the code i Have. please help
epochs = 20
batch_size = 100
image_vector = 28*28
for i in range(epochs):
training_accuracy = []
epoch_loss = []
for ii in tqdm(range(mnist.train.num_examples // batch_size)):
batch = mnist.train.next_batch(batch_size)
images = batch[0].reshape((-1, 28, 28))
targets = batch[1]
c, _, a = session.run([model.cost, model.opt, model.accuracy], feed_dict={model.inputs: images, model.targets:targets})
epoch_loss.append(c)
training_accuracy.append(a)
print("Epoch: {}/{}".format(i, epochs), " | Current loss: {}".format(np.mean(epoch_loss)),
" | Training accuracy: {:.4f}%".format(np.mean(training_accuracy)))
EDIT 1 : As suggested , I did the following-
num_examples=271
batch_size=10
buffer_size=271
num_cpu_cores=4
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.shuffle(buffer_size, reshuffle_each_iteration=True).repeat()
#dataset = dataset.apply(tf.data.batch( batch_size=batch_size, num_parallel_batches=num_cpu_cores))
#batch1=dataset.batch(10)
iterator = dataset.make_one_shot_iterator()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for ii in tqdm(range(num_examples // batch_size)):
batch = iterator.get_next()
images = batch[0]
targets = batch[1]
c, _, a = sess.run([model.cost, model.opt, model.accuracy])
epoch_loss.append(c)
training_accuracy.append(a)
print("Epoch: {}/{}".format(i, epochs), " | Current loss: {}".format(np.mean(epoch_loss)),
" | Training accuracy: {:.4f}%".format(np.mean(training_accuracy)))
The images and targets are not batches but a single image and label.
(, )
Please suggest how to batch the data and feed into sess.run
EDIT 2 : This is the entire code for the algorithm-
def LSTM_layer(lstm_cell_units, number_of_layers, batch_size, dropout_rate=0.8):
'''
This method is used to create LSTM layer/s for PixelRNN
Input(s): lstm_cell_unitis - used to define the number of units in a LSTM layer
number_of_layers - used to define how many of LSTM layers do we want in the network
batch_size - in this method this information is used to build starting state for the network
dropout_rate - used to define how many cells in a layer do we want to 'turn off'
Output(s): cell - lstm layer
init_state - zero vectors used as a starting state for the network
'''
#layer = tf.contrib.rnn.BasicLSTMCell(lstm_cell_units)
layer = tf.nn.rnn_cell.LSTMCell(lstm_cell_units,name='basic_lstm_cell')
if dropout_rate != 0:
layer = tf.contrib.rnn.DropoutWrapper(layer, dropout_rate)
cell = tf.contrib.rnn.MultiRNNCell([layer]*number_of_layers)
init_size = cell.zero_state(batch_size, tf.float32)
return cell, init_size
def rnn_output(lstm_outputs, input_size, output_size):
'''
Output layer for the lstm netowrk
Input(s): lstm_outputs - outputs from the RNN part of the network
input_size - in this case it is RNN size (number of neuros in RNN layer)
output_size - number of neuros for the output layer == number of classes
Output(s) - logits,
'''
outputs = lstm_outputs[:, -1, :]
weights = tf.Variable(tf.random_uniform([input_size, output_size]), name='rnn_out_weights')
bias = tf.Variable(tf.zeros([output_size]), name='rnn_out_bias')
output_layer = tf.matmul(outputs, weights) + bias
return output_layer
def loss_optimizer(rnn_out, targets, learning_rate):
'''
Function used to calculate loss and minimize it
Input(s): rnn_out - logits from the fully_connected layer
targets - targets used to train network
learning_rate/step_size
Output(s): optimizer - optimizer of choice
loss - calculated loss function
'''
loss = tf.nn.softmax_cross_entropy_with_logits(logits=rnn_out, labels=targets)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return optimizer, loss
class PixelRNN(object):
def __init__(self, learning_rate=0.001, batch_size=10, classes=4, img_size = (129, 251), lstm_size=64,
number_of_layers=1, dropout_rate=0.6,clip_rate=None):
'''
PixelRNN - call this class to create whole model
Input(s): learning_rate - how fast are we going to move towards global minima
batch_size - how many samples do we feed at ones
classes - number of classes that we are trying to recognize
img_size - width and height of a single image
lstm_size - number of neurons in a LSTM layer
number_of_layers - number of RNN layers in the PixelRNN
dropout_rate - % of cells in a layer that we are stopping gradients to flow through
'''
#This placeholders are just for images
self.inputs = tf.placeholder(tf.float32, [None, img_size[0], img_size[1]], name='inputs')
self.targets = tf.placeholder(tf.int32, [None, classes], name='targets')
cell, init_state = LSTM_layer(lstm_size, number_of_layers, batch_size, dropout_rate)
outputs, states = tf.nn.dynamic_rnn(cell, self.inputs, initial_state=init_state)
rnn_out = rnn_output(outputs, lstm_size, classes)
self.opt, self.cost = loss_optimizer(rnn_out, self.targets, learning_rate)
predictions = tf.nn.softmax(rnn_out)
currect_pred = tf.equal(tf.cast(tf.round(tf.argmax(predictions, 1)), tf.int32), tf.cast(tf.argmax(self.targets, 1), tf.int32))
self.accuracy = tf.reduce_mean(tf.cast(currect_pred, tf.float32))
self.predictions = tf.argmax(tf.nn.softmax(rnn_out), 1)
tf.reset_default_graph()
model = PixelRNN()
num_examples=271
batch_size=10
buffer_size=271
num_cpu_cores=4
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.shuffle(buffer_size, reshuffle_each_iteration=True).repeat()
#dataset = dataset.apply(tf.data.batch( batch_size=batch_size, num_parallel_batches=num_cpu_cores))
dataset = dataset.batch(10) # apply batch to dataset
iterator = dataset.make_one_shot_iterator() # create iterator
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for ii in tqdm(range(num_examples // batch_size)):
batch = iterator.get_next() #run iterator
images = batch[0]
targets = batch[1]
c, _, a = sess.run([model.cost, model.opt, model.accuracy],feed_dict={model.inputs: images, model.targets:targets})
epoch_loss.append(c)
training_accuracy.append(a)
print("Epoch: {}/{}".format(i, epochs), " | Current loss: {}".format(np.mean(epoch_loss)),
" | Training accuracy: {:.4f}%".format(np.mean(training_accuracy)))
When I do as suggested, I get the following error-
TypeError: The value of a feed cannot be a tf.Tensor object. Acceptable feed values include Python scalars, strings, lists, numpy ndarrays, or TensorHandles.For reference, the tensor object was Tensor("IteratorGetNext:0", shape=(?, 129, 251), dtype=float32) which was passed to the feed with key Tensor("inputs:0", shape=(?, 129, 251), dtype=float32).
Unable to figure out whats going wrong here
Upvotes: 3
Views: 995
Reputation: 4543
If you have your dataset as numpy array or list of image files, use from_tensor_slices
.
Define parse function, use read_file
and decode_image
if you use list of filenames, else just apply any preprocessing
def parse_image(filename, label):
file = tf.read_file(filename)
image = tf.image.decode_image(file)
#do any image/label preprocessing here
return image, label
Then define dataset object. In general, use length of your dataset as shuffle buffer, but it may depend on size. Repeat function will control epochs(no value pass = indefinite iteration). If you don't need any preprocessing, substitute line dataset.apply
, with dataset = dataset.batch(batch_size)
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset_train.shuffle(buffer_size, reshuffle_each_iteration=True).repeat()
dataset = dataset.apply(tf.data.batch( batch_size=batch_size, num_parallel_batches=num_cpu_cores))
Create iterator. In general, there's no need to use feed dict, if only your input array will not cause 2GB graphdef limit.
iterator = dataset.make_one_shot_iterator()
batch = iterator.get_next()
Edit: You need to create iterator out of dataset, Here's the overall structure:
dataset = dataset.batch(10) # apply batch to dataset
iterator = dataset.make_one_shot_iterator() # create iterator
batch = iterator.get_next() #run iterator
images = batch[0]
targets = batch[1]
logits = Model_function(images)
loss = loss_function(logits, targets)
train_op = optimizer.minimize()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for i in range(steps):
sess.run(train_op)
Upvotes: 1