python 反传播_python实现maxpooling/avgpooling，及其反向传播

maxpooling

import numpy as np

import torch

class MaxPooling2D:

def __init__(self, kernel_size=(2, 2), stride=2):

self.kernel_size = kernel_size

self.w_height = kernel_size[0]

self.w_width = kernel_size[1]

self.stride = stride

self.x = None

self.in_height = None

self.in_width = None

self.out_height = None

self.out_width = None

self.arg_max = None

def __call__(self, x):

self.x = x

self.in_height = np.shape(x)[0]

self.in_width = np.shape(x)[1]

self.out_height = int((self.in_height - self.w_height) / self.stride) + 1

self.out_width = int((self.in_width - self.w_width) / self.stride) + 1

out = np.zeros((self.out_height, self.out_width))

self.arg_max = np.zeros_like(out, dtype=np.int32)

for i in range(self.out_height):

for j in range(self.out_width):

start_i = i * self.stride

start_j = j * self.stride

end_i = start_i + self.w_height

end_j = start_j + self.w_width

out[i, j] = np.max(x[start_i: end_i, start_j: end_j])

self.arg_max[i, j] = np.argmax(x[start_i: end_i, start_j: end_j])

self.arg_max = self.arg_max

return out

def backward(self, d_loss):

dx = np.zeros_like(self.x)

for i in range(self.out_height):

for j in range(self.out_width):

start_i = i * self.stride

start_j = j * self.stride

end_i = start_i + self.w_height

end_j = start_j + self.w_width

index = np.unravel_index(self.arg_max[i, j], self.kernel_size)

dx[start_i:end_i, start_j:en