第一步定义卷积核类：
class Filter(object):
# 滤波器类 对卷积核进行初始化
def __init__(self,width,height,depth):
# initialize the filter parameter
self.weights=np.random.uniform(-1e-4,1e-4,(depth,height,width))
self.bias=0
self.weights_grad=np.zeros(self.weights.shape)
self.bias_grad=0
def get_weights(self):
return self.weights
def get_bias(self):
return self.bias
def update_weight(self,learning_rate):
self.weights-=self.weights_grad*learning_rate
self.bias-=self.bias_grad*learning_rate
定义卷积层
def conv(input_array,kernel_array,output_array,stride,bias):
channel_number=input_array.ndim
output_width=output_array.shape[1]
output_height=output_array.shape[0]
kernel_width=kernel_array.shape[-1]
kernel_height=kernel_array.shape[-2]
for i in range(output_height):
for j in range(output_width):
# get_patch 得到i,j位置对应的图像的块
output_array[i][j]=(get_patch(input_array,i,j,kernel_width,kernel_height,stride)*kernel_array).sum()+bias
定义padding 函数：根据扩展的大小进行0填充
def padding(input_array, zero_padding):
if zero_padding == 0:
return input_array
else:
if input_array.ndim == 3:
input_width = input_array.shape[2]
input_height = input_array.shape[1]
input_depth = input_array.shape[0]
padded_array = np.zeros((input_depth, input_height + 2 * zero_padding,
input_width + 2 * zero_padding))
padded_array[:, zero_padding:zero_padding + input_height,
zero_padding:zero_padding + input_width] = input_array
elif input_array.ndim == 2:
input_width = input_array.shape[1]
input_height = input_array.shape[0]
padded_array = np.zeros((input_height + 2 * zero_padding, input_width + 2 * zero_padding))
padded_array[zero_padding:zero_padding + input_width,
zero_padding:zero_padding + input_height] = input_array
return padded_array
定义卷积类：
def calculate_output_size(input_size,filter_size,zero_padding,stride):
return (input_size-filter_size+2*zero_padding)/stride+1
class ConvLayer(object):
def __init__(self,input_width,input_height,channel_number,
filter_width,filter_height,filter_number,zero_padding,stride,
activator,learning_rate):
self.input_width=input_width
self.input_height=input_height
self.channel_number=channel_number
self.filter_width=filter_width
self.filter_height=filter_height
self.filter_number=filter_number
self.zero_padding=zero_padding
self.stride=stride
# 根据（f-w+2p）/2+1
self.outpu_width=ConvLayer.calculate_output_size(self.input_width,
filter_width,zero_padding,stride)
self.output_height=ConvLayer.calculate_output_size(self.input_height,
filter_height,zero_padding,
stride)
# 得到padding 后的图像
self.output_array=np.zeros(self.filter_number,self.output_width,self.output_height)
# the output of the convolution
# 初始化filters
self.filters=[]
# initialize filters
for i in range(filter_number):
self.filters.append(Filter(filter_width,filter_height,self.channel_number))
self.activator=activator
self.learning_rate=learning_rate
# 对 灵敏度图进行扩充
def expand_sentivity_map(self,sensitivity_array):
depth=sensitivity_array.shape[0]
expanded_width=(self.input_width-self.filter_width+2*self.zero_padding+1)
expanded_height=(self.input_height-self.filter_height+2*self.zero_padding+1)
expand_array=np.zeros((depth,expanded_height,expanded_width))
for i in range(self.output_height):
for j in range(self.output_width):
i_pos=i*self.stride
j_pos=j*self.stride
expand_array[:,i_pos,j_pos]=sensitivity_array[:,i,j]
return expand_array
# 创建灵敏度矩阵
def create_delta_array(self):
return np.zeros((self.channnel_number,self.input_height,self.input_width))
# 前向传递
def forward(self,input_array):
self.input_array=input_array
# first pad image to the size needed
self.padded_input_array=padding(input_array,self.zero_padding)
for f in range(self.filter_number):
filter=self.filters[f]
conv(self.paded_input_array,filter.get_weights(),filter.get_bias())
element_wise_op(self.output_array,self.acitator.forward)
# 反向传递
def bp_sensitivity_map(self, sensitivity_array,activator):
# padding sensitivity map
expanded_array=self.expand_sentivity_map(sensitivity_array)
expanded_width=expanded_array.shape[2]
zp=(self.input_width+self.filter_width-1-expanded_width)/2
padded_array=padding(expanded_array,zp)
self.delta_array=self.create_delta_array()
for f in range(self.filter_number):
filter=self.filter[f]
filpped_weights=np.array(map(lambda i: np.rot90(i,2),filter.get_weights()))
delta_array=self.create_delta_array()
for d in range(delta_array.shape[0])
conv(padded_array[f],filpped_weights[d],delta_array[d],1,0)
self.delta_array+=delta_array
derivative_array=np.array(self.input_array)
element_wise_op(derivative_array,activator.backward)
self.delta_array*=derivative_array
# 参数的梯度是 输入乘以灵敏度矩阵
def bp_gradient(self,sensitivity_array):
expanded_array=self.expand_sensitivity_map(sensitivity_array)
for f in range(self.filter_number):
filter=self.filter[f]
for d in range(filter.weights.shape[0]):
conv(self.padded_input_array[d],expanded_array[f],filter.weights_grad[d],1,0)
filter.bias_grad=expanded_array[f].sum()
# 对参数进行update
def update(self):
for filter in self.filters:
filter.update(self.learning_rate)