def channel_shuffle(self, x): batchsize, num_channels, height, width = x.shape # assert (num_channels % 4 == 0) x = x.reshape(batchsize * num_channels // 2, 2, height * width) x = F.transpose(x, (1, 0, 2)) x = x.reshape(2, -1, num_channels // 2, height, width) return x[0], x[1]
def __getitem__(self, idx): dummy_data = np.zeros([512, 640, 2]) imgs = [self.samples[idx]["img1"], self.samples[idx]["img2"]] gyro_homo = self.samples[idx]["h**o"] gt_flow = self.samples[idx]["gt_flow"] split = self.samples[idx]["split"] gyro_filed = homo_to_flow(np.expand_dims(gyro_homo, 0), H=600, W=800).squeeze() imgs = [cv2.resize(i, (640, 512)) for i in imgs] gt_flow = self.resize_flow(gt_flow, dummy_data, True).transpose(2, 0, 1) gyro_filed = self.resize_flow(gyro_filed, dummy_data, True).transpose(2, 0, 1) if self.input_transform: imgs_it = [F.transpose(i, (2, 0, 1)) for i in imgs] ret = {"img{}".format(i + 1): v for i, v in enumerate(imgs_it)} ret["gyro_field"] = gyro_filed ret["gt_flow"] = gt_flow ret["label"] = split ret["rain_label"] = split return ret
def forward(self, xin, labels=None, imgs=None): outputs = [] assert not self.training for k, (cls_conv, reg_conv, stride_this_level, x) in enumerate( zip(self.cls_convs, self.reg_convs, self.strides, xin)): x = self.stems[k](x) cls_x = x reg_x = x cls_feat = cls_conv(cls_x) cls_output = self.cls_preds[k](cls_feat) reg_feat = reg_conv(reg_x) reg_output = self.reg_preds[k](reg_feat) obj_output = self.obj_preds[k](reg_feat) output = F.concat( [reg_output, F.sigmoid(obj_output), F.sigmoid(cls_output)], 1) outputs.append(output) self.hw = [x.shape[-2:] for x in outputs] # [batch, n_anchors_all, 85] outputs = F.concat([F.flatten(x, start_axis=2) for x in outputs], axis=2) outputs = F.transpose(outputs, (0, 2, 1)) if self.decode_in_inference: return self.decode_outputs(outputs) else: return outputs
def channel_shuffle(self, x): batchsize, num_channels, height, width = x.shape # assert num_channels.numpy() % self.group == 0 group_channels = num_channels // self.group x = x.reshape(batchsize, group_channels, self.group, height, width) x = F.transpose(x, (0, 2, 1, 3, 4)) x = x.reshape(batchsize, num_channels, height, width) return x
def flow_warp(x, flow12): B, _, H, W = x.shape base_grid = mesh_grid(B, H, W).astype(x) # B2HW grid_warp = base_grid + flow12 grid_warp = F.transpose(grid_warp, (0, 2, 3, 1)) warp_imgs = F.vision.remap(x, grid_warp) return warp_imgs
def convert_to_nchw4(var): var = F.reshape(var, (var.shape[0], var.shape[1] // 4, 4, var.shape[2], var.shape[3])) var = F.transpose(var, (0, 1, 3, 4, 2)) return var
def run( N, IC, OC, IH, IW, KH, KW, PH, PW, SH, SW, has_bias=True, nonlinear_mode="identity", ): inp_v = np.random.normal(size=(N, IC, IH, IW)) w_v = np.random.normal(size=(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 convert_to_nchw4(var): var = F.reshape(var, (var.shape[0], var.shape[1] // 4, 4, var.shape[2], var.shape[3])) var = F.transpose(var, (0, 1, 3, 4, 2)) return var 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 run_conv_bias(inp, w, b, format="NCHW"): b = b if has_bias else Parameter(np.zeros_like(b.numpy())) if format == "NCHW4": inp = convert_to_nchw4(inp) w = convert_to_nchw4(w) b = convert_to_nchw4(b) return F.quantized.conv_bias_activation( inp, w, b, stride=(SH, SW), padding=(PH, PW), dtype=out_dtype, nonlinear_mode=nonlinear_mode, ) format = "NCHW4" if is_cuda_available() else "NCHW" expected = run_conv2d(inp_fp32, w_fp32, b_fp32) expected = expected.astype(out_dtype).astype("float32") result = run_conv_bias(inp_int8, w_int8, b_int32, format=format).astype("float32") if format == "NCHW4": result = F.transpose(result, (0, 1, 4, 2, 3)) expected = F.flatten(expected) result = F.flatten(result) np.testing.assert_allclose(result.numpy(), expected.numpy(), atol=outp_scale)
def forward(self, inps): pattern = [int(i) for i in self.param["perm"]] return F.transpose(inps[0], pattern)
[(1000, 1000)], True, 1000, ), ( "tile", lambda x: MF.tile(x, (2, ) * len(x.shape)), lambda x: torch.tile(x, (2, ) * len(x.shape)), [(100, 100)], [(64, 512, 16, 16)], True, 1000, ), ( "transpose", lambda x: MF.transpose(x, list(range(len(x.shape)))[::-1]), lambda x: torch.permute(x, list(range(len(x.shape)))[::-1]), [(100, 100)], [(64, 512, 16, 16)], True, 1000, ), ( "where", lambda x: MF.where(x > 0.5, x, x), lambda x: torch.where(x > 0.5, x, x), [(100, 100)], [(64, 512, 16, 16)], True, 1000,
def forward(self, x): return F.transpose(x, self.perm)