Trjtdtk

I tried deconvolving the result of the convolution of an image 100x100x3 (hight, width, number of channels) with filter 3x3x3x5 (filter hight, filter width, number of channels, number of filters) then add a bias 1x1x1x5. The convolution works very well but the deconvolution doesn't work.
Can anyone help explain more about deconvolution with numpy.

Here is my code:

def conv(img, W, b, s, p): 
"""
calculate the convolving betwen image and filter und save the result in array (feature_map)

Argument:
img-- input Image, list of array with shape (h, w, number_of_channels)
W-- Filter, array of shape (f, f, number_of_channels, c)
b-- Bias, a vector of the shape (1, 1, 1, c)
s-- Stride
p-- Padding

Returns:
feature_map -- the result of convolving betwenn image and filter, an array of the shape (m, new_h, new_w, c)

"""
#Image dimensions
(h, w, number_of_channels) = img.shape

#Filter dimensions
(f, f, number_of_channels, c) = W.shape

# Compute the dimensions of the CONV output volume using the formula given above. Hint: use int() to floor. (≈2 lines)
n_h = int((h - f + 2 * p) / s) + 1
n_w = int((w - f + 2 * p) / s) + 1

#create initial feature map
feature_map = np.zeros((n_h, n_w, c))

#add Padding to the input
img_pad = np.pad(img, ((p,p),(p,p), (0,0)) , 'constant', constant_values = 0)

#loop over the vertical of the output
for h_i in range (n_h):

 #loop over the horizontal of the output
 for w_i in range (n_w):

 #loop over the Filter layers (output channels)
 for c_i in range(c):

 #defin the image region, that will convoliving with the filter
 img_region = img_pad[h_i*s:h_i*s + f,w_i*s:w_i*s + f, :]
 # convolve the image_region with the filter W and bias b to get the feature map
 feature_map[h_i, w_i, c_i] = conv_opertation(img_region, W[...,c_i], b[...,c_i])

 #activation function Relu
 #return the original value in the feature map if it is larger than 0
 feature_map[h_i, w_i, c_i] = np.max([feature_map[h_i, w_i, c_i], 0])

assert(feature_map.shape == (n_h, n_w, c))

return feature_map

def deConv (feature_map, W, b, s, p):
'''
calculate the decovolution between the feature map and the filter

Arguements:
 feature_map-- the result of convolving the image and the filter W, array of the shape (new_h, new_w, c)
 W-- filter, an array of the shape (f, f, number_of_channels, c)
 b-- Bias, a vector of the shape (1, 1, 1, c)
 s-- Stird
 p-- Padding

Returns:
 new_img-- reconstruktion image, an array of the shape (h, w, number of channels) 

'''
#dimensions of the filter
(f, f, number_of_channels, c) = W.shape

#add Padding to the filter
feature_map_pad = np.pad(feature_map, ((p,p),(p,p), (0,0)) , 'constant', constant_values = 0)

#dimensions of the feature map
(n_h, n_w, c) = feature_map_pad.shape

#dimenstions of the new image
new_h= int((n_h - f + 2 * p)/s)-1
new_w= int((n_w - f + 2 * p)/s)-1

#create initial new image
image = np.zeros((new_h, new_w, number_of_channels))

#loop over the vertical axis of the filter
for h_i in range(new_h):
 #loop over the vertical axis of the filter
 for w_i in range(new_w):
 #loop over the filter channels
 for c_i in range(c):

 #defin the feature map region, that will convoliving with the filter
 feature_map_region = feature_map_pad[h_i*s:h_i*s+f, w_i*s:w_i*s+f,c_i]

 #loop over the feature map layer
 for i in range(number_of_channels): 
 # convolve the the feature map region with the filter W and bias b to get image 
 image[h_i, w_i, i] = conv_opertation(feature_map_region, W[:,:,i,c_i], b[:,:,0,c_i])

 #activation function Relu
 #return the original value in the feature map if it is larger than 0
 image[h_i, w_i, c_i] = np.max([image[h_i,w_i,c_i], 0])

assert(image.shape == (new_h,new_w, number_of_channels))

return image