input.jpeg
import numpy
from skimage import io
import skimage.data
import matplotlib.pyplot as plt
import numpy
import sys
def conv(img, conv_filter):
if len(img.shape) > 2 or len(conv_filter.shape) > 3:
if img.shape[-1] != conv_filter.shape[-1]:
print("Error: Number of channels in both image and filter must match.")
sys.exit()
if conv_filter.shape[1] != conv_filter.shape[2]:
print('Error: Filter must be a square matrix.')
sys.exit()
if conv_filter.shape[1]%2==0:
print('Error: Filter must have an odd size.')
sys.exit()
feature_maps = numpy.zeros((img.shape[0]-conv_filter.shape[1]+1,
img.shape[1]-conv_filter.shape[1]+1,
conv_filter.shape[0]))
for filter_num in range(conv_filter.shape[0]):
print("Filter ", filter_num + 1)
curr_filter = conv_filter[filter_num, :]
if len(curr_filter.shape) > 2:
conv_map = conv_(img[:, :, 0], curr_filter[:, :, 0])
for ch_num in range(1, curr_filter.shape[-1]):
conv_map = conv_map + conv_(img[:, :, ch_num],curr_filter[:, :, ch_num])
else:
conv_map = conv_(img, curr_filter)
feature_maps[:, :, filter_num] = conv_map
return feature_maps
def conv_(img, conv_filter):
filter_size = conv_filter.shape[0]
result = numpy.zeros((img.shape))
for r in numpy.uint16(numpy.arange(filter_size/2, img.shape[0]-filter_size/2-2)):
for c in numpy.uint16(numpy.arange(filter_size/2, img.shape[1]-filter_size/2-2)):
curr_region = img[r:r+filter_size, c:c+filter_size]
curr_result = curr_region * conv_filter
conv_sum = numpy.sum(curr_result)
result[r, c] = conv_sum
final_result = result[numpy.uint16(filter_size/2):result.shape[0]-numpy.uint16(filter_size/2),
numpy.uint16(filter_size/2):result.shape[1]-numpy.uint16(filter_size/2)]
return final_result
def relu(feature_map):
relu_out = numpy.zeros(feature_map.shape)
for map_num in range(feature_map.shape[-1]):
for r in numpy.arange(0, feature_map.shape[0]):
for c in numpy.arange(0, feature_map.shape[1]):
relu_out[r, c, map_num] = numpy.max(feature_map[r, c, map_num], 0)
return relu_out
def pooling(feature_map, size, stride):
pool_out = numpy.zeros((numpy.uint16((feature_map.shape[0] - size + 1) / stride),
numpy.uint16((feature_map.shape[1] - size+1) / stride),
feature_map.shape[-1]))
for map_num in range(feature_map.shape[-1]):
r2 = 0
for r in numpy.arange(0, feature_map.shape[0]-size-1, stride):
c2 = 0
for c in numpy.arange(0, feature_map.shape[1]-size-1, stride):
pool_out[r2, c2, map_num] = numpy.max(feature_map[r:r+size, c:c+size])
c2 = c2 + 1
r2 = r2 + 1
return pool_out
img0 = io.imread('input.jpeg')
img = skimage.color.rgb2gray(img0)
# First conv layer
l1_filter = numpy.zeros((2, 3, 3))
l1_filter[0, :, :] = numpy.array([[[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]])
l1_filter[1, :, :] = numpy.array([[[1, 1, 1], [0, 0, 0], [-1, -1, -1]]])
print("**Working with conv layer 1**")
l1_feature_map = conv(img, l1_filter)
print("**ReLU**")
l1_feature_map_relu = relu(l1_feature_map)
print("**Pooling**")
l1_feature_map_relu_pool = pooling(l1_feature_map_relu, 2, 2)
print("**End of conv layer 1**n")
# Second conv layer
l2_filter = numpy.random.rand(3, 5, 5, l1_feature_map_relu_pool.shape[-1])
print("**Working with conv layer 2**")
l2_feature_map = conv(l1_feature_map_relu_pool, l2_filter)
print("**ReLU**")
l2_feature_map_relu = relu(l2_feature_map)
print("**Pooling**")
l2_feature_map_relu_pool = pooling(l2_feature_map_relu, 2, 2)
print("**End of conv layer 2**n")
# Third conv layer
l3_filter = numpy.random.rand(1, 7, 7, l2_feature_map_relu_pool.shape[-1])
print("**Working with conv layer 3**")
l3_feature_map = conv(l2_feature_map_relu_pool, l3_filter)
print("**ReLU**")
l3_feature_map_relu = relu(l3_feature_map)
print("**Pooling**")
l3_feature_map_relu_pool = pooling(l3_feature_map_relu, 2, 2)
print("**End of conv layer 3**n")
plt.figure(1)
plt.subplot(4,2,1)
plt.imshow(img0)
plt.subplot(4,2,2)
plt.imshow(img,cmap='gray')
plt.subplot(4,2,3)
plt.imshow(l1_feature_map[:,:,0],cmap='gray')
plt.subplot(4,2,4)
plt.imshow(l1_feature_map[:,:,1],cmap='gray')
plt.subplot(4,2,5)
plt.imshow(l1_feature_map_relu[:,:,0],cmap='gray')
plt.subplot(4,2,6)
plt.imshow(l1_feature_map_relu[:,:,1],cmap='gray')
plt.subplot(4,2,7)
plt.imshow(l1_feature_map_relu_pool[:,:,0],cmap='gray')
plt.subplot(4,2,8)
plt.imshow(l1_feature_map_relu_pool[:,:,1],cmap='gray')
plt.figure(2)
plt.subplot(3,2,1)
plt.imshow(l2_feature_map[:,:,0],cmap='gray')
plt.subplot(3,2,2)
plt.imshow(l2_feature_map[:,:,1],cmap='gray')
plt.subplot(3,2,3)
plt.imshow(l2_feature_map_relu[:,:,0],cmap='gray')
plt.subplot(3,2,4)
plt.imshow(l2_feature_map_relu[:,:,1],cmap='gray')
plt.subplot(3,2,5)
plt.imshow(l2_feature_map_relu_pool[:,:,0],cmap='gray')
plt.subplot(3,2,6)
plt.imshow(l2_feature_map_relu_pool[:,:,1],cmap='gray')
plt.figure(3)
plt.subplot(3,1,1)
plt.imshow(l3_feature_map,cmap='gray')
plt.subplot(3,1,2)
plt.imshow(l3_feature_map_relu,cmap='gray')
plt.subplot(3,1,3)
plt.imshow(l3_feature_map_relu_pool,cmap='gray')
plt.show()
First conv layer
Second conv layer
Third conv layer
