python：4维数据最大池化及卷积自定义函数实现

#不断修改，减少对numpy的依赖，尽量底层#

最大池化

第一次定义

import numpy as np
import tensorflow as tf#测试使用
def max_pooling(x, pooling, strides=(2, 2), padding=(0, 0)):
    """
    最大池化前向过程
    :param x: 卷积层矩阵,形状(N,C,H,W)，N为batch_size，C为通道数
    :param pooling: 池化大小(k1,k2)
    :param strides: 步长 参数可改
    :param padding: 0填充  参数可改
    #28/2=0>pad=0
    :return:
    """
    N, H, W, C = x.shape

    # 零填充
    #如（（1，2），（2，2）），表示在第一个维度上水平方向上padding=1,垂直方向上padding=2,在第二个维度上水平方向上padding=2,垂直方向上padding=2。如果直接输入一个整数，则说明各个维度和各个方向所填补的长度都一样。
    padding_z = np.pad(x, ((0, 0), (padding[0], padding[0]), (padding[1], padding[1]), (0, 0)), 'constant',
                       constant_values=0)

    # 输出的高度和宽度
    out_h = (H + 2 * padding[0] - pooling[0]) // strides[0] + 1
    out_w = (W + 2 * padding[1] - pooling[1]) // strides[1] + 1

    pool_z = np.zeros((N, out_h, out_w, C))

    for n in np.arange(N):
        for c in np.arange(C):
            for i in np.arange(out_h):
                for j in np.arange(out_w):
                    pool_z[n, i, j, c] = np.max(padding_z[n, strides[0] * i:strides[0] * i + pooling[0],
                                                strides[1] * j:strides[1] * j + pooling[1], c])
    return pool_z  # N,H, W, C

第二次定义

import numpy as np
def max_pooling(x, pooling, strides=2, padding=0):
    """
    最大池化前向过程
    :param x: 卷积层矩阵,形状(N,C,H,W)，N为batch_size，C为通道数
    :param pooling: 池化大小(k1,k2)
    :param strides: 步长  参数可改，H与W步长不一致可参考第一次strides表示
    :param padding: 0填充  参数可改 H与W填充不一致可参考第一次pad表示
    #28/2=0>pad=0
    :return:
    """
    N, H, W, C = x.shape

    # 零填充
    #如（（1，2），（2，2）），表示在第一个维度上水平方向上padding=1,垂直方向上padding=2,在第二个维度上水平方向上padding=2,垂直方向上padding=2。如果直接输入一个整数，则说明各个维度和各个方向所填补的长度都一样。
    #padding_z = np.pad(x, ((0, 0), (padding[0], padding[0]), (padding[1], padding[1]), (0, 0)), 'constant',constant_values=0)
    
    padding_z = np.zeros((N, H + 2 * padding, W + 2 * padding, C))  # 填充pad 后的维度
    padding_z[:, padding:padding + H, padding:padding + W, :] = x  # 填充pad 后的x
    
    

    # 输出的高度和宽度
    out_h = (H + 2 * padding - pooling) // strides + 1
    out_w = (W + 2 * padding - pooling) // strides + 1

    pool_z = np.zeros((N, out_h, out_w, C))
    max_z  = np.zeros((N, pooling, pooling, C))

    for n in range(N):
        for c in range(C):
            for i in range(out_h):
                for j in range(out_w):
                    for p in range(pooling):                      
                        for q in range(pooling):                        
                            max_z[n, p, q, c]=padding_z[n, strides * i + p, strides * j + q, c]       
                    pool_z[n, i, j, c] = np.max(max_z[n, : ,: , c])              #当用max求二维列表中最大值时，输出的结果是子列表首元素最大的那个列表
    return pool_z  # N,H, W, C

第三次定义

import numpy as np
def max_pooling(x, pooling, strides=2, padding=0):
    """
    最大池化前向过程
    :param x: 卷积层矩阵,形状(N,C,H,W)，N为batch_size，C为通道数
    :param pooling: 池化大小(k1,k2)
    :param strides: 步长  参数可改 H与W步长不一致可参考第一次strides表示
    :param padding: 0填充 参数可改 H与W填充不一致可参考第一次pad表示
    #28/2=0>pad=0
    :return:
    """
    N, H, W, C = x.shape

    # 零填充
    #如（（1，2），（2，2）），表示在第一个维度上水平方向上padding=1,垂直方向上padding=2,在第二个维度上水平方向上padding=2,垂直方向上padding=2。如果直接输入一个整数，则说明各个维度和各个方向所填补的长度都一样。
    #padding_z = np.pad(x, ((0, 0), (padding[0], padding[0]), (padding[1], padding[1]), (0, 0)), 'constant',constant_values=0)
    
    padding_z = np.zeros((N, H + 2 * padding, W + 2 * padding, C))  # 填充pad 后的维度
    padding_z[:, padding:padding + H, padding:padding + W, :] = x  # 填充pad 后的x
    
    

    # 输出的高度和宽度
    out_h = (H + 2 * padding - pooling) // strides + 1
    out_w = (W + 2 * padding - pooling) // strides + 1

    pool_z = np.zeros((N, out_h, out_w, C))#输出
    max_z  = np.zeros((N, pooling, pooling, C))#池化的值
    max_p = np.zeros((N,  1, C))#大小比较

    for n in range(N):
        for c in range(C):
            for i in range(out_h):
                for j in range(out_w):
                    for p in range(pooling):
                        max_p[n,: ,c]=padding_z[n, strides * i,  strides * j,  c]
                        for q in range(pooling):                        
                            max_z[n, p, q, c]=padding_z[n, strides * i + p, strides * j + q, c]
                            if  max_z[n, p, q, c] > max_p[n,:,c]:
                                max_p[n,:,c]=max_z[n, p, q, c]
                    pool_z[n, i, j, c] = max_p[n, : , c]
                    #pool_z[n, i, j, c] = np.max(max_z[n, : ,: , c])              #当用max求二维列表中最大值时，输出的结果是子列表首元素最大的那个列表
    return pool_z  # N,H, W, C

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

卷积

第一次

import numpy as np
import tensorflow as tf #测试使用
def conv2d(x, w, b, Stride, Pad):
    """
     输入包含N个数据，每个数据具有C个通道，高度H和宽度W.
     用F个不同的滤波器对每个输入进行卷积，每个滤波器跨越所有C通道，高度HH和宽度HH。
    - x: (N,H, W, C)
    - w:  (HH, WW,C,F)
    - b: (F,)
    - 'stride':移动步长
    - 'pad': 输入零填充的像素数
    - Output data：(N, F, H', W')
      H' = 1 + (H + 2 * pad - HH) // stride
      W' = 1 + (W + 2 * pad - WW) // stride
    """
    out = None
    N, H, W, C = x.shape  # N,H, W, C
    HH, WW, _, F = w.shape  # HH, WW, C，F

    Ho = 1 + (H + 2 * Pad - HH) // Stride  # 输出H
    Wo = 1 + (W + 2 * Pad - WW) // Stride  # 输出W

    x_pad = np.zeros((N, H + 2 * Pad, W + 2 * Pad, C))  # 填充pad 后的维度
    x_pad[:, Pad:Pad + H, Pad:Pad + W, :] = x  # 填充pad 后的x
    out = np.zeros((N, Ho, Wo, F))  # 输出

    for f in range(F):
        for i in range(Ho):
            for j in range(Wo):  # N*C*HH*WW, C*HH*WW = N*C*HH*WW, sum -> N*1
                out[:, i, j, f] = np.sum(x_pad[:, i * Stride: i * Stride + HH, j * Stride: j * Stride + WW, :] * w[:, :, :, f],axis=(1, 2, 3))#把axis对应的维度压缩相加
        out[:, :, :, f] += b[f]  # 加偏置
    return out  # N,H,W,F

第二次

import numpy as np
import tensorflow as tf #测试使用
def conv2d(x, w, b, Stride, Pad):
    """
     输入包含N个数据，每个数据具有C个通道，高度H和宽度W.
     用F个不同的滤波器对每个输入进行卷积，每个滤波器跨越所有C通道，高度HH和宽度HH。
    - x: (N,H, W, C,)
    - w:  (HH, WW,C,F)
    - b: (F,)
    - 'stride':移动步长
    - 'pad': 输入零填充的像素数
    - Output data：(N, F, H', W')
      H' = 1 + (H + 2 * pad - HH) // stride
      W' = 1 + (W + 2 * pad - WW) // stride
    """
    out = None
    N, H, W, C = x.shape  # N,H, W, C
    HH, WW, CC, F = w.shape  # HH, WW, C，F

    Ho = 1 + (H + 2 * Pad - HH) // Stride  # 输出H
    Wo = 1 + (W + 2 * Pad - WW) // Stride  # 输出W

    x_pad = np.zeros((N, H + 2 * Pad, W + 2 * Pad, C))  # 填充pad 后的维度
    x_pad[:, Pad:Pad + H, Pad:Pad + W, :] = x  # 填充pad 后的x
    
    kernel= np.zeros((N, HH, WW, CC))
    
    out = np.zeros((N, Ho, Wo, F))  # 输出

    for f in range(F):
        for i in range(Ho):
            for j in range(Wo):  # N*C*HH*WW, C*HH*WW = N*C*HH*WW, sum -> N*1
                for m in range(HH):
                    for n in range(WW):
                        kernel[:,m,n,:]=x_pad[:, i * Stride + m, j * Stride + n, :] * w[m, n, :,f]
                out[:,i,j,f]=np.sum(kernel[:,:,:,:], axis=(1, 2,3) ) #把axis对应的维压缩相加。             
        out[:, :, :, f] += b[f]  # 加偏置
    return out  # N,H,W,F