def xcorr_depthwise(x, kernel): """ x: [B,C,H,W] 250 kernel: [B,C,h,w] 160 """ batch, channel, kH, kW = kernel.shape _, _, xH, xW = x.shape bc = batch * channel x = x.reshape(1, bc, xH, xW) kernel = kernel.reshape(bc, 1, 1, kH, kW) # divide by 2 * 2 kernel_lt = kernel[:, :, :, 0:kH // 2, 0:kW // 2] kernel_rb = kernel[:, :, :, kH // 2:kH, kW // 2:kW] kernel_rt = kernel[:, :, :, 0:kH // 2, kW // 2:kW] kernel_lb = kernel[:, :, :, kH // 2:kH, 0:kW // 2] # cal result out_lt = F.conv2d(x[:, :, 0:(xH - kH // 2), 0:(xW - kW // 2)], kernel_lt, groups=bc) out_rb = F.conv2d(x[:, :, (kH // 2):xH, (kW // 2):xW], kernel_rb, groups=bc) out_rt = F.conv2d(x[:, :, 0:(xH - kH // 2), (kW // 2):xW], kernel_rt, groups=bc) out_lb = F.conv2d(x[:, :, (kH // 2):xH, 0:(xW - kW // 2)], kernel_lb, groups=bc) oH, oW = out_lt.shape[2], out_lt.shape[3] out = (out_lt + out_rb + out_rt + out_lb).reshape(batch, channel, oH, oW) return out
def two_layer_conv(x): # (8, 3, 3, 3) 代表(输出信道数,输入信道数,卷积核高度,卷积核宽度) conv_weight = mge.Parameter(np.random.randn(8, 3, 3, 3).astype(np.float32)) # 对于 8 个卷积核,提供 8 个 bias conv_bias = mge.Parameter(np.zeros((1, 8, 1, 1), dtype=np.float32)) x = F.conv2d(x, conv_weight, conv_bias) x = F.relu(x) conv_weight = mge.Parameter( np.random.randn(16, 8, 3, 3).astype(np.float32)) conv_bias = mge.Parameter(np.zeros((1, 16, 1, 1), dtype=np.float32)) x = F.conv2d(x, conv_weight, conv_bias) x = F.relu(x) return x
def forward(self, x, x_gap): x_w = self.wn_fc1(x_gap) x_w = self.sigmoid(x_w) x_w = self.wn_fc2(x_w) if x.shape[0] == 1: # case of batch size = 1 x_w = x_w.reshape(self.oup, self.inp, self.ksize, self.ksize) x = F.conv2d(x, weight=x_w, stride=self.stride, padding=self.pad) return x x = x.reshape(1, -1, x.shape[2], x.shape[3]) x_w = x_w.reshape(-1, self.oup, self.inp, self.ksize, self.ksize) x = F.conv2d(x, weight=x_w, stride=self.stride, padding=self.pad, groups=x_w.shape[0]) x = x.reshape(-1, self.oup, x.shape[2], x.shape[3]) return x
def test_conv2d_zero_stride_numpy_array(): inp = np.random.randn(3, 224, 224).astype(np.float32) inp = inp[np.newaxis, :] inp = tensor(inp, dtype=np.float32) weight = tensor(np.random.randn(16, 3, 3, 3), dtype=np.float32) out = F.conv2d(inp, weight, None, (2, 2), (3, 3), (1, 1), 1)
def forward(self, inps): src = inps[0] weight = inps[1] try: bias = inps[2] except IndexError: bias = None if bias is not None: if bias.shape.ndim == 3: bias = F.expand_dims(bias, axis=0) elif bias.shape.ndim == 1: bias = F.expand_dims(bias, axis=[0, 2, 3]) else: raise Exception(f"Invalid Conv2d bias's shape {bias.shape}") if self.param["groups"] != 1: groups = self.param["groups"] IC = src.shape.numpy()[1] OC = weight.shape.numpy()[0] FH = weight.shape.numpy()[2] FW = weight.shape.numpy()[3] target_shape = [groups, int(OC / groups), int(IC / groups), FH, FW] weight = F.reshape(weight, target_shape) return F.conv2d( src, weight, bias, stride=self.param["stride"], padding=self.param["padding"], dilation=self.param["dilation"], groups=self.param["groups"], )
def gaussblur(x, kernel, p=5, chn=3): x_pad = F.pad(x, pad=[ int((p - 1) / 2), ] * 4, mode='reflect') y = F.conv2d(x_pad, kernel, padding=0, stride=1, groups=chn) return y
def convf(x, kernel): batch = int(kernel.shape[0]) channel = int(kernel.shape[1]) bc = batch * channel x = x.reshape((1, bc, int(x.shape[2]), int(x.shape[3]))) kernel = kernel.reshape(bc, 1, 1, int(kernel.shape[2]), int(kernel.shape[3])) out = F.conv2d(x, kernel, groups=bc) out = out.reshape(batch, channel, int(out.shape[2]), int(out.shape[3])) return out
def run( N, IC, OC, IH, IW, KH, KW, PH, PW, SH, SW, has_bias=True, ): inp_v = np.random.normal(size=(N, IC, IH, IW)) w_v = np.random.normal(size=(N, OC, IC, KH, KW)) b_v = np.random.normal(size=(1, OC, 1, 1)) inp_scale = dtype.get_scale(inp_dtype) w_scale = dtype.get_scale(w_dtype) b_scale = dtype.get_scale(b_dtype) inpv = dtype.convert_to_qint8(inp_v * inp_scale, inp_dtype) wv = dtype.convert_to_qint8(w_v * w_scale, w_dtype) bv = dtype.convert_to_qint32(b_v * b_scale, b_dtype) inp_int8 = tensor(inpv, dtype=inp_dtype) w_int8 = Parameter(wv, dtype=w_dtype) b_int32 = Parameter(bv, dtype=b_dtype) inp_fp32 = inp_int8.astype("float32") w_fp32 = w_int8.astype("float32") b_fp32 = b_int32.astype("float32") def run_batch_conv_bias(inp, w, b): b = b if has_bias else Parameter(np.zeros_like(b.numpy())) result = F.quantized.batch_conv_bias_activation( inp, w, b, stride=(SH, SW), padding=(PH, PW), dtype=out_dtype, ) return result.astype("float32") expected = F.conv2d(inp_fp32, w_fp32[0], b_fp32 if has_bias else None)[0] expected = expected.astype(out_dtype).astype("float32") expected = F.flatten(expected) result = run_batch_conv_bias(inp_int8, w_int8, b_int32) result = F.flatten(result) np.testing.assert_allclose(result.numpy(), expected.numpy(), atol=outp_scale)
def test_conv2d_autocast(): """check amp's result is equal to manually converted result""" amp.enabled = True inp = tensor(np.random.randn(1, 3, 224, 224), dtype=np.float32) weight = tensor(np.random.randn(64, 3, 7, 7), dtype=np.float32) out = F.conv2d(inp, weight, None, (2, 2), (3, 3), (1, 1), 1) amp.enabled = False expected = F.conv2d( inp.astype("float16"), weight.astype("float16"), None, (2, 2), (3, 3), (1, 1), 1, compute_mode="float32", ) assert out.dtype == np.float16 assert expected.dtype == np.float16 np.testing.assert_allclose(out.numpy(), expected.numpy())
def run_conv2d(inp, w, b): O = F.conv2d( inp, w, b if has_bias else None, stride=(SH, SW), padding=(PH, PW), ) if nonlinear_mode == "relu": return F.relu(O) else: return O
def test_set_conv2d_config(): """check setting config by contextmanager is equal to manually converted result""" config._compute_mode = "float32" inp = tensor(np.random.randn(1, 3, 224, 224), dtype=np.float16) weight = tensor(np.random.randn(64, 3, 7, 7), dtype=np.float16) config_out = F.conv2d(inp, weight, None, (2, 2), (3, 3), (1, 1), 1) config._compute_mode = "default" with config._override(compute_mode="float32"): context_out = F.conv2d(inp, weight, None, (2, 2), (3, 3), (1, 1), 1) expected = F.conv2d( inp, weight, None, (2, 2), (3, 3), (1, 1), 1, compute_mode="float32", ) np.testing.assert_allclose(config_out.numpy(), expected.numpy()) np.testing.assert_allclose(context_out.numpy(), expected.numpy())
def forward( self, inp, weight, bias=None, stride=(1, 1), padding=(0, 0), dilation=(1, 1), groups=1, ): x = F.conv2d(inp, weight, bias, stride, padding, dilation, groups) return x
def xcorr_depthwise(x, kernel): """ x: [B,C,H,W] kernel: [B,C,h,w] """ batch = int(kernel.shape[0]) channel = int(kernel.shape[1]) bc = batch * channel x = x.reshape(1, bc, x.shape[2], x.shape[3]) kernel = kernel.reshape(bc, 1, 1, kernel.shape[2], kernel.shape[3]) out = F.conv2d(x, kernel, groups=bc) out = out.reshape(batch, channel, out.shape[2], out.shape[3]) return out
def forward(self, x, y): return F.conv2d(x, y)