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")
