def backward(self, delta):
dx = patch2img(np.tensordot(delta, self.y.value, (3, 3)), self.stride,
self.shape)
slices = [slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape)]
dx = dx[slices]
dy = np.tensordot(self.patch, delta, axes=((0, 1, 2), ) * 2)
self.x.backward(dx)
self.y.backward(dy)
def backward(self, delta):
delta_patch = np.zeros(delta.shape + (np.prod(self.pool_size), ))
index = np.where(delta == delta) + (self.index.ravel(), )
delta_patch[index] = delta.ravel()
delta_patch = np.reshape(delta_patch, delta.shape + self.pool_size)
delta_patch = delta_patch.transpose(0, 1, 2, 4, 5, 3)
dx = patch2img(delta_patch, self.stride, self.shape)
slices = [slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape)]
dx = dx[slices]
self.x.backward(dx)
def _backward(self, delta, x, y):
delta_flattened = delta.reshape(-1, delta.shape[-1])
dpatch_flattened = delta_flattened @ y.T
dpatch = dpatch_flattened.reshape(self.patch.shape)
dimg = patch2img(dpatch, self.stride, self.paddedshape)
slices = tuple(
slice(p, len_ - p) for p, len_ in zip(self.pad, self.paddedshape))
dx = dimg[slices]
dy = self.patch_flattened.T @ delta_flattened
return dx, dy
def backward(self, delta):
delta_patch = np.zeros(delta.shape + (np.prod(self.pool_size),))
index = np.where(delta == delta) + (self.index.ravel(),)
delta_patch[index] = delta.ravel()
delta_patch = np.reshape(delta_patch, delta.shape + self.pool_size)
delta_patch = delta_patch.transpose(0, 1, 2, 4, 5, 3)
dx = patch2img(delta_patch, self.stride, self.shape)
slices = [slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape)]
dx = dx[slices]
self.x.backward(dx)
def backward(self, delta):
dx = patch2img(
np.tensordot(delta, self.y.value, (3, 3)),
self.stride,
self.shape
)
slices = [slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape)]
dx = dx[slices]
dy = np.tensordot(self.patch, delta, axes=((0, 1, 2),) * 2)
self.x.backward(dx)
self.y.backward(dy)
def _forward(self, x, y):
if self.shape is None:
shape = (len(x),) + tuple(s * (imlen - 1) + klen
for s, imlen, klen in zip(self.stride, x.shape[1:], self.kernel_size)) + (self.out_ch,)
else:
shape = (len(x),) + self.shape + (self.out_ch,)
patch_flat = np.matmul(x, y.T) # (N, Hx, Wx, kx * ky * out_ch)
output = patch2img(patch_flat.reshape(*patch_flat.shape[:3], *self.kernel_size, -1), self.stride, shape)
output = output[
:,
self.pad[1]: output.shape[1] - self.pad[1],
self.pad[2]: output.shape[2] - self.pad[2]
]
return output
def _backward(self, delta, x):
delta_patch = np.zeros(delta.shape + (np.prod(self.pool_size), ),
dtype=config.dtype)
index = np.where(delta == delta) + (self.index.ravel(), )
delta_patch[index] = delta.ravel()
delta_patch = np.reshape(delta_patch, delta.shape + self.pool_size)
delta_patch = delta_patch.transpose(0, 1, 2, 4, 5, 3)
if self.pool_size == self.stride:
dx = patch2img_no_overlap(delta_patch, self.stride, self.shape)
else:
dx = patch2img(delta_patch, self.stride, self.shape)
slices = tuple(
slice(p, len_ - p) for p, len_ in zip(self.pad, self.shape))
dx = dx[slices]
return dx