实现卷积层的前向传播与反向传播

小鱼儿 2023-07-10 05:24 22阅读 0赞

第一次学习，看的这个视频教程实在觉得不好，这个过程也不是很理解，以后我会结合相关书籍和视频课程继续学习，遇到好的一定会为大家推荐  
（这是我的一个不太理解的过程=^=！）  
以三层卷积为例：  
 d a t a → W 1 , b 1 c o n v 1 → r e l u → p o o l → W 2 , b 2 f c → W 3 , b 3 o u t p u t data\\overset\{W1,b1\}\{\\rightarrow\}conv1\\rightarrow relu\\rightarrow pool\\overset\{W2,b2\}\{\\rightarrow\}fc\\overset\{W3,b3\}\{\\rightarrow\}output data→W1,b1conv1→relu→pool→W2,b2fc→W3,b3output

网络结构：

class ThreeLayerConvNet(object):
        def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,
                     hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,
                     dtype=np.float32):
            self.params = { }
            self.reg = reg
            self.dtype = dtype
    
            C, H, W = input_dim
            self.params['W1'] = weight_scale * np.random.randn(num_filters, C, filter_size, filter_size)
            self.params['b1'] = np.zeros(num_filters)
            self.params['W2'] = weight_scale * np.random.randn(num_filters * H * W / 4, hidden_dim)
            self.params['b2'] = np.zeros(hidden_dim)
            self.params['W3'] = weight_scale * np.random.randn(hidden_dim,num_classes)
            self.params['b3'] = np.zeros(num_classes)
    
            for k,v in self.params.items():
                self.params[k]=v.astype(dtype)
    
        def loss(self,X,y=None):
            W1,b1=self.params['W1'],self.params['b1']
            W2, b2 = self.params['W2'], self.params['b3']
            W3, b3 = self.params['W2'], self.params['b3']
    
            filter_size=W1.shape[2]
            conv_param={ 'stride':1,'pad':(filter_size-1)/2}
    
            pool_param={ 'pool_height':2,'pool_width':2,'stride':2}
            # 前向传导
            a1,cache1=conv_relu_pool_forward(X,W1,b1,conv_param,pool_param)
            a2,cache2=affine_relu_forward(a1,W2,b2)
            scores,cache3=affine_forward(a2,W3,b3)
    
            if y is None:
                return scores
    
            # 后向传导
            data_loss,dscores=softmax_loss(scores,y)
            da2,dW3,db3=affine_backward(dscores,cache3)
            da1,dW2,db2=affine_relu_backward(da2,cache2)
            dX,dW1,db1=conv_relu_pool_backward(da1,cache1)
    
            dW1+=self.reg*W1
            dW2+=self.reg*W2
            dW3+=self.reg*W3
            reg_loss=0.5*self.reg*sum(np.sum(W*W)for W in [W1,W2,W3])
    
            loss=data_loss+reg_loss
            grads={ 'W1':dW1,'b1':db1,'W2':dW2,'b2':db2,'W3':dW3,'b3':db3}
    
            return loss,grads

卷积前向传导：

def conv_forward_naive(x,w,b,conv_param):
        stride,pad=conv_param['stride'],conv_param['pad']
        N,C,H,W=x.shape
        F,C,HH,WW=w.shape
        x_padded=np.pad(x,((0,0),(0,0),(pad,pad),(pad,pad)),mode='constant')
        H_new=1+(H+2*pad-HH)/stride
        W_new=1+(W+2*pad-WW)/stride
        s=stride
        out=np.zeros((N,F,H_new,W_new))
    
        for i in range(N):# ith image
            for f in range(F):# fth filter
                for j in range(H_new):
                    for k in range(W_new):
                        out[i,f,j,k]=np.sum(x_padded[i,:,j*s:HH+j*s,k*s:WW+k*s]*w[f])+b[f]
        cache=(x,w,b,conv_param)
        return out,cache

卷积反向传导：

def conv_backward_naive(dout,cache):
        x,w,b,conv_param=cache
        pad=conv_param['pad']
        stride=conv_param['stride']
        F,C,HH,WW=w.shape
        N,C,H,W=x.shape
        H_new=1+(H+2*pad-HH)/stride
        W_new=1+(W+2*pad-WW)/stride
    
        dx=np.zeros_like(x)
        dw=np.zeros_like(w)
        db=np.zeros_like(b)
    
        s=stride
        x_padded=np.pad(x,((0,0),(0,0),(pad,pad),(pad,pad)),'constant')
        dx_padded=np.pad(dx,((0,0),(0,0),(pad,pad),(pad,pad)),'constant')
    
        for i in range(N):
            for f in range(F):
                for j in range(H_new):
                    for k in range(W_new):
                        window=x_padded[i,:,j*s:HH+j*s,k*s:WW+k*s]
                        db[f]+=dout[i,f,j,k]
                        dw[f]+=window*dout[i,f,j,k]
                        dx_padded[i,:,j*s:HH+j*s,k*s:WW+k*s]+=w[f]*dout[i,f,j,k]
    
        dx=dx_padded[:,:,pad:pad+H,pad:pad+W]
        return dx,dw,db