From 3733452068f84c0e90c9a453a81ee4412e84f063 Mon Sep 17 00:00:00 2001 From: Crispig Date: Mon, 1 Aug 2022 12:24:33 +0800 Subject: [PATCH 1/3] rebuild test file --- deephub/detection_model/necks/second_fpn.py | 21 +- deephub/detection_model/pointpillars.py | 22 + .../voxel_encoders/pillar_encoder.py | 16 +- .../detection_model/voxel_encoders/utils.py | 10 +- demo.py | 155 +++++++ deploy.py | 129 ++++++ log.txt | 9 + log1.txt | 351 ++++++++++++++++ log2.txt | 349 ++++++++++++++++ log3.txt | 390 ++++++++++++++++++ run.sh | 1 + test/test_model_ops/test_compressor.py | 142 +++++++ tools/demo.py | 12 + 13 files changed, 1601 insertions(+), 6 deletions(-) create mode 100644 demo.py create mode 100644 deploy.py create mode 100644 log.txt create mode 100644 log1.txt create mode 100644 log2.txt create mode 100644 log3.txt create mode 100755 run.sh create mode 100644 test/test_model_ops/test_compressor.py create mode 100644 tools/demo.py diff --git a/deephub/detection_model/necks/second_fpn.py b/deephub/detection_model/necks/second_fpn.py index 22198a9..d64d36f 100644 --- a/deephub/detection_model/necks/second_fpn.py +++ b/deephub/detection_model/necks/second_fpn.py @@ -4,7 +4,7 @@ from mmcv.cnn import build_conv_layer, build_norm_layer, build_upsample_layer from mmcv.runner import BaseModule, auto_fp16 from torch import nn as nn - +from torch.quantization import QuantStub, DeQuantStub class SECONDFPN(BaseModule): @@ -37,6 +37,8 @@ def __init__(self, self.in_channels = in_channels self.out_channels = out_channels self.fp16_enabled = False + self.quant = QuantStub() + self.dequant = DeQuantStub() deblocks = [] for i, out_channel in enumerate(out_channels): @@ -80,7 +82,22 @@ def forward(self, x): list[torch.Tensor]: Multi-level feature maps. """ assert len(x) == len(self.in_channels) - ups = [deblock(x[i]) for i, deblock in enumerate(self.deblocks)] + # x = map(self.quant, x) + # x = list(x) + + ups = [] + for i, deblock in enumerate(self.deblocks): + temp = x[i] + for j, item in enumerate(deblock): + if j == 0: + temp = item(temp) + elif j == 1: + temp = item(self.quant(temp)) + + ups.append(temp) + + + # ups = [deblock(x[i]) for i, deblock in enumerate(self.deblocks)] if len(ups) > 1: out = torch.cat(ups, dim=1) diff --git a/deephub/detection_model/pointpillars.py b/deephub/detection_model/pointpillars.py index c72e398..e4b38d8 100644 --- a/deephub/detection_model/pointpillars.py +++ b/deephub/detection_model/pointpillars.py @@ -5,6 +5,8 @@ from .backbones import SECOND from .necks import SECONDFPN from .heads import Anchor3DHead +import numpy as np +from torch.quantization import QuantStub, DeQuantStub class Pointpillars(BaseModule): """Backbone network for SECOND/PointPillars/PartA2/MVXNet. @@ -43,6 +45,8 @@ def __init__(self, in_channels=384, feat_channels=384 ) + self.quant = QuantStub() + self.dequant = DeQuantStub() def forward(self, voxels, @@ -59,8 +63,14 @@ def forward(self, Returns: List: Result of model. """ + voxels= self.quant(voxels) + # num_points= self.quant(num_points) + # coors= self.quant(coors) x = self.extract_feat(voxels, num_points, coors) bbox_preds, scores, dir_scores = self.bbox_head(x) + # bbox_preds = self.dequant(bbox_preds) + # scores = self.dequant(scores) + # dir_scores = self.dequant(dir_scores) return bbox_preds, scores, dir_scores def extract_feat(self, @@ -79,9 +89,21 @@ def extract_feat(self, """ voxel_features = self.voxel_encoder(voxels, num_points, coors) batch_size = coors[-1, 0] + 1 # refactor + print(coors[-1, 0]) + # print(batch_size, '------------------') + # print("SIZESIZESIZE : ", np.array(voxels.cpu()).shape) + # print("SIZESIZESIZE : ", np.array(num_points.cpu()).shape) + # print("SIZESIZESIZE : ", np.array(coors.cpu()).shape) assert batch_size == 1 + voxel_features = self.dequant(voxel_features) x = self.middle_encoder(voxel_features, coors, batch_size) + x = self.quant(x) x = self.backbone(x) + + x = map(self.dequant, x) + x = list(x) + + # print(size(x)) x = self.neck(x) return x diff --git a/deephub/detection_model/voxel_encoders/pillar_encoder.py b/deephub/detection_model/voxel_encoders/pillar_encoder.py index ad332b7..8802c43 100644 --- a/deephub/detection_model/voxel_encoders/pillar_encoder.py +++ b/deephub/detection_model/voxel_encoders/pillar_encoder.py @@ -4,7 +4,7 @@ from torch import nn from .utils import PFNLayer, get_paddings_indicator - +from torch.quantization import QuantStub, DeQuantStub class PillarFeatureNet(nn.Module): """Pillar Feature Net. @@ -85,6 +85,8 @@ def __init__(self, self.y_offset = self.vy / 2 + point_cloud_range[1] self.z_offset = self.vz / 2 + point_cloud_range[2] self.point_cloud_range = point_cloud_range + self.quant = QuantStub() + self.dequant = DeQuantStub() @force_fp32(out_fp16=True) def forward(self, features, num_points, coors): @@ -100,12 +102,14 @@ def forward(self, features, num_points, coors): Returns: torch.Tensor: Features of pillars. """ + features = self.dequant(features) features_ls = [features] # Find distance of x, y, and z from cluster center if self._with_cluster_center: points_mean = features[:, :, :3].sum( dim=1, keepdim=True) / num_points.type_as(features).view(-1, 1, 1) f_cluster = features[:, :, :3] - points_mean + # f_cluster = self.quant(f_cluster) features_ls.append(f_cluster) # Find distance of x, y, and z from pillar center @@ -131,7 +135,16 @@ def forward(self, features, num_points, coors): features_ls.append(points_dist) # Combine together feature decorations + # features_ls = self.dequant(features_ls) + # for i1 in features_ls: + # for i2 in i1: + # for i3 in i2: + # i3 = self.dequant(i3) + features = torch.cat(features_ls, dim=-1) + # features = self.quant(features) + # features = [self.quant(i) for i in features] + # The feature decorations were calculated without regard to whether # pillar was empty. Need to ensure that # empty pillars remain set to zeros. @@ -142,5 +155,6 @@ def forward(self, features, num_points, coors): for pfn in self.pfn_layers: features = pfn(features, num_points) + features = self.quant(features) return features.squeeze(1) diff --git a/deephub/detection_model/voxel_encoders/utils.py b/deephub/detection_model/voxel_encoders/utils.py index 5904593..662a54d 100644 --- a/deephub/detection_model/voxel_encoders/utils.py +++ b/deephub/detection_model/voxel_encoders/utils.py @@ -4,7 +4,7 @@ from mmcv.runner import auto_fp16 from torch import nn from torch.nn import functional as F - +from torch.quantization import QuantStub, DeQuantStub def get_paddings_indicator(actual_num, max_num, axis=0): @@ -67,6 +67,8 @@ def __init__(self, assert mode in ['max', 'avg'] self.mode = mode + self.quant = QuantStub() + self.dequant = DeQuantStub() @auto_fp16(apply_to=('inputs'), out_fp32=True) def forward(self, inputs, num_voxels=None, aligned_distance=None): @@ -84,11 +86,13 @@ def forward(self, inputs, num_voxels=None, aligned_distance=None): Returns: torch.Tensor: Features of Pillars. """ - x = self.linear(inputs) + x = self.quant(inputs) + x = self.linear(x) + x = self.dequant(x) x = self.norm(x.permute(0, 2, 1).contiguous()).permute(0, 2, 1).contiguous() x = F.relu(x) - + # x = self.dequant(x) if self.mode == 'max': if aligned_distance is not None: x = x.mul(aligned_distance.unsqueeze(-1)) diff --git a/demo.py b/demo.py new file mode 100644 index 0000000..ba98cb8 --- /dev/null +++ b/demo.py @@ -0,0 +1,155 @@ +import os +import sys +import torch + +from deephub.detection_model import Pointpillars, Centerpoint +from mmcv.runner import load_checkpoint +from model.model_deployor.deployor_utils import create_input +from nni.compression.pytorch.pruning import L1NormPruner +from model.model_deployor.deployor import deploy +from nni.compression.pytorch.speedup import ModelSpeedup +from model.model_compressor.compressor import * + +import time +import faulthandler;faulthandler.enable() +import numpy as np +import copy +import torch.nn.utils.prune as prune +def main(): + start = time.time() + model = Pointpillars() + + load_checkpoint(model, 'checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth', map_location='cpu') + model.cpu() + + # for name, parameters in model.named_parameters(): + # print(name, ':', parameters.dtype) + + model.eval() + # print(model) + # print('--------------------------------------------------------') + input_names = ['voxels', 'num_points', 'coors'] + output_names = ['scores', 'bbox_preds', 'dir_scores'] + dynamic_axes = {'voxels': {0: 'voxels_num'}, + 'num_points': {0: 'voxels_num'}, + 'coors': {0: 'voxels_num'}} + # dynamic_axes = None + + # #0 NNI pruning + # ---------------------------------------- + # config_list = [{ + # 'sparsity_per_layer': 0.5, + # 'op_types': ['Linear', 'Conv2d'] + # }] + + # pruner = L1NormPruner(model, config_list) + + # _, masks = pruner.compress() + + # for name, mask in masks.items(): + # print(name, ' sparsity : ', '{:.2}'.format(mask['weight'].sum() / mask['weight'].numel())) + + # pruner._unwrap_model() + + # from nni.compression.pytorch.speedup import ModelSpeedup + # ---------------------------------------- + + + pcd = 'test/test_model_ops/data/kitti/kitti_000008.bin' + checkpoint = 'checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth' + dataset = 'kitti' + model_name = 'pointpillars' + device = 'cpu' + backend = 'onnxruntime' + output = 'pointpillars' + fp16 = False + + data, model_inputs = create_input(pcd, dataset, model_name, device) + + backend_file = deploy(model, model_inputs, input_names, output_names, dynamic_axes, + backend=backend, output_file=output, fp16=fp16, dataset=dataset) + print("SIZESIZESIZE : ", np.array(model_inputs[0].cpu()).shape) + print("SIZESIZESIZE : ", np.array(model_inputs[1].cpu()).shape) + print("SIZESIZESIZE : ", np.array(model_inputs[2].cpu()).shape) + + + # #0 NNI pruning + #---------------------------------------- + # ModelSpeedup(model, [model_inputs[0], model_inputs[1].short(), model_inputs[2].short()], masks).speedup_model() + #---------------------------------------- + + # #1 dynamic quant (torch) + #---------------------------------------- + # model.cpu() + # torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8) + # model.cuda() + # dynamic_quant(model) + #---------------------------------------- + + # # #2 static quant (torch) + # #---------------------------------------- + # # print(model) + input_data = [model_inputs[0], model_inputs[1], model_inputs[2]] + + static_quant(model, input_data) + # model.qconfig = torch.quantization.get_default_qconfig('fbgemm') + + # model_prepared = torch.quantization.prepare(model) + + # model_prepared(model_inputs[0], model_inputs[1], model_inputs[2]) + # # model_prepared.cpu() + + + # model_prepared.cpu() + # model_int8 = torch.quantization.convert(model_prepared, inplace=True) + + # # print(model_int8) + # print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") + # # model_int8.cpu() + # # model_int8.cuda() + # # data, model_inputs_cuda = create_input(pcd, dataset, model_name, 'cuda:0') + # torch_out = model_int8(model_inputs[0], model_inputs[1], model_inputs[2]) + #---------------------------------------- + + # for n,p in model.named_parameters(): + # print(n) + # print(p) + + # torch_prune + #---------------------------------------- + # prune_list = [torch.nn.Conv2d, torch.nn.Linear] + # amount_list = [0.3, 0.9] + + # torch_prune(model, prune_list, amount_list) + #---------------------------------------- + + # for n,p in model.named_parameters(): + # print(n) + # print(p) + + + # torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) + + + # if backend == 'onnxruntime': + # import onnxruntime + + # ort_session = onnxruntime.InferenceSession(backend_file) + + # input_dict = {} + # input_dict['voxels'] = model_inputs[0].cpu().numpy() + # input_dict['num_points'] = model_inputs[1].cpu().numpy() + # input_dict['coors'] = model_inputs[2].cpu().numpy() + # ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) + + # outputs = {} + # outputs['scores'] = torch.tensor(ort_output[0]) + # outputs['bbox_preds'] = torch.tensor(ort_output[1]) + # outputs['dir_scores'] = torch.tensor(ort_output[2]) + + # print('onnx : inference successful!') + + print(time.time() - start) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/deploy.py b/deploy.py new file mode 100644 index 0000000..47f4639 --- /dev/null +++ b/deploy.py @@ -0,0 +1,129 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import os +os.environ["CUDA_VISIBLE_DEVICES"] = "0" + +import torch +from argparse import ArgumentParser + +from deephub.detection_model import Pointpillars, Centerpoint + +from mmcv.runner import load_checkpoint +from model.model_deployor.deployor import deploy +from model.model_deployor.deployor_utils import create_input +from model.model_deployor.onnx2tensorrt import load_trt_engine, torch_dtype_from_trt, torch_device_from_trt + + +def main(): + parser = ArgumentParser() + parser.add_argument('--pcd', default='test/test_model_ops/data/kitti/kitti_000008.bin', help='Point cloud file') + parser.add_argument('--checkpoint', default='checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth', help='Checkpoint file') + parser.add_argument('--backend', default='onnxruntime', help='backend name') + parser.add_argument('--output', default='pointpillars', help='backend name') + parser.add_argument('--dataset', default='kitti', help='backend name') + parser.add_argument('--model_name', default='pointpillars', help='backend name') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + + args = parser.parse_args() + print(torch.cuda.is_available()) + print(torch.cuda.device_count()) + # Init model and load checkpoints + if args.model_name == 'pointpillars': + model = Pointpillars() + elif args.model_name == 'centerpoint': + model = Centerpoint() + load_checkpoint(model, args.checkpoint, map_location='cpu') + model.cuda() + model.eval() + + # define deploy params + input_names = ['voxels', 'num_points', 'coors'] + output_names = ['scores', 'bbox_preds', 'dir_scores'] + dynamic_axes = {'voxels': {0: 'voxels_num'}, + 'num_points': {0: 'voxels_num'}, + 'coors': {0: 'voxels_num'}} + # dynamic_axes = None + fp16 = False + + data, model_inputs = create_input(args.pcd, args.dataset, args.model_name, args.device) + + # deploy + backend_file = deploy(model, model_inputs, input_names, output_names, dynamic_axes, + backend=args.backend, output_file=args.output, fp16=fp16, dataset=args.dataset) + + # verify + torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) + if args.backend == 'onnxruntime': + import onnxruntime + + ort_session = onnxruntime.InferenceSession(backend_file) + + input_dict = {} + input_dict['voxels'] = model_inputs[0].cpu().numpy() + input_dict['num_points'] = model_inputs[1].cpu().numpy() + input_dict['coors'] = model_inputs[2].cpu().numpy() + ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) + + outputs = {} + outputs['scores'] = torch.tensor(ort_output[0]) + outputs['bbox_preds'] = torch.tensor(ort_output[1]) + outputs['dir_scores'] = torch.tensor(ort_output[2]) + + print('onnx : inference successful!') + + if args.backend == 'tensorrt': + engine = load_trt_engine(backend_file) + context = engine.create_execution_context() + names = [_ for _ in engine] + input_names = list(filter(engine.binding_is_input, names)) + output_names = list(set(names) - set(input_names)) + input_dict = { + 'voxels': model_inputs[0], + 'num_points': model_inputs[1], + 'coors': model_inputs[2] + } + bindings = [None] * (len(input_names) + len(output_names)) + + profile_id = 0 + for input_name, input_tensor in input_dict.items(): + # check if input shape is valid + profile = engine.get_profile_shape(profile_id, input_name) + assert input_tensor.dim() == len( + profile[0]), 'Input dim is different from engine profile.' + for s_min, s_input, s_max in zip(profile[0], input_tensor.shape, + profile[2]): + assert s_min <= s_input <= s_max, \ + 'Input shape should be between ' \ + + f'{profile[0]} and {profile[2]}' \ + + f' but get {tuple(input_tensor.shape)}.' + idx = engine.get_binding_index(input_name) + + # All input tensors must be gpu variables + assert 'cuda' in input_tensor.device.type + input_tensor = input_tensor.contiguous() + if input_tensor.dtype == torch.long: + input_tensor = input_tensor.int() + context.set_binding_shape(idx, tuple(input_tensor.shape)) + bindings[idx] = input_tensor.contiguous().data_ptr() + + # create output tensors + outputs = {} + for output_name in output_names: + idx = engine.get_binding_index(output_name) + dtype = torch_dtype_from_trt(engine.get_binding_dtype(idx)) + shape = tuple(context.get_binding_shape(idx)) + + device = torch_device_from_trt(engine.get_location(idx)) + output = torch.empty(size=shape, dtype=dtype, device=device) + outputs[output_name] = output + bindings[idx] = output.data_ptr() + + context.execute_async_v2(bindings, torch.cuda.current_stream().cuda_stream) + + print('tensorrt : inference successful!') + + + + +if __name__ == '__main__': + main() diff --git a/log.txt b/log.txt new file mode 100644 index 0000000..6fce98e --- /dev/null +++ b/log.txt @@ -0,0 +1,9 @@ +load checkpoint from local path: checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth +tensor(0, dtype=torch.int32) +SIZESIZESIZE : (3945, 32, 4) +SIZESIZESIZE : (3945,) +SIZESIZESIZE : (3945, 4) +tensor(0, dtype=torch.int32) +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +tensor(0, dtype=torch.int32) +3.690884590148926 diff --git a/log1.txt b/log1.txt new file mode 100644 index 0000000..1628a66 --- /dev/null +++ b/log1.txt @@ -0,0 +1,351 @@ +load checkpoint from local path: checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + (conv_reg): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + (conv_dir_cls): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) +) +-------------------------------------------------------- +voxel_encoder.pfn_layers.0.linear sparsity : 0.5 +backbone.blocks.0.0 sparsity : 0.5 +backbone.blocks.0.3 sparsity : 0.5 +backbone.blocks.0.6 sparsity : 0.5 +backbone.blocks.0.9 sparsity : 0.5 +backbone.blocks.1.0 sparsity : 0.5 +backbone.blocks.1.3 sparsity : 0.5 +backbone.blocks.1.6 sparsity : 0.5 +backbone.blocks.1.9 sparsity : 0.5 +backbone.blocks.1.12 sparsity : 0.5 +backbone.blocks.1.15 sparsity : 0.5 +backbone.blocks.2.0 sparsity : 0.5 +backbone.blocks.2.3 sparsity : 0.5 +backbone.blocks.2.6 sparsity : 0.5 +backbone.blocks.2.9 sparsity : 0.5 +backbone.blocks.2.12 sparsity : 0.5 +backbone.blocks.2.15 sparsity : 0.5 +bbox_head.conv_cls sparsity : 0.5 +bbox_head.conv_reg sparsity : 0.5 +bbox_head.conv_dir_cls sparsity : 0.5 +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): PrunerModuleWrapper( + (module): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + ) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): PrunerModuleWrapper( + (module): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + ) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): PrunerModuleWrapper( + (module): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + ) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): PrunerModuleWrapper( + (module): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + ) + (conv_reg): PrunerModuleWrapper( + (module): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + ) + (conv_dir_cls): PrunerModuleWrapper( + (module): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) + ) +) +-------------------------------------------------------- +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + (conv_reg): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + (conv_dir_cls): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) +) +-------------------------------------------------------- +onnx : inference successful! +4.114543914794922 diff --git a/log2.txt b/log2.txt new file mode 100644 index 0000000..a6901ae --- /dev/null +++ b/log2.txt @@ -0,0 +1,349 @@ +load checkpoint from local path: checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + (conv_reg): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + (conv_dir_cls): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) +) +-------------------------------------------------------- +voxel_encoder.pfn_layers.0.linear sparsity : 0.5 +backbone.blocks.0.0 sparsity : 0.5 +backbone.blocks.0.3 sparsity : 0.5 +backbone.blocks.0.6 sparsity : 0.5 +backbone.blocks.0.9 sparsity : 0.5 +backbone.blocks.1.0 sparsity : 0.5 +backbone.blocks.1.3 sparsity : 0.5 +backbone.blocks.1.6 sparsity : 0.5 +backbone.blocks.1.9 sparsity : 0.5 +backbone.blocks.1.12 sparsity : 0.5 +backbone.blocks.1.15 sparsity : 0.5 +backbone.blocks.2.0 sparsity : 0.5 +backbone.blocks.2.3 sparsity : 0.5 +backbone.blocks.2.6 sparsity : 0.5 +backbone.blocks.2.9 sparsity : 0.5 +backbone.blocks.2.12 sparsity : 0.5 +backbone.blocks.2.15 sparsity : 0.5 +bbox_head.conv_cls sparsity : 0.5 +bbox_head.conv_reg sparsity : 0.5 +bbox_head.conv_dir_cls sparsity : 0.5 +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): PrunerModuleWrapper( + (module): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + ) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): PrunerModuleWrapper( + (module): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): PrunerModuleWrapper( + (module): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + ) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): PrunerModuleWrapper( + (module): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): PrunerModuleWrapper( + (module): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + ) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): PrunerModuleWrapper( + (module): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + ) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): PrunerModuleWrapper( + (module): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + ) + (conv_reg): PrunerModuleWrapper( + (module): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + ) + (conv_dir_cls): PrunerModuleWrapper( + (module): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) + ) +) +-------------------------------------------------------- +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + (conv_reg): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + (conv_dir_cls): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) +) +-------------------------------------------------------- diff --git a/log3.txt b/log3.txt new file mode 100644 index 0000000..71130e7 --- /dev/null +++ b/log3.txt @@ -0,0 +1,390 @@ +load checkpoint from local path: checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth +voxel_encoder.pfn_layers.0.linear sparsity : 0.5 +backbone.blocks.0.0 sparsity : 0.5 +backbone.blocks.0.3 sparsity : 0.5 +backbone.blocks.0.6 sparsity : 0.5 +backbone.blocks.0.9 sparsity : 0.5 +backbone.blocks.1.0 sparsity : 0.5 +backbone.blocks.1.3 sparsity : 0.5 +backbone.blocks.1.6 sparsity : 0.5 +backbone.blocks.1.9 sparsity : 0.5 +backbone.blocks.1.12 sparsity : 0.5 +backbone.blocks.1.15 sparsity : 0.5 +backbone.blocks.2.0 sparsity : 0.5 +backbone.blocks.2.3 sparsity : 0.5 +backbone.blocks.2.6 sparsity : 0.5 +backbone.blocks.2.9 sparsity : 0.5 +backbone.blocks.2.12 sparsity : 0.5 +backbone.blocks.2.15 sparsity : 0.5 +bbox_head.conv_cls sparsity : 0.5 +bbox_head.conv_reg sparsity : 0.5 +bbox_head.conv_dir_cls sparsity : 0.5 +SIZESIZESIZE : (3945, 32, 4) +SIZESIZESIZE : (3945,) +SIZESIZESIZE : (3945, 4) +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): Linear(in_features=10, out_features=64, bias=False) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + ) + (1): Sequential( + (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + (2): Sequential( + (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) + (1): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (4): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (5): ReLU(inplace=True) + (6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (7): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (8): ReLU(inplace=True) + (9): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (10): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (11): ReLU(inplace=True) + (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (13): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (14): ReLU(inplace=True) + (15): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) + (16): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (17): ReLU(inplace=True) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (2): ReLU(inplace=True) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): Conv2d(384, 2, kernel_size=(1, 1), stride=(1, 1)) + (conv_reg): Conv2d(384, 14, kernel_size=(1, 1), stride=(1, 1)) + (conv_dir_cls): Conv2d(384, 4, kernel_size=(1, 1), stride=(1, 1)) + ) +) +(------------------------------------------------) +Pointpillars( + (voxel_encoder): PillarFeatureNet( + (pfn_layers): ModuleList( + (0): PFNLayer( + (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) + (linear): Linear( + in_features=10, out_features=64, bias=False + (activation_post_process): HistogramObserver() + ) + ) + ) + ) + (middle_encoder): PointPillarsScatter() + (backbone): SECOND( + (blocks): ModuleList( + (0): Sequential( + (0): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (1): BatchNorm2d( + 64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (2): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (3): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (4): BatchNorm2d( + 64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (5): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (6): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (7): BatchNorm2d( + 64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (8): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (9): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (10): BatchNorm2d( + 64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (11): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + ) + (1): Sequential( + (0): Conv2d( + 64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (1): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (2): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (3): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (4): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (5): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (6): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (7): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (8): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (9): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (10): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (11): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (12): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (13): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (14): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (15): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (16): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (17): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + ) + (2): Sequential( + (0): Conv2d( + 128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (1): BatchNorm2d( + 256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (2): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (3): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (4): BatchNorm2d( + 256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (5): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (6): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (7): BatchNorm2d( + 256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (8): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (9): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (10): BatchNorm2d( + 256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (11): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (12): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (13): BatchNorm2d( + 256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (14): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + (15): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (activation_post_process): HistogramObserver() + ) + (16): BatchNorm2d( + 256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (17): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + ) + ) + ) + init_cfg={'type': 'Kaiming', 'layer': 'Conv2d'} + (neck): SECONDFPN( + (deblocks): ModuleList( + (0): Sequential( + (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) + (1): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (2): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + ) + (1): Sequential( + (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False) + (1): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (2): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + ) + (2): Sequential( + (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False) + (1): BatchNorm2d( + 128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True + (activation_post_process): HistogramObserver() + ) + (2): ReLU( + inplace=True + (activation_post_process): HistogramObserver() + ) + ) + ) + ) + init_cfg=[{'type': 'Kaiming', 'layer': 'ConvTranspose2d'}, {'type': 'Constant', 'layer': 'NaiveSyncBatchNorm2d', 'val': 1.0}] + (bbox_head): Anchor3DHead( + (conv_cls): Conv2d( + 384, 2, kernel_size=(1, 1), stride=(1, 1) + (activation_post_process): HistogramObserver() + ) + (conv_reg): Conv2d( + 384, 14, kernel_size=(1, 1), stride=(1, 1) + (activation_post_process): HistogramObserver() + ) + (conv_dir_cls): Conv2d( + 384, 4, kernel_size=(1, 1), stride=(1, 1) + (activation_post_process): HistogramObserver() + ) + ) +) +(------------------------------------------------) diff --git a/run.sh b/run.sh new file mode 100755 index 0000000..3caf2fb --- /dev/null +++ b/run.sh @@ -0,0 +1 @@ +python deploy.py diff --git a/test/test_model_ops/test_compressor.py b/test/test_model_ops/test_compressor.py new file mode 100644 index 0000000..13622d3 --- /dev/null +++ b/test/test_model_ops/test_compressor.py @@ -0,0 +1,142 @@ +import os +import sys +import torch +CURRENT_DIR = os.path.split(os.path.abspath(__file__))[0] +config_path = CURRENT_DIR.rsplit('/', 2)[0] +sys.path.append(config_path) +from deephub.detection_model import Pointpillars, Centerpoint +from mmcv.runner import load_checkpoint +from model.model_deployor.deployor_utils import create_input +from nni.compression.pytorch.pruning import L1NormPruner +from model.model_deployor.deployor import deploy +from nni.compression.pytorch.speedup import ModelSpeedup +from model.model_compressor.compressor import * + +import time +import faulthandler;faulthandler.enable() +import numpy as np +import copy +import torch.nn.utils.prune as prune + +import unittest + +input_names = ['voxels', 'num_points', 'coors'] +output_names = ['scores', 'bbox_preds', 'dir_scores'] +dynamic_axes = {'voxels': {0: 'voxels_num'}, + 'num_points': {0: 'voxels_num'}, + 'coors': {0: 'voxels_num'}} + # dynamic_axes = None + +pcd = '../../test/test_model_ops/data/kitti/kitti_000008.bin' +checkpoint = '../../checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth' +dataset = 'kitti' +model_name = 'pointpillars' +# device = 'cpu' +backend = 'onnxruntime' +output = 'pointpillars' +fp16 = False + +class TestCompressor(unittest.TestCase): + + @classmethod + def setUpClass(cls): + model = Pointpillars() + load_checkpoint(model, '../../checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth', map_location='cpu') + model.eval() + cls.model = model + + # noinspection DuplicatedCode + def test_static_quant(self): + device = 'cpu' + model.cpu() + + data, model_inputs = create_input(pcd, dataset, model_name, device) + + backend_file = deploy(model, model_inputs, input_names, output_names, dynamic_axes, + backend=backend, output_file=output, fp16=fp16, dataset=dataset) + + input_data = [model_inputs[0], model_inputs[1], model_inputs[2]] + + model_int8 = static_quant(model, input_data) + + torch_out = model_int8(model_inputs[0], model_inputs[1], model_inputs[2]) + + import onnxruntime + + ort_session = onnxruntime.InferenceSession(backend_file) + + input_dict = {} + input_dict['voxels'] = model_inputs[0].cpu().numpy() + input_dict['num_points'] = model_inputs[1].cpu().numpy() + input_dict['coors'] = model_inputs[2].cpu().numpy() + ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) + + outputs = {} + outputs['scores'] = torch.tensor(ort_output[0]) + outputs['bbox_preds'] = torch.tensor(ort_output[1]) + outputs['dir_scores'] = torch.tensor(ort_output[2]) + + print('onnx : inference successful!') + + def test_dynamic_quant(self): + device = 'cuda:0' + model.cuda() + + data, model_inputs = create_input(pcd, dataset, model_name, device) + + backend_file = deploy(model, model_inputs, input_names, output_names, dynamic_axes, + backend=backend, output_file=output, fp16=fp16, dataset=dataset) + + dynamic_quant(model) + + torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) + + import onnxruntime + + ort_session = onnxruntime.InferenceSession(backend_file) + + input_dict = {} + input_dict['voxels'] = model_inputs[0].cpu().numpy() + input_dict['num_points'] = model_inputs[1].cpu().numpy() + input_dict['coors'] = model_inputs[2].cpu().numpy() + ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) + + outputs = {} + outputs['scores'] = torch.tensor(ort_output[0]) + outputs['bbox_preds'] = torch.tensor(ort_output[1]) + outputs['dir_scores'] = torch.tensor(ort_output[2]) + + print('onnx : inference successful!') + + def test_torch_prune(self): + device = 'cuda:0' + model.cuda() + + data, model_inputs = create_input(pcd, dataset, model_name, device) + + backend_file = deploy(model, model_inputs, input_names, output_names, dynamic_axes, + backend=backend, output_file=output, fp16=fp16, dataset=dataset) + + prune_list = [torch.nn.Conv2d, torch.nn.Linear] + amount_list = [0.3, 0.9] + + torch_prune(model, prune_list, amount_list) + + torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) + + import onnxruntime + + ort_session = onnxruntime.InferenceSession(backend_file) + + input_dict = {} + input_dict['voxels'] = model_inputs[0].cpu().numpy() + input_dict['num_points'] = model_inputs[1].cpu().numpy() + input_dict['coors'] = model_inputs[2].cpu().numpy() + ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) + + outputs = {} + outputs['scores'] = torch.tensor(ort_output[0]) + outputs['bbox_preds'] = torch.tensor(ort_output[1]) + outputs['dir_scores'] = torch.tensor(ort_output[2]) + + print('onnx : inference successful!') \ No newline at end of file diff --git a/tools/demo.py b/tools/demo.py new file mode 100644 index 0000000..4574dc5 --- /dev/null +++ b/tools/demo.py @@ -0,0 +1,12 @@ +import os +import sys +import torch +from deephub.detection_model import Pointpillars, Centerpoint + +def main(): + model = Pointpillars() + + # print(model.name_parameters()) + +if __name__ == '__main__': + main() \ No newline at end of file From 333b0f27ab9ae4ad79cdd16ad5c06358d414ecb7 Mon Sep 17 00:00:00 2001 From: Crispig Date: Mon, 1 Aug 2022 12:29:31 +0800 Subject: [PATCH 2/3] rebuild test file(main) --- test/test_model_ops/test_compressor.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/test_model_ops/test_compressor.py b/test/test_model_ops/test_compressor.py index 13622d3..0e3865c 100644 --- a/test/test_model_ops/test_compressor.py +++ b/test/test_model_ops/test_compressor.py @@ -139,4 +139,7 @@ def test_torch_prune(self): outputs['bbox_preds'] = torch.tensor(ort_output[1]) outputs['dir_scores'] = torch.tensor(ort_output[2]) - print('onnx : inference successful!') \ No newline at end of file + print('onnx : inference successful!') + +if __name__ == '__main__': + unittest.main() \ No newline at end of file From e161b373cb223c6259aac2f91e727a43f4ac1517 Mon Sep 17 00:00:00 2001 From: Crispig Date: Wed, 31 Aug 2022 16:58:37 +0800 Subject: [PATCH 3/3] rebuild compressor test --- model/model_compressor/compressor.py | 2 +- model/model_compressor/demo_torch_prune.py | 4 +- test/test_model_ops/test_compressor.py | 83 +++++----------------- 3 files changed, 19 insertions(+), 70 deletions(-) diff --git a/model/model_compressor/compressor.py b/model/model_compressor/compressor.py index c4eb98b..4b814e3 100644 --- a/model/model_compressor/compressor.py +++ b/model/model_compressor/compressor.py @@ -1,7 +1,7 @@ import torch.nn.utils.prune as prune import torch -def torch_prune(model, prune_list, amount_list): +def prune_1(model, prune_list, amount_list): for n, module in model.named_modules(): for j, prune_item in enumerate(prune_list): diff --git a/model/model_compressor/demo_torch_prune.py b/model/model_compressor/demo_torch_prune.py index eb35698..4371181 100644 --- a/model/model_compressor/demo_torch_prune.py +++ b/model/model_compressor/demo_torch_prune.py @@ -49,12 +49,12 @@ def main(): backend=backend, output_file=output, fp16=fp16, dataset=dataset) - # torch_prune + # prune_1 #---------------------------------------- prune_list = [torch.nn.Conv2d, torch.nn.Linear] amount_list = [0.3, 0.9] - torch_prune(model, prune_list, amount_list) + prune_1(model, prune_list, amount_list) #---------------------------------------- torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) diff --git a/test/test_model_ops/test_compressor.py b/test/test_model_ops/test_compressor.py index 0e3865c..54e1791 100644 --- a/test/test_model_ops/test_compressor.py +++ b/test/test_model_ops/test_compressor.py @@ -20,26 +20,24 @@ import unittest -input_names = ['voxels', 'num_points', 'coors'] -output_names = ['scores', 'bbox_preds', 'dir_scores'] -dynamic_axes = {'voxels': {0: 'voxels_num'}, - 'num_points': {0: 'voxels_num'}, - 'coors': {0: 'voxels_num'}} - # dynamic_axes = None - -pcd = '../../test/test_model_ops/data/kitti/kitti_000008.bin' -checkpoint = '../../checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth' -dataset = 'kitti' -model_name = 'pointpillars' -# device = 'cpu' -backend = 'onnxruntime' -output = 'pointpillars' -fp16 = False - class TestCompressor(unittest.TestCase): @classmethod def setUpClass(cls): + input_names = ['voxels', 'num_points', 'coors'] + output_names = ['scores', 'bbox_preds', 'dir_scores'] + dynamic_axes = {'voxels': {0: 'voxels_num'}, + 'num_points': {0: 'voxels_num'}, + 'coors': {0: 'voxels_num'}} + + pcd = '../../test/test_model_ops/data/kitti/kitti_000008.bin' + checkpoint = '../../checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth' + dataset = 'kitti' + model_name = 'pointpillars' + # device = 'cpu' + backend = 'onnxruntime' + output = 'pointpillars' + fp16 = False model = Pointpillars() load_checkpoint(model, '../../checkpoints/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth', map_location='cpu') model.eval() @@ -61,23 +59,6 @@ def test_static_quant(self): torch_out = model_int8(model_inputs[0], model_inputs[1], model_inputs[2]) - import onnxruntime - - ort_session = onnxruntime.InferenceSession(backend_file) - - input_dict = {} - input_dict['voxels'] = model_inputs[0].cpu().numpy() - input_dict['num_points'] = model_inputs[1].cpu().numpy() - input_dict['coors'] = model_inputs[2].cpu().numpy() - ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) - - outputs = {} - outputs['scores'] = torch.tensor(ort_output[0]) - outputs['bbox_preds'] = torch.tensor(ort_output[1]) - outputs['dir_scores'] = torch.tensor(ort_output[2]) - - print('onnx : inference successful!') - def test_dynamic_quant(self): device = 'cuda:0' model.cuda() @@ -91,24 +72,8 @@ def test_dynamic_quant(self): torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) - import onnxruntime - - ort_session = onnxruntime.InferenceSession(backend_file) - - input_dict = {} - input_dict['voxels'] = model_inputs[0].cpu().numpy() - input_dict['num_points'] = model_inputs[1].cpu().numpy() - input_dict['coors'] = model_inputs[2].cpu().numpy() - ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) - - outputs = {} - outputs['scores'] = torch.tensor(ort_output[0]) - outputs['bbox_preds'] = torch.tensor(ort_output[1]) - outputs['dir_scores'] = torch.tensor(ort_output[2]) - - print('onnx : inference successful!') - def test_torch_prune(self): + def test_prune_1(self): device = 'cuda:0' model.cuda() @@ -120,26 +85,10 @@ def test_torch_prune(self): prune_list = [torch.nn.Conv2d, torch.nn.Linear] amount_list = [0.3, 0.9] - torch_prune(model, prune_list, amount_list) + prune_1(model, prune_list, amount_list) torch_out = model(model_inputs[0], model_inputs[1], model_inputs[2]) - import onnxruntime - - ort_session = onnxruntime.InferenceSession(backend_file) - - input_dict = {} - input_dict['voxels'] = model_inputs[0].cpu().numpy() - input_dict['num_points'] = model_inputs[1].cpu().numpy() - input_dict['coors'] = model_inputs[2].cpu().numpy() - ort_output = ort_session.run(['scores', 'bbox_preds', 'dir_scores'], input_dict) - - outputs = {} - outputs['scores'] = torch.tensor(ort_output[0]) - outputs['bbox_preds'] = torch.tensor(ort_output[1]) - outputs['dir_scores'] = torch.tensor(ort_output[2]) - - print('onnx : inference successful!') if __name__ == '__main__': unittest.main() \ No newline at end of file