笔记：CS231n+assignment2（作业二）（三）

终于来到了最终的大BOSS，卷积神经网络~

这里我想还是主要关注代码的实现，具体的CNN的知识点想以后在好好写一写，CNN的代码关键就是要加上卷积层和池话层.

一、卷积层

　　卷积层的前向传播还是比较容易的，我们主要关注的是反向传播，看下图就知道了：

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 xrange(N):       # ith image

        for f in xrange(F):   # fth filter

            for j in xrange(H_new):

                for k in xrange(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 xrange(N):       # ith image

        for f in xrange(F):   # fth filter

            for j in xrange(H_new):

                for k in xrange(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]#上面的式子，关键就在于+号

    # Unpad

    dx = dx_padded[:, :, pad:pad+H, pad:pad+W]

    return dx, dw, db

　　和http://www.cnblogs.com/tornadomeet/p/3468450.html中提到的一样，卷积层的BP算法就是这么计算的，也就是一个正统的卷积操作

二、pooling层

def max_pool_forward_naive(x, pool_param):

    HH, WW = pool_param['pool_height'], pool_param['pool_width']

    s = pool_param['stride']

    N, C, H, W = x.shape

    H_new = 1 + (H - HH) / s

    W_new = 1 + (W - WW) / s

    out = np.zeros((N, C, H_new, W_new))

    for i in xrange(N):

        for j in xrange(C):

            for k in xrange(H_new):

                for l in xrange(W_new):

                    window = x[i, j, k*s:HH+k*s, l*s:WW+l*s]

                    out[i, j, k, l] = np.max(window)

    cache = (x, pool_param)

    return out, cache

def max_pool_backward_naive(dout, cache):

    x, pool_param = cache

    HH, WW = pool_param['pool_height'], pool_param['pool_width']

    s = pool_param['stride']

    N, C, H, W = x.shape

    H_new = 1 + (H - HH) / s

    W_new = 1 + (W - WW) / s

    dx = np.zeros_like(x)

    for i in xrange(N):

        for j in xrange(C):

            for k in xrange(H_new):

                for l in xrange(W_new):

                    window = x[i, j, k*s:HH+k*s, l*s:WW+l*s]

                    m = np.max(window)               #获得之前的那个值，这样下面只要windows==m就能得到相应的位置

                    dx[i, j, k*s:HH+k*s, l*s:WW+l*s] = (window == m) * dout[i, j, k, l]

    return dx

三、与之前的区别

　　这里BN算法与之前是不太一样的，因为网络的输入变成了saptail的

def spatial_batchnorm_forward(x, gamma, beta, bn_param):

    N, C, H, W = x.shape

    x_new = x.transpose(0, 2, 3, 1).reshape(N*H*W, C)#分成不同的channel来算，所以可以直接用之前的代码

    out, cache = batchnorm_forward(x_new, gamma, beta, bn_param)

    out = out.reshape(N, H, W, C).transpose(0, 3, 1, 2)

    return out, cache

def spatial_batchnorm_backward(dout, cache):

    N, C, H, W = dout.shape

    dout_new = dout.transpose(0, 2, 3, 1).reshape(N*H*W, C)

    dx, dgamma, dbeta = batchnorm_backward(dout_new, cache)

    dx = dx.reshape(N, H, W, C).transpose(0, 3, 1, 2)

    return dx, dgamma, dbeta

四、总结

　　assignment2终于弄完了，总的来说..numpy还是要多熟悉，具体的操作也要熟悉。卷积层的前向传播很好理解，反向传播和之前的区别不大，只不过需要做一个卷积的操作。

巴特西

笔记：CS231n+assignment2（作业二）（三）

最新文章

热门文章