Reading a new dataset in the same format as mnist dataset is read in TensorFlow

Question

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

Answer 1

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)