Trjtdtk

I have an image (for example (7x7x3) and a filter (3x3x3)). I convolved the image with the filter and it became a (3x3) output. If I want to do the inverse operation and want it to become the image from the output and the filter. How can I implement this operation in Python with Numpy?

I don't know which operation I should use with the filter (inverse or transpose)?

Here is my code for the Deconvolution:

import numpy as np

def deConv(Z, cashe):

'''

deConv calculate the transpoe Convoultion between the output of the ConvNet and the filter

Arguments:
 Z-- Output of the ConvNet Layer, an array of the shape()
'''
# Retrieve information from "cache"
(X_prev, W, b, s, p) = cashe

# Retrieve dimensions from X_prev's shape
(m, n_H_prev, n_W_prev, n_C_prev) = X_prev.shape 

# Retrieve dimensions from W's shape
(f, f, n_C_prev, n_C) = W.shape

# Retrieve dimensions from Z's shape
(m, n_H, n_W, n_C) = Z.shape

#create initial array for the output of the Deconvolution
X_curr = np.zeros((m, n_H_prev, n_W_prev, n_C_prev))

#loop over the Training examples
for i in range (m):

 #loop over the vertical of the output
 for h in range(n_H):

 #loop over the horizontal of the output
 for w in range(n_W):

 #loop over the 
 for c in range (n_C):

 #loop over the color channels
 for x in range(n_C_prev):

 #inverse_W = np.linalg.pinv(W[:, :, x, c])
 transpose_W = np.transpose(W[:,:,x,c]) 
 #X_curr[i, h*s:h*s+f, w*s:w*s+f, x] += Z[i, h, w, c] * inverse_W
 X_curr[i, h*s:h*s+f, w*s:w*s+f, x] += Z[i, h, w, c] * transpose_W
 X_curr[i, h*s:h*s+f, w*s:w*s+f, :] += b[:,:,:,c]

X_curr = relu(X_curr)

return X_curr

This is probably irreversible operation unless the pre-convolution data was not full rank. But note that you reduced the dimensions of your signal, so the convolution was probably cropped to "valid" information (which doesn't need padding)

If you have at least the image or the filter, recovery might be possible, since convolution can be inverted using deconvolution but note that:

• Convolution is defined as
  $$ f(x) circledast g(x) = h(x) = int_-infty^inftyf(x-t)g(t)dt $$




• The some integral transforms (such as Fourier and Laplace) have the property that:

$$ Tf(x) circledast g(x)(s) = Th(x)(s) = Tf(x)(s) times Tg(x)(s) $$

• This is true for the Discrete Fourier Transform and Discrete Convolution as well, so to find your image $i$ from the filtered image $j$ by a filter $h$ given $I$,$J$ and $H$ as the Discrete Fourier transform of $i$,$j$ and $h$, respectively. Let $F.$ denote the discrete fourier transform and $F^-1.$ denote its inverse transformation:

$$ i = F^-1I = F^-1fracJH $$

• The discrete fourier transform is implemented efficiently by SciPy(signal module), FFTW, NumPy(fft module) and probably Theano. Having a lot of wrappers arround.

Note 1: Is important to notice that you will need at least an estimation of your filter, there are a lot of algorithms to do so.

Note 2: Deconvolution is very sensitive to noise, you can check on this class on Digital Image Processing to understand image filtering, mainly the part on Wiener filters.

Note 3: Image Deconvolution is implemented on scikit-image (e.g. Unsupervised Wiener) and on OpenCV using many algorithms (also on matlab in Image Processing Toolbox).