Numpy实现MaxPooling2D（最大池化）和AveragePooling2D（平均池化）

向右看齐 2022-09-11 11:10 63阅读 0赞

class PoolingLayer(Layer):
        """A parent class of MaxPooling2D and AveragePooling2D """
        def __init__(self, pool_shape=(2, 2), stride=1, padding=0):
            self.pool_shape = pool_shape
            self.stride = stride
            self.padding = padding
            self.trainable = True
    
        def forward_pass(self, X, training=True):
            self.layer_input = X
    
            batch_size, channels, height, width = X.shape
    
            _, out_height, out_width = self.output_shape()
    
            X = X.reshape(batch_size*channels, 1, height, width)
            X_col = image_to_column(X, self.pool_shape, self.stride, self.padding)
    
            # MaxPool or AveragePool specific method
            output = self._pool_forward(X_col)
    
            output = output.reshape(out_height, out_width, batch_size, channels)
            output = output.transpose(2, 3, 0, 1)
    
            return output
    
        def backward_pass(self, accum_grad):
            batch_size, _, _, _ = accum_grad.shape
            channels, height, width = self.input_shape
            accum_grad = accum_grad.transpose(2, 3, 0, 1).ravel()
    
            # MaxPool or AveragePool specific method
            accum_grad_col = self._pool_backward(accum_grad)
    
            accum_grad = column_to_image(accum_grad_col, (batch_size * channels, 1, height, width), self.pool_shape, self.stride, 0)
            accum_grad = accum_grad.reshape((batch_size,) + self.input_shape)
    
            return accum_grad
    
        def output_shape(self):
            channels, height, width = self.input_shape
            out_height = (height - self.pool_shape[0]) / self.stride + 1
            out_width = (width - self.pool_shape[1]) / self.stride + 1
            assert out_height % 1 == 0
            assert out_width % 1 == 0
            return channels, int(out_height), int(out_width)
    
    
    class MaxPooling2D(PoolingLayer):
        def _pool_forward(self, X_col):
            arg_max = np.argmax(X_col, axis=0).flatten()
            output = X_col[arg_max, range(arg_max.size)]
            self.cache = arg_max
            return output
    
        def _pool_backward(self, accum_grad):
            accum_grad_col = np.zeros((np.prod(self.pool_shape), accum_grad.size))
            arg_max = self.cache
            accum_grad_col[arg_max, range(accum_grad.size)] = accum_grad
            return accum_grad_col
    
    class AveragePooling2D(PoolingLayer):
        def _pool_forward(self, X_col):
            output = np.mean(X_col, axis=0)
            return output
    
        def _pool_backward(self, accum_grad):
            accum_grad_col = np.zeros((np.prod(self.pool_shape), accum_grad.size))
            accum_grad_col[:, range(accum_grad.size)] = 1. / accum_grad_col.shape[0] * accum_grad
            return accum_grad_col