def conv_(img, conv_filter):
    filter_size = conv_filter.shape[1]
    result = numpy.zeros((img.shape))
    print('loop r: ', numpy.uint16(numpy.arange(filter_size/2.0,img.shape[0]-filter_size/2.0+1)))
    #Looping through the image to apply the convolution operation.
    for r in numpy.uint16(numpy.arange(filter_size/2.0,img.shape[0]-filter_size/2.0+1)):
        for c in numpy.uint16(numpy.arange(filter_size/2.0,
                                           img.shape[1]-filter_size/2.0+1)):
           # Getting the current region to get multiplied with the filter.
            # How to loop through the image and get the region based on
            # the image and filer sizes is the most tricky part of convolution.
            curr_region = img[r-numpy.uint16(numpy.floor(filter_size/2.0)):r+numpy.uint16(numpy.ceil(filter_size/2.0)),
                              c-numpy.uint16(numpy.floor(filter_size/2.0)):c+numpy.uint16(numpy.ceil(filter_size/2.0))]
            #Element-wise multiplication between the current region and the filter.
            curr_result = curr_region * conv_filter
            conv_sum = numpy.sum(curr_result) #Summing the result of multiplication.
            result[r, c] = conv_sum
            #Saving the summation in the convolution layer feature map.
            #Clipping the outliers of the result matrix.
    print('result: ', result)
    final_result = result[numpy.uint16(filter_size/2.0):result.shape[0]- numpy.uint16(filter_size/2.0),
                          numpy.uint16(filter_size/2.0):result.shape[1]- numpy.uint16(filter_size/2.0)]
    return final_result
  
def  convolution(img, conv_filter):
  '''
  如果图片的规格为[img_height, img_width],过滤器规格为[filter_height, filter_width]
  那么在水平方向上横向移动过滤器进行卷积运算的次数为img_width - filter_width +1.
  在竖直方向上竖直移动过滤器进行卷积运算次数为image_hieght - filter_height + 1
  '''
  move_steps_vertical = img.shape[0] - conv_filter.shape[0] + 1
  move_steps_horizontal = img.shape[1] - conv_filter.shape[1] + 1
  
  result = numpy.zeros((move_steps_vertical, move_steps_horizontal))
 
  for vertical_index in range(move_steps_vertical):
    for horizontal_index in range(move_steps_horizontal):
      '''
      先从最顶端开始，选取3*3小块与过滤器进行卷积运算，然后在水平方向平移一个单位。
      当水平移动抵达最右边后，返回到最左边但是往下挪到一个单位，再重复上面步骤进行
      卷积运算
      '''
      region = img[vertical_index : vertical_index + conv_filter.shape[0],
                  horizontal_index : horizontal_index + conv_filter.shape[1]]
      
      #调试时可以反注释下面两条语句以理解代码逻辑
      #print('region index: ', vertical_index, horizontal_index)
      #print('current region: ', region)
      
      current_result = region * conv_filter
      conv_sum = np.sum(current_result)
      if conv_sum < 0:
        conv_sum = 0
      result[vertical_index, horizontal_index] = conv_sum
      
  return result 
      
      
from google.colab import drive
drive.mount('/content/gdrive')

 

 

import numpy as np
import numpy

img = np.array([
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
])

filter = np.array(
    [
        [1, 0, -1],
        [1, 0, -1],
        [1, 0, -1],
    ]
  
)

filter1 = np.array(
    [
        [1, 1, 1],
        [0, 0, 0],
        [-1, -1, -1],
    ]
  
)

conv_img = convolution(img, filter)
print(conv_img)

img = np.array([
    [10, 10, 10, 10, 10 ,10],
    [10, 0, 0, 0, 0 ,0],
    [10, 0, 0, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
    [10, 10, 10, 0, 0 ,0],
])

conv_img = convolution(img, filter1)
print(conv_img)

#加载图片，并将图片转换为像素点只包含一个数值的灰度图
import  skimage.data

image_path = '/content/gdrive/My Drive/dog.jpg'
#加载图片同时将RGB图片转换为灰度图
img = skimage.data.load(image_path, as_grey = True)

import matplotlib
from matplotlib import pyplot as plt
plt.axis('off')
plt.imshow(img)
plt.show()

 

 

#准备两个过滤器，每个过滤器的规格为（3，3）
filters = np.array([
    [
        [-1, 0, 1],
        [-1, 0, 1],
        [-1, 0, 1]
    ],
    [
        [1, 1, 1],
        [0, 0, 0],
        [-1, -1, -1]
    ]
])

def  convolution(img, conv_filter):
  '''
  如果图片的规格为[img_height, img_width],过滤器规格为[filter_height, filter_width]
  那么在水平方向上横向移动进行卷积运算的次数为img_width - filter_width +1.
  在竖直方向上竖直移动进行卷积运算次数为image_hieght - filter_height + 1
  '''
  move_steps_vertical = img.shape[0] - conv_filter.shape[0] + 1
  move_steps_horizontal = img.shape[1] - conv_filter.shape[1] + 1
  
  result = numpy.zeros((move_steps_vertical, move_steps_horizontal))
 
  for vertical_index in range(move_steps_vertical):
    for horizontal_index in range(move_steps_horizontal):
      '''
      先从最顶端开始，选取3*3小块与运算参数进行卷积运算，然后在水平方向平移一个单位。
      当水平移动抵达最右边后，返回到最左边但是往下挪到一个单位，再重复上面步骤进行
      卷积运算
      '''
      region = img[vertical_index : vertical_index + conv_filter.shape[0],
                  horizontal_index : horizontal_index + conv_filter.shape[1]]
      
       
      current_result = region * conv_filter
      conv_sum = np.sum(current_result)
      
      #注意这里去掉了conv_sum < 0判断，因为在后面的激活函数实现中会处理这个问题
      
      result[vertical_index, horizontal_index] = conv_sum
      
  return result 

def  conv(img, conv_filter):
  '''
  #将过滤器依次作用到图像数组上
  '''
  #feature_map是运算参数作用到图片上后得到的结果
  feature_maps = np.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]):
    curr_filter = conv_filter[filter_num, :]
    conv_map = convolution(img, curr_filter)
    feature_maps[:,:, filter_num] = conv_map
    
  return feature_maps

image_path = '/content/gdrive/My Drive/dog.jpg'
#加载图片同时将RGB图片转换为灰度图
img = skimage.data.load(image_path, as_grey = True)
#将两组运算参数作用到加载的灰度图上
l1_feature_map = conv(img, filters)

#显示第一组运算参数作用到图片上的结果，它抽取图片中物体的竖直边缘
fig1, ax1 = matplotlib.pyplot.subplots(nrows=1, ncols=2)
ax1[0].imshow(l1_feature_map[:, :, 0]).set_cmap("gray")
ax1[0].get_xaxis().set_ticks([])
ax1[0].get_yaxis().set_ticks([])
ax1[0].set_title("L1-Map1")

#显示第二组运算参数作用到图片上的结果，它抽取图片中物体的水平边缘
ax1[1].imshow(l1_feature_map[:, :, 1]).set_cmap("gray")
ax1[1].get_xaxis().set_ticks([])
ax1[1].get_yaxis().set_ticks([])
ax1[1].set_title("L1-Map2")

'''
模拟relu运算，它的逻辑简单，如果给定数值小于0，那就将它设置为0，如果大于0，那就保持不变
'''
def  relu(feature_map):
  relu_out = np.zeros(feature_map.shape)
  for map_num in range(feature_map.shape[-1]):
    for r in np.arange(0, feature_map.shape[0]):
      for c in np.arange(0, feature_map.shape[1]):
        relu_out[r, c, map_num] = np.max([feature_map[r, c, map_num], 0])
        
  return relu_out
#显示第一幅图relu运算后的结果
fig1, ax1 = matplotlib.pyplot.subplots(nrows=1, ncols=2)
reluMap = relu(l1_feature_map)
ax1[0].imshow(reluMap[:, :, 0]).set_cmap("gray")
ax1[0].get_xaxis().set_ticks([])
ax1[0].get_yaxis().set_ticks([])
ax1[0].set_title("L1-MapRelu1")

#显示第二幅图relu运算后结果的结果
ax1[1].imshow(reluMap[:, :, 1]).set_cmap("gray")
ax1[1].get_xaxis().set_ticks([])
ax1[1].get_yaxis().set_ticks([])
ax1[1].set_title("L1-MapRelu2")

'''
模拟MaxPooling操作实现数据压缩
'''
def  pooling(feature_map, size = 2, stride = 2):
  #size表示将上下左右4个元素进行比较，每次操作在水平和竖直方向上移动2个单位
  pool_out_height = np.uint16((feature_map.shape[0] - size + 1) / stride + 1) 
  pool_out_width = np.uint16((feature_map.shape[1] - size + 1) / stride + 1)
  
  pool_out = np.zeros((pool_out_height, pool_out_width, feature_map.shape[-1]))
  
  #现在水平方向上平移，每次间隔2个单位，然后在竖直方向平移，每次间隔2个单位
  for map_num in range(feature_map.shape[-1]):
    r2 = 0
    for r in np.arange(0, feature_map.shape[0] - size + 1, stride):
      c2 = 0
      for c in np.arange(0, feature_map.shape[1] - size + 1, stride):
        pool_out[r2, c2, map_num] = np.max([feature_map[r : r + size,
                                                       c: c + size,
                                                       map_num]])
        c2 = c2 + 1
        
      r2 = r2 + 1
      
  return  pool_out
#显示第一幅图relu运算,再做max pooling结果
fig1, ax1 = matplotlib.pyplot.subplots(nrows=1, ncols=2)
poolingMap = pooling(reluMap)
ax1[0].imshow(poolingMap[:, :, 0]).set_cmap("gray")
ax1[0].get_xaxis().set_ticks([])
ax1[0].get_yaxis().set_ticks([])
ax1[0].set_title("L1-pooling1")

#显示第二幅图relu运算后，再做max pooling结果的结果
ax1[1].imshow(poolingMap[:, :, 1]).set_cmap("gray")
ax1[1].get_xaxis().set_ticks([])
ax1[1].get_yaxis().set_ticks([])
ax1[1].set_title("L1-pooling2")

filters2 = np.random.rand(2, 5, 5)
print('adding conv layer 2')
feature_map_2 = conv(poolingMap[:,:, 0], filters2)
print('ReLU')
relu_map_2 = relu(feature_map_2)
print('max pooling')
poolingMap_2 = pooling(relu_map_2)
print('End of conv layer 2')

#显示第二层卷积层运算后第一幅图
fig1, ax1 = matplotlib.pyplot.subplots(nrows=1, ncols=2)

ax1[0].imshow(poolingMap_2[:, :, 0]).set_cmap("gray")
ax1[0].get_xaxis().set_ticks([])
ax1[0].get_yaxis().set_ticks([])
ax1[0].set_title("Layer 2, L1-pooling1")

#显示第二层卷积层运算后第二幅图
ax1[1].imshow(poolingMap_2[:, :, 1]).set_cmap("gray")
ax1[1].get_xaxis().set_ticks([])
ax1[1].get_yaxis().set_ticks([])
ax1[1].set_title("Layer 2, L1-pooling2")

filters3 = np.random.rand(2, 7, 7)
print('adding conv layer 3')
feature_map_3 = conv(poolingMap_2[:,:, 0], filters3)
print('ReLU')
relu_map_3 = relu(feature_map_3)
print('max pooling')
poolingMap_3 = pooling(relu_map_3)
print('End of conv layer 3')

#显示第三层卷积层运算后第一幅图
fig1, ax1 = matplotlib.pyplot.subplots(nrows=1, ncols=2)

ax1[0].imshow(poolingMap_3[:, :, 0]).set_cmap("gray")
ax1[0].get_xaxis().set_ticks([])
ax1[0].get_yaxis().set_ticks([])
ax1[0].set_title("Layer 2, L1-pooling1")

#显示第三层卷积层运算后第二幅图
ax1[1].imshow(poolingMap_3[:, :, 1]).set_cmap("gray")
ax1[1].get_xaxis().set_ticks([])
ax1[1].get_yaxis().set_ticks([])
ax1[1].set_title("Layer 2, L1-pooling2")