Image adjustments with Conv2d - numpy

Question

I am working on a project related to CNN using TensorFlow.
I imported image using (20 such images)
for filename in glob.glob('input_data/*.jpg'):
input_images.append(cv2.imread(filename,0))
image_size_input = len(input_images[0])
The images were of size (250,250) because of grayscale.
But for conv2D, it requires a 4D input tensor to feed. My input tensor looks like
x = tf.placeholder(tf.float32,shape=[None,image_size_output,image_size_output,1], name='x')
So i was not able to convert the above 2d image into the given shape(4D). How to deal with the "None" field.
I tried this:
input_images_padded = []
for image in input_images:
temp = np.zeros((1,image_size_output,image_size_output,1))
for i in range(image_size_input):
for j in range(image_size_input):
temp[0,i,j,0] = image[i,j]
input_images_padded.append(temp)
I got the following error:
File "/opt/intel/intelpython3/lib/python3.5/site-packages/tensorflow/python/client/session.py", line 975, in _run
% (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape())))
ValueError: Cannot feed value of shape (20, 1, 250, 250, 1) for Tensor 'x_11:0', which has shape '(?, 250, 250, 1)'
Here's the entire code(for reference):
import tensorflow as tf
from PIL import Image
import glob
import cv2
import os
import numpy as np
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
input_images = []
output_images = []
for filename in glob.glob('input_data/*.jpg'):
input_images.append(cv2.imread(filename,0))
for filename in glob.glob('output_data/*.jpg'):
output_images.append(cv2.imread(filename,0))
image_size_input = len(input_images[0])
image_size_output = len(output_images[0])
'''
now adding padding to the input images to convert from 125x125 to 250x2050 sized images
'''
input_images_padded = []
for image in input_images:
temp = np.zeros((1,image_size_output,image_size_output,1))
for i in range(image_size_input):
for j in range(image_size_input):
temp[0,i,j,0] = image[i,j]
input_images_padded.append(temp)
output_images_padded = []
for image in output_images:
temp = np.zeros((1,image_size_output,image_size_output,1))
for i in range(image_size_input):
for j in range(image_size_input):
temp[0,i,j,0] = image[i,j]
output_images_padded.append(temp)
sess = tf.Session()
'''
Creating tensor for the input
'''
x = tf.placeholder(tf.float32,shape= [None,image_size_output,image_size_output,1], name='x')
'''
Creating tensor for the output
'''
y = tf.placeholder(tf.float32,shape= [None,image_size_output,image_size_output,1], name='y')
def create_weights(shape):
return tf.Variable(tf.truncated_normal(shape, stddev=0.05))
def create_biases(size):
return tf.Variable(tf.constant(0.05, shape=[size]))
def create_convolutional_layer(input, bias_count, filter_height, filter_width, num_input_channels, num_out_channels, activation_function):
weights = create_weights(shape=[filter_height, filter_width, num_input_channels, num_out_channels])
biases = create_biases(bias_count)
layer = tf.nn.conv2d(input=input,
filter=weights,
strides=[1, 1, 1, 1],
padding='SAME')
layer += biases
layer = tf.nn.max_pool(value=layer,
ksize=[1, 2, 2, 1],
strides=[1, 1, 1, 1],
padding='SAME')
if activation_function=="relu":
layer = tf.nn.relu(layer)
return layer
'''
Conv. Layer 1: Patch extraction
64 filters of size 1 x 9 x 9
Activation function: ReLU
Output: 64 feature maps
Parameters to optimize:
1 x 9 x 9 x 64 = 5184 weights and 64 biases
'''
layer1 = create_convolutional_layer(input=x,
bias_count=64,
filter_height=9,
filter_width=9,
num_input_channels=1,
num_out_channels=64,
activation_function="relu")
'''
Conv. Layer 2: Non-linear mapping
32 filters of size 64 x 1 x 1
Activation function: ReLU
Output: 32 feature maps
Parameters to optimize: 64 x 1 x 1 x 32 = 2048 weights and 32 biases
'''
layer2 = create_convolutional_layer(input=layer1,
bias_count=32,
filter_height=1,
filter_width=1,
num_input_channels=64,
num_out_channels=32,
activation_function="relu")
'''Conv. Layer 3: Reconstruction
1 filter of size 32 x 5 x 5
Activation function: Identity
Output: HR image
Parameters to optimize: 32 x 5 x 5 x 1 = 800 weights and 1 bias'''
layer3 = create_convolutional_layer(input=layer2,
bias_count=1,
filter_height=5,
filter_width=5,
num_input_channels=32,
num_out_channels=1,
activation_function="identity")
'''print(layer1.get_shape().as_list())
print(layer2.get_shape().as_list())
print(layer3.get_shape().as_list())'''
'''
applying gradient descent algorithm
'''
#loss_function
loss = tf.reduce_sum(tf.square(layer3-y))
#optimiser
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
init = tf.global_variables_initializer()
sess.run(init)
for i in range(len(input_images)):
sess.run(train,{x: input_images_padded, y:output_images_padded})
curr_loss = sess.run([loss], {x: x_train, y: y_train})
print("loss: %s"%(curr_loss))

Answer 1

I think your image_padded is not right. I don't have tf-code writing experience (though have read some code). But try this:
// imgs is your input-image-sequences
// padded is to feed
cnt = len(imgs)
H,W = imgs[0].shape[:2]
padded = np.zeros((cnt, H, W, 1))
for i in range(cnt):
padded[i, :,:,0] = img[i]

Answer 2

One option would be to ignore giving the shape when you create the placeholder so that it accepts a tensor of any shape that you feed during sess.run()
From the docs:
shape: The shape of the tensor to be fed (optional). If the shape is not
specified, you can feed a tensor of any shape.
Alternatively, you can specify 20, which is your batch size. Note that the first dimension in the tensor always corresponds to batch_size

Answer 3

Check the next lines. It works for me :
train_set = np.zeros((input_images.shape[0], input_images.shape[1], input_images.shape[2],1))
for image in range(input_images.shape[0]):
train_set[image,:,:,0] = input_images[image,:,:]