Showing preview only (6,389K chars total). Download the full file or copy to clipboard to get everything.
Repository: liangjiandeng/DLPan-Toolbox
Branch: main
Commit: a34f884af889
Files: 1396
Total size: 5.7 MB
Directory structure:
gitextract_54ils51p/
├── .gitignore
├── 01-DL-toolbox(Pytorch)/
│ ├── LICENSE
│ ├── UDL/
│ │ ├── AutoDL/
│ │ │ ├── __init__.py
│ │ │ └── trainer.py
│ │ ├── Basis/
│ │ │ ├── auxiliary/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── base.py
│ │ │ │ ├── fp16_utils.py
│ │ │ │ ├── torchstat/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── __main__.py
│ │ │ │ │ ├── compute_flops.py
│ │ │ │ │ ├── compute_madd.py
│ │ │ │ │ ├── compute_memory.py
│ │ │ │ │ ├── model_hook.py
│ │ │ │ │ ├── reporter.py
│ │ │ │ │ ├── stat_tree.py
│ │ │ │ │ └── statistics.py
│ │ │ │ └── utils.py
│ │ │ ├── cal_ssim.py
│ │ │ ├── config.py
│ │ │ ├── criterion_metrics.py
│ │ │ ├── dist_utils.py
│ │ │ ├── kill_dist.sh
│ │ │ ├── launch.py
│ │ │ ├── logger.py
│ │ │ ├── metrics.py
│ │ │ ├── optim.py
│ │ │ ├── option.py
│ │ │ ├── postprocess.py
│ │ │ ├── python_sub_class.py
│ │ │ ├── slurm_train.sh
│ │ │ ├── snmn_d.sh
│ │ │ └── variance_sacling_initializer.py
│ │ ├── Data/
│ │ │ └── pansharpening/
│ │ │ ├── test_data/
│ │ │ │ └── readme-test.txt
│ │ │ ├── training_data/
│ │ │ │ └── readme-test.txt
│ │ │ └── validation_data/
│ │ │ └── readme-test.txt
│ │ ├── mmcv/
│ │ │ ├── CITATION.cff
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── Dockerfile
│ │ │ ├── Jenkinsfile
│ │ │ ├── LICENSE
│ │ │ ├── LICENSES.md
│ │ │ ├── MANIFEST.in
│ │ │ ├── README_zh-CN.md
│ │ │ ├── TERMINOLOGY.md
│ │ │ ├── docs/
│ │ │ │ ├── en/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── _static/
│ │ │ │ │ │ └── css/
│ │ │ │ │ │ └── readthedocs.css
│ │ │ │ │ ├── api.rst
│ │ │ │ │ ├── community/
│ │ │ │ │ │ └── pr.md
│ │ │ │ │ ├── compatibility.md
│ │ │ │ │ ├── conf.py
│ │ │ │ │ ├── deployment/
│ │ │ │ │ │ ├── mmcv_ops_definition.md
│ │ │ │ │ │ ├── onnx.md
│ │ │ │ │ │ ├── onnxruntime_custom_ops.md
│ │ │ │ │ │ ├── onnxruntime_op.md
│ │ │ │ │ │ ├── tensorrt_custom_ops.md
│ │ │ │ │ │ └── tensorrt_plugin.md
│ │ │ │ │ ├── faq.md
│ │ │ │ │ ├── get_started/
│ │ │ │ │ │ ├── build.md
│ │ │ │ │ │ ├── installation.md
│ │ │ │ │ │ ├── introduction.md
│ │ │ │ │ │ └── previous_versions.md
│ │ │ │ │ ├── index.rst
│ │ │ │ │ ├── make.bat
│ │ │ │ │ └── understand_mmcv/
│ │ │ │ │ ├── cnn.md
│ │ │ │ │ ├── config.md
│ │ │ │ │ ├── data_process.md
│ │ │ │ │ ├── io.md
│ │ │ │ │ ├── ops.md
│ │ │ │ │ ├── registry.md
│ │ │ │ │ ├── runner.md
│ │ │ │ │ ├── utils.md
│ │ │ │ │ └── visualization.md
│ │ │ │ └── zh_cn/
│ │ │ │ ├── Makefile
│ │ │ │ ├── _static/
│ │ │ │ │ └── css/
│ │ │ │ │ └── readthedocs.css
│ │ │ │ ├── api.rst
│ │ │ │ ├── community/
│ │ │ │ │ ├── contributing.md
│ │ │ │ │ └── pr.md
│ │ │ │ ├── compatibility.md
│ │ │ │ ├── conf.py
│ │ │ │ ├── deployment/
│ │ │ │ │ ├── onnx.md
│ │ │ │ │ ├── onnxruntime_custom_ops.md
│ │ │ │ │ ├── onnxruntime_op.md
│ │ │ │ │ ├── tensorrt_custom_ops.md
│ │ │ │ │ └── tensorrt_plugin.md
│ │ │ │ ├── faq.md
│ │ │ │ ├── get_started/
│ │ │ │ │ ├── build.md
│ │ │ │ │ ├── installation.md
│ │ │ │ │ ├── introduction.md
│ │ │ │ │ └── previous_versions.md
│ │ │ │ ├── index.rst
│ │ │ │ ├── make.bat
│ │ │ │ └── understand_mmcv/
│ │ │ │ ├── cnn.md
│ │ │ │ ├── config.md
│ │ │ │ ├── data_process.md
│ │ │ │ ├── io.md
│ │ │ │ ├── ops.md
│ │ │ │ ├── registry.md
│ │ │ │ ├── runner.md
│ │ │ │ ├── utils.md
│ │ │ │ └── visualization.md
│ │ │ ├── examples/
│ │ │ │ └── train.py
│ │ │ ├── mmcv/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── arraymisc/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── quantization.py
│ │ │ │ ├── cnn/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── alexnet.py
│ │ │ │ │ ├── bricks/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── activation.py
│ │ │ │ │ │ ├── context_block.py
│ │ │ │ │ │ ├── conv.py
│ │ │ │ │ │ ├── conv2d_adaptive_padding.py
│ │ │ │ │ │ ├── conv_module.py
│ │ │ │ │ │ ├── conv_ws.py
│ │ │ │ │ │ ├── depthwise_separable_conv_module.py
│ │ │ │ │ │ ├── drop.py
│ │ │ │ │ │ ├── generalized_attention.py
│ │ │ │ │ │ ├── hsigmoid.py
│ │ │ │ │ │ ├── hswish.py
│ │ │ │ │ │ ├── non_local.py
│ │ │ │ │ │ ├── norm.py
│ │ │ │ │ │ ├── padding.py
│ │ │ │ │ │ ├── plugin.py
│ │ │ │ │ │ ├── registry.py
│ │ │ │ │ │ ├── scale.py
│ │ │ │ │ │ ├── swish.py
│ │ │ │ │ │ ├── transformer.py
│ │ │ │ │ │ ├── upsample.py
│ │ │ │ │ │ └── wrappers.py
│ │ │ │ │ ├── builder.py
│ │ │ │ │ ├── resnet.py
│ │ │ │ │ ├── utils/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── flops_counter.py
│ │ │ │ │ │ ├── fuse_conv_bn.py
│ │ │ │ │ │ ├── sync_bn.py
│ │ │ │ │ │ └── weight_init.py
│ │ │ │ │ └── vgg.py
│ │ │ │ ├── engine/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── test.py
│ │ │ │ ├── fileio/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── file_client.py
│ │ │ │ │ ├── handlers/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── base.py
│ │ │ │ │ │ ├── json_handler.py
│ │ │ │ │ │ ├── pickle_handler.py
│ │ │ │ │ │ └── yaml_handler.py
│ │ │ │ │ ├── io.py
│ │ │ │ │ └── parse.py
│ │ │ │ ├── image/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── colorspace.py
│ │ │ │ │ ├── geometric.py
│ │ │ │ │ ├── io.py
│ │ │ │ │ ├── misc.py
│ │ │ │ │ └── photometric.py
│ │ │ │ ├── onnx/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── info.py
│ │ │ │ │ ├── onnx_utils/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── symbolic_helper.py
│ │ │ │ │ └── symbolic.py
│ │ │ │ ├── ops/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── active_rotated_filter.py
│ │ │ │ │ ├── assign_score_withk.py
│ │ │ │ │ ├── ball_query.py
│ │ │ │ │ ├── bbox.py
│ │ │ │ │ ├── border_align.py
│ │ │ │ │ ├── box_iou_rotated.py
│ │ │ │ │ ├── carafe.py
│ │ │ │ │ ├── cc_attention.py
│ │ │ │ │ ├── contour_expand.py
│ │ │ │ │ ├── convex_iou.py
│ │ │ │ │ ├── corner_pool.py
│ │ │ │ │ ├── correlation.py
│ │ │ │ │ ├── csrc/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── common/
│ │ │ │ │ │ │ ├── box_iou_rotated_utils.hpp
│ │ │ │ │ │ │ ├── cuda/
│ │ │ │ │ │ │ │ ├── active_rotated_filter_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── assign_score_withk_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── ball_query_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── bbox_overlaps_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── border_align_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── box_iou_rotated_cuda.cuh
│ │ │ │ │ │ │ │ ├── carafe_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── carafe_naive_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── common_cuda_helper.hpp
│ │ │ │ │ │ │ │ ├── convex_iou_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── correlation_cuda.cuh
│ │ │ │ │ │ │ │ ├── deform_conv_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── deform_roi_pool_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── furthest_point_sample_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── gather_points_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── group_points_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── iou3d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── knn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── masked_conv2d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── min_area_polygons_cuda.cuh
│ │ │ │ │ │ │ │ ├── modulated_deform_conv_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── ms_deform_attn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── nms_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── nms_rotated_cuda.cuh
│ │ │ │ │ │ │ │ ├── parrots_cudawarpfunction.cuh
│ │ │ │ │ │ │ │ ├── points_in_boxes_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── points_in_polygons_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── psamask_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── riroi_align_rotated_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roi_align_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roi_align_rotated_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roi_pool_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roiaware_pool3d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roipoint_pool3d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── rotated_feature_align_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── scatter_points_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── sigmoid_focal_loss_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── softmax_focal_loss_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── sync_bn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── three_interpolate_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── three_nn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── tin_shift_cuda_kernel.cuh
│ │ │ │ │ │ │ │ └── voxelization_cuda_kernel.cuh
│ │ │ │ │ │ │ ├── parrots_cpp_helper.hpp
│ │ │ │ │ │ │ ├── parrots_cuda_helper.hpp
│ │ │ │ │ │ │ ├── pytorch_cpp_helper.hpp
│ │ │ │ │ │ │ ├── pytorch_cuda_helper.hpp
│ │ │ │ │ │ │ └── pytorch_device_registry.hpp
│ │ │ │ │ │ ├── onnxruntime/
│ │ │ │ │ │ │ ├── corner_pool.h
│ │ │ │ │ │ │ ├── cpu/
│ │ │ │ │ │ │ │ ├── corner_pool.cpp
│ │ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ │ ├── gridSample.cpp
│ │ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ │ ├── onnxruntime_register.cpp
│ │ │ │ │ │ │ │ ├── reduce_ops.cpp
│ │ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ │ └── soft_nms.cpp
│ │ │ │ │ │ │ ├── deform_conv.h
│ │ │ │ │ │ │ ├── grid_sample.h
│ │ │ │ │ │ │ ├── modulated_deform_conv.h
│ │ │ │ │ │ │ ├── nms.h
│ │ │ │ │ │ │ ├── onnxruntime_register.h
│ │ │ │ │ │ │ ├── onnxruntime_session_options_config_keys.h
│ │ │ │ │ │ │ ├── ort_mmcv_utils.h
│ │ │ │ │ │ │ ├── reduce_ops.h
│ │ │ │ │ │ │ ├── roi_align.h
│ │ │ │ │ │ │ ├── roi_align_rotated.h
│ │ │ │ │ │ │ └── soft_nms.h
│ │ │ │ │ │ ├── parrots/
│ │ │ │ │ │ │ ├── active_rotated_filter.cpp
│ │ │ │ │ │ │ ├── active_rotated_filter_parrots.cpp
│ │ │ │ │ │ │ ├── active_rotated_filter_pytorch.h
│ │ │ │ │ │ │ ├── assign_score_withk.cpp
│ │ │ │ │ │ │ ├── assign_score_withk_parrots.cpp
│ │ │ │ │ │ │ ├── assign_score_withk_pytorch.h
│ │ │ │ │ │ │ ├── ball_query._parrots.cpp
│ │ │ │ │ │ │ ├── ball_query.cpp
│ │ │ │ │ │ │ ├── ball_query_pytorch.h
│ │ │ │ │ │ │ ├── bbox_overlaps.cpp
│ │ │ │ │ │ │ ├── bbox_overlaps_parrots.cpp
│ │ │ │ │ │ │ ├── bbox_overlaps_pytorch.h
│ │ │ │ │ │ │ ├── border_align.cpp
│ │ │ │ │ │ │ ├── border_align_parrots.cpp
│ │ │ │ │ │ │ ├── border_align_pytorch.h
│ │ │ │ │ │ │ ├── box_iou_rotated.cpp
│ │ │ │ │ │ │ ├── box_iou_rotated_parrots.cpp
│ │ │ │ │ │ │ ├── box_iou_rotated_pytorch.h
│ │ │ │ │ │ │ ├── carafe.cpp
│ │ │ │ │ │ │ ├── carafe_naive.cpp
│ │ │ │ │ │ │ ├── carafe_naive_parrots.cpp
│ │ │ │ │ │ │ ├── carafe_naive_pytorch.h
│ │ │ │ │ │ │ ├── carafe_parrots.cpp
│ │ │ │ │ │ │ ├── carafe_pytorch.h
│ │ │ │ │ │ │ ├── contour_expand.cpp
│ │ │ │ │ │ │ ├── contour_expand_parrots.cpp
│ │ │ │ │ │ │ ├── contour_expand_pytorch.h
│ │ │ │ │ │ │ ├── convex_iou.cpp
│ │ │ │ │ │ │ ├── convex_iou_parrots.cpp
│ │ │ │ │ │ │ ├── convex_iou_pytorch.h
│ │ │ │ │ │ │ ├── corner_pool.cpp
│ │ │ │ │ │ │ ├── corner_pool_parrots.cpp
│ │ │ │ │ │ │ ├── corner_pool_pytorch.h
│ │ │ │ │ │ │ ├── correlation.cpp
│ │ │ │ │ │ │ ├── correlation_parrots.cpp
│ │ │ │ │ │ │ ├── correlation_pytorch.h
│ │ │ │ │ │ │ ├── cudabind.cpp
│ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ ├── deform_conv_parrots.cpp
│ │ │ │ │ │ │ ├── deform_conv_pytorch.h
│ │ │ │ │ │ │ ├── deform_roi_pool.cpp
│ │ │ │ │ │ │ ├── deform_roi_pool_parrots.cpp
│ │ │ │ │ │ │ ├── deform_roi_pool_pytorch.h
│ │ │ │ │ │ │ ├── focal_loss.cpp
│ │ │ │ │ │ │ ├── focal_loss_parrots.cpp
│ │ │ │ │ │ │ ├── focal_loss_pytorch.h
│ │ │ │ │ │ │ ├── furthest_point_sample.cpp
│ │ │ │ │ │ │ ├── furthest_point_sample_parrots.cpp
│ │ │ │ │ │ │ ├── furthest_point_sample_pytorch.h
│ │ │ │ │ │ │ ├── fused_bias_leakyrelu.cpp
│ │ │ │ │ │ │ ├── fused_bias_parrots.cpp
│ │ │ │ │ │ │ ├── gather_points.cpp
│ │ │ │ │ │ │ ├── gather_points_parrots.cpp
│ │ │ │ │ │ │ ├── gather_points_pytorch.h
│ │ │ │ │ │ │ ├── group_points.cpp
│ │ │ │ │ │ │ ├── group_points_parrots.cpp
│ │ │ │ │ │ │ ├── group_points_pytorch.h
│ │ │ │ │ │ │ ├── info.cpp
│ │ │ │ │ │ │ ├── iou3d.cpp
│ │ │ │ │ │ │ ├── iou3d_parrots.cpp
│ │ │ │ │ │ │ ├── iou3d_pytorch.h
│ │ │ │ │ │ │ ├── knn.cpp
│ │ │ │ │ │ │ ├── knn_parrots.cpp
│ │ │ │ │ │ │ ├── knn_pytorch.h
│ │ │ │ │ │ │ ├── masked_conv2d.cpp
│ │ │ │ │ │ │ ├── masked_conv2d_parrots.cpp
│ │ │ │ │ │ │ ├── masked_conv2d_pytorch.h
│ │ │ │ │ │ │ ├── min_area_polygons.cpp
│ │ │ │ │ │ │ ├── min_area_polygons_parrots.cpp
│ │ │ │ │ │ │ ├── min_area_polygons_pytorch.h
│ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ ├── modulated_deform_conv_parrots.cpp
│ │ │ │ │ │ │ ├── modulated_deform_conv_pytorch.h
│ │ │ │ │ │ │ ├── ms_deform_attn.cpp
│ │ │ │ │ │ │ ├── ms_deform_attn_parrots.cpp
│ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ ├── nms_parrots.cpp
│ │ │ │ │ │ │ ├── nms_pytorch.h
│ │ │ │ │ │ │ ├── nms_rotated.cpp
│ │ │ │ │ │ │ ├── pixel_group.cpp
│ │ │ │ │ │ │ ├── pixel_group_parrots.cpp
│ │ │ │ │ │ │ ├── pixel_group_pytorch.h
│ │ │ │ │ │ │ ├── points_in_boxes.cpp
│ │ │ │ │ │ │ ├── points_in_boxes_parrots.cpp
│ │ │ │ │ │ │ ├── points_in_boxes_pytorch.h
│ │ │ │ │ │ │ ├── points_in_polygons.cpp
│ │ │ │ │ │ │ ├── points_in_polygons_parrots.cpp
│ │ │ │ │ │ │ ├── points_in_polygons_pytorch.h
│ │ │ │ │ │ │ ├── psamask.cpp
│ │ │ │ │ │ │ ├── psamask_parrots.cpp
│ │ │ │ │ │ │ ├── psamask_pytorch.h
│ │ │ │ │ │ │ ├── riroi_align_rotated.cpp
│ │ │ │ │ │ │ ├── riroi_align_rotated_parrots.cpp
│ │ │ │ │ │ │ ├── riroi_align_rotated_pytorch.h
│ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ ├── roi_align_parrots.cpp
│ │ │ │ │ │ │ ├── roi_align_pytorch.h
│ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ ├── roi_align_rotated_parrots.cpp
│ │ │ │ │ │ │ ├── roi_align_rotated_pytorch.h
│ │ │ │ │ │ │ ├── roi_pool.cpp
│ │ │ │ │ │ │ ├── roi_pool_parrots.cpp
│ │ │ │ │ │ │ ├── roi_pool_pytorch.h
│ │ │ │ │ │ │ ├── roiaware_pool3d.cpp
│ │ │ │ │ │ │ ├── roiaware_pool3d_parrots.cpp
│ │ │ │ │ │ │ ├── roiaware_pool3d_pytorch.h
│ │ │ │ │ │ │ ├── roipoint_pool3d.cpp
│ │ │ │ │ │ │ ├── roipoint_pool3d_parrots.cpp
│ │ │ │ │ │ │ ├── roipoint_pool3d_pytorch.h
│ │ │ │ │ │ │ ├── rotated_feature_align.cpp
│ │ │ │ │ │ │ ├── rotated_feature_align_parrots.cpp
│ │ │ │ │ │ │ ├── rotated_feature_align_pytorch.h
│ │ │ │ │ │ │ ├── sync_bn.cpp
│ │ │ │ │ │ │ ├── sync_bn_parrots.cpp
│ │ │ │ │ │ │ ├── sync_bn_pytorch.h
│ │ │ │ │ │ │ ├── three_interpolate.cpp
│ │ │ │ │ │ │ ├── three_interpolate_parrots.cpp
│ │ │ │ │ │ │ ├── three_interpolate_pytorch.h
│ │ │ │ │ │ │ ├── three_nn.cpp
│ │ │ │ │ │ │ ├── three_nn_parrots.cpp
│ │ │ │ │ │ │ ├── three_nn_pytorch.h
│ │ │ │ │ │ │ ├── tin_shift.cpp
│ │ │ │ │ │ │ ├── tin_shift_parrots.cpp
│ │ │ │ │ │ │ ├── tin_shift_pytorch.h
│ │ │ │ │ │ │ ├── upfirdn2d.cpp
│ │ │ │ │ │ │ ├── upfirdn2d_parrots.cpp
│ │ │ │ │ │ │ ├── voxelization.cpp
│ │ │ │ │ │ │ ├── voxelization_parrots.cpp
│ │ │ │ │ │ │ └── voxelization_pytorch.h
│ │ │ │ │ │ ├── pytorch/
│ │ │ │ │ │ │ ├── active_rotated_filter.cpp
│ │ │ │ │ │ │ ├── assign_score_withk.cpp
│ │ │ │ │ │ │ ├── ball_query.cpp
│ │ │ │ │ │ │ ├── bbox_overlaps.cpp
│ │ │ │ │ │ │ ├── border_align.cpp
│ │ │ │ │ │ │ ├── box_iou_rotated.cpp
│ │ │ │ │ │ │ ├── carafe.cpp
│ │ │ │ │ │ │ ├── carafe_naive.cpp
│ │ │ │ │ │ │ ├── contour_expand.cpp
│ │ │ │ │ │ │ ├── convex_iou.cpp
│ │ │ │ │ │ │ ├── corner_pool.cpp
│ │ │ │ │ │ │ ├── correlation.cpp
│ │ │ │ │ │ │ ├── cpu/
│ │ │ │ │ │ │ │ ├── active_rotated_filter.cpp
│ │ │ │ │ │ │ │ ├── box_iou_rotated.cpp
│ │ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ │ ├── nms_rotated.cpp
│ │ │ │ │ │ │ │ ├── pixel_group.cpp
│ │ │ │ │ │ │ │ ├── points_in_boxes.cpp
│ │ │ │ │ │ │ │ ├── psamask.cpp
│ │ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ │ └── voxelization.cpp
│ │ │ │ │ │ │ ├── cuda/
│ │ │ │ │ │ │ │ ├── active_rotated_filter_cuda.cu
│ │ │ │ │ │ │ │ ├── assign_score_withk_cuda.cu
│ │ │ │ │ │ │ │ ├── ball_query_cuda.cu
│ │ │ │ │ │ │ │ ├── bbox_overlaps_cuda.cu
│ │ │ │ │ │ │ │ ├── border_align_cuda.cu
│ │ │ │ │ │ │ │ ├── box_iou_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── carafe_cuda.cu
│ │ │ │ │ │ │ │ ├── carafe_naive_cuda.cu
│ │ │ │ │ │ │ │ ├── convex_iou.cu
│ │ │ │ │ │ │ │ ├── correlation_cuda.cu
│ │ │ │ │ │ │ │ ├── cudabind.cpp
│ │ │ │ │ │ │ │ ├── deform_conv_cuda.cu
│ │ │ │ │ │ │ │ ├── deform_roi_pool_cuda.cu
│ │ │ │ │ │ │ │ ├── focal_loss_cuda.cu
│ │ │ │ │ │ │ │ ├── furthest_point_sample_cuda.cu
│ │ │ │ │ │ │ │ ├── fused_bias_leakyrelu_cuda.cu
│ │ │ │ │ │ │ │ ├── gather_points_cuda.cu
│ │ │ │ │ │ │ │ ├── group_points_cuda.cu
│ │ │ │ │ │ │ │ ├── iou3d_cuda.cu
│ │ │ │ │ │ │ │ ├── knn_cuda.cu
│ │ │ │ │ │ │ │ ├── masked_conv2d_cuda.cu
│ │ │ │ │ │ │ │ ├── min_area_polygons.cu
│ │ │ │ │ │ │ │ ├── modulated_deform_conv_cuda.cu
│ │ │ │ │ │ │ │ ├── ms_deform_attn_cuda.cu
│ │ │ │ │ │ │ │ ├── nms_cuda.cu
│ │ │ │ │ │ │ │ ├── nms_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── points_in_boxes_cuda.cu
│ │ │ │ │ │ │ │ ├── points_in_polygons_cuda.cu
│ │ │ │ │ │ │ │ ├── psamask_cuda.cu
│ │ │ │ │ │ │ │ ├── riroi_align_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── roi_align_cuda.cu
│ │ │ │ │ │ │ │ ├── roi_align_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── roi_pool_cuda.cu
│ │ │ │ │ │ │ │ ├── roiaware_pool3d_cuda.cu
│ │ │ │ │ │ │ │ ├── roipoint_pool3d_cuda.cu
│ │ │ │ │ │ │ │ ├── rotated_feature_align_cuda.cu
│ │ │ │ │ │ │ │ ├── scatter_points_cuda.cu
│ │ │ │ │ │ │ │ ├── sync_bn_cuda.cu
│ │ │ │ │ │ │ │ ├── three_interpolate_cuda.cu
│ │ │ │ │ │ │ │ ├── three_nn_cuda.cu
│ │ │ │ │ │ │ │ ├── tin_shift_cuda.cu
│ │ │ │ │ │ │ │ ├── upfirdn2d_kernel.cu
│ │ │ │ │ │ │ │ └── voxelization_cuda.cu
│ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ ├── deform_roi_pool.cpp
│ │ │ │ │ │ │ ├── focal_loss.cpp
│ │ │ │ │ │ │ ├── furthest_point_sample.cpp
│ │ │ │ │ │ │ ├── fused_bias_leakyrelu.cpp
│ │ │ │ │ │ │ ├── gather_points.cpp
│ │ │ │ │ │ │ ├── group_points.cpp
│ │ │ │ │ │ │ ├── info.cpp
│ │ │ │ │ │ │ ├── iou3d.cpp
│ │ │ │ │ │ │ ├── knn.cpp
│ │ │ │ │ │ │ ├── masked_conv2d.cpp
│ │ │ │ │ │ │ ├── min_area_polygons.cpp
│ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ ├── ms_deform_attn.cpp
│ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ ├── nms_rotated.cpp
│ │ │ │ │ │ │ ├── pixel_group.cpp
│ │ │ │ │ │ │ ├── points_in_boxes.cpp
│ │ │ │ │ │ │ ├── points_in_polygons.cpp
│ │ │ │ │ │ │ ├── psamask.cpp
│ │ │ │ │ │ │ ├── pybind.cpp
│ │ │ │ │ │ │ ├── riroi_align_rotated.cpp
│ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ ├── roi_pool.cpp
│ │ │ │ │ │ │ ├── roiaware_pool3d.cpp
│ │ │ │ │ │ │ ├── roipoint_pool3d.cpp
│ │ │ │ │ │ │ ├── rotated_feature_align.cpp
│ │ │ │ │ │ │ ├── scatter_points.cpp
│ │ │ │ │ │ │ ├── sync_bn.cpp
│ │ │ │ │ │ │ ├── three_interpolate.cpp
│ │ │ │ │ │ │ ├── three_nn.cpp
│ │ │ │ │ │ │ ├── tin_shift.cpp
│ │ │ │ │ │ │ ├── upfirdn2d.cpp
│ │ │ │ │ │ │ └── voxelization.cpp
│ │ │ │ │ │ └── tensorrt/
│ │ │ │ │ │ ├── plugins/
│ │ │ │ │ │ │ ├── trt_corner_pool.cpp
│ │ │ │ │ │ │ ├── trt_corner_pool_kernel.cu
│ │ │ │ │ │ │ ├── trt_cuda_helper.cu
│ │ │ │ │ │ │ ├── trt_cummaxmin.cpp
│ │ │ │ │ │ │ ├── trt_cummaxmin_kernel.cu
│ │ │ │ │ │ │ ├── trt_deform_conv.cpp
│ │ │ │ │ │ │ ├── trt_deform_conv_kernel.cu
│ │ │ │ │ │ │ ├── trt_grid_sampler.cpp
│ │ │ │ │ │ │ ├── trt_grid_sampler_kernel.cu
│ │ │ │ │ │ │ ├── trt_instance_norm.cpp
│ │ │ │ │ │ │ ├── trt_modulated_deform_conv.cpp
│ │ │ │ │ │ │ ├── trt_modulated_deform_conv_kernel.cu
│ │ │ │ │ │ │ ├── trt_nms.cpp
│ │ │ │ │ │ │ ├── trt_nms_kernel.cu
│ │ │ │ │ │ │ ├── trt_plugin.cpp
│ │ │ │ │ │ │ ├── trt_roi_align.cpp
│ │ │ │ │ │ │ ├── trt_roi_align_kernel.cu
│ │ │ │ │ │ │ ├── trt_scatternd.cpp
│ │ │ │ │ │ │ └── trt_scatternd_kernel.cu
│ │ │ │ │ │ ├── trt_corner_pool.hpp
│ │ │ │ │ │ ├── trt_cuda_helper.cuh
│ │ │ │ │ │ ├── trt_cummaxmin.hpp
│ │ │ │ │ │ ├── trt_deform_conv.hpp
│ │ │ │ │ │ ├── trt_grid_sampler.hpp
│ │ │ │ │ │ ├── trt_instance_norm.hpp
│ │ │ │ │ │ ├── trt_modulated_deform_conv.hpp
│ │ │ │ │ │ ├── trt_nms.hpp
│ │ │ │ │ │ ├── trt_plugin.hpp
│ │ │ │ │ │ ├── trt_plugin_helper.hpp
│ │ │ │ │ │ ├── trt_roi_align.hpp
│ │ │ │ │ │ ├── trt_scatternd.hpp
│ │ │ │ │ │ └── trt_serialize.hpp
│ │ │ │ │ ├── deform_conv.py
│ │ │ │ │ ├── deform_roi_pool.py
│ │ │ │ │ ├── deprecated_wrappers.py
│ │ │ │ │ ├── focal_loss.py
│ │ │ │ │ ├── furthest_point_sample.py
│ │ │ │ │ ├── fused_bias_leakyrelu.py
│ │ │ │ │ ├── gather_points.py
│ │ │ │ │ ├── group_points.py
│ │ │ │ │ ├── info.py
│ │ │ │ │ ├── iou3d.py
│ │ │ │ │ ├── knn.py
│ │ │ │ │ ├── masked_conv.py
│ │ │ │ │ ├── merge_cells.py
│ │ │ │ │ ├── min_area_polygons.py
│ │ │ │ │ ├── modulated_deform_conv.py
│ │ │ │ │ ├── multi_scale_deform_attn.py
│ │ │ │ │ ├── nms.py
│ │ │ │ │ ├── pixel_group.py
│ │ │ │ │ ├── point_sample.py
│ │ │ │ │ ├── points_in_boxes.py
│ │ │ │ │ ├── points_in_polygons.py
│ │ │ │ │ ├── points_sampler.py
│ │ │ │ │ ├── psa_mask.py
│ │ │ │ │ ├── readme.md
│ │ │ │ │ ├── riroi_align_rotated.py
│ │ │ │ │ ├── roi_align.py
│ │ │ │ │ ├── roi_align_rotated.py
│ │ │ │ │ ├── roi_pool.py
│ │ │ │ │ ├── roiaware_pool3d.py
│ │ │ │ │ ├── roipoint_pool3d.py
│ │ │ │ │ ├── rotated_feature_align.py
│ │ │ │ │ ├── saconv.py
│ │ │ │ │ ├── scatter_points.py
│ │ │ │ │ ├── sync_bn.py
│ │ │ │ │ ├── three_interpolate.py
│ │ │ │ │ ├── three_nn.py
│ │ │ │ │ ├── tin_shift.py
│ │ │ │ │ ├── upfirdn2d.py
│ │ │ │ │ └── voxelize.py
│ │ │ │ ├── parallel/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── _functions.py
│ │ │ │ │ ├── collate.py
│ │ │ │ │ ├── data_container.py
│ │ │ │ │ ├── data_parallel.py
│ │ │ │ │ ├── distributed.py
│ │ │ │ │ ├── distributed_deprecated.py
│ │ │ │ │ ├── registry.py
│ │ │ │ │ ├── scatter_gather.py
│ │ │ │ │ └── utils.py
│ │ │ │ ├── readme.md
│ │ │ │ ├── runner/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── base_module.py
│ │ │ │ │ ├── base_runner.py
│ │ │ │ │ ├── builder.py
│ │ │ │ │ ├── checkpoint.py
│ │ │ │ │ ├── default_constructor.py
│ │ │ │ │ ├── dist_utils.py
│ │ │ │ │ ├── epoch_based_runner.py
│ │ │ │ │ ├── fp16_utils.py
│ │ │ │ │ ├── hooks/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── checkpoint.py
│ │ │ │ │ │ ├── closure.py
│ │ │ │ │ │ ├── ema.py
│ │ │ │ │ │ ├── evaluation.py
│ │ │ │ │ │ ├── hook.py
│ │ │ │ │ │ ├── iter_timer.py
│ │ │ │ │ │ ├── logger/
│ │ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ │ ├── base.py
│ │ │ │ │ │ │ ├── dvclive.py
│ │ │ │ │ │ │ ├── mlflow.py
│ │ │ │ │ │ │ ├── neptune.py
│ │ │ │ │ │ │ ├── pavi.py
│ │ │ │ │ │ │ ├── tensorboard.py
│ │ │ │ │ │ │ ├── text.py
│ │ │ │ │ │ │ └── wandb.py
│ │ │ │ │ │ ├── lr_updater.py
│ │ │ │ │ │ ├── memory.py
│ │ │ │ │ │ ├── momentum_updater.py
│ │ │ │ │ │ ├── nni_hook.py
│ │ │ │ │ │ ├── optimizer.py
│ │ │ │ │ │ ├── profiler.py
│ │ │ │ │ │ ├── sampler_seed.py
│ │ │ │ │ │ └── sync_buffer.py
│ │ │ │ │ ├── iter_based_runner.py
│ │ │ │ │ ├── log_buffer.py
│ │ │ │ │ ├── misc.py
│ │ │ │ │ ├── optimizer/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── builder.py
│ │ │ │ │ │ └── default_constructor.py
│ │ │ │ │ ├── priority.py
│ │ │ │ │ ├── record.py
│ │ │ │ │ └── utils.py
│ │ │ │ ├── tensorrt/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── init_plugins.py
│ │ │ │ │ ├── preprocess.py
│ │ │ │ │ └── tensorrt_utils.py
│ │ │ │ ├── utils/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── config.py
│ │ │ │ │ ├── env.py
│ │ │ │ │ ├── ext_loader.py
│ │ │ │ │ ├── hub.py
│ │ │ │ │ ├── logging.py
│ │ │ │ │ ├── misc.py
│ │ │ │ │ ├── parrots_jit.py
│ │ │ │ │ ├── parrots_wrapper.py
│ │ │ │ │ ├── path.py
│ │ │ │ │ ├── progressbar.py
│ │ │ │ │ ├── registry.py
│ │ │ │ │ ├── testing.py
│ │ │ │ │ ├── timer.py
│ │ │ │ │ ├── trace.py
│ │ │ │ │ └── version_utils.py
│ │ │ │ ├── version.py
│ │ │ │ ├── video/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── io.py
│ │ │ │ │ ├── optflow.py
│ │ │ │ │ └── processing.py
│ │ │ │ └── visualization/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── color.py
│ │ │ │ ├── image.py
│ │ │ │ └── optflow.py
│ │ │ ├── readme.md
│ │ │ ├── setup.cfg
│ │ │ ├── setup.py
│ │ │ └── tests/
│ │ │ ├── test_arraymisc.py
│ │ │ ├── test_cnn/
│ │ │ │ ├── test_build_layers.py
│ │ │ │ ├── test_context_block.py
│ │ │ │ ├── test_conv2d_adaptive_padding.py
│ │ │ │ ├── test_conv_module.py
│ │ │ │ ├── test_depthwise_seperable_conv_module.py
│ │ │ │ ├── test_flops_counter.py
│ │ │ │ ├── test_fuse_conv_bn.py
│ │ │ │ ├── test_generalized_attention.py
│ │ │ │ ├── test_hsigmoid.py
│ │ │ │ ├── test_hswish.py
│ │ │ │ ├── test_model_registry.py
│ │ │ │ ├── test_non_local.py
│ │ │ │ ├── test_revert_syncbn.py
│ │ │ │ ├── test_scale.py
│ │ │ │ ├── test_swish.py
│ │ │ │ ├── test_transformer.py
│ │ │ │ ├── test_weight_init.py
│ │ │ │ └── test_wrappers.py
│ │ │ ├── test_fileclient.py
│ │ │ ├── test_fileio.py
│ │ │ ├── test_image/
│ │ │ │ ├── test_colorspace.py
│ │ │ │ ├── test_geometric.py
│ │ │ │ ├── test_image_misc.py
│ │ │ │ ├── test_io.py
│ │ │ │ └── test_photometric.py
│ │ │ ├── test_load_model_zoo.py
│ │ │ ├── test_ops/
│ │ │ │ ├── test_active_rotated_filter.py
│ │ │ │ ├── test_assign_score_withk.py
│ │ │ │ ├── test_ball_query.py
│ │ │ │ ├── test_bbox.py
│ │ │ │ ├── test_bilinear_grid_sample.py
│ │ │ │ ├── test_border_align.py
│ │ │ │ ├── test_box_iou_rotated.py
│ │ │ │ ├── test_carafe.py
│ │ │ │ ├── test_cc_attention.py
│ │ │ │ ├── test_contour_expand.py
│ │ │ │ ├── test_convex_iou.py
│ │ │ │ ├── test_corner_pool.py
│ │ │ │ ├── test_correlation.py
│ │ │ │ ├── test_deform_conv.py
│ │ │ │ ├── test_deform_roi_pool.py
│ │ │ │ ├── test_focal_loss.py
│ │ │ │ ├── test_furthest_point_sample.py
│ │ │ │ ├── test_fused_bias_leakyrelu.py
│ │ │ │ ├── test_gather_points.py
│ │ │ │ ├── test_group_points.py
│ │ │ │ ├── test_info.py
│ │ │ │ ├── test_iou3d.py
│ │ │ │ ├── test_knn.py
│ │ │ │ ├── test_masked_conv2d.py
│ │ │ │ ├── test_merge_cells.py
│ │ │ │ ├── test_min_area_polygons.py
│ │ │ │ ├── test_modulated_deform_conv.py
│ │ │ │ ├── test_ms_deformable_attn.py
│ │ │ │ ├── test_nms.py
│ │ │ │ ├── test_nms_rotated.py
│ │ │ │ ├── test_onnx.py
│ │ │ │ ├── test_pixel_group.py
│ │ │ │ ├── test_points_in_polygons.py
│ │ │ │ ├── test_psa_mask.py
│ │ │ │ ├── test_riroi_align_rotated.py
│ │ │ │ ├── test_roi_align.py
│ │ │ │ ├── test_roi_align_rotated.py
│ │ │ │ ├── test_roi_pool.py
│ │ │ │ ├── test_roiaware_pool3d.py
│ │ │ │ ├── test_roipoint_pool3d.py
│ │ │ │ ├── test_rotated_feature_align.py
│ │ │ │ ├── test_saconv.py
│ │ │ │ ├── test_scatter_points.py
│ │ │ │ ├── test_syncbn.py
│ │ │ │ ├── test_tensorrt.py
│ │ │ │ ├── test_tensorrt_preprocess.py
│ │ │ │ ├── test_three_interpolate.py
│ │ │ │ ├── test_three_nn.py
│ │ │ │ ├── test_tin_shift.py
│ │ │ │ ├── test_upfirdn2d.py
│ │ │ │ └── test_voxelization.py
│ │ │ ├── test_parallel.py
│ │ │ ├── test_runner/
│ │ │ │ ├── test_basemodule.py
│ │ │ │ ├── test_checkpoint.py
│ │ │ │ ├── test_dist_utils.py
│ │ │ │ ├── test_eval_hook.py
│ │ │ │ ├── test_fp16.py
│ │ │ │ ├── test_hooks.py
│ │ │ │ ├── test_optimizer.py
│ │ │ │ ├── test_runner.py
│ │ │ │ └── test_utils.py
│ │ │ ├── test_utils/
│ │ │ │ ├── test_config.py
│ │ │ │ ├── test_env.py
│ │ │ │ ├── test_hub.py
│ │ │ │ ├── test_logging.py
│ │ │ │ ├── test_misc.py
│ │ │ │ ├── test_parrots_jit.py
│ │ │ │ ├── test_path.py
│ │ │ │ ├── test_progressbar.py
│ │ │ │ ├── test_registry.py
│ │ │ │ ├── test_testing.py
│ │ │ │ ├── test_timer.py
│ │ │ │ ├── test_trace.py
│ │ │ │ └── test_version_utils.py
│ │ │ ├── test_video/
│ │ │ │ ├── test_optflow.py
│ │ │ │ ├── test_processing.py
│ │ │ │ └── test_reader.py
│ │ │ └── test_visualization.py
│ │ ├── pansharpening/
│ │ │ ├── common/
│ │ │ │ ├── dataset.py
│ │ │ │ ├── dataset_hp.py
│ │ │ │ ├── evaluate.py
│ │ │ │ └── psdata.py
│ │ │ ├── configs/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── hook_configs.py
│ │ │ │ ├── option_bdpn.py
│ │ │ │ ├── option_dicnn.py
│ │ │ │ ├── option_drpnn.py
│ │ │ │ ├── option_fusionnet.py
│ │ │ │ ├── option_msdcnn.py
│ │ │ │ ├── option_pannet.py
│ │ │ │ └── option_pnn.py
│ │ │ ├── evaluation/
│ │ │ │ └── ps_evaluate.py
│ │ │ ├── models/
│ │ │ │ ├── APNN/
│ │ │ │ │ ├── data_qb.py
│ │ │ │ │ ├── data_single_read.py
│ │ │ │ │ ├── data_wv2.py
│ │ │ │ │ ├── data_wv3.py
│ │ │ │ │ ├── data_wv4.py
│ │ │ │ │ ├── evaluate.py
│ │ │ │ │ ├── main_pre_train_trainData_qb.py
│ │ │ │ │ ├── main_pre_train_trainData_wv2.py
│ │ │ │ │ ├── main_pre_train_trainData_wv3.py
│ │ │ │ │ ├── main_pre_train_trainData_wv4.py
│ │ │ │ │ ├── main_test_qb.py
│ │ │ │ │ ├── main_test_wv2.py
│ │ │ │ │ ├── main_test_wv3.py
│ │ │ │ │ ├── main_test_wv4.py
│ │ │ │ │ ├── model_qb.py
│ │ │ │ │ ├── model_wv2.py
│ │ │ │ │ ├── model_wv3.py
│ │ │ │ │ ├── model_wv4.py
│ │ │ │ │ ├── variance_sacling_initializer.py
│ │ │ │ │ └── wald_utilities.py
│ │ │ │ ├── BDPN/
│ │ │ │ │ ├── bdpn_main.py
│ │ │ │ │ ├── loss_utils.py
│ │ │ │ │ ├── main_train_wv3.py
│ │ │ │ │ └── model_bdpn.py
│ │ │ │ ├── DRPNN/
│ │ │ │ │ ├── drpnn_main.py
│ │ │ │ │ └── model_drpnn.py
│ │ │ │ ├── DiCNN/
│ │ │ │ │ ├── dicnn_main.py
│ │ │ │ │ └── model_dicnn.py
│ │ │ │ ├── FusionNet/
│ │ │ │ │ ├── fusionnet_main.py
│ │ │ │ │ ├── model_fusionnet.py
│ │ │ │ │ └── run_fusionnet.py
│ │ │ │ ├── MSDCNN/
│ │ │ │ │ ├── model_msdcnn.py
│ │ │ │ │ └── msdcnn_main.py
│ │ │ │ ├── PNN/
│ │ │ │ │ ├── model_pnn.py
│ │ │ │ │ └── pnn_main.py
│ │ │ │ ├── PanNet/
│ │ │ │ │ ├── model_pannet.py
│ │ │ │ │ └── pannet_main.py
│ │ │ │ └── __init__.py
│ │ │ ├── run_pansharpening.py
│ │ │ └── run_test_pansharpening.py
│ │ ├── pretrained-model/
│ │ │ ├── QB/
│ │ │ │ ├── bdpn.pth
│ │ │ │ ├── dicnn1.pth
│ │ │ │ ├── drpnn.pth
│ │ │ │ ├── fusionnet.pth
│ │ │ │ ├── msdcnn.pth
│ │ │ │ ├── panet.pth
│ │ │ │ ├── pnn.pth
│ │ │ │ └── readme.txt
│ │ │ ├── WV2/
│ │ │ │ ├── bdpn.pth
│ │ │ │ ├── dicnn1.pth
│ │ │ │ ├── drpnn.pth
│ │ │ │ ├── fusionnet.pth
│ │ │ │ ├── msdcnn.pth
│ │ │ │ ├── pannet.pth
│ │ │ │ ├── pnn.pth
│ │ │ │ └── readme.txt
│ │ │ ├── WV3/
│ │ │ │ ├── bdpn.pth
│ │ │ │ ├── dicnn1.pth
│ │ │ │ ├── drpnn.pth
│ │ │ │ ├── fusionnet.pth
│ │ │ │ ├── msdcnn.pth
│ │ │ │ ├── pannet.pth
│ │ │ │ └── pnn.pth
│ │ │ └── WV4/
│ │ │ ├── bdpn.pth
│ │ │ ├── dicnn1.pth
│ │ │ ├── drpnn.pth
│ │ │ ├── fusionnet.pth
│ │ │ ├── msdcnn.pth
│ │ │ ├── pannet.pth
│ │ │ ├── pnn.pth
│ │ │ └── readme.txt
│ │ ├── readme.md
│ │ └── results/
│ │ └── readme.txt
│ ├── readme.md
│ └── setup.py
├── 02-Test-toolbox-for-traditional-and-DL(Matlab)/
│ ├── 1_TestData/
│ │ ├── Datasets Testing/
│ │ │ └── Download link for WV3-NewYork test data.txt
│ │ ├── QB/
│ │ │ └── readme.txt
│ │ ├── WV2/
│ │ │ └── readme.txt
│ │ ├── WV3/
│ │ │ └── readme.txt
│ │ ├── WV4/
│ │ │ └── readme.txt
│ │ └── readme.txt
│ ├── 2_DL_Result/
│ │ ├── QB/
│ │ │ └── readme.txt
│ │ ├── WV2/
│ │ │ └── readme.txt
│ │ ├── WV3/
│ │ │ ├── APNN/
│ │ │ │ └── readme.txt
│ │ │ ├── BDPN/
│ │ │ │ └── readme.txt
│ │ │ ├── DRPNN/
│ │ │ │ └── readme.txt
│ │ │ ├── DiCNN1/
│ │ │ │ └── readme.txt
│ │ │ ├── Download link for the 8 DL methods on WV3 dataset.txt
│ │ │ ├── FusionNet/
│ │ │ │ └── readme.txt
│ │ │ ├── MSDCNN/
│ │ │ │ └── readme.txt
│ │ │ ├── PNN/
│ │ │ │ └── readme.txt
│ │ │ └── PanNet/
│ │ │ └── readme.txt
│ │ ├── WV4/
│ │ │ └── readme.txt
│ │ └── readme.txt
│ ├── 3_EPS/
│ │ ├── QB/
│ │ │ └── readme.txt
│ │ ├── WV2/
│ │ │ └── readme.txt
│ │ ├── WV3/
│ │ │ └── readme.txt
│ │ ├── WV4/
│ │ │ └── readme.txt
│ │ └── readme.txt
│ ├── AWLP/
│ │ └── AWLP.m
│ ├── Avg_RR_Assessment.tex
│ ├── BDSD/
│ │ ├── BDSD.m
│ │ ├── BDSD_PC.m
│ │ └── C_BDSD.m
│ ├── BT-H/
│ │ └── BroveyRegHazeMin.m
│ ├── Demo_Full_Resolution.m
│ ├── Demo_Reduced_Resolution.m
│ ├── FE-HPM/
│ │ ├── FE.m
│ │ └── FE_HPM.m
│ ├── FR_Assessment.tex
│ ├── GLP/
│ │ ├── GS2_GLP.m
│ │ ├── MTF_GLP.m
│ │ ├── MTF_GLP_FS.m
│ │ ├── MTF_GLP_HPM.m
│ │ ├── MTF_GLP_HPM_Haze_min.m
│ │ └── MTF_GLP_HPM_R.m
│ ├── GS/
│ │ ├── GS.m
│ │ ├── GSA.m
│ │ └── GS_Segm.m
│ ├── MF/
│ │ ├── MF_HG_Pansharpen.m
│ │ └── Pyr_Dec.m
│ ├── PRACS/
│ │ └── PRACS.m
│ ├── PWMBF/
│ │ ├── PWMBF.m
│ │ ├── compute_PhiTX.m
│ │ ├── compute_PhiX.m
│ │ ├── readme
│ │ └── rwt/
│ │ ├── AUTHORS
│ │ ├── CMakeLists.txt
│ │ ├── HACKING
│ │ ├── INSTALL
│ │ ├── LICENSE
│ │ ├── bin/
│ │ │ ├── HardTh.m
│ │ │ ├── SoftTh.m
│ │ │ ├── compile.m
│ │ │ ├── daubcqf.m
│ │ │ ├── denoise.m
│ │ │ ├── makesig.m
│ │ │ ├── mdwt.m
│ │ │ ├── mdwt.mexw64
│ │ │ ├── midwt.m
│ │ │ ├── midwt.mexw64
│ │ │ ├── mirdwt.m
│ │ │ ├── mirdwt.mexw64
│ │ │ ├── mrdwt.m
│ │ │ ├── mrdwt.mexw64
│ │ │ └── setopt.m
│ │ ├── dist/
│ │ │ ├── 2.01/
│ │ │ │ ├── INSTALL
│ │ │ │ ├── README
│ │ │ │ ├── RWT-2.01.tar.Z
│ │ │ │ └── doc/
│ │ │ │ └── index.html
│ │ │ └── 2.3/
│ │ │ ├── INSTALL
│ │ │ ├── INSTALL_PRECOMPILED
│ │ │ ├── LICENSE
│ │ │ └── README
│ │ ├── doc/
│ │ │ ├── CMakeLists.txt
│ │ │ └── Doxyfile.in
│ │ ├── lib/
│ │ │ ├── inc/
│ │ │ │ ├── rwt_init.h
│ │ │ │ ├── rwt_platform.h
│ │ │ │ └── rwt_transforms.h
│ │ │ └── src/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── dwt.c
│ │ │ ├── idwt.c
│ │ │ ├── init.c
│ │ │ ├── irdwt.c
│ │ │ ├── platform.c
│ │ │ └── rdwt.c
│ │ ├── mex/
│ │ │ ├── mdwt.c
│ │ │ ├── midwt.c
│ │ │ ├── mirdwt.c
│ │ │ └── mrdwt.c
│ │ ├── python/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── LICENSE.numpy
│ │ │ ├── numpy.i
│ │ │ ├── rwt.i
│ │ │ └── test_rwt.py
│ │ ├── readme
│ │ └── tests/
│ │ ├── matlab_xunit/
│ │ │ ├── Readme.html
│ │ │ ├── architecture/
│ │ │ │ ├── class_diagram_a.vsd
│ │ │ │ ├── class_diagram_b.vsd
│ │ │ │ ├── class_diagram_c.vsd
│ │ │ │ ├── html/
│ │ │ │ │ └── matlab_xunit_architecture.html
│ │ │ │ ├── matlab_xunit_architecture.m
│ │ │ │ └── testSample.m
│ │ │ ├── doc/
│ │ │ │ ├── +abc/
│ │ │ │ │ └── +tests/
│ │ │ │ │ ├── test_that.m
│ │ │ │ │ └── test_this.m
│ │ │ │ ├── +abc_tests/
│ │ │ │ │ ├── test_that.m
│ │ │ │ │ └── test_this.m
│ │ │ │ ├── exException.m
│ │ │ │ ├── exQuickStart.m
│ │ │ │ ├── exRunSpecificTest.m
│ │ │ │ ├── exRunTestsInADirectory.m
│ │ │ │ ├── exRunTestsInPackage.m
│ │ │ │ ├── exSilentRunning.m
│ │ │ │ ├── exSubfunctionTests.m
│ │ │ │ ├── exTestCase.m
│ │ │ │ ├── exTestCaseSearching.m
│ │ │ │ ├── exTestFixtures.m
│ │ │ │ ├── exTolerance.m
│ │ │ │ ├── example_quick_start/
│ │ │ │ │ ├── testFliplrMatrix.m
│ │ │ │ │ └── testFliplrVector.m
│ │ │ │ ├── example_subfunction_tests/
│ │ │ │ │ └── testFliplr.m
│ │ │ │ ├── examples_general/
│ │ │ │ │ ├── TestUsingTestCase.m
│ │ │ │ │ ├── testBadSinTest.m
│ │ │ │ │ ├── testCos.m
│ │ │ │ │ ├── testSetupExample.m
│ │ │ │ │ ├── testSin.m
│ │ │ │ │ └── testWithSetupError.m
│ │ │ │ ├── file_exchange_description.txt
│ │ │ │ ├── html/
│ │ │ │ │ ├── exException.html
│ │ │ │ │ ├── exQuickStart.html
│ │ │ │ │ ├── exRunSpecificTest.html
│ │ │ │ │ ├── exRunTestsInADirectory.html
│ │ │ │ │ ├── exRunTestsInPackage.html
│ │ │ │ │ ├── exSilentRunning.html
│ │ │ │ │ ├── exSubfunctionTests.html
│ │ │ │ │ ├── exTestCase.html
│ │ │ │ │ ├── exTestCaseSearching.html
│ │ │ │ │ ├── exTestFixtures.html
│ │ │ │ │ └── exTolerance.html
│ │ │ │ ├── index.html
│ │ │ │ ├── release-history.html
│ │ │ │ └── xunit_product_page.html
│ │ │ ├── license.txt
│ │ │ ├── obsolete/
│ │ │ │ ├── +mtest/
│ │ │ │ │ └── +utils/
│ │ │ │ │ ├── Contents.m
│ │ │ │ │ ├── compareFloats.m
│ │ │ │ │ ├── containsRegexp.m
│ │ │ │ │ ├── generateDoc.m
│ │ │ │ │ ├── isAlmostEqual.m
│ │ │ │ │ ├── isSetUpString.m
│ │ │ │ │ ├── isTearDownString.m
│ │ │ │ │ ├── isTestCaseSubclass.m
│ │ │ │ │ ├── isTestString.m
│ │ │ │ │ └── parseFloatAssertInputs.m
│ │ │ │ ├── assertAlmostEqual.m
│ │ │ │ ├── mtest.m
│ │ │ │ └── tests/
│ │ │ │ ├── MtestTest.m
│ │ │ │ ├── cwd_test/
│ │ │ │ │ ├── TestCaseSubclass.m
│ │ │ │ │ ├── testFoobar.m
│ │ │ │ │ └── testSubfunctions.m
│ │ │ │ ├── testAssertAlmostEqual.m
│ │ │ │ └── testIsAlmostEqual.m
│ │ │ ├── readme
│ │ │ ├── tests/
│ │ │ │ ├── +xunit/
│ │ │ │ │ └── +mocktests/
│ │ │ │ │ ├── +subpkg/
│ │ │ │ │ │ └── test_a_bit.m
│ │ │ │ │ ├── A.m
│ │ │ │ │ ├── B.m
│ │ │ │ │ ├── FooTest.m
│ │ │ │ │ ├── helper_that.m
│ │ │ │ │ ├── test_that.m
│ │ │ │ │ └── test_this.m
│ │ │ │ ├── Readme.m
│ │ │ │ ├── RuntestsTest.m
│ │ │ │ ├── TestCaseTest.m
│ │ │ │ ├── TestCaseWithAddPathTest.m
│ │ │ │ ├── TestFuncHandleTests.m
│ │ │ │ ├── TestRunLoggerTest.m
│ │ │ │ ├── TestSuiteTest.m
│ │ │ │ ├── ThrowsExceptionTest.m
│ │ │ │ ├── almost_black.tif
│ │ │ │ ├── black.tif
│ │ │ │ ├── cwd_test/
│ │ │ │ │ ├── TestCaseSubclass.m
│ │ │ │ │ ├── testFoobar.m
│ │ │ │ │ └── testSubfunctions.m
│ │ │ │ ├── dir1/
│ │ │ │ │ └── test_thatPasses.m
│ │ │ │ ├── dir2/
│ │ │ │ │ └── test_thatFails.m
│ │ │ │ ├── empty_file
│ │ │ │ ├── helper_classes/
│ │ │ │ │ ├── BadFixture.m
│ │ │ │ │ ├── Contents.m
│ │ │ │ │ ├── ExceptionNotThrownTest.m
│ │ │ │ │ ├── FailingTestCase.m
│ │ │ │ │ ├── LoggingTestCase.m
│ │ │ │ │ ├── NoTestMethods.m
│ │ │ │ │ ├── PassingExceptionTest.m
│ │ │ │ │ ├── TestsToBeDiscovered.m
│ │ │ │ │ ├── TwoPassingTests.m
│ │ │ │ │ ├── WrongExceptionThrownTest.m
│ │ │ │ │ ├── notTestString.m
│ │ │ │ │ ├── testFunctionHandlesA.m
│ │ │ │ │ ├── testFunctionHandlesB.m
│ │ │ │ │ ├── testFunctionHandlesC.m
│ │ │ │ │ ├── testFunctionHandlesD.m
│ │ │ │ │ ├── testFunctionHandlesE.m
│ │ │ │ │ ├── testFunctionHandlesTeardownNoSetup.m
│ │ │ │ │ └── testSimple.m
│ │ │ │ ├── testAssertEqual.m
│ │ │ │ ├── testAssertExceptionThrown.m
│ │ │ │ ├── testAssertFalse.m
│ │ │ │ ├── testAssertTrue.m
│ │ │ │ ├── testContainsRegexp.m
│ │ │ │ ├── testIsSetUpString.m
│ │ │ │ ├── testIsTearDownString.m
│ │ │ │ ├── testIsTestCaseSubclass.m
│ │ │ │ ├── testIsTestString.m
│ │ │ │ ├── testRuntestsWithDirectoryName.m
│ │ │ │ ├── test_TestSuiteInDir.m
│ │ │ │ ├── test_arrayToString.m
│ │ │ │ ├── test_assertElementsAlmostEqual.m
│ │ │ │ ├── test_assertFilesEqual.m
│ │ │ │ ├── test_assertVectorsAlmostEqual.m
│ │ │ │ ├── test_compareFloats.m
│ │ │ │ ├── test_comparisonMessage.m
│ │ │ │ ├── test_packageName.m
│ │ │ │ ├── test_parseFloatAssertInputs.m
│ │ │ │ └── test_stringToCellArray.m
│ │ │ └── xunit/
│ │ │ ├── +xunit/
│ │ │ │ └── +utils/
│ │ │ │ ├── Contents.m
│ │ │ │ ├── arrayToString.m
│ │ │ │ ├── compareFloats.m
│ │ │ │ ├── comparisonMessage.m
│ │ │ │ ├── containsRegexp.m
│ │ │ │ ├── generateDoc.m
│ │ │ │ ├── isAlmostEqual.m
│ │ │ │ ├── isSetUpString.m
│ │ │ │ ├── isTearDownString.m
│ │ │ │ ├── isTestCaseSubclass.m
│ │ │ │ ├── isTestString.m
│ │ │ │ ├── parseFloatAssertInputs.m
│ │ │ │ └── stringToCellArray.m
│ │ │ ├── CommandWindowTestRunDisplay.m
│ │ │ ├── Contents.m
│ │ │ ├── FunctionHandleTestCase.m
│ │ │ ├── TestCase.m
│ │ │ ├── TestCaseInDir.m
│ │ │ ├── TestCaseWithAddPath.m
│ │ │ ├── TestComponent.m
│ │ │ ├── TestComponentInDir.m
│ │ │ ├── TestRunDisplay.m
│ │ │ ├── TestRunLogger.m
│ │ │ ├── TestRunMonitor.m
│ │ │ ├── TestSuite.m
│ │ │ ├── TestSuiteInDir.m
│ │ │ ├── VerboseTestRunDisplay.m
│ │ │ ├── assertElementsAlmostEqual.m
│ │ │ ├── assertEqual.m
│ │ │ ├── assertExceptionThrown.m
│ │ │ ├── assertFalse.m
│ │ │ ├── assertFilesEqual.m
│ │ │ ├── assertTrue.m
│ │ │ ├── assertVectorsAlmostEqual.m
│ │ │ ├── initTestSuite.m
│ │ │ └── runtests.m
│ │ ├── octave/
│ │ │ ├── assertEqual.m
│ │ │ ├── assertVectorsAlmostEqual.m
│ │ │ ├── runtests.m
│ │ │ ├── test_denoise.m
│ │ │ ├── test_makesig.m
│ │ │ ├── test_mdwt.m
│ │ │ ├── test_midwt.m
│ │ │ ├── test_mirdwt.m
│ │ │ ├── test_mrdwt.m
│ │ │ └── test_setopt.m
│ │ ├── readme
│ │ ├── runtests.m
│ │ ├── test_daubcqf.m
│ │ ├── test_denoise.m
│ │ ├── test_makesig.m
│ │ ├── test_mdwt.m
│ │ ├── test_midwt.m
│ │ ├── test_mirdwt.m
│ │ ├── test_mrdwt.m
│ │ └── test_setopt.m
│ ├── Quality_Indices/
│ │ ├── D_lambda.m
│ │ ├── D_lambda_K.m
│ │ ├── D_s.m
│ │ ├── ERGAS.m
│ │ ├── HQNR.m
│ │ ├── Q.m
│ │ ├── QNR.m
│ │ ├── SAM.m
│ │ ├── SCC.m
│ │ ├── img_qi.m
│ │ ├── norm_blocco.m
│ │ ├── onion_mult.m
│ │ ├── onion_mult2D.m
│ │ ├── onions_quality.m
│ │ ├── q2n.m
│ │ └── ssim.m
│ ├── RR/
│ │ ├── RRpansharp.m
│ │ ├── manopt/
│ │ │ ├── CLA.txt
│ │ │ ├── COPYING.txt
│ │ │ ├── CREDITS.txt
│ │ │ ├── LICENSE.txt
│ │ │ ├── README.txt
│ │ │ ├── checkinstall/
│ │ │ │ └── basicexample.m
│ │ │ ├── examples/
│ │ │ │ ├── PCA_stochastic.m
│ │ │ │ ├── dominant_invariant_subspace.m
│ │ │ │ ├── dominant_invariant_subspace_complex.m
│ │ │ │ ├── elliptope_SDP.m
│ │ │ │ ├── elliptope_SDP_complex.m
│ │ │ │ ├── essential_svd.m
│ │ │ │ ├── generalized_eigenvalue_computation.m
│ │ │ │ ├── generalized_procrustes.m
│ │ │ │ ├── low_rank_dist_completion.m
│ │ │ │ ├── low_rank_matrix_completion.m
│ │ │ │ ├── low_rank_tensor_completion.m
│ │ │ │ ├── maxcut.m
│ │ │ │ ├── nonlinear_eigenspace.m
│ │ │ │ ├── packing_on_the_sphere.m
│ │ │ │ ├── positive_definite_karcher_mean.m
│ │ │ │ ├── radio_interferometric_calibration.m
│ │ │ │ ├── robust_pca.m
│ │ │ │ ├── shapefit_smoothed.m
│ │ │ │ ├── sparse_pca.m
│ │ │ │ ├── thomson_problem.m
│ │ │ │ └── truncated_svd.m
│ │ │ ├── importmanopt.m
│ │ │ ├── manopt/
│ │ │ │ ├── core/
│ │ │ │ │ ├── StoreDB.m
│ │ │ │ │ ├── applyStatsfun.m
│ │ │ │ │ ├── canGetApproxGradient.m
│ │ │ │ │ ├── canGetApproxHessian.m
│ │ │ │ │ ├── canGetCost.m
│ │ │ │ │ ├── canGetDirectionalDerivative.m
│ │ │ │ │ ├── canGetEuclideanGradient.m
│ │ │ │ │ ├── canGetGradient.m
│ │ │ │ │ ├── canGetHessian.m
│ │ │ │ │ ├── canGetLinesearch.m
│ │ │ │ │ ├── canGetPartialEuclideanGradient.m
│ │ │ │ │ ├── canGetPartialGradient.m
│ │ │ │ │ ├── canGetPrecon.m
│ │ │ │ │ ├── canGetSqrtPrecon.m
│ │ │ │ │ ├── canGetSubgradient.m
│ │ │ │ │ ├── getApproxGradient.m
│ │ │ │ │ ├── getApproxHessian.m
│ │ │ │ │ ├── getCost.m
│ │ │ │ │ ├── getCostGrad.m
│ │ │ │ │ ├── getDirectionalDerivative.m
│ │ │ │ │ ├── getEuclideanGradient.m
│ │ │ │ │ ├── getGlobalDefaults.m
│ │ │ │ │ ├── getGradient.m
│ │ │ │ │ ├── getGradientFD.m
│ │ │ │ │ ├── getHessian.m
│ │ │ │ │ ├── getHessianFD.m
│ │ │ │ │ ├── getLinesearch.m
│ │ │ │ │ ├── getPartialEuclideanGradient.m
│ │ │ │ │ ├── getPartialGradient.m
│ │ │ │ │ ├── getPrecon.m
│ │ │ │ │ ├── getSqrtPrecon.m
│ │ │ │ │ ├── getStore.m
│ │ │ │ │ ├── getSubgradient.m
│ │ │ │ │ ├── handle_light.m
│ │ │ │ │ ├── mergeOptions.m
│ │ │ │ │ ├── purgeStoredb.m
│ │ │ │ │ ├── setStore.m
│ │ │ │ │ └── stoppingcriterion.m
│ │ │ │ ├── manifolds/
│ │ │ │ │ ├── complexcircle/
│ │ │ │ │ │ ├── complexcirclefactory.m
│ │ │ │ │ │ └── realphasefactory.m
│ │ │ │ │ ├── essential/
│ │ │ │ │ │ ├── README_Essential.txt
│ │ │ │ │ │ ├── essential_costE2cost.m
│ │ │ │ │ │ ├── essential_egradE2egrad.m
│ │ │ │ │ │ ├── essential_ehessE2ehess.m
│ │ │ │ │ │ ├── essential_flat.m
│ │ │ │ │ │ ├── essential_hat3.m
│ │ │ │ │ │ ├── essential_sharp.m
│ │ │ │ │ │ ├── essentialfactory.m
│ │ │ │ │ │ └── privateessential/
│ │ │ │ │ │ ├── essential_closestRepresentative.m
│ │ │ │ │ │ ├── essential_distMinAngle.m
│ │ │ │ │ │ ├── essential_distMinAnglePair.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_base.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_computeDfBreak.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_dfNewton.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_discontinuityDistance.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_ft.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_ftFromQ.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_test.m
│ │ │ │ │ │ └── modAngle.m
│ │ │ │ │ ├── euclidean/
│ │ │ │ │ │ ├── centeredmatrixfactory.m
│ │ │ │ │ │ ├── euclideancomplexfactory.m
│ │ │ │ │ │ ├── euclideanfactory.m
│ │ │ │ │ │ ├── shapefitfactory.m
│ │ │ │ │ │ ├── skewsymmetricfactory.m
│ │ │ │ │ │ └── symmetricfactory.m
│ │ │ │ │ ├── fixedrank/
│ │ │ │ │ │ ├── fixedrankMNquotientfactory.m
│ │ │ │ │ │ ├── fixedrankembeddedfactory.m
│ │ │ │ │ │ ├── fixedrankfactory_2factors.m
│ │ │ │ │ │ ├── fixedrankfactory_2factors_preconditioned.m
│ │ │ │ │ │ ├── fixedrankfactory_2factors_subspace_projection.m
│ │ │ │ │ │ ├── fixedrankfactory_3factors.m
│ │ │ │ │ │ └── fixedrankfactory_3factors_preconditioned.m
│ │ │ │ │ ├── fixedranktensors/
│ │ │ │ │ │ ├── fixedrankfactory_tucker_preconditioned.m
│ │ │ │ │ │ └── tucker2multiarray.m
│ │ │ │ │ ├── grassmann/
│ │ │ │ │ │ ├── grassmanncomplexfactory.m
│ │ │ │ │ │ ├── grassmannfactory.m
│ │ │ │ │ │ └── grassmanngeneralizedfactory.m
│ │ │ │ │ ├── multinomial/
│ │ │ │ │ │ └── multinomialfactory.m
│ │ │ │ │ ├── oblique/
│ │ │ │ │ │ ├── obliquecomplexfactory.m
│ │ │ │ │ │ └── obliquefactory.m
│ │ │ │ │ ├── rotations/
│ │ │ │ │ │ ├── randrot.m
│ │ │ │ │ │ ├── randskew.m
│ │ │ │ │ │ └── rotationsfactory.m
│ │ │ │ │ ├── specialeuclidean/
│ │ │ │ │ │ └── specialeuclideanfactory.m
│ │ │ │ │ ├── sphere/
│ │ │ │ │ │ ├── spherecomplexfactory.m
│ │ │ │ │ │ ├── spherefactory.m
│ │ │ │ │ │ └── spheresymmetricfactory.m
│ │ │ │ │ ├── stiefel/
│ │ │ │ │ │ ├── stiefelcomplexfactory.m
│ │ │ │ │ │ ├── stiefelfactory.m
│ │ │ │ │ │ ├── stiefelgeneralizedfactory.m
│ │ │ │ │ │ └── stiefelstackedfactory.m
│ │ │ │ │ └── symfixedrank/
│ │ │ │ │ ├── elliptopefactory.m
│ │ │ │ │ ├── spectrahedronfactory.m
│ │ │ │ │ ├── symfixedrankYYcomplexfactory.m
│ │ │ │ │ ├── symfixedrankYYfactory.m
│ │ │ │ │ └── sympositivedefinitefactory.m
│ │ │ │ ├── readme
│ │ │ │ ├── solvers/
│ │ │ │ │ ├── barzilaiborwein/
│ │ │ │ │ │ └── barzilaiborwein.m
│ │ │ │ │ ├── bfgs/
│ │ │ │ │ │ └── rlbfgs.m
│ │ │ │ │ ├── conjugategradient/
│ │ │ │ │ │ ├── conjugategradient.m
│ │ │ │ │ │ └── linear_conjugategradient.m
│ │ │ │ │ ├── gradientapproximations/
│ │ │ │ │ │ └── approxgradientFD.m
│ │ │ │ │ ├── hessianapproximations/
│ │ │ │ │ │ └── approxhessianFD.m
│ │ │ │ │ ├── linesearch/
│ │ │ │ │ │ ├── linesearch.m
│ │ │ │ │ │ ├── linesearch_adaptive.m
│ │ │ │ │ │ ├── linesearch_decrease.m
│ │ │ │ │ │ └── linesearch_hint.m
│ │ │ │ │ ├── neldermead/
│ │ │ │ │ │ ├── centroid.m
│ │ │ │ │ │ └── neldermead.m
│ │ │ │ │ ├── preconditioners/
│ │ │ │ │ │ └── preconhessiansolve.m
│ │ │ │ │ ├── pso/
│ │ │ │ │ │ └── pso.m
│ │ │ │ │ ├── steepestdescent/
│ │ │ │ │ │ └── steepestdescent.m
│ │ │ │ │ ├── stochasticgradient/
│ │ │ │ │ │ ├── stepsize_sg.m
│ │ │ │ │ │ └── stochasticgradient.m
│ │ │ │ │ └── trustregions/
│ │ │ │ │ ├── license for original GenRTR code.txt
│ │ │ │ │ ├── tCG.m
│ │ │ │ │ └── trustregions.m
│ │ │ │ └── tools/
│ │ │ │ ├── checkdiff.m
│ │ │ │ ├── checkgradient.m
│ │ │ │ ├── checkhessian.m
│ │ │ │ ├── checkretraction.m
│ │ │ │ ├── criticalpointfinder.m
│ │ │ │ ├── dexpm.m
│ │ │ │ ├── dfunm.m
│ │ │ │ ├── diagsum.m
│ │ │ │ ├── dlogm.m
│ │ │ │ ├── dsqrtm.m
│ │ │ │ ├── grammatrix.m
│ │ │ │ ├── hashmd5.m
│ │ │ │ ├── hessianextreme.m
│ │ │ │ ├── hessianmatrix.m
│ │ │ │ ├── hessianspectrum.m
│ │ │ │ ├── identify_linear_piece.m
│ │ │ │ ├── lincomb.m
│ │ │ │ ├── manoptsolve.m
│ │ │ │ ├── matrixlincomb.m
│ │ │ │ ├── multihconj.m
│ │ │ │ ├── multiherm.m
│ │ │ │ ├── multiprod.m
│ │ │ │ ├── multiprodmultitransp_license.txt
│ │ │ │ ├── multiscale.m
│ │ │ │ ├── multiskew.m
│ │ │ │ ├── multisqnorm.m
│ │ │ │ ├── multisym.m
│ │ │ │ ├── multitrace.m
│ │ │ │ ├── multitransp.m
│ │ │ │ ├── orthogonalize.m
│ │ │ │ ├── plotprofile.m
│ │ │ │ ├── powermanifold.m
│ │ │ │ ├── productmanifold.m
│ │ │ │ ├── smallestinconvexhull.m
│ │ │ │ ├── statsfunhelper.m
│ │ │ │ ├── surfprofile.m
│ │ │ │ ├── tangent2vec.m
│ │ │ │ ├── tangentorthobasis.m
│ │ │ │ ├── tangentspacefactory.m
│ │ │ │ └── tangentspherefactory.m
│ │ │ ├── manopt_version.m
│ │ │ └── readme
│ │ └── readme
│ ├── RR_Assessment.tex
│ ├── SR-D/
│ │ ├── CS.m
│ │ ├── Dict_Learn.m
│ │ ├── OMP.m
│ │ └── OMP_Rec_Detile.m
│ ├── TV/
│ │ └── TV_pansharpen.m
│ ├── Tools/
│ │ ├── LPfilter.m
│ │ ├── LPfilterGauss.m
│ │ ├── LPfilterPlusDec.m
│ │ ├── MTF.m
│ │ ├── MTF_PAN.m
│ │ ├── estimation_alpha.m
│ │ ├── genMTF.m
│ │ ├── gen_LP_image.m
│ │ ├── indexes_evaluation.m
│ │ ├── indexes_evaluation_FS.m
│ │ ├── indwt2_working.m
│ │ ├── interp23tap.m
│ │ ├── k_means_clustering.m
│ │ ├── matrix2latex.m
│ │ ├── ndwt2_working.m
│ │ ├── printAllImagesImWriteFR.m
│ │ ├── printAllImagesImWriteRR.m
│ │ ├── printImage.m
│ │ ├── rectangleonimage.m
│ │ ├── resize_images.m
│ │ ├── showImage4.m
│ │ ├── showImage4LR.m
│ │ ├── showImage4LR_zoomin.m
│ │ ├── showImage4_zoomin.m
│ │ ├── showImage8.m
│ │ ├── showImage8LR.m
│ │ ├── showImage8LR_zoomin.m
│ │ ├── showImage8_zoomin.m
│ │ ├── showImagesAll.m
│ │ ├── showImagesAllOld.m
│ │ ├── showPan.m
│ │ ├── showPan_zoomin.m
│ │ ├── tight_subplot.m
│ │ ├── viewimage.m
│ │ └── viewimage2.m
│ └── readme.md
├── 03-Data-Simulation(Matlab)/
│ ├── 01-DataSimu/
│ │ └── QB/
│ │ └── readme.md.txt
│ ├── Demo_DataSimu_qb.m
│ ├── imgs/
│ │ └── readme
│ └── segImg_new.m
├── LICENSE
├── README.md
└── docs/
├── en/
│ ├── DLPanToolbox/
│ │ ├── Evaluation.md
│ │ ├── Example.md
│ │ ├── PreProcess.md
│ │ └── Simulation.md
│ ├── Makefile
│ ├── _static/
│ │ └── css/
│ │ └── readthedocs.css
│ ├── _templates/
│ │ └── classtemplate.rst
│ ├── citation.md
│ ├── conf.py
│ ├── docutils.conf
│ ├── faq.md
│ ├── get_started/
│ │ ├── Installation.md
│ │ └── Introduction.md
│ ├── index.rst
│ ├── make.bat
│ └── switch_language.md
├── requirements.txt
├── run.sh
└── zh-cn/
├── DLPanToolbox/
│ ├── Evaluation.md
│ ├── Example.md
│ ├── PreProcess.md
│ └── Simulation.md
├── Makefile
├── _static/
│ └── css/
│ └── readthedocs.css
├── _templates/
│ └── classtemplate.rst
├── citation.md
├── conf.py
├── docutils.conf
├── faq.md
├── get_started/
│ ├── Installation.md
│ └── Introduction.md
├── index.rst
├── make.bat
├── related.md
└── switch_language.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.log
*.pyc
*.xml
*.json
*.mat
*.eps
*.cpython-37.pyc
/DLPan-Toolbox/01-DL-toolbox(Pytorch)/results/*
/bak/*
================================================
FILE: 01-DL-toolbox(Pytorch)/LICENSE
================================================
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/AutoDL/__init__.py
================================================
# GPL License
# Copyright (C) 2021 , UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
from UDL.Basis.python_sub_class import PanSharpeningModel, TaskDispatcher, ModelDispatcher
import UDL.Basis.option
def build_model(arch, task, cfg=None):
if task == "pansharpening":
from UDL.pansharpening.models import PanSharpeningModel as MODELS
return MODELS.build_model(cfg)
else:
raise NotImplementedError(f"It's not supported in {task}")
def getDataSession(cfg):
task = cfg.task
if task in ["pansharpening"]:
from UDL.pansharpening.common.psdata import PansharpeningSession as DataSession
else:
raise NotImplementedError
return DataSession(cfg)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/AutoDL/trainer.py
================================================
# GPL License
# Copyright (C) UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import argparse
import copy
import os
import os.path as osp
import warnings
import random
import numpy as np
import torch
import torch.distributed as dist
import time
tic = time.time()
# 1.14s
import sys
sys.path.append('../..')
sys.path.append('../mmcv')
from UDL.AutoDL import build_model, getDataSession, ModelDispatcher
from UDL.Basis.auxiliary import init_random_seed, set_random_seed
from mmcv.utils.logging import print_log, create_logger
# 1.5s
from mmcv.runner import init_dist, find_latest_checkpoint
from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
from mmcv.runner import (DistSamplerSeedHook, EpochBasedRunner,
Fp16OptimizerHook, OptimizerHook, build_optimizer,
build_runner, get_dist_info)
# 10s
# from mmdet.datasets import (build_dataloader, build_dataset,
# replace_ImageToTensor)
def trainer(cfg, logger,
distributed=False,
meta=None):
model, criterion, optimizer, scheduler = build_model(cfg.arch, cfg.task, cfg)
if hasattr(model, 'init_weights'):
model.init_weights()
sess = getDataSession(cfg)
if cfg.eval:
cfg.workflow = [('val', 1)]
if not any('train' in mode for mode, _ in cfg.workflow):
cfg.eval = True
# put model on gpus
if distributed:
find_unused_parameters = cfg.get('find_unused_parameters', False)
# Sets the `find_unused_parameters` parameter in
# torch.nn.parallel.DistributedDataParallel
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False,
find_unused_parameters=find_unused_parameters)
else:
if not hasattr(model, 'train'):
if isinstance(model.model, dict):
for name, m in model.model.items():
model.model[name] = MMDataParallel(m, device_ids=cfg.gpu_ids)
else:
model.model = MMDataParallel(model.model, device_ids=cfg.gpu_ids)
else:
model = MMDataParallel(model, device_ids=cfg.gpu_ids)
if cfg.get('optimizer', None) is not None:
optimizer = build_optimizer(model, cfg.optimizer)
if 'runner' not in cfg:
cfg.runner = {
'type': 'EpochBasedRunner',
'max_epochs': cfg.epochs # argparser
}
warnings.warn(
'config is now expected to have a `runner` section, '
'please set `runner` in your config.', UserWarning)
else:
if 'epochs' in cfg and 'max_iters' not in cfg.runner:
cfg.runner['max_epochs'] = cfg.epochs
# assert cfg.epochs == cfg.runner['max_epochs'], print(cfg.epochs, cfg.runner['max_epochs'])
runner = build_runner(
cfg.runner,
default_args=dict(
model=model,
optimizer=optimizer,
work_dir=cfg.work_dir,
logger=logger,
meta=meta,
opt_cfg={'print_freq': cfg.print_freq,
'accumulated_step': cfg.accumulated_step,
'clip_max_norm': cfg.clip_max_norm,
'dataset': cfg.dataset,
'img_range': cfg.img_range,
'metrics': cfg.metrics,
'save_fmt': cfg.save_fmt,
'mode': cfg.mode,
'eval': cfg.eval,
'save_dir': cfg.work_dir + "/results"}))
# an ugly workaround to make .log and .log.json filenames the same
# runner.timestamp = timestamp
# fp16 setting
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
optimizer_config = Fp16OptimizerHook(
**cfg.optimizer_config, **fp16_cfg, distributed=distributed)
elif distributed and 'type' not in cfg.optimizer_config:
optimizer_config = OptimizerHook(**cfg.optimizer_config)
else:
optimizer_config = cfg.get('optimizer_config', None)
############################################################
# register training hooks
############################################################
if cfg.get('config', None) is not None:
'''
optimizer = dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.0001)
optimizer_config = dict(grad_clip=None)
lr_config = dict(policy='step', step=[100, 150])
checkpoint_config = dict(interval=1)
log_config = dict(
interval=100,
hooks=[
dict(type='TextLoggerHook'),
# dict(type='TensorboardLoggerHook')
])
'''
runner.register_training_hooks(
cfg.lr_config,
optimizer_config,
cfg.checkpoint_config,
cfg.log_config,
cfg.get('momentum_config', None),
custom_hooks_config=cfg.get('custom_hooks', None))
elif cfg.get('log_config', None) is None and len(cfg.workflow) and cfg.workflow[0][0] != 'simple_train':
if cfg.mode == 'nni':
runner.register_custom_hooks({'type': 'NNIHook', 'priority': 'very_low'})
if scheduler is not None:
runner.register_lr_hook(dict(policy=scheduler.__class__.__name__[:-2], step=scheduler.step_size))
runner.register_checkpoint_hook(
dict(type='ModelCheckpoint', indicator='loss', save_top_k=cfg.save_top_k, print_freq=cfg.save_print_freq))
runner.register_optimizer_hook(dict(grad_clip=10)) # ExternOptimizer
runner.register_timer_hook(dict(type='IterTimerHook'))
log_config = [dict(type='TextLoggerHook')]
if cfg.use_tfb:
log_config.append(dict(type='TensorboardLoggerHook'))
runner.register_logger_hooks(dict(
interval=cfg.print_freq,
hooks=log_config))
else:
runner.register_checkpoint_hook(dict(type='ModelCheckpoint', indicator='loss'))
if distributed:
if isinstance(runner, EpochBasedRunner):
runner.register_hook(DistSamplerSeedHook())
data_loaders = {}
############################################################
# load data
############################################################
for flow in cfg.workflow:
mode, _ = flow
if 'val' in mode:
# cfg.dataset = cfg.dataset + '_OrigScale_multiExm1.h5'
# cfg.dataset = cfg.dataset + '_multiExm1.h5'
eval_loader, eval_sampler = sess.get_eval_dataloader(cfg.dataset[mode], distributed)
eval_cfg = cfg.get('evaluation', {})
eval_cfg['by_epoch'] = cfg.runner['type'] != 'IterBasedRunner'
from mmcv.runner import EvalHook, DistEvalHook
eval_hook = DistEvalHook if distributed else EvalHook
# In this PR (https://github.com/open-mmlab/mmcv/pull/1193), the
# priority of IterTimerHook has been modified from 'NORMAL' to 'LOW'.
if mode != 'simple_val':
runner.register_hook(
eval_hook(eval_loader, **eval_cfg), priority='LOW')
data_loaders[mode] = eval_loader
# if len(cfg.workflow) == 0:
# cfg.workflow.append(('val', 1))
if 'train' in mode:
train_loader, train_sampler = sess.get_dataloader(cfg.dataset[mode], distributed)
if cfg.once_epoch:
train_loader = iter(list(train_loader))
data_loaders[mode] = train_loader
if len(cfg.workflow) == 0:
cfg.workflow.append(('simple_train', 1))
############################################################
# load model
############################################################
resume_from = None
if cfg.get('resume_from', None) is None and cfg.get('auto_resume'):
resume_from = find_latest_checkpoint(cfg.work_dir)
if resume_from is not None:
cfg.resume_from = resume_from
# if cfg.get('resume_from', None):
runner.resume(cfg.resume_from, cfg.resume_mode, cfg.reset_lr, cfg.lr)
if cfg.get('load_from', None) and cfg.get('resume_from', None) is not None:
runner.load_checkpoint(cfg.load_from, cfg.resume_mode)
############################################################
# run train/val/test
############################################################
runner.run(data_loaders, cfg.workflow)
def main(cfg):
# init distributed env first, since logger depends on the dist info.
if cfg.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(cfg.launcher, **cfg.dist_params)
# re-set gpu_ids with distributed training mode
_, world_size = get_dist_info()
cfg.gpu_ids = range(world_size)
logger, out_dir, model_save_dir, tfb_dir = create_logger(cfg, cfg.experimental_desc, 0)
cfg.out_dir = cfg.work_dir = model_save_dir
seed = init_random_seed(cfg.seed)
print_log(f'Set random seed to {seed}', logger=logger)
set_random_seed(seed)
# if cfg.checkpoint_config is not None:
# # save mmdet version, config file content and class names in
# # checkpoints as meta data
# cfg.checkpoint_config.meta = dict(
# mmdet_version=__version__ + get_git_hash()[:7],
# CLASSES=datasets[0].CLASSES)
# add an attribute for visualization convenience
trainer(
cfg,
logger,
distributed=distributed,
meta={})
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/__init__.py
================================================
from ..auxiliary.utils import AverageMeter, accuracy, MetricLogger, SmoothedValue, set_random_seed, init_random_seed, show_memory_info
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/base.py
================================================
from nvidia.dali.plugin.pytorch import DALIGenericIterator
class DALIDataloader(DALIGenericIterator):
def __init__(self, pipeline, size, batch_size, output_map=["data", "label"], auto_reset=True, onehot_label=False):
# self.size = size
self.batch_size = batch_size
self.onehot_label = onehot_label
self.output_map = output_map
super().__init__(pipelines=pipeline, size=size, auto_reset=auto_reset, output_map=output_map)
def __next__(self):
if self._first_batch is not None:
batch = self._first_batch
self._first_batch = None
return batch
data = super().__next__()[0]
if self.onehot_label:
return [data[self.output_map[0]], data[self.output_map[1]].squeeze().long()]
else:
return [data[self.output_map[0]], data[self.output_map[1]]]
def __len__(self):
if self.size % self.batch_size == 0:
return self.size // self.batch_size
else:
return self.size // self.batch_size + 1
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/fp16_utils.py
================================================
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
class tofp16(nn.Module):
"""
Utility module that implements::
def forward(self, input):
return input.half()
"""
def __init__(self):
super(tofp16, self).__init__()
def forward(self, input):
return input.half()
def BN_convert_float(module):
"""
Utility function for network_to_half().
Retained for legacy purposes.
"""
if isinstance(module, torch.nn.modules.batchnorm._BatchNorm) and module.affine is True:
module.float()
for child in module.children():
BN_convert_float(child)
return module
def network_to_half(network):
"""
Convert model to half precision in a batchnorm-safe way.
Retained for legacy purposes. It is recommended to use FP16Model.
"""
return nn.Sequential(tofp16(), BN_convert_float(network.half()))
def convert_module(module, dtype):
"""
Converts a module's immediate parameters and buffers to dtype.
"""
for param in module.parameters(recurse=False):
if param is not None:
if param.data.dtype.is_floating_point:
param.data = param.data.to(dtype=dtype)
if param._grad is not None and param._grad.data.dtype.is_floating_point:
param._grad.data = param._grad.data.to(dtype=dtype)
for buf in module.buffers(recurse=False):
if buf is not None and buf.data.dtype.is_floating_point:
buf.data = buf.data.to(dtype=dtype)
def convert_network(network, dtype):
"""
Converts a network's parameters and buffers to dtype.
"""
for module in network.modules():
if isinstance(module, torch.nn.modules.batchnorm._BatchNorm) and module.affine is True:
continue
convert_module(module, dtype)
if isinstance(module, torch.nn.RNNBase) or isinstance(module, torch.nn.modules.rnn.RNNBase):
module.flatten_parameters()
return network
class FP16Model(nn.Module):
"""
Convert model to half precision in a batchnorm-safe way.
"""
def __init__(self, network):
super(FP16Model, self).__init__()
self.network = convert_network(network, dtype=torch.half)
def forward(self, *inputs):
inputs = tuple(t.half() for t in inputs)
return self.network(*inputs)
def backwards_debug_hook(grad):
raise RuntimeError("master_params recieved a gradient in the backward pass!")
def prep_param_lists(model, flat_master=False):
"""
Creates a list of FP32 master parameters for a given model, as in
`Training Neural Networks with Mixed Precision: Real Examples`_.
Args:
model (torch.nn.Module): Existing Pytorch model
flat_master (bool, optional, default=False): Flatten the master parameters into a single tensor, as a performance optimization.
Returns:
A tuple (``model_params``, ``master_params``). ``model_params`` is a list of the model's parameters for later use with :func:`model_grads_to_master_grads` and :func:`master_params_to_model_params`. ``master_params`` is a list of FP32 master gradients. If ``flat_master=True``, ``master_params`` will be a list with one element.
Example::
model_params, master_params = prep_param_lists(model)
.. warning::
Currently, if ``flat_master=True``, all the model's parameters must be the same type. If the model has parameters of different types, use ``flat_master=False``, or use :class:`FP16_Optimizer`.
.. _`Training Neural Networks with Mixed Precision: Real Examples`:
http://on-demand.gputechconf.com/gtc/2018/video/S81012/
"""
model_params = [param for param in model.parameters() if param.requires_grad]
if flat_master:
# Give the user some more useful error messages
try:
# flatten_dense_tensors returns a contiguous flat array.
# http://pytorch.org/docs/master/_modules/torch/_utils.html
master_params = _flatten_dense_tensors([param.data for param in model_params]).float()
except:
print("Error in prep_param_lists: model may contain a mixture of parameters "
"of different types. Use flat_master=False, or use F16_Optimizer.")
raise
master_params = torch.nn.Parameter(master_params)
master_params.requires_grad = True
# master_params.register_hook(backwards_debug_hook)
if master_params.grad is None:
master_params.grad = master_params.new(*master_params.size())
return model_params, [master_params]
else:
master_params = [param.clone().float().detach() for param in model_params]
for param in master_params:
param.requires_grad = True
return model_params, master_params
def model_grads_to_master_grads(model_params, master_params, flat_master=False):
"""
Copy model gradients to master gradients.
Args:
model_params: List of model parameters created by :func:`prep_param_lists`.
master_params: List of FP32 master parameters created by :func:`prep_param_lists`. If ``master_params`` was created with ``flat_master=True``, ``flat_master=True`` should also be supplied to :func:`model_grads_to_master_grads`.
"""
if flat_master:
# The flattening may incur one more deep copy than is necessary.
master_params[0].grad.data.copy_(
_flatten_dense_tensors([p.grad.data for p in model_params]))
else:
for model, master in zip(model_params, master_params):
if model.grad is not None:
if master.grad is None:
master.grad = Variable(master.data.new(*master.data.size()))
master.grad.data.copy_(model.grad.data)
else:
master.grad = None
def master_params_to_model_params(model_params, master_params, flat_master=False):
"""
Copy master parameters to model parameters.
Args:
model_params: List of model parameters created by :func:`prep_param_lists`.
master_params: List of FP32 master parameters created by :func:`prep_param_lists`. If ``master_params`` was created with ``flat_master=True``, ``flat_master=True`` should also be supplied to :func:`master_params_to_model_params`.
"""
if flat_master:
for model, master in zip(model_params,
_unflatten_dense_tensors(master_params[0].data, model_params)):
model.data.copy_(master)
else:
for model, master in zip(model_params, master_params):
model.data.copy_(master.data)
# Backward compatibility fixes
def to_python_float(t):
if hasattr(t, 'item'):
return t.item()
else:
return t[0]
TORCH_MAJOR = int(torch.__version__.split('.')[0])
TORCH_MINOR = int(torch.__version__.split('.')[1])
if TORCH_MAJOR == 0 and TORCH_MINOR <= 4:
clip_grad_norm = torch.nn.utils.clip_grad_norm
else:
clip_grad_norm = torch.nn.utils.clip_grad_norm_
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/__init__.py
================================================
__copyright__ = 'Copyright (C) 2018 Swall0w'
__version__ = '0.0.7'
__author__ = 'Swall0w'
__url__ = 'https://github.com/Swall0w/torchstat'
from torchstat.compute_memory import compute_memory
from torchstat.compute_madd import compute_madd
from torchstat.compute_flops import compute_flops
from torchstat.stat_tree import StatTree, StatNode
from torchstat.model_hook import ModelHook
from torchstat.reporter import report_format
from torchstat.statistics import stat, ModelStat
__all__ = ['report_format', 'StatTree', 'StatNode', 'compute_madd',
'compute_flops', 'ModelHook', 'stat', 'ModelStat', '__main__',
'compute_memory']
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/__main__.py
================================================
from torchstat import stat
import argparse
import importlib.util
import torch
def arg():
parser = argparse.ArgumentParser(description='Torch model statistics')
parser.add_argument('--file', '-f', type=str,
help='Module file.')
parser.add_argument('--model', '-m', type=str,
help='Model name')
parser.add_argument('--size', '-s', type=str, default='3x224x224',
help='Input size. channels x height x width (default: 3x224x224)')
return parser.parse_args()
def main():
args = arg()
try:
spec = importlib.util.spec_from_file_location('models', args.file)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
model = getattr(module, args.model)()
except Exception:
import traceback
print(f'Tried to import {args.model} from {args.file}. but failed.')
traceback.print_exc()
import sys
sys.exit()
input_size = tuple(int(x) for x in args.size.split('x'))
stat(model, input_size, query_granularity=1)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_flops.py
================================================
import torch.nn as nn
import torch
import numpy as np
import inspect
def compute_flops(module, inp, out):
# print(module.__class__)
# if 'attn' in module.__name__:
# print(module.__class__)
# print(list(filter(lambda m: not m.startswith("__") and not m.endswith("__") and callable(getattr(module, m)), dir(module))))
if isinstance(module, nn.Conv2d):
return compute_Conv2d_flops(module, inp, out)
elif isinstance(module, nn.BatchNorm2d):
return compute_BatchNorm2d_flops(module, inp, out)
elif isinstance(module, nn.LayerNorm) or 'LayerNorm' in type(module).__name__:
return compute_LayerNorm_flops(module, inp, out)
elif isinstance(module, (nn.AvgPool2d, nn.MaxPool2d)):
return compute_Pool2d_flops(module, inp, out)
elif isinstance(module, (nn.ReLU, nn.ReLU6, nn.PReLU, nn.ELU, nn.LeakyReLU)):
return compute_ReLU_flops(module, inp, out)
# elif isinstance(module, nn.Upsample):
# return compute_Upsample_flops(module, inp, out)
elif isinstance(module, nn.Linear):
return compute_Linear_flops(module, inp, out)
elif 'SwinTEB' in module.__class__.__name__:#
return compute_WindowAttention_flops(module, inp, out)
elif 'XCTEB' in module.__class__.__name__:
return compute_XCA_flops(module, inp, out)
elif 'MSA' in module.__class__.__name__:
return compute_MSA_flops(module, inp, out)
elif 'cGCN' == module.__class__.__name__:
return compute_cGCN_flops(module, inp, out)
elif 'sGCN' == module.__class__.__name__:
return compute_sGCN_flops(module, inp, out)
else:
print(f"[Flops]: {module.__class__.__name__} is not supported!")
return 0
pass
def compute_cGCN_flops(module, inp, out):
batch_size, dim, H, W = inp.size()
dim = dim // 2
L = H * W
# N = window_size ** 2
# num_patches = H * W // N
# calculate flops for 1 window with token length of N
flops = 0
# qkv = self.qkv(x)
# flops += N * dim * 3 * dim
# attn = (q @ k.transpose(-2, -1)) b head c (h w) b head (h w) c
flops += dim * (dim//2) * L
# x = (attn @ v) b head c c b head c (h w)
flops += L * dim * (dim//2)
return batch_size * flops
def compute_sGCN_flops(module, inp, out):
batch_size, dim, H, W = inp.size()
dim = dim // 2
L = H * W
# calculate flops for 1 window with token length of N
flops = 0
# qkv = self.qkv(x)
# flops += N * dim * 3 * dim
# attn = (q @ k.transpose(-2, -1)) b head c (h w) b head (h w) c
flops += dim * dim * L
# x = (attn @ v) b head c c b head c (h w)
flops += L * dim * dim
return batch_size * flops
def compute_Conv2d_flops(module, inp, out):
# Can have multiple inputs, getting the first one
assert isinstance(module, nn.Conv2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
batch_size = inp.size()[0]
in_c = inp.size()[1]
k_h, k_w = module.kernel_size
out_c, out_h, out_w = out.size()[1:]
groups = module.groups
filters_per_channel = out_c // groups
conv_per_position_flops = k_h * k_w * in_c * filters_per_channel
active_elements_count = batch_size * out_h * out_w
total_conv_flops = conv_per_position_flops * active_elements_count
bias_flops = 0
if module.bias is not None:
bias_flops = out_c * active_elements_count
# k * k * c * H * W * o = (乘法 + 加法 + bias) * active_elements_count
total_flops = total_conv_flops + bias_flops
return total_flops
def compute_BatchNorm2d_flops(module, inp, out):
assert isinstance(module, nn.BatchNorm2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
in_c, in_h, in_w = inp.size()[1:]
batch_flops = np.prod(inp.shape)
if module.affine:
batch_flops *= 2
return batch_flops
def compute_LayerNorm_flops(module, inp, out):
# assert isinstance(module, nn.LayerNorm)
if len(inp.size()) == 3:
inp = inp.unsqueeze(0)
if len(out.size()) == 3:
out = out.unsqueeze(0)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
flops = np.prod(inp.shape)
return flops
def compute_ReLU_flops(module, inp, out):
assert isinstance(module, (nn.ReLU, nn.ReLU6, nn.PReLU, nn.ELU, nn.LeakyReLU))
batch_size = inp.size()[0]
active_elements_count = batch_size
for s in inp.size()[1:]:
active_elements_count *= s
return active_elements_count
def compute_Pool2d_flops(module, inp, out):
assert isinstance(module, nn.MaxPool2d) or isinstance(module, nn.AvgPool2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
return np.prod(inp.shape)
def compute_Linear_flops(module, inp, out):
assert isinstance(module, nn.Linear)
if len(inp.size()) > 3:
inp = inp.reshape(inp.size(0), inp.size(1), -1)
if len(out.size()) > 3:
out = out.reshape(out.size(0), out.size(1), -1)
batch_size = inp.size()[0]
if len(inp.size()) == 3:# and inp.size(0) == 1:
inp = inp[0, ...]#.squeeze(0)
if len(out.size()) == 3:# and out.size(0) == 1:
out = out[0, ...]#.squeeze(0)
assert len(inp.size()) == 2 and len(out.size()) == 2
return batch_size * inp.size()[1] * out.size()[1]
def compute_Upsample_flops(module, inp, out):
assert isinstance(module, nn.Upsample)
output_size = out[0]
batch_size = inp.size()[0]
output_elements_count = batch_size
# for s in output_size.
def compute_MSA_flops(module, inp, out):
# q = inp[0]
if isinstance(inp, tuple):
inp = inp[0]
if module.__class__.__name__ == "MSA":
N, batch_size, dim = inp.size()
elif module.__class__.__name__ == "MSA_BNC":
batch_size, N, dim = inp.size()
# window_size = module.window_size
if hasattr(module, 'num_heads'):
num_heads = module.num_heads
elif hasattr(module, 'n_heads'):
num_heads = module.num_heads
num_patches = 1#H * W // N
# num_patches = module.num_patches
# batch_size /= num_patches# B*nH*nW
# assert batch_size == 1, print(f"{inp.size()} is not compatiable with {num_patches}")
# print(inp.size(), out.size(), dir(module))
# calculate flops for 1 window with token length of N
flops = 0
# qkv = self.qkv(x)
# flops += N * dim * 3 * dim
# attn = (q @ k.transpose(-2, -1))
flops += num_heads * N * (dim // num_heads) * N
# x = (attn @ v)
flops += num_heads * N * N * (dim // num_heads)
# x = self.proj(x)
# flops += N * dim * dim
return batch_size * num_patches * flops
def compute_WindowAttention_flops(module, inp, out):
# inp = inp[0].permute(0, 3, 1, 2) # B, p, L, C
# out = out.permute(0, 3, 1, 2)
# dim = out.size(1)
if isinstance(inp, tuple):
inp = inp[0]
# inp = inp[0]
L = len(inp.size())
if L == 3:
batch_size, HW, dim = inp.size()
H = W = int(np.sqrt(HW))
elif L == 4:
batch_size, dim, H, W = inp.size()
window_size = module.window_size
num_heads = module.num_heads
N = window_size ** 2
num_patches = H * W // N
# num_patches = module.num_patches
# batch_size /= num_patches# B*nH*nW
# assert batch_size == 1, print(f"{inp.size()} is not compatiable with {num_patches}")
# print(inp.size(), out.size(), dir(module))
# calculate flops for 1 window with token length of N
flops = 0
# qkv = self.qkv(x)
# flops += N * dim * 3 * dim
# attn = (q @ k.transpose(-2, -1))
flops += num_heads * N * (dim // num_heads) * N
# x = (attn @ v)
flops += num_heads * N * N * (dim // num_heads)
# x = self.proj(x)
# flops += N * dim * dim
# module.__base__ = f'{module.__class__.__name__}(dim={dim}, win_size={window_size}, nh={num_heads}, n_p={num_patches}, size=({H}, {W}))'
# print(f'{module.__class__.__name__}, dim={dim}, win_size={window_size}, num_heads={num_heads},'
# f'num_patches={num_patches}, img_size=({H}, {W})')
return batch_size * num_patches * flops
def compute_XCA_flops(module, inp, out):
dim = out.size(1)
batch_size, _, H, W = inp.size()
if hasattr(module, "window_size"):
window_size = module.window_size
N = window_size ** 2
num_patches = H * W // N
else:
num_patches = 1
window_size = 1
N = H * W
# window_size = module.window_size
num_heads = module.num_heads
# N = window_size ** 2
# num_patches = H * W // N
# calculate flops for 1 window with token length of N
flops = 0
# qkv = self.qkv(x)
# flops += N * dim * 3 * dim
# attn = (q @ k.transpose(-2, -1)) b head c (h w) b head (h w) c
flops += num_heads * (dim // num_heads) * (dim // num_heads) * N
# x = (attn @ v) b head c c b head c (h w)
flops += num_heads * N * (dim // num_heads) * (dim // num_heads)
# x = self.proj(x)
# flops += N * dim * dim
return batch_size * num_patches * flops
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_madd.py
================================================
"""
compute Multiply-Adds(MAdd) of each leaf module
"""
import torch.nn as nn
def compute_Conv2d_madd(module, inp, out):
assert isinstance(module, nn.Conv2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
in_c = inp.size()[1]
k_h, k_w = module.kernel_size
out_c, out_h, out_w = out.size()[1:]
groups = module.groups
# ops per output element
kernel_mul = k_h * k_w * (in_c // groups)
kernel_add = kernel_mul - 1 + (0 if module.bias is None else 1)
kernel_mul_group = kernel_mul * out_h * out_w * (out_c // groups)
kernel_add_group = kernel_add * out_h * out_w * (out_c // groups)
total_mul = kernel_mul_group * groups
total_add = kernel_add_group * groups
return total_mul + total_add
def compute_ConvTranspose2d_madd(module, inp, out):
assert isinstance(module, nn.ConvTranspose2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
in_c, in_h, in_w = inp.size()[1:]
k_h, k_w = module.kernel_size
out_c, out_h, out_w = out.size()[1:]
groups = module.groups
kernel_mul = k_h * k_w * (in_c // groups)
kernel_add = kernel_mul - 1 + (0 if module.bias is None else 1)
kernel_mul_group = kernel_mul * in_h * in_w * (out_c // groups)
kernel_add_group = kernel_add * in_h * in_w * (out_c // groups)
total_mul = kernel_mul_group * groups
total_add = kernel_add_group * groups
return total_mul + total_add
def compute_LayerNorm_madd(module, inp, out):
# assert isinstance(module, nn.LayerNorm)
if len(inp.size()) == 3:
inp = inp.unsqueeze(0)
if len(out.size()) == 3:
out = out.unsqueeze(0)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
in_c, in_h, in_w = inp.size()[1:]
# 1. sub mean
# 2. div standard deviation
# 3. mul alpha
# 4. add beta
return 4 * in_h * in_w
def compute_BatchNorm2d_madd(module, inp, out):
assert isinstance(module, nn.BatchNorm2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
in_c, in_h, in_w = inp.size()[1:]
# 1. sub mean
# 2. div standard deviation
# 3. mul alpha
# 4. add beta
return 4 * in_c * in_h * in_w
def compute_MaxPool2d_madd(module, inp, out):
assert isinstance(module, nn.MaxPool2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
if isinstance(module.kernel_size, (tuple, list)):
k_h, k_w = module.kernel_size
else:
k_h, k_w = module.kernel_size, module.kernel_size
out_c, out_h, out_w = out.size()[1:]
return (k_h * k_w - 1) * out_h * out_w * out_c
def compute_AvgPool2d_madd(module, inp, out):
assert isinstance(module, nn.AvgPool2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
if isinstance(module.kernel_size, (tuple, list)):
k_h, k_w = module.kernel_size
else:
k_h, k_w = module.kernel_size, module.kernel_size
out_c, out_h, out_w = out.size()[1:]
kernel_add = k_h * k_w - 1
kernel_avg = 1
return (kernel_add + kernel_avg) * (out_h * out_w) * out_c
def compute_ReLU_madd(module, inp, out):
assert isinstance(module, (nn.ReLU, nn.ReLU6))
count = 1
for i in inp.size()[1:]:
count *= i
return count
def compute_Softmax_madd(module, inp, out):
assert isinstance(module, nn.Softmax)
assert len(inp.size()) > 1
count = 1
for s in inp.size()[1:]:
count *= s
exp = count
add = count - 1
div = count
return exp + add + div
def compute_Linear_madd(module, inp, out):
assert isinstance(module, nn.Linear)
if len(inp.size()) > 3:
inp = inp.reshape(inp.size(0), inp.size(1), -1)
if len(out.size()) > 3:
out = out.reshape(out.size(0), out.size(1), -1)
if len(inp.size()) == 3:# and inp.size(0) == 1
inp = inp[0, ...]#.squeeze(0)
if len(out.size()) == 3:# and out.size(0) == 1
out = out[0, ...]#.squeeze(0)
assert len(inp.size()) == 2 and len(out.size()) == 2, print(inp.size(), out.size())
num_in_features = inp.size()[1]
num_out_features = out.size()[1]
mul = num_in_features
add = num_in_features - 1
return num_out_features * (mul + add)
def compute_Bilinear_madd(module, inp1, inp2, out):
assert isinstance(module, nn.Bilinear)
assert len(inp1.size()) == 2 and len(inp2.size()) == 2 and len(out.size()) == 2
num_in_features_1 = inp1.size()[1]
num_in_features_2 = inp2.size()[1]
num_out_features = out.size()[1]
mul = num_in_features_1 * num_in_features_2 + num_in_features_2
add = num_in_features_1 * num_in_features_2 + num_in_features_2 - 1
return num_out_features * (mul + add)
def compute_madd(module, inp, out):
if isinstance(module, nn.Conv2d):
return compute_Conv2d_madd(module, inp, out)
elif isinstance(module, nn.ConvTranspose2d):
return compute_ConvTranspose2d_madd(module, inp, out)
elif isinstance(module, nn.BatchNorm2d):
return compute_BatchNorm2d_madd(module, inp, out)
elif isinstance(module, nn.LayerNorm) or 'LayerNorm' in type(module).__name__:
return compute_LayerNorm_madd(module, inp, out)
elif isinstance(module, nn.MaxPool2d):
return compute_MaxPool2d_madd(module, inp, out)
elif isinstance(module, nn.AvgPool2d):
return compute_AvgPool2d_madd(module, inp, out)
elif isinstance(module, (nn.ReLU, nn.ReLU6)):
return compute_ReLU_madd(module, inp, out)
elif isinstance(module, nn.Softmax):
return compute_Softmax_madd(module, inp, out)
elif isinstance(module, nn.Linear):
return compute_Linear_madd(module, inp, out)
elif isinstance(module, nn.Bilinear):
return compute_Bilinear_madd(module, inp[0], inp[1], out)
else:
print(f"[MAdd]: {type(module).__name__} is not supported!")
return 0
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_memory.py
================================================
import torch.nn as nn
import torch
import numpy as np
def compute_memory(module, inp, out):
if isinstance(module, (nn.ReLU, nn.ReLU6, nn.ELU, nn.LeakyReLU)):
return compute_ReLU_memory(module, inp, out)
elif isinstance(module, nn.PReLU):
return compute_PReLU_memory(module, inp, out)
elif isinstance(module, nn.Conv2d):
return compute_Conv2d_memory(module, inp, out)
elif isinstance(module, nn.BatchNorm2d):
return compute_BatchNorm2d_memory(module, inp, out)
elif isinstance(module, nn.LayerNorm) or 'LayerNorm' in type(module).__name__:
return compute_LayerNorm_memory(module, inp, out)
elif isinstance(module, nn.Linear):
return compute_Linear_memory(module, inp, out)
elif isinstance(module, (nn.AvgPool2d, nn.MaxPool2d)):
return compute_Pool2d_memory(module, inp, out)
else:
print(f"[Memory]: {type(module).__name__} is not supported!")
return (0, 0)
pass
def num_params(module):
return sum(p.numel() for p in module.parameters() if p.requires_grad)
def compute_ReLU_memory(module, inp, out):
assert isinstance(module, (nn.ReLU, nn.ReLU6, nn.ELU, nn.LeakyReLU))
batch_size = inp.size()[0]
mread = batch_size * inp.size()[1:].numel()
mwrite = batch_size * inp.size()[1:].numel()
return (mread, mwrite)
def compute_PReLU_memory(module, inp, out):
assert isinstance(module, (nn.PReLU))
batch_size = inp.size()[0]
mread = batch_size * (inp.size()[1:].numel() + num_params(module))
mwrite = batch_size * inp.size()[1:].numel()
return (mread, mwrite)
def compute_Conv2d_memory(module, inp, out):
# Can have multiple inputs, getting the first one
assert isinstance(module, nn.Conv2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
batch_size = inp.size()[0]
in_c = inp.size()[1]
out_c, out_h, out_w = out.size()[1:]
# This includes weighs with bias if the module contains it.
mread = batch_size * (inp.size()[1:].numel() + num_params(module))
mwrite = batch_size * out_c * out_h * out_w
return (mread, mwrite)
def compute_BatchNorm2d_memory(module, inp, out):
assert isinstance(module, nn.BatchNorm2d)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
batch_size, in_c, in_h, in_w = inp.size()
mread = batch_size * (inp.size()[1:].numel() + 2 * in_c)
mwrite = inp.size().numel()
return (mread, mwrite)
def compute_LayerNorm_memory(module, inp, out):
# assert isinstance(module, nn.LayerNorm)
if len(inp.size()) == 3:
inp = inp.unsqueeze(0)
if len(out.size()) == 3:
out = out.unsqueeze(0)
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
batch_size, in_c = inp.size()[:2]
mread = batch_size * (inp.size()[2:].numel() + 2 * in_c)
mwrite = inp.size().numel()
return (mread, mwrite)
def compute_Linear_memory(module, inp, out):
assert isinstance(module, nn.Linear)
if len(inp.size()) > 3:
inp = inp.reshape(inp.size(0), inp.size(1), -1)
if len(out.size()) > 3:
out = out.reshape(out.size(0), out.size(1), -1)
batch_size = inp.size()[0]
if len(inp.size()) == 3:# and inp.size(0) == 1:
inp = inp[0, ...]#.squeeze(0)
if len(out.size()) == 3:# and out.size(0) == 1:
out = out[0, ...]#.squeeze(0)
assert len(inp.size()) == 2 and len(out.size()) == 2
mread = batch_size * (inp.size()[1:].numel() + num_params(module))
mwrite = out.size().numel()
return (mread, mwrite)
def compute_Pool2d_memory(module, inp, out):
assert isinstance(module, (nn.MaxPool2d, nn.AvgPool2d))
assert len(inp.size()) == 4 and len(inp.size()) == len(out.size())
batch_size = inp.size()[0]
mread = batch_size * inp.size()[1:].numel()
mwrite = batch_size * out.size()[1:].numel()
return (mread, mwrite)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/model_hook.py
================================================
import time
from collections import OrderedDict
import numpy as np
import torch
import torch.nn as nn
from functools import partial
from torchstat import compute_madd
from torchstat import compute_flops
from torchstat import compute_memory
class ModelHook(object):
def __init__(self, model, input_size, device="cuda", debug_layers=[]):
assert isinstance(model, nn.Module)
assert isinstance(input_size, (list, tuple))
self.leaf_modules = []
self.debug_layers = debug_layers
self._model = model
self._input_size = input_size
self._origin_call = dict() # sub module call hook
self.hooks = []
self._hook_model()
# x = [torch.rand(1, *self._input_size)] # add module duration time
device = device.lower()
assert device in [
"cuda",
"cpu",
], "Input device is not valid, please specify 'cuda' or 'cpu'"
if device == "cuda" and torch.cuda.is_available():
dtype = torch.cuda.FloatTensor
else:
dtype = torch.FloatTensor
x = [torch.rand(*in_size).type(dtype) for in_size in input_size]
self._model.eval()
self._model(*x)
# if len(debug_layers) > 0:
# self.debug_partial_layer(debug_layers)
@staticmethod
def _register_buffer(module):
assert isinstance(module, nn.Module)
if len(list(module.children())) > 0:
return
module.register_buffer('input_shape', torch.zeros(3).int())
module.register_buffer('output_shape', torch.zeros(3).int())
module.register_buffer('parameter_quantity', torch.zeros(1).int())
module.register_buffer('inference_memory', torch.zeros(1).long())
module.register_buffer('MAdd', torch.zeros(1).long())
module.register_buffer('duration', torch.zeros(1).float())
module.register_buffer('Flops', torch.zeros(1).long())
module.register_buffer('Memory', torch.zeros(2).long())
def _sub_module_call_hook(self):
def wrap_call(module, *input, **kwargs):
assert module.__class__ in self._origin_call
# Itemsize for memory
try:
itemsize = input[0].detach().numpy().itemsize
except:
itemsize = input[0].detach().cpu().numpy().itemsize
start = time.time()
output = self._origin_call[module.__class__](module, *input, **kwargs) # 都是nn.Conv2D则有相同的_call__不需要重复存储
end = time.time()
module.duration = torch.from_numpy(
np.array([end - start], dtype=np.float32))
# c, h, w
module.input_shape = torch.from_numpy(
np.array(input[0].size()[1:], dtype=np.int32))
module.output_shape = torch.from_numpy(
np.array(output.size()[1:], dtype=np.int32))
# print(module.name)
parameter_quantity = 0
inference_memory = 1
# iterate through parameters and count num params
if 'XCTEB' in module.__class__.__name__:
c, h, w = module.input_shape
num_heads = module.num_heads
parameter_quantity += c * c * num_heads
elif 'SwinTEB' in module.__class__.__name__:
if len(module.input_shape) == 3:
# c, h, w = module.input_shape # c, h, w
_, N, c = module.input_shape
# N = h * w
elif len(module.input_shape) == 2:
N = module.input_shape[0]
num_heads = module.num_heads
# hh = nH * h WindowAttention只减少了flops并没有减少显存占用，因此参数量按照图像大小算
parameter_quantity += N * N * num_heads
print(parameter_quantity, N, module.input_shape)
elif 'MSA' == module.__class__.__name__:
# L, B, D
# if hasattr(module, '__name__'):
# print('model.body.decoder.layers.0.self_attn')
# print(module.__name__, module.input_shape)
module.input_shape = torch.from_numpy(
np.array(input[0].permute(1, 2, 0).size()[1:], dtype=np.int32))
c, L = module.input_shape
num_heads = module.num_heads
parameter_quantity += L * L * num_heads
# print(L, c)
elif 'MSA_BNC' == module.__class__.__name__:
# B, L, C
module.input_shape = torch.from_numpy(
np.array(input[0].permute(0, 2, 1).size()[1:], dtype=np.int32))
c, L = module.input_shape
num_heads = module.num_heads
parameter_quantity += L * L * num_heads
# print(L, c)
elif 'sGCN' == module.__class__.__name__:
module.input_shape = torch.from_numpy(
np.array(input[0][0].permute(0, 2, 1).size(), dtype=np.int32))
c, H, W = module.input_shape
c = c // 2
parameter_quantity += c * c
elif 'cGCN' == module.__class__.__name__:
module.input_shape = torch.from_numpy(
np.array(input[0][0].permute(0, 2, 1).size(), dtype=np.int32))
c, H, W = module.input_shape
c = c // 2
parameter_quantity += c * c // 2
else:
for s in output.size()[1:]:
inference_memory *= s
# memory += parameters_number # exclude parameter memory
for name, p in module._parameters.items():
parameter_quantity += (0 if p is None else torch.numel(p.data))
module.parameter_quantity = torch.from_numpy(
np.array([parameter_quantity], dtype=np.long))
inference_memory = inference_memory * 4 / (1024 ** 2) # shown as MB unit
module.inference_memory = torch.from_numpy(
np.array([inference_memory], dtype=np.float32))
if len(input) == 1:
madd = compute_madd(module, input[0], output)
flops = compute_flops(module, input[0], output)
Memory = compute_memory(module, input[0], output)
elif len(input) > 1:
madd = compute_madd(module, input, output)
flops = compute_flops(module, input, output)
Memory = compute_memory(module, input, output)
else: # error
madd = 0
flops = 0
Memory = (0, 0)
module.MAdd = torch.from_numpy(
np.array([madd], dtype=np.int64))
module.Flops = torch.from_numpy(
np.array([flops], dtype=np.int64))
Memory = np.array(Memory, dtype=np.int64) * itemsize
module.Memory = torch.from_numpy(Memory)
return output
leaf_modules = self.leaf_modules
# for m in self._model.modules():
# print(m.__class__)
for name, module in self._model.named_modules():
if len(list(module.children())) == 0:
module.name = name
leaf_modules.append((name, module))
if module.__class__ not in self._origin_call:
# 只记录一类与具体实例无关的__call__
self._origin_call[module.__class__] = module.__class__.__call__
module.__class__.__call__ = wrap_call
elif name != '' and len(list(module.children())) > 0 and any([L in module.__class__.__name__ for L in self.debug_layers]):
#name in self.debug_layers:# module.__class__.__name__ in self.debug_layers
# if module.__class__.__name__ in self.debug_layers:
# print("111")
leaf_modules.append((name, module))
if module.__class__ not in self._origin_call:
self._origin_call[module.__class__] = module.__class__.__call__
module.__class__.__call__ = wrap_call
print(name, module.__class__.__name__)
# for module in self._model.modules():
# if len(list(module.children())) == 0 and module.__class__ not in self._origin_call:
# self.hooks.append(module.register_forward_hook(wrap_call))
def _hook_model(self):
self._model.apply(self._register_buffer)
self._sub_module_call_hook()
def clear_hooks(self) -> None:
"""Clear model hooks"""
# for handle in self.hook_handles:
# handle.pop()
def unwarp_calls(module):
if module.__class__ in self._origin_call:
module.__class__.__call__ = self._origin_call[module.__class__]
# module.__delattr__('__name__')
calls = list(map(unwarp_calls, self._model.modules()))
del calls
# for module in self._model.modules():
# if module.__class__ in self._origin_call:
# module.__class__.__call__ = self._origin_call[module.__class__]
# @staticmethod
# def _retrieve_leaf_modules(model):
# leaf_modules = []
# for name, m in model.named_modules():
# if len(list(m.children())) == 0:
# leaf_modules.append((name, m))
# return leaf_modules
def retrieve_leaf_modules(self):
return OrderedDict(self.leaf_modules)
# return OrderedDict(self._retrieve_leaf_modules(self._model))
def debug_partial_layer(self, target_keys):
target_layers = []
submodule_name = dict(list(self._model.named_modules())[1:]).keys()
for t in target_keys:
for name in submodule_name:
if t in name:
target_layers.append(name)
return target_layers
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/reporter.py
================================================
import pandas as pd
pd.set_option('display.width', 1000)
pd.set_option('display.max_rows', 10000)
pd.set_option('display.max_columns', 10000)
def round_value(value, binary=False):
divisor = 1024. if binary else 1000.
if value // divisor**4 > 0:
return str(round(value / divisor**4, 2)) + 'T'
elif value // divisor**3 > 0:
return str(round(value / divisor**3, 2)) + 'G'
elif value // divisor**2 > 0:
return str(round(value / divisor**2, 2)) + 'M'
elif value // divisor > 0:
return str(round(value / divisor, 2)) + 'K'
return str(value)
def report_format(collected_nodes):
data = list()
properties = list()
for node in collected_nodes:
name = node.name
mtype = node.mtype
input_shape = ' '.join(['{:>3d}'] * len(node.input_shape)).format(
*[e for e in node.input_shape])
output_shape = ' '.join(['{:>3d}'] * len(node.output_shape)).format(
*[e for e in node.output_shape])
parameter_quantity = node.parameter_quantity
inference_memory = node.inference_memory
MAdd = node.MAdd
Flops = node.Flops
mread, mwrite = [i for i in node.Memory]
duration = node.duration
data.append([name, input_shape, output_shape, parameter_quantity,
inference_memory, MAdd, duration, Flops, mread,
mwrite])
properties.append(mtype)
pd.set_option('display.max_columns', None)
df = pd.DataFrame(data)
df_properties = pd.DataFrame(properties)
df.columns = ['module name', 'input shape', 'output shape',
'params', 'memory(MB)',
'MAdd', 'duration', 'Flops', 'MemRead(B)', 'MemWrite(B)']
df['duration[%]'] = df['duration'] / (df['duration'].sum() + 1e-7)
df['MemR+W(B)'] = df['MemRead(B)'] + df['MemWrite(B)']
df['type'] = df_properties
total_parameters_quantity = df['params'].sum()
total_memory = df['memory(MB)'].sum()
total_operation_quantity = df['MAdd'].sum()
total_flops = df['Flops'].sum()
total_duration = df['duration[%]'].sum()
total_mread = df['MemRead(B)'].sum()
total_mwrite = df['MemWrite(B)'].sum()
total_memrw = df['MemR+W(B)'].sum()
del df['duration']
# Add Total row
total_df = pd.Series([total_parameters_quantity, total_memory,
total_operation_quantity, total_flops,
total_duration, mread, mwrite, total_memrw],
index=['params', 'memory(MB)', 'MAdd', 'Flops', 'duration[%]',
'MemRead(B)', 'MemWrite(B)', 'MemR+W(B)'],
name='total')
# df_properties = pd.DataFrame(properties, columns=['type'])
df = df.append([total_df])
df = df.fillna(' ')
df['memory(MB)'] = df['memory(MB)'].apply(
lambda x: '{:.2f}'.format(x))
df['duration[%]'] = df['duration[%]'].apply(lambda x: '{:.2%}'.format(x))
df['MAdd'] = df['MAdd'].apply(lambda x: '{:,}'.format(x))
df['Flops'] = df['Flops'].apply(lambda x: '{:,}'.format(x))
summary = str(df) + '\n'
summary += "=" * len(str(df).split('\n')[0])
summary += '\n'
summary += "Total params: {:,}\n".format(total_parameters_quantity)
summary += "-" * len(str(df).split('\n')[0])
summary += '\n'
summary += "Total memory: {:.2f}MB\n".format(total_memory)
summary += "Total MAdd: {}MAdd\n".format(round_value(total_operation_quantity))
summary += "Total Flops: {}Flops\n".format(round_value(total_flops))
summary += "Total MemR+W: {}B\n".format(round_value(total_memrw, True))
return summary
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/stat_tree.py
================================================
import queue
class StatTree(object):
def __init__(self, root_node):
assert isinstance(root_node, StatNode)
self.root_node = root_node
def get_same_level_max_node_depth(self, query_node):
if query_node.name == self.root_node.name:
return 0
same_level_depth = max([child.depth for child in query_node.parent.children])
return same_level_depth
def update_stat_nodes_granularity(self):
q = queue.Queue()
q.put(self.root_node)
while not q.empty():
node = q.get()
node.granularity = self.get_same_level_max_node_depth(node)
for child in node.children:
q.put(child)
def get_collected_stat_nodes(self, debug_layers, query_granularity):
self.update_stat_nodes_granularity()
collected_nodes = []
stack = list()
stack.append(self.root_node)
while len(stack) > 0:
node = stack.pop()
if any([L in node.mtype for L in debug_layers]): #node.name
collected_nodes.append(node)
for child in reversed(node.children):
stack.append(child)
if node.depth == query_granularity:
collected_nodes.append(node)
if node.depth < query_granularity <= node.granularity:
collected_nodes.append(node)
return collected_nodes
class StatNode(object):
def __init__(self, name=str(), mtype=str(), parent=None):
self._name = name
self._mtype = mtype
self._input_shape = None
self._output_shape = None
self._parameter_quantity = 0
self._inference_memory = 0
self._MAdd = 0
self._Memory = (0, 0)
self._Flops = 0
self._duration = 0
self._duration_percent = 0
self._granularity = 1
self._depth = 1
self.parent = parent
self.children = list()
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
@property
def mtype(self):
return self._mtype
@mtype.setter
def mtype(self, mtype):
self._mtype = mtype
@property
def granularity(self):
return self._granularity
@granularity.setter
def granularity(self, g):
self._granularity = g
@property
def depth(self):
d = self._depth
if len(self.children) > 0:
d += max([child.depth for child in self.children])
return d
@property
def input_shape(self):
if len(self.children) == 0: # leaf
return self._input_shape
else:
return self.children[0].input_shape
@input_shape.setter
def input_shape(self, input_shape):
assert isinstance(input_shape, (list, tuple))
self._input_shape = input_shape
@property
def output_shape(self):
if len(self.children) == 0: # leaf
return self._output_shape
else:
return self.children[-1].output_shape
@output_shape.setter
def output_shape(self, output_shape):
assert isinstance(output_shape, (list, tuple))
self._output_shape = output_shape
@property
def parameter_quantity(self):
# return self.parameters_quantity
total_parameter_quantity = self._parameter_quantity
# for child in self.children:
# total_parameter_quantity += child.parameter_quantity
return total_parameter_quantity
@parameter_quantity.setter
def parameter_quantity(self, parameter_quantity):
assert parameter_quantity >= 0
self._parameter_quantity = parameter_quantity
@property
def inference_memory(self):
total_inference_memory = self._inference_memory
for child in self.children:
total_inference_memory += child.inference_memory
return total_inference_memory
@inference_memory.setter
def inference_memory(self, inference_memory):
self._inference_memory = inference_memory
@property
def MAdd(self):
total_MAdd = self._MAdd
# for child in self.children:
# total_MAdd += child.MAdd
return total_MAdd
@MAdd.setter
def MAdd(self, MAdd):
self._MAdd = MAdd
@property
def Flops(self):
total_Flops = self._Flops
# for child in self.children:
# total_Flops += child.Flops
return total_Flops
@Flops.setter
def Flops(self, Flops):
self._Flops = Flops
@property
def Memory(self):
total_Memory = self._Memory
# for child in self.children:
# total_Memory[0] += child.Memory[0]
# total_Memory[1] += child.Memory[1]
# print(total_Memory)
return total_Memory
@Memory.setter
def Memory(self, Memory):
assert isinstance(Memory, (list, tuple))
self._Memory = Memory
@property
def duration(self):
total_duration = self._duration
# for child in self.children:
# total_duration += child.duration
return total_duration
@duration.setter
def duration(self, duration):
self._duration = duration
def find_child_index(self, child_name):
assert isinstance(child_name, str)
index = -1
for i in range(len(self.children)):
if child_name == self.children[i].name:
index = i
return index
def add_child(self, node):
assert isinstance(node, StatNode)
if self.find_child_index(node.name) == -1: # not exist
self.children.append(node)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/statistics.py
================================================
import torch
import torch.nn as nn
from torchstat import ModelHook
from collections import OrderedDict
from torchstat import StatTree, StatNode, report_format
def get_parent_node(root_node, stat_node_name):
assert isinstance(root_node, StatNode)
node = root_node
names = stat_node_name.split('.')
for i in range(len(names) - 1):
node_name = '.'.join(names[0:i+1])
child_index = node.find_child_index(node_name)
assert child_index != -1
node = node.children[child_index]
return node
def convert_leaf_modules_to_stat_tree(leaf_modules):
assert isinstance(leaf_modules, OrderedDict)
create_index = 1
root_node = StatNode(name='root', parent=None)
for leaf_module_name, leaf_module in leaf_modules.items():
if 'model.body.decoder.layers.0.self_attn' in leaf_module_name:
print("111", leaf_module_name, leaf_module.__class__.__name__)
names = leaf_module_name.split('.')
for i in range(len(names)):
create_index += 1
stat_node_name = '.'.join(names[0:i+1])
parent_node = get_parent_node(root_node, stat_node_name)
node = StatNode(name=stat_node_name, mtype=leaf_module.__base__ if hasattr(leaf_module, '__base__') else leaf_module.__class__.__name__, parent=parent_node)#.__class__.__name__
parent_node.add_child(node)
if i == len(names) - 1: # leaf module itself
input_shape = leaf_module.input_shape.numpy().tolist()
output_shape = leaf_module.output_shape.numpy().tolist()
node.input_shape = input_shape
node.output_shape = output_shape
node.parameter_quantity = leaf_module.parameter_quantity.numpy()[0]
node.inference_memory = leaf_module.inference_memory.numpy()[0]
node.MAdd = leaf_module.MAdd.numpy()[0]
node.Flops = leaf_module.Flops.numpy()[0]
node.duration = leaf_module.duration.numpy()[0]
node.Memory = leaf_module.Memory.numpy().tolist()
return StatTree(root_node)
class ModelStat(object):
def __init__(self, model, input_size, query_granularity=1, debug_layers=[]):
assert isinstance(model, nn.Module)
# assert isinstance(input_size, (tuple, list)) and len(input_size) == 3
self._model = model
self._input_size = input_size
self._query_granularity = query_granularity
self.debug_layers = debug_layers
def _analyze_model(self):
model_hook = ModelHook(self._model, self._input_size, debug_layers=self.debug_layers)
leaf_modules = model_hook.retrieve_leaf_modules()
stat_tree = convert_leaf_modules_to_stat_tree(leaf_modules)
collected_nodes = stat_tree.get_collected_stat_nodes(self.debug_layers, self._query_granularity)
model_hook.clear_hooks()
return collected_nodes
def show_report(self):
collected_nodes = self._analyze_model()
report = report_format(collected_nodes)
print(report)
def stat(model, input_size, query_granularity=1, debug_layers=["MSA", "SwinTEB", "XCTEB", "MSA_BNC", 'cGCN', 'sGCN']):
ms = ModelStat(model, input_size, query_granularity, debug_layers)
ms.show_report()
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/utils.py
================================================
import os
import datetime
import torch
import psutil
from collections import defaultdict, deque
import time
import sys
sys.path.append('../..')
sys.path.append('../mmcv')
from mmcv.utils.logging import print_log
import numpy as np
import random
import torch.backends.cudnn as cudnn
import torch.distributed as dist
from functools import partial
def get_dist_info():
if dist.is_available() and dist.is_initialized():
rank = dist.get_rank()
world_size = dist.get_world_size()
else:
rank = 0
world_size = 1
return rank, world_size
def init_random_seed(seed=None, device='cuda'):
"""Initialize random seed.
If the seed is not set, the seed will be automatically randomized,
and then broadcast to all processes to prevent some potential bugs.
Args:
seed (int, Optional): The seed. Default to None.
device (str): The device where the seed will be put on.
Default to 'cuda'.
Returns:
int: Seed to be used.
"""
if seed is not None:
return seed
# Make sure all ranks share the same random seed to prevent
# some potential bugs. Please refer to
# https://github.com/open-mmlab/mmdetection/issues/6339
rank, world_size = get_dist_info()
seed = np.random.randint(2**31)
if world_size == 1:
return seed
if rank == 0:
random_num = torch.tensor(seed, dtype=torch.int32, device=device)
else:
random_num = torch.tensor(0, dtype=torch.int32, device=device)
dist.broadcast(random_num, src=0)
return random_num.item()
def set_random_seed(seed, deterministic=True):
"""Set random seed.
Args:
seed (int): Seed to be used.
deterministic (bool): Whether to set the deterministic option for
CUDNN backend, i.e., set `torch.backends.cudnn.deterministic`
to True and `torch.backends.cudnn.benchmark` to False.
Default: False.
"""
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
if deterministic:
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# def set_random_seed(seed):
# np.random.seed(seed)
# random.seed(seed)
# torch.manual_seed(seed)
# torch.cuda.manual_seed(seed)
# torch.cuda.manual_seed_all(seed)
# cudnn.deterministic = True
def show_memory_info(hint):
pid = os.getpid()
p = psutil.Process(pid)
info = p.memory_full_info()
memory = info.uss / 1024. / 1024
print('{} memory used: {} MB'.format(hint, memory))
# class OrderedAverageMeter(object):
# def __init__(self):
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self, name=None, fmt=":f"):
# self.name = name
# self.fmt = fmt
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
# def __str__(self):
# fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
# return fmtstr.format(**self.__dict__)
class ProgressMeter(object):
def __init__(self, num_batches, meters, prefix=""):
self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
self.meters = meters
self.prefix = prefix
def display(self, batch):
entries = [self.prefix + self.batch_fmtstr.format(batch)]
entries += [str(meter) for meter in self.meters]
print('\t'.join(entries))
def _get_batch_fmtstr(self, num_batches):
num_digits = len(str(num_batches // 1))
fmt = '{:' + str(num_digits) + 'd}'
return '[' + fmt + '/' + fmt.format(num_batches) + ']'
def accuracy(output, target, topk=(1,)):
"""Computes the precision@k for the specified values of k"""
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res
# class logger():
# def __init__(self, obj, LOG_DIR, parser):
# logname = 'log_train' + datetime.datetime.now().strftime('%Y_%m_%d-%H_%M_%S')+'.txt'
# self.LOG_FOUT = open(os.path.join(LOG_DIR, logname), 'w')
# self.LOG_FOUT.write(str(parser)+'\n')
# def __call__(self, out_str):
# self.LOG_FOUT.write(out_str+'\n')
# self.LOG_FOUT.flush()
# print(out_str)
def is_dist_avail_and_initialized():
if not dist.is_available():
return False
if not dist.is_initialized():
return False
return True
class SmoothedValue(object):
"""Track a series of values and provide access to smoothed values over a
window or the global series average.
"""
def __init__(self, window_size=20, fmt=None, eval=False):
if fmt is None:
if not eval:
fmt = "{value:.7f} (avg:{avg:.7f})"
else:
fmt = "{value:.7f} (avg:{avg:.7f}, std:{std:.7f})"
self.reset(window_size)
self.fmt = fmt
def reset(self, window_size):
self.deque = deque(maxlen=window_size)
self.val = 0
self.avg = 0
self.total = 0
self.count = 0
def update(self, value, n=1):
self.deque.append(value)
self.val = value
self.count += n
self.total += value * n
self.avg = self.total / self.count
def synchronize_between_processes(self):
"""
Warning: does not synchronize the deque!
"""
if not is_dist_avail_and_initialized():
return
t = torch.tensor([self.val, self.count, self.total], dtype=torch.float64, device='cuda')
dist.barrier()
dist.all_reduce(t)
t = t.tolist()
self.val = t[0]
self.count = int(t[1])
self.total = t[2]
self.avg = self.total / self.count
@property
def median(self):
d = torch.tensor(list(self.deque))
return d.median().item()
@property
def std(self):
return torch.tensor(list(self.deque)).std().item()
# @property
# def avg(self):
# d = torch.tensor(list(self.deque), dtype=torch.float32)
# return d.mean().item()
# @property
# def global_avg(self):
# return self.total / self.count
@property
def max(self):
return max(self.deque)
#
# @property
# def value(self):
# return self.deque[-1]
def __str__(self):
# return self.fmt.format(
# median=self.median,
# avg=self.avg,
# global_avg=self.global_avg,
# max=self.max,
# value=self.value)
return self.fmt.format(
median=self.median,
avg=self.avg,
max=self.max,
value=self.val,
std=self.std)
class MetricLogger(object):
def __init__(self, logger=None, delimiter="\t", dist_print=0, window_size=20, eval=False):
self.meters = defaultdict(partial(SmoothedValue, window_size=window_size, eval=eval))
self.delimiter = delimiter
self.dist_print = dist_print
# self.log = get_root_logger("UDL")
# self.logger = logger
# {k:v}打印，对每个k都有val、avg、max、deque属性
def update(self, **kwargs):
# dist.barrier()
for k, v in kwargs.items():
if isinstance(v, torch.Tensor):
v = torch.mean(v)
if hasattr(v, 'item'):
v = v.item()
assert isinstance(v, (float, int, str)), print("type: ", type(v))
self.meters[k].update(v)
# {k:v}打印，对每个k都有val、avg、max、deque属性
def update_dict(self, kwargs: dict):
# dist.barrier()
for k, v in kwargs.items():
if isinstance(v, torch.Tensor):
v = torch.mean(v)
if hasattr(v, 'item'):
v = v.item()
assert isinstance(v, (float, int, str)), print("type: ", type(v))
self.meters[k].update(v)
def __getattr__(self, attr):
if attr in self.meters:
return self.meters[attr]
if attr in self.__dict__:
return self.__dict__[attr]
raise AttributeError("'{}' object has no attribute '{}'".format(
type(self).__name__, attr))
def __str__(self):
loss_str = []
for name, meter in self.meters.items():
loss_str.append(
"{}: {}".format(name, str(meter))
)
return self.delimiter.join(loss_str)
def synchronize_between_processes(self):
for meter in self.meters.values():
meter.synchronize_between_processes()
def add_meter(self, name, meter):
self.meters[name] = meter
def clear(self):
self.meters.clear()
def log_every(self, iterable, print_freq, header=None):
i = 1
if not header:
header = ''
start_time = time.time()
end = time.time()
iter_time = SmoothedValue(fmt='{avg:.4f}')
data_time = SmoothedValue(fmt='{avg:.4f}')
space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
if torch.cuda.is_available():
log_msg = self.delimiter.join([
header,
'[{0' + space_fmt + '}/{1}]',
'eta: {eta}',
'{meters}',
'time: {time}',
'data: {data}',
'max mem: {memory:.0f}MB'
])
else:
log_msg = self.delimiter.join([
header,
'[{0' + space_fmt + '}/{1}]',
'eta: {eta}',
'{meters}',
'time: {time}',
'data: {data}'
])
MB = 1024.0 * 1024.0
# log_string = self.logger.info
for obj in iterable:
data_time.update(time.time() - end)
yield obj, i
iter_time.update(time.time() - end)
if i % print_freq == 0 or i == len(iterable):
eta_seconds = iter_time.avg * (len(iterable) - i)
eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
if torch.cuda.is_available():
if self.dist_print == 0:
print_log(log_msg.format(
i, len(iterable), eta=eta_string,
meters=str(self),
time=str(iter_time), data=str(data_time),
memory=torch.cuda.max_memory_allocated() / MB))
else:
print_log(log_msg.format(
i, len(iterable), eta=eta_string,
meters=str(self),
time=str(iter_time), data=str(data_time)))
i += 1
end = time.time()
total_time = time.time() - start_time
total_time_str = str(datetime.timedelta(seconds=int(total_time)))
if self.dist_print == 0:
print_log('{} Total time: {} ({:.4f} s / it)'.format(
header, total_time_str, total_time / len(iterable)))
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/cal_ssim.py
================================================
# GPL License
# Copyright (C) UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import numpy as np
from math import exp
def gaussian(window_size, sigma):
gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])
return gauss/gauss.sum()
def create_window(window_size, channel, sigma=1.5):
_1D_window = gaussian(window_size, sigma).unsqueeze(1)
_2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous())
return window
def _ssim(img1, img2, window, window_size, channel, size_average = True):
mu1 = F.conv2d(img1, window, padding = window_size//2, groups = channel)
mu2 = F.conv2d(img2, window, padding = window_size//2, groups = channel)
mu1_sq = mu1.pow(2)
mu2_sq = mu2.pow(2)
mu1_mu2 = mu1*mu2
sigma1_sq = F.conv2d(img1*img1, window, padding = window_size//2, groups = channel) - mu1_sq
sigma2_sq = F.conv2d(img2*img2, window, padding = window_size//2, groups = channel) - mu2_sq
sigma12 = F.conv2d(img1*img2, window, padding = window_size//2, groups = channel) - mu1_mu2
C1 = 0.01**2
C2 = 0.03**2
ssim_map = ((2*mu1_mu2 + C1)*(2*sigma12 + C2))/((mu1_sq + mu2_sq + C1)*(sigma1_sq + sigma2_sq + C2))
if size_average:
return ssim_map.mean()
else:
return ssim_map.mean(1).mean(1).mean(1)
class SSIM(torch.nn.Module):
def __init__(self, win_size=11, win_sigma=1.5, data_range=1, size_average=True, channel=3):
super(SSIM, self).__init__()
self.window_size = win_size
self.size_average = size_average
self.channel = channel
self.window = create_window(win_size, self.channel, win_sigma)
self.win_sigma = win_sigma
def forward(self, img1, img2):
#print(img1.size())
(_, channel, _, _) = img1.size()
if channel == self.channel and self.window.data.type() == img1.data.type():
window = self.window
else:
window = create_window(self.window_size, channel, self.win_sigma)
if img1.is_cuda:
window = window.cuda(img1.get_device())
window = window.type_as(img1)
self.window = window
self.channel = channel
return _ssim(img1, img2, window, self.window_size, channel, self.size_average)
def ssim(img1, img2, win_size = 11, data_range=1, size_average = True):
(_, channel, _, _) = img1.size()
window = create_window(win_size, channel)
if img1.is_cuda:
window = window.cuda(img1.get_device())
window = window.type_as(img1)
return _ssim(img1, img2, window, win_size, channel, size_average)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/config.py
================================================
# Copyright (c) Open-MMLab. All rights reserved.
# GPL License
# Copyright (C) UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import ast
import copy
import os
import os.path as osp
import platform
import shutil
import sys
import tempfile
import uuid
import warnings
from argparse import Action, ArgumentParser, Namespace
from collections import abc
from importlib import import_module
from addict import Dict
from yapf.yapflib.yapf_api import FormatCode
# from .misc import import_modules_from_strings
# from .path import check_file_exist
def import_modules_from_strings(imports, allow_failed_imports=False):
"""Import modules from the given list of strings.
Args:
imports (list | str | None): The given module names to be imported.
allow_failed_imports (bool): If True, the failed imports will return
None. Otherwise, an ImportError is raise. Default: False.
Returns:
list[module] | module | None: The imported modules.
Examples:
>>> osp, sys = import_modules_from_strings(
... ['os.path', 'sys'])
>>> import os.path as osp_
>>> import sys as sys_
>>> assert osp == osp_
>>> assert sys == sys_
"""
if not imports:
return
single_import = False
if isinstance(imports, str):
single_import = True
imports = [imports]
if not isinstance(imports, list):
raise TypeError(
f'custom_imports must be a list but got type {type(imports)}')
imported = []
for imp in imports:
if not isinstance(imp, str):
raise TypeError(
f'{imp} is of type {type(imp)} and cannot be imported.')
try:
imported_tmp = import_module(imp)
except ImportError:
if allow_failed_imports:
warnings.warn(f'{imp} failed to import and is ignored.',
UserWarning)
imported_tmp = None
else:
raise ImportError
imported.append(imported_tmp)
if single_import:
imported = imported[0]
return imported
def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
if not osp.isfile(filename):
raise FileNotFoundError(msg_tmpl.format(filename))
if platform.system() == 'Windows':
import regex as re
else:
import re
BASE_KEY = '_base_'
DELETE_KEY = '_delete_'
RESERVED_KEYS = ['filename', 'text', 'pretty_text']
class ConfigDict(Dict):
def __missing__(self, name):
raise KeyError(name)
def __getattr__(self, name):
try:
value = super(ConfigDict, self).__getattr__(name)
except KeyError:
ex = AttributeError(f"'{self.__class__.__name__}' object has no "
f"attribute '{name}'")
except Exception as e:
ex = e
else:
return value
raise ex
def add_args(parser, cfg, prefix=''):
for k, v in cfg.items():
if isinstance(v, str):
parser.add_argument('--' + prefix + k)
elif isinstance(v, int):
parser.add_argument('--' + prefix + k, type=int)
elif isinstance(v, float):
parser.add_argument('--' + prefix + k, type=float)
elif isinstance(v, bool):
parser.add_argument('--' + prefix + k, action='store_true')
elif isinstance(v, dict):
add_args(parser, v, prefix + k + '.')
elif isinstance(v, abc.Iterable):
parser.add_argument('--' + prefix + k, type=type(v[0]), nargs='+')
else:
print(f'cannot parse key {prefix + k} of type {type(v)}')
return parser
class Config:
"""A facility for config and config files.
It supports common file formats as configs: python/json/yaml. The interface
is the same as a dict object and also allows access config values as
attributes.
Example:
>>> cfg = Config(dict(a=1, b=dict(b1=[0, 1])))
>>> cfg.a
1
>>> cfg.b
{'b1': [0, 1]}
>>> cfg.b.b1
[0, 1]
>>> cfg = Config.fromfile('tests/data/config/a.py')
>>> cfg.filename
"/home/kchen/projects/mmcv/tests/data/config/a.py"
>>> cfg.item4
'test'
>>> cfg
"Config [path: /home/kchen/projects/mmcv/tests/data/config/a.py]: "
"{'item1': [1, 2], 'item2': {'a': 0}, 'item3': True, 'item4': 'test'}"
"""
@staticmethod
def _validate_py_syntax(filename):
with open(filename, 'r', encoding='utf-8') as f:
# Setting encoding explicitly to resolve coding issue on windows
content = f.read()
try:
ast.parse(content)
except SyntaxError as e:
raise SyntaxError('There are syntax errors in config '
f'file {filename}: {e}')
@staticmethod
def _substitute_predefined_vars(filename, temp_config_name):
file_dirname = osp.dirname(filename)
file_basename = osp.basename(filename)
file_basename_no_extension = osp.splitext(file_basename)[0]
file_extname = osp.splitext(filename)[1]
support_templates = dict(
fileDirname=file_dirname,
fileBasename=file_basename,
fileBasenameNoExtension=file_basename_no_extension,
fileExtname=file_extname)
with open(filename, 'r', encoding='utf-8') as f:
# Setting encoding explicitly to resolve coding issue on windows
config_file = f.read()
for key, value in support_templates.items():
regexp = r'\{\{\s*' + str(key) + r'\s*\}\}'
value = value.replace('\\', '/')
config_file = re.sub(regexp, value, config_file)
with open(temp_config_name, 'w') as tmp_config_file:
tmp_config_file.write(config_file)
@staticmethod
def _pre_substitute_base_vars(filename, temp_config_name):
"""Substitute base variable placehoders to string, so that parsing
would work."""
with open(filename, 'r', encoding='utf-8') as f:
# Setting encoding explicitly to resolve coding issue on windows
config_file = f.read()
base_var_dict = {}
regexp = r'\{\{\s*' + BASE_KEY + r'\.([\w\. ]+)\s*\}\}'
base_vars = set(re.findall(regexp, config_file))
for base_var in base_vars:
randstr = f'_{base_var}_{uuid.uuid4().hex.lower()[:6]}'
base_var_dict[randstr] = base_var
regexp = r'\{\{\s*' + BASE_KEY + r'\.' + base_var + r'\s*\}\}'
config_file = re.sub(regexp, f'"{randstr}"', config_file)
with open(temp_config_name, 'w') as tmp_config_file:
tmp_config_file.write(config_file)
return base_var_dict
@staticmethod
def _substitute_base_vars(cfg, base_var_dict, base_cfg):
"""Substitute variable strings to their actual values."""
cfg = copy.deepcopy(cfg)
if isinstance(cfg, dict):
for k, v in cfg.items():
if isinstance(v, str) and v in base_var_dict:
new_v = base_cfg
for new_k in base_var_dict[v].split('.'):
new_v = new_v[new_k]
cfg[k] = new_v
elif isinstance(v, (list, tuple, dict)):
cfg[k] = Config._substitute_base_vars(
v, base_var_dict, base_cfg)
elif isinstance(cfg, tuple):
cfg = tuple(
Config._substitute_base_vars(c, base_var_dict, base_cfg)
for c in cfg)
elif isinstance(cfg, list):
cfg = [
Config._substitute_base_vars(c, base_var_dict, base_cfg)
for c in cfg
]
elif isinstance(cfg, str) and cfg in base_var_dict:
new_v = base_cfg
for new_k in base_var_dict[cfg].split('.'):
new_v = new_v[new_k]
cfg = new_v
return cfg
@staticmethod
def _file2dict(filename, use_predefined_variables=True):
filename = osp.abspath(osp.expanduser(filename))
check_file_exist(filename)
fileExtname = osp.splitext(filename)[1]
if fileExtname not in ['.py', '.json', '.yaml', '.yml']:
raise IOError('Only py/yml/yaml/json type are supported now!')
with tempfile.TemporaryDirectory() as temp_config_dir:
temp_config_file = tempfile.NamedTemporaryFile(
dir=temp_config_dir, suffix=fileExtname)
if platform.system() == 'Windows':
temp_config_file.close()
temp_config_name = osp.basename(temp_config_file.name)
# Substitute predefined variables
if use_predefined_variables:
Config._substitute_predefined_vars(filename,
temp_config_file.name)
else:
shutil.copyfile(filename, temp_config_file.name)
# Substitute base variables from placeholders to strings
base_var_dict = Config._pre_substitute_base_vars(
temp_config_file.name, temp_config_file.name)
if filename.endswith('.py'):
temp_module_name = osp.splitext(temp_config_name)[0]
sys.path.insert(0, temp_config_dir)
Config._validate_py_syntax(filename)
mod = import_module(temp_module_name)
sys.path.pop(0)
cfg_dict = {}
for name, value in mod.__dict__.items():
if not name.startswith('__'):
if callable(value):
name = 'data'
cfg_dict.update({
name: value
})
# cfg_dict = {name: value for name, value in mod.__dict__.items() if not name.startswith('__')}
# delete imported module
del sys.modules[temp_module_name]
elif filename.endswith(('.yml', '.yaml', '.json')):
import mmcv
cfg_dict = mmcv.load(temp_config_file.name)
# close temp file
temp_config_file.close()
cfg_text = filename + '\n'
with open(filename, 'r', encoding='utf-8') as f:
# Setting encoding explicitly to resolve coding issue on windows
cfg_text += f.read()
if BASE_KEY in cfg_dict:
cfg_dir = osp.dirname(filename)
base_filename = cfg_dict.pop(BASE_KEY)
base_filename = base_filename if isinstance(
base_filename, list) else [base_filename]
cfg_dict_list = list()
cfg_text_list = list()
for f in base_filename:
_cfg_dict, _cfg_text = Config._file2dict(osp.join(cfg_dir, f))
cfg_dict_list.append(_cfg_dict)
cfg_text_list.append(_cfg_text)
base_cfg_dict = dict()
for c in cfg_dict_list:
if len(base_cfg_dict.keys() & c.keys()) > 0:
raise KeyError('Duplicate key is not allowed among bases')
base_cfg_dict.update(c)
# Subtitute base variables from strings to their actual values
cfg_dict = Config._substitute_base_vars(cfg_dict, base_var_dict,
base_cfg_dict)
base_cfg_dict = Config._merge_a_into_b(cfg_dict, base_cfg_dict)
cfg_dict = base_cfg_dict
# merge cfg_text
cfg_text_list.append(cfg_text)
cfg_text = '\n'.join(cfg_text_list)
return cfg_dict, cfg_text
@staticmethod
def _merge_a_into_b(a, b, allow_list_keys=False):
"""merge dict ``a`` into dict ``b`` (non-inplace).
Values in ``a`` will overwrite ``b``. ``b`` is copied first to avoid
in-place modifications.
Args:
a (dict): The source dict to be merged into ``b``.
b (dict): The origin dict to be fetch keys from ``a``.
allow_list_keys (bool): If True, int string keys (e.g. '0', '1')
are allowed in source ``a`` and will replace the element of the
corresponding index in b if b is a list. Default: False.
Returns:
dict: The modified dict of ``b`` using ``a``.
Examples:
# Normally merge a into b.
>>> Config._merge_a_into_b(
... dict(obj=dict(a=2)), dict(obj=dict(a=1)))
{'obj': {'a': 2}}
# Delete b first and merge a into b.
>>> Config._merge_a_into_b(
... dict(obj=dict(_delete_=True, a=2)), dict(obj=dict(a=1)))
{'obj': {'a': 2}}
# b is a list
>>> Config._merge_a_into_b(
... {'0': dict(a=2)}, [dict(a=1), dict(b=2)], True)
[{'a': 2}, {'b': 2}]
"""
b = b.copy()
for k, v in a.items():
if allow_list_keys and k.isdigit() and isinstance(b, list):
k = int(k)
if len(b) <= k:
raise KeyError(f'Index {k} exceeds the length of list {b}')
b[k] = Config._merge_a_into_b(v, b[k], allow_list_keys)
elif isinstance(v,
dict) and k in b and not v.pop(DELETE_KEY, False):
allowed_types = (dict, list) if allow_list_keys else dict
if not isinstance(b[k], allowed_types):
raise TypeError(
f'{k}={v} in child config cannot inherit from base '
f'because {k} is a dict in the child config but is of '
f'type {type(b[k])} in base config. You may set '
f'`{DELETE_KEY}=True` to ignore the base config')
b[k] = Config._merge_a_into_b(v, b[k], allow_list_keys)
else:
b[k] = v
return b
@staticmethod
def fromfile(filename,
use_predefined_variables=True,
import_custom_modules=True):
cfg_dict, cfg_text = Config._file2dict(filename,
use_predefined_variables)
if import_custom_modules and cfg_dict.get('custom_imports', None):
import_modules_from_strings(**cfg_dict['custom_imports'])
return Config(cfg_dict, cfg_text=cfg_text, filename=filename)
@staticmethod
def fromstring(cfg_str, file_format):
"""Generate config from config str.
Args:
cfg_str (str): Config str.
file_format (str): Config file format corresponding to the
config str. Only py/yml/yaml/json type are supported now!
Returns:
obj:`Config`: Config obj.
"""
if file_format not in ['.py', '.json', '.yaml', '.yml']:
raise IOError('Only py/yml/yaml/json type are supported now!')
if file_format != '.py' and 'dict(' in cfg_str:
# check if users specify a wrong suffix for python
warnings.warn(
'Please check "file_format", the file format may be .py')
with tempfile.NamedTemporaryFile(
'w', suffix=file_format, delete=False) as temp_file:
temp_file.write(cfg_str)
# on windows, previous implementation cause error
# see PR 1077 for details
cfg = Config.fromfile(temp_file.name)
os.remove(temp_file.name)
return cfg
@staticmethod
def auto_argparser(description=None):
"""Generate argparser from config file automatically (experimental)"""
partial_parser = ArgumentParser(description=description)
partial_parser.add_argument('--config', help='config file path', default="../../dev/config_detr.yml")
cfg_file = partial_parser.parse_known_args()[0].config
cfg = Config.fromfile(cfg_file)
parser = ArgumentParser(description=description)
parser.add_argument('config', help='config file path')
add_args(parser, cfg)
return parser, cfg
@staticmethod
def fromargparse(args):
cfg_dict = {}
for k, v in args._get_kwargs():
cfg_dict.update({k: v})
return cfg_dict
def merge_args2cfg(self, args, allow_list_keys=True):
cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
option_cfg_dict = self.fromargparse(args) #cfg_dict
super(Config, self).__setattr__(
'_cfg_dict',
Config._merge_a_into_b(
option_cfg_dict, cfg_dict, allow_list_keys=allow_list_keys))
def __init__(self, cfg_dict=None, cfg_text=None, filename=None):
if cfg_dict is None:
cfg_dict = dict()
elif isinstance(cfg_dict, Namespace):
cfg_dict = self.fromargparse(cfg_dict)
elif not isinstance(cfg_dict, (dict, Namespace)):
raise TypeError('cfg_dict must be a dict or Namespace, but '
f'got {type(cfg_dict)}')
for key in cfg_dict:
if key in RESERVED_KEYS:
raise KeyError(f'{key} is reserved for config file')
super(Config, self).__setattr__('_cfg_dict', ConfigDict(cfg_dict))
super(Config, self).__setattr__('_filename', filename)
if cfg_text:
text = cfg_text
elif filename:
with open(filename, 'r') as f:
text = f.read()
else:
text = ''
super(Config, self).__setattr__('_text', text)
@property
def filename(self):
return self._filename
@property
def text(self):
return self._text
@property
def pretty_text(self):
indent = 4
def _indent(s_, num_spaces):
s = s_.split('\n')
if len(s) == 1:
return s_
first = s.pop(0)
s = [(num_spaces * ' ') + line for line in s]
s = '\n'.join(s)
s = first + '\n' + s
return s
def _format_basic_types(k, v, use_mapping=False):
if isinstance(v, str):
v_str = f"'{v}'"
else:
v_str = str(v)
if use_mapping:
k_str = f"'{k}'" if isinstance(k, str) else str(k)
attr_str = f'{k_str}: {v_str}'
else:
attr_str = f'{str(k)}={v_str}'
attr_str = _indent(attr_str, indent)
return attr_str
def _format_list(k, v, use_mapping=False):
# check if all items in the list are dict
if all(isinstance(_, dict) for _ in v):
v_str = '[\n'
v_str += '\n'.join(
f'dict({_indent(_format_dict(v_), indent)}),'
for v_ in v).rstrip(',')
if use_mapping:
k_str = f"'{k}'" if isinstance(k, str) else str(k)
attr_str = f'{k_str}: {v_str}'
else:
attr_str = f'{str(k)}={v_str}'
attr_str = _indent(attr_str, indent) + ']'
else:
attr_str = _format_basic_types(k, v, use_mapping)
return attr_str
def _contain_invalid_identifier(dict_str):
contain_invalid_identifier = False
for key_name in dict_str:
contain_invalid_identifier |= \
(not str(key_name).isidentifier())
return contain_invalid_identifier
def _format_dict(input_dict, outest_level=False):
r = ''
s = []
use_mapping = _contain_invalid_identifier(input_dict)
if use_mapping:
r += '{'
for idx, (k, v) in enumerate(input_dict.items()):
is_last = idx >= len(input_dict) - 1
end = '' if outest_level or is_last else ','
if isinstance(v, dict):
v_str = '\n' + _format_dict(v)
if use_mapping:
k_str = f"'{k}'" if isinstance(k, str) else str(k)
attr_str = f'{k_str}: dict({v_str}'
else:
attr_str = f'{str(k)}=dict({v_str}'
attr_str = _indent(attr_str, indent) + ')' + end
elif isinstance(v, list):
attr_str = _format_list(k, v, use_mapping) + end
else:
attr_str = _format_basic_types(k, v, use_mapping) + end
s.append(attr_str)
r += '\n'.join(s)
if use_mapping:
r += '}'
return r
cfg_dict = self._cfg_dict.to_dict()
text = _format_dict(cfg_dict, outest_level=True)
# copied from setup.cfg
yapf_style = dict(
based_on_style='pep8',
blank_line_before_nested_class_or_def=True,
split_before_expression_after_opening_paren=True)
text, _ = FormatCode(text.replace('\\', '/'), style_config=yapf_style, verify=True)
return text
def __repr__(self):
return f'Config (path: {self.filename}): {self._cfg_dict.__repr__()}'
def __len__(self):
return len(self._cfg_dict)
def __getattr__(self, name):
return getattr(self._cfg_dict, name)
def __delattr__(self, name):
return delattr(self._cfg_dict, name)
def __getitem__(self, name):
return self._cfg_dict.__getitem__(name)
def __setattr__(self, name, value):
if isinstance(value, dict):
value = ConfigDict(value)
self._cfg_dict.__setattr__(name, value)
def __setitem__(self, name, value):
if isinstance(value, dict):
value = ConfigDict(value)
self._cfg_dict.__setitem__(name, value)
def __iter__(self):
return iter(self._cfg_dict)
def __getstate__(self):
return (self._cfg_dict, self._filename, self._text)
def __setstate__(self, state):
_cfg_dict, _filename, _text = state
super(Config, self).__setattr__('_cfg_dict', _cfg_dict)
super(Config, self).__setattr__('_filename', _filename)
super(Config, self).__setattr__('_text', _text)
def dump(self, file=None):
cfg_dict = super(Config, self).__getattribute__('_cfg_dict').to_dict()
if self.filename.endswith('.py'):
if file is None:
return self.pretty_text
else:
with open(file, 'w') as f:
f.write(self.pretty_text)
else:
import mmcv
if file is None:
file_format = self.filename.split('.')[-1]
return mmcv.dump(cfg_dict, file_format=file_format)
else:
mmcv.dump(cfg_dict, file)
def merge_from_dict(self, options, allow_list_keys=True):
"""Merge list into cfg_dict.
Merge the dict parsed by MultipleKVAction into this cfg.
Examples:
>>> options = {'model.backbone.depth': 50,
... 'model.backbone.with_cp':True}
>>> cfg = Config(dict(model=dict(backbone=dict(type='ResNet'))))
>>> cfg.merge_from_dict(options)
>>> cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
>>> assert cfg_dict == dict(
... model=dict(backbone=dict(depth=50, with_cp=True)))
# Merge list element
>>> cfg = Config(dict(pipeline=[
... dict(type='LoadImage'), dict(type='LoadAnnotations')]))
>>> options = dict(pipeline={'0': dict(type='SelfLoadImage')})
>>> cfg.merge_from_dict(options, allow_list_keys=True)
>>> cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
>>> assert cfg_dict == dict(pipeline=[
... dict(type='SelfLoadImage'), dict(type='LoadAnnotations')])
Args:
options (dict): dict of configs to merge from.
allow_list_keys (bool): If True, int string keys (e.g. '0', '1')
are allowed in ``options`` and will replace the element of the
corresponding index in the config if the config is a list.
Default: True.
"""
option_cfg_dict = {}
for full_key, v in options.items():
d = option_cfg_dict
key_list = full_key.split('.')
for subkey in key_list[:-1]:
d.setdefault(subkey, ConfigDict())
d = d[subkey]
subkey = key_list[-1]
d[subkey] = v
cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
super(Config, self).__setattr__(
'_cfg_dict',
Config._merge_a_into_b(
option_cfg_dict, cfg_dict, allow_list_keys=allow_list_keys))
class DictAction(Action):
"""
argparse action to split an argument into KEY=VALUE form
on the first = and append to a dictionary. List options can
be passed as comma separated values, i.e 'KEY=V1,V2,V3', or with explicit
brackets, i.e. 'KEY=[V1,V2,V3]'. It also support nested brackets to build
list/tuple values. e.g. 'KEY=[(V1,V2),(V3,V4)]'
"""
@staticmethod
def _parse_int_float_bool(val):
try:
return int(val)
except ValueError:
pass
try:
return float(val)
except ValueError:
pass
if val.lower() in ['true', 'false']:
return True if val.lower() == 'true' else False
return val
@staticmethod
def _parse_iterable(val):
"""Parse iterable values in the string.
All elements inside '()' or '[]' are treated as iterable values.
Args:
val (str): Value string.
Returns:
list | tuple: The expanded list or tuple from the string.
Examples:
>>> DictAction._parse_iterable('1,2,3')
[1, 2, 3]
>>> DictAction._parse_iterable('[a, b, c]')
['a', 'b', 'c']
>>> DictAction._parse_iterable('[(1, 2, 3), [a, b], c]')
[(1, 2, 3), ['a', 'b'], 'c']
"""
def find_next_comma(string):
"""Find the position of next comma in the string.
If no ',' is found in the string, return the string length. All
chars inside '()' and '[]' are treated as one element and thus ','
inside these brackets are ignored.
"""
assert (string.count('(') == string.count(')')) and (
string.count('[') == string.count(']')), \
f'Imbalanced brackets exist in {string}'
end = len(string)
for idx, char in enumerate(string):
pre = string[:idx]
# The string before this ',' is balanced
if ((char == ',') and (pre.count('(') == pre.count(')'))
and (pre.count('[') == pre.count(']'))):
end = idx
break
return end
# Strip ' and " characters and replace whitespace.
val = val.strip('\'\"').replace(' ', '')
is_tuple = False
if val.startswith('(') and val.endswith(')'):
is_tuple = True
val = val[1:-1]
elif val.startswith('[') and val.endswith(']'):
val = val[1:-1]
elif ',' not in val:
# val is a single value
return DictAction._parse_int_float_bool(val)
values = []
while len(val) > 0:
comma_idx = find_next_comma(val)
element = DictAction._parse_iterable(val[:comma_idx])
values.append(element)
val = val[comma_idx + 1:]
if is_tuple:
values = tuple(values)
return values
def __call__(self, parser, namespace, values, option_string=None):
options = {}
for kv in values:
key, val = kv.split('=', maxsplit=1)
options[key] = self._parse_iterable(val)
setattr(namespace, self.dest, options)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/criterion_metrics.py
================================================
# GPL License
# Copyright (C) 2021 , UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
from torch import nn
import torch
from torch import distributed as dist
from collections import OrderedDict
class SetCriterion(nn.Module):
""" This class computes the loss for DETR.
The process happens in two steps:
1) we compute hungarian assignment between ground truth boxes and the outputs of the model
2) we supervise each pair of matched ground-truth / prediction (supervise class and box)
"""
def __init__(self, losses, weight_dict):
""" Create the criterion.
Parameters:
num_classes: n able to compute a matching between targets and proposals
weight_dict: dict containing as key the names of the losses and as values their relative weight.
eos_coef: relatiumber of object categories, omitting the special no-object category
matcher: moduleve classification weight applied to the no-object category
losses: list of all the losses to be applied. See get_loss for list of available losses.
"""
super().__init__()
self.weight_dict = weight_dict
self.losses = losses
self.loss_dicts = {}
def forward(self, outputs, targets, *args, **kwargs):
""" This performs the loss computation.
Parameters:
outputs: dict of tensors, see the output specification of the model for the format
targets: list of dicts, such that len(targets) == batch_size.
The expected keys in each dict depends on the losses applied, see each loss' doc
"""
# Compute all the requested losses
for k in self.losses.keys():
# k, loss = loss_dict
if k == 'loss':
loss = self.losses[k]
loss_dicts = loss(outputs, targets)
if isinstance(loss_dicts, dict):
self.loss_dicts.update(loss(outputs, targets))
else:
self.loss_dicts.update({k: loss(outputs, targets)})
else:
loss = self.losses[k]
loss_dicts = loss(outputs, targets, *args)
if isinstance(loss_dicts, dict):
self.loss_dicts.update(loss(outputs, targets, *args))
else:
self.loss_dicts.update({k: loss(outputs, targets, *args)})
return self.loss_dicts#self._parse_losses(self.loss_dicts)
def _parse_losses(self, losses):
log_vars = OrderedDict()
for loss_name, loss_value in losses.items():
if isinstance(loss_value, torch.Tensor):
log_vars[loss_name] = loss_value.mean()
elif isinstance(loss_value, list):
log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value)
# top-1, top-5 both belong to accuracy
elif isinstance(loss_value, dict):
# log_vars[loss_name] = {}
for name, value in loss_value.items():
log_vars[name] = value
# log_vars[loss_name].update({name: value.item()})
else:
raise TypeError(
f'{loss_name} is not a tensor or list of tensors')
assert 'loss' not in log_vars.keys(), KeyError("key: 'loss' can't be set from cfg_file.")
loss = sum(_value for _key, _value in log_vars.items()
if 'top' not in _key)#if 'loss' in _key
log_vars['loss'] = loss
# output = log_vars.pop('acc') #get
for loss_name, loss_value in log_vars.items():
# reduce loss when distributed training
if dist.is_available() and dist.is_initialized():
loss_value = loss_value.data.clone()
dist.all_reduce(loss_value.div_(dist.get_world_size()))
log_vars[loss_name] = loss_value.item()
# log_vars.update(acc=output)
return loss, log_vars
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/dist_utils.py
================================================
import os
import subprocess
import torch
from torch import nn
import torch.multiprocessing as mp
from torch import distributed as dist
from torch.nn.parallel.distributed import DistributedDataParallel
from logging import info as log_string
try:
from apex.parallel.distributed import DistributedDataParallel as DDP
except:
Warning("No module named 'apex")
def scaled_all_reduce(tensors):
"""Performs the scaled all_reduce operation on the provided tensors.
The input tensors are modified in-place. Currently supports only the sum
reduction operator. The reduced values are scaled by the inverse size of the
process group.
"""
# There is no need for reduction in the single-proc case
gpus = dist.get_world_size()
if gpus == 1:
return tensors
# Queue the reductions
reductions = []
for tensor in tensors:
reduction = dist.all_reduce(tensor, async_op=True)
reductions.append(reduction)
# Wait for reductions to finish
for reduction in reductions:
reduction.wait()
# Scale the results
for tensor in tensors:
tensor.mul_(1.0 / gpus)
return tensors
def init_dist(launcher, args, backend='nccl', **kwargs):
if 'LOCAL_RANK' not in os.environ:
os.environ['LOCAL_RANK'] = str(args.local_rank)
if mp.get_start_method(allow_none=True) is None:
mp.set_start_method('spawn')
if launcher == 'pytorch':
_init_dist_pytorch(backend, **kwargs)
elif launcher == 'mpi':
_init_dist_mpi(backend, **kwargs)
elif launcher == 'slurm':
_init_dist_slurm(backend, **kwargs)
else:
raise ValueError(f'Invalid launcher type: {launcher}')
def get_dist_info():
if dist.is_available():
initialized = dist.is_initialized()
else:
initialized = False
if initialized:
rank = dist.get_rank()
world_size = dist.get_world_size()
else:
rank = 0
world_size = 1
# print(f"DDP: {dist.is_available()} {world_size}")
return rank, world_size
def _init_dist_pytorch(backend, **kwargs):
# TODO: use local_rank instead of rank % num_gpus
rank = int(os.environ['RANK'])
num_gpus = torch.cuda.device_count()
torch.cuda.set_device(rank % num_gpus)
dist.init_process_group(backend=backend, **kwargs)
def _init_dist_mpi(backend, **kwargs):
# TODO: use local_rank instead of rank % num_gpus
rank = int(os.environ['OMPI_COMM_WORLD_RANK'])
num_gpus = torch.cuda.device_count()
torch.cuda.set_device(rank % num_gpus)
dist.init_process_group(backend=backend, **kwargs)
def _init_dist_slurm(backend, port=None, **kwargs):
"""Initialize slurm distributed training environment.
If argument ``port`` is not specified, then the master port will be system
environment variable ``MASTER_PORT``. If ``MASTER_PORT`` is not in system
environment variable, then a default port ``29500`` will be used.
Args:
backend (str): Backend of torch.distributed.
port (int, optional): Master port. Defaults to None.
"""
proc_id = int(os.environ['SLURM_PROCID'])
ntasks = int(os.environ['SLURM_NTASKS'])
node_list = os.environ['SLURM_NODELIST']
num_gpus = torch.cuda.device_count()
torch.cuda.set_device(proc_id % num_gpus)
addr = subprocess.getoutput(
f'scontrol show hostname {node_list} | head -n1')
# print(proc_id, ntasks, node_list, addr)
# specify master port
if port is not None:
os.environ['MASTER_PORT'] = str(port)
elif 'MASTER_PORT' in os.environ:
pass # use MASTER_PORT in the environment variable
else:
# 29500 is torch.distributed default port
os.environ['MASTER_PORT'] = '29500'
# use MASTER_ADDR in the environment variable if it already exists
if 'MASTER_ADDR' not in os.environ:
os.environ['MASTER_ADDR'] = addr
os.environ['WORLD_SIZE'] = str(ntasks)
os.environ['LOCAL_RANK'] = str(proc_id % num_gpus)
os.environ['RANK'] = str(proc_id)
# print(os.environ)
dist.init_process_group(backend=backend)
def reduce_mean(tensor, nprocs=None):
if nprocs is None:
_, nprocs = get_dist_info()
if nprocs == 1:
return tensor
# print("reduce_mean", tensor)
rt = tensor.clone()
dist.all_reduce(rt, op=dist.ReduceOp.SUM)
# print(rt, nprocs)
rt /= nprocs
# print(rt)
return rt
class MMDistributedDataParallel(DistributedDataParallel):
def __init__(self, model, device_ids):
super(MMDistributedDataParallel, self).__init__(model, device_ids, find_unused_parameters=True)
self.ddp = model
def reduce_mean(self, tensor, nprocs=None):
if nprocs is None:
_, nprocs = get_dist_info()
rt = tensor.clone()
dist.all_reduce(rt, op=dist.ReduceOp.SUM)
rt /= nprocs
return rt
def ddp_step(self, loss_dicts):
losses = {}
_, world_size = get_dist_info()
if world_size == 1:
return loss_dicts
dist.barrier()
# keys = loss_dicts.keys()
# reduced_loss = scaled_all_reduce(loss_dicts.values())
# losses = {k: v for k, v in zip(keys, reduced_loss)}
for k, loss in loss_dicts.items():
reduced_loss = self.reduce_mean(loss)
losses.update({k: reduced_loss})
return losses
def dist_train_v1(args, model):
if args.mode == "DDP":
if args.global_rank == 0:
log_string(f'Distributed training: {args.distributed}')
if args.distributed:
if args.amp is not None:
if not args.amp:
# delay_allreduce delays all communication to the end of the backward pass.
log_string("IN apex DistributedDataParallel mode.")
model = DDP(model, delay_allreduce=True)
else:
# model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank])
model = MMDistributedDataParallel(model, device_ids=[args.local_rank])
# train_sampler = torch.auxiliary.data.distributed.DistributedSampler(train_dataset)
# val_sampler = torch.auxiliary.data.distributed.DistributedSampler(val_dataset)
elif args.mode == "DP":
log_string(f'DataParallel training')
model = nn.DataParallel(model, device_ids=args.device_ids)
return model
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/kill_dist.sh
================================================
kill -9 $(ps aux | grep main.py | grep -v grep | awk '{print $2}')
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/launch.py
================================================
r"""
`torch.distributed.launch` is a module that spawns up multiple distributed
training processes on each of the training nodes.
The utility can be used for single-node distributed training, in which one or
more processes per node will be spawned. The utility can be used for either
CPU training or GPU training. If the utility is used for GPU training,
each distributed process will be operating on a single GPU. This can achieve
well-improved single-node training performance. It can also be used in
multi-node distributed training, by spawning up multiple processes on each node
for well-improved multi-node distributed training performance as well.
This will especially be benefitial for systems with multiple Infiniband
interfaces that have direct-GPU support, since all of them can be utilized for
aggregated communication bandwidth.
In both cases of single-node distributed training or multi-node distributed
training, this utility will launch the given number of processes per node
(``--nproc_per_node``). If used for GPU training, this number needs to be less
or equal to the number of GPUs on the current system (``nproc_per_node``),
and each process will be operating on a single GPU from *GPU 0 to
GPU (nproc_per_node - 1)*.
**How to use this module:**
1. Single-Node multi-process distributed training
::
>>> #python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3 and all other
arguments of your training script)
2. Multi-Node multi-process distributed training: (e.g. two nodes)
Node 1: *(IP: 192.168.1.1, and has a free port: 1234)*
::
>>> #python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
--nnodes=2 --node_rank=0 --master_addr="192.168.1.1"
--master_port=1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
and all other arguments of your training script)
Node 2:
::
>>> #python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
--nnodes=2 --node_rank=1 --master_addr="192.168.1.1"
--master_port=1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
and all other arguments of your training script)
3. To look up what optional arguments this module offers:
::
>>> #python -m torch.distributed.launch --help
**Important Notices:**
1. This utility and multi-process distributed (single-node or
multi-node) GPU training currently only achieves the best performance using
the NCCL distributed backend. Thus NCCL backend is the recommended backend to
use for GPU training.
2. In your training program, you must parse the command-line argument:
``--local_rank=LOCAL_PROCESS_RANK``, which will be provided by this module.
If your training program uses GPUs, you should ensure that your code only
runs on the GPU device of LOCAL_PROCESS_RANK. This can be done by:
Parsing the local_rank argument
::
# >>> import argparse
# >>> parser = argparse.ArgumentParser()
# >>> parser.add_argument("--local_rank", type=int)
# >>> args = parser.parse_args()
# Set your device to local rank using either
# ::
# >>> torch.cuda.set_device(args.local_rank) # before your code runs
# or
# ::
# >>> with torch.cuda.device(args.local_rank):
# >>> # your code to run
# 3. In your training program, you are supposed to call the following function
at the beginning to start the distributed backend. You need to make sure that
the init_method uses ``env://``, which is the only supported ``init_method``
by this module.
::
torch.distributed.init_process_group(backend='YOUR BACKEND',
init_method='env://')
4. In your training program, you can either use regular distributed functions
or use :func:`torch.nn.parallel.DistributedDataParallel` module. If your
training program uses GPUs for training and you would like to use
:func:`torch.nn.parallel.DistributedDataParallel` module,
here is how to configure it.
::
model = torch.nn.parallel.DistributedDataParallel(model,
device_ids=[args.local_rank],
output_device=args.local_rank)
Please ensure that ``device_ids`` argument is set to be the only GPU device id
that your code will be operating on. This is generally the local rank of the
process. In other words, the ``device_ids`` needs to be ``[args.local_rank]``,
and ``output_device`` needs to be ``args.local_rank`` in order to use this
utility
5. Another way to pass ``local_rank`` to the subprocesses via environment variable
``LOCAL_RANK``. This behavior is enabled when you launch the script with
``--use_env=True``. You must adjust the subprocess example above to replace
``args.local_rank`` with ``os.environ['LOCAL_RANK']``; the launcher
will not pass ``--local_rank`` when you specify this flag.
.. warning::
``local_rank`` is NOT globally unique: it is only unique per process
on a machine. Thus, don't use it to decide if you should, e.g.,
write to a networked filesystem. See
https://github.com/pytorch/pytorch/issues/12042 for an example of
how things can go wrong if you don't do this correctly.
"""
import time
import signal
import sys
import subprocess
import os
from argparse import ArgumentParser, REMAINDER
from typing import Optional, IO, List, Any
node_local_rank_stdout_filename = "node_{}_local_rank_{}_stdout"
node_local_rank_stderr_filename = "node_{}_local_rank_{}_stderr"
def parse_args():
"""
Helper function parsing the command line options
@retval ArgumentParser
"""
parser = ArgumentParser(description="PyTorch distributed training launch "
"helper utility that will spawn up "
"multiple distributed processes")
# Optional arguments for the launch helper
parser.add_argument("--nnodes", type=int, default=1,
help="The number of nodes to use for distributed "
"training")
parser.add_argument("--node_rank", type=int, default=0,
help="The rank of the node for multi-node distributed "
"training")
parser.add_argument("--nproc_per_node", type=int, default=1,
help="The number of processes to launch on each node, "
"for GPU training, this is recommended to be set "
"to the number of GPUs in your system so that "
"each process can be bound to a single GPU.")
parser.add_argument("--master_addr", default="127.0.0.1", type=str,
help="Master node (rank 0)'s address, should be either "
"the IP address or the hostname of node 0, for "
"single node multi-proc training, the "
"--master_addr can simply be 127.0.0.1")
parser.add_argument("--master_port", default=29500, type=int,
help="Master node (rank 0)'s free port that needs to "
"be used for communication during distributed "
"training")
parser.add_argument("--use_env", default=False, action="store_true",
help="Use environment variable to pass "
"'local rank'. For legacy reasons, the default value is False. "
"If set to True, the script will not pass "
"--local_rank as argument, and will instead set LOCAL_RANK.")
parser.add_argument("-m", "--module", default=False, action="store_true",
help="Changes each process to interpret the launch script "
"as a python module, executing with the same behavior as"
"'python -m'.")
parser.add_argument("--no_python", default=False, action="store_true",
help="Do not prepend the training script with \"python\" - just exec "
"it directly. Useful when the script is not a Python script.")
parser.add_argument(
"--logdir",
default=None,
type=str,
help=f"""Relative path to write subprocess logs to. Passing in a relative
path will create a directory if needed, and write the stdout and stderr to files
{node_local_rank_stdout_filename} and {node_local_rank_stderr_filename}. Note that
successive runs with the same path to write logs to will overwrite existing logs,
so be sure to save logs as needed.""",
)
# positional
parser.add_argument("training_script", type=str,
help="The full path to the single GPU training "
"program/script to be launched in parallel, "
"followed by all the arguments for the "
"training script")
# rest from the training program
parser.add_argument('training_script_args', nargs=REMAINDER)
return parser.parse_args()
def main():
args = parse_args()
# world size in terms of number of processes
dist_world_size = args.nproc_per_node * args.nnodes
# set PyTorch distributed related environmental variables
current_env = os.environ.copy()
current_env["MASTER_ADDR"] = args.master_addr
current_env["MASTER_PORT"] = str(args.master_port)
current_env["WORLD_SIZE"] = str(dist_world_size)
processes: List[Any] = []
if 'OMP_NUM_THREADS' not in os.environ and args.nproc_per_node > 1:
current_env["OMP_NUM_THREADS"] = str(1)
print("*****************************************\n"
"Setting OMP_NUM_THREADS environment variable for each process "
"to be {} in default, to avoid your system being overloaded, "
"please further tune the variable for optimal performance in "
"your application as needed. \n"
"*****************************************".format(current_env["OMP_NUM_THREADS"]))
if args.logdir:
# Possibly create the directory to write subprocess log output to.
if os.path.exists(args.logdir):
if not os.path.isdir(args.logdir):
raise ValueError("argument --logdir must be a path to a directory.")
else:
# create the relative directory
os.mkdir(os.path.join(os.getcwd(), args.logdir))
subprocess_file_handles = []
for local_rank in range(0, args.nproc_per_node):
# each process's rank
dist_rank = args.nproc_per_node * args.node_rank + local_rank
current_env["RANK"] = str(dist_rank)
current_env["LOCAL_RANK"] = str(local_rank)
# spawn the processes
with_python = not args.no_python
cmd = []
if with_python:
cmd = [sys.executable, "-u"]
if args.module:
cmd.append("-m")
else:
if not args.use_env:
raise ValueError("When using the '--no_python' flag, you must also set the '--use_env' flag.")
if args.module:
raise ValueError("Don't use both the '--no_python' flag and the '--module' flag at the same time.")
cmd.append(args.training_script)
if not args.use_env:
cmd.append("--local_rank={}".format(local_rank))
cmd.extend(args.training_script_args)
stdout_handle: Optional[IO]
stderr_handle: Optional[IO]
if args.logdir:
directory_path = os.path.join(os.getcwd(), args.logdir)
node_rank = args.node_rank
stdout_file_name = node_local_rank_stdout_filename.format(node_rank, local_rank)
stderr_file_name = node_local_rank_stderr_filename.format(node_rank, local_rank)
stdout_handle = open(os.path.join(directory_path, stdout_file_name), "w")
stderr_handle = open(os.path.join(directory_path, stderr_file_name), "w")
subprocess_file_handles.append((stdout_handle, stderr_handle))
stdout_name = stdout_handle.name
stderr_name = stderr_handle.name
print(f"""Note: Stdout and stderr for node {node_rank} rank {local_rank} will
be written to {stdout_name}, {stderr_name} respectively.""")
sig_names = {2: "SIGINT", 15: "SIGTERM"}
last_return_code = None
def sigkill_handler(signum, frame):
for process in processes:
print(f"Killing subprocess {process.pid}")
try:
process.kill()
except Exception as e:
pass
if last_return_code is not None:
raise subprocess.CalledProcessError(returncode=last_return_code, cmd=cmd)
if signum in sig_names:
print(f"Main process received {sig_names[signum]}, exiting")
sys.exit(1)
# pass SIGINT/SIGTERM to children if the parent is being terminated
signal.signal(signal.SIGINT, sigkill_handler)
signal.signal(signal.SIGTERM, sigkill_handler)
stdout_handle = None if not subprocess_file_handles else subprocess_file_handles[local_rank][0]
stderr_handle = None if not subprocess_file_handles else subprocess_file_handles[local_rank][1]
process = subprocess.Popen(cmd, env=current_env, stdout=stdout_handle, stderr=stderr_handle)
processes.append(process)
try:
alive_processes = set(processes)
while len(alive_processes):
finished_processes = []
for process in alive_processes:
if process.poll() is None:
# the process is still running
continue
else:
if process.returncode != 0:
last_return_code = process.returncode # for sigkill_handler
sigkill_handler(signal.SIGTERM, None) # not coming back
else:
# exited cleanly
finished_processes.append(process)
alive_processes = set(alive_processes) - set(finished_processes)
time.sleep(1)
finally:
# close open file descriptors
for (stdout_handle, stderr_handle) in subprocess_file_handles:
stdout_handle.close()
stderr_handle.close()
if __name__ == "__main__":
main()
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/logger.py
================================================
# Copyright (c) OpenMMLab. All rights reserved.
# GPL License
# Copyright (C) 2021 , UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import json
from collections import defaultdict
import logging
import os
import functools
import torch.distributed as dist
import colorlog
import time
from pathlib import Path
logger_initialized = {}
log_colors_config = {
'DEBUG': 'cyan',
'INFO': 'white',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red',
}
# def get_root_logger(name, log_file=None, log_level=logging.INFO):
# return get_logger('mmcls', log_file, log_level)
def get_root_logger(name=None, cfg=None, cfg_name=None, log_level=logging.INFO):
return get_logger(name, cfg, cfg_name, log_level)
# TODO: Depre
# the same as "get_root_logger"
def create_logger(cfg=None, cfg_name=None, dist_print=0, log_level=logging.INFO):
return get_logger(None, cfg, cfg_name, log_level)
@functools.lru_cache() # so that calling setup_logger multiple times won't add many handlers
def setup_logger(name, final_log_file, color=True):
# LOG_DIR = cfg.log_dir
# LOG_FOUT = open(final_log_file, 'w')
# head = '%(asctime)-15s %(message)s'
logging.basicConfig(filename=str(final_log_file).replace('\\', '/'), format='%(message)s', level=logging.INFO)
# logger = logging.getLogger()
# logger.setLevel(logging.INFO)
# console = logging.StreamHandler()
# logging.getLogger('').addHandler(console)
logger = logging.getLogger(name)
# if name in logger_initialized:
# return logger
for handler in logger.root.handlers:
if type(handler) is logging.StreamHandler:
handler.setLevel(logging.ERROR)
# stream_handler = logging.StreamHandler()
console = colorlog.StreamHandler()
handlers = [console]
# logger.setLevel(logging.INFO)
# formatter = colorlog.ColoredFormatter(
# '%(log_color)s[%(asctime)s] [%(filename)s:%(lineno)d] [%(module)s:%(funcName)s] [%(levelname)s]- %(message)s',
# log_colors=log_colors_config) # 日志输出格式
if dist.is_available() and dist.is_initialized():
rank = dist.get_rank()
else:
rank = 0
if rank == 0:
# console = colorlog.StreamHandler()
# console.setLevel(logging.DEBUG)
handlers.append(console)
# if color:
# formatter = _ColorfulFormatter(
# colored("%(message)s", "green")
# )
# else:
formatter = colorlog.ColoredFormatter(
'%(log_color)s- %(message)s',
log_colors=log_colors_config) # 日志输出格式
# console.setFormatter(formatter)
# logger.addHandler(console)
for handler in handlers:
handler.setFormatter(formatter)
handler.setLevel(logging.INFO) # log_level
logger.addHandler(handler)
# if rank == 0:
# logger.setLevel(logging.INFO) # log_level
# else:
# logger.setLevel(logging.ERROR)
logger_initialized[name] = True
return logger
def get_logger(name=None, cfg=None, cfg_name=None, phase='train', log_level=logging.INFO, file_mode='w'): # log_file=None,
"""Initialize and get a logger by name.
If the logger has not been initialized, this method will initialize the
logger by adding one or two handlers, otherwise the initialized logger will
be directly returned. During initialization, a StreamHandler will always be
added. If `log_file` is specified and the process rank is 0, a FileHandler
will also be added.
Args:
name (str): Logger name.
log_file (str | None): The log filename. If specified, a FileHandler
will be added to the logger.
log_level (int): The logger level. Note that only the process of
rank 0 is affected, and other processes will set the level to
"Error" thus be silent most of the time.
file_mode (str): The file mode used in opening log file.
Defaults to 'w'.
Returns:
logging.Logger: The expected logger.
"""
if name in logger_initialized:
if cfg is None: # cfg.use_log
return logging.getLogger(name)
else:
return None
# handle hierarchical names
# e.g., logger "a" is initialized, then logger "a.b" will skip the
# initialization since it is a child of "a".
for logger_name in logger_initialized:
if name.startswith(logger_name):
if cfg.use_log:
return logging.getLogger(name)
else:
return None
logger = None
tensorboard_log_dir = None
root_output_dir = Path(cfg.out_dir)
# set up logger in root_path
if not root_output_dir.exists():
# if not dist_print: #rank 0-N, 0 is False
print('=> creating {}'.format(root_output_dir))
root_output_dir.mkdir(parents=True, exist_ok=True)
dataset = cfg.dataset
model = cfg.arch
cfg_name = os.path.basename(cfg_name).split('.')[0]
time_str = time.strftime('%Y-%m-%d-%H-%M-%S')
# store all output except tb_log file
final_output_dir = root_output_dir / dataset / model / cfg_name
if cfg.eval:
model_save_tmp = os.path.dirname(cfg.resume).split('/')[-1]
else:
model_save_tmp = "model_{}".format(time_str)
model_save_dir = final_output_dir / model_save_tmp
# if not dist_print:
log_string('=> creating {}'.format(final_output_dir))
final_output_dir.mkdir(parents=True, exist_ok=True)
model_save_dir.mkdir(parents=True, exist_ok=True)
if cfg.use_log:
cfg_name = '{}_{}'.format(cfg_name, time_str)
# a logger to save results
log_file = '{}_{}.log'.format(cfg_name, phase)
if cfg.eval:
final_log_file = model_save_dir / log_file
else:
final_log_file = final_output_dir / log_file
# tensorboard_log
tensorboard_log_dir = root_output_dir / Path(cfg.log_dir) / dataset / model / cfg_name
# if not dist_print:
print('=> creating tfb logs {}'.format(tensorboard_log_dir))
tensorboard_log_dir.mkdir(parents=True, exist_ok=True)
logger = setup_logger(name, final_log_file)
return logger, str(final_output_dir), str(model_save_dir), str(
tensorboard_log_dir) # logger,
def print_log(msg, logger=None, level=logging.INFO):
"""Print a log message.
Args:
msg (str): The message to be logged.
logger (logging.Logger | str | None): The logger to be used.
Some special loggers are:
- "silent": no message will be printed.
- other str: the logger obtained with `get_root_logger(logger)`.
- None: The `print()` method will be used to print log messages.
level (int): Logging level. Only available when `logger` is a Logger
object or "root".
"""
if logger is None:
print(msg)
elif isinstance(logger, logging.Logger):
logger.log(level, msg)
elif logger == 'silent':
pass
elif isinstance(logger, str):
_logger = get_logger(logger)
_logger.log(level, msg)
else:
raise TypeError(
'logger should be either a logging.Logger object, str, '
f'"silent" or None, but got {type(logger)}')
def load_json_log(json_log):
"""load and convert json_logs to log_dicts.
Args:
json_log (str): The path of the json log file.
Returns:
dict[int, dict[str, list]]:
Key is the epoch, value is a sub dict. The keys in each sub dict
are different metrics, e.g. memory, bbox_mAP, and the value is a
list of corresponding values in all iterations in this epoch.
.. code-block:: python
# An example output
{
1: {'iter': [100, 200, 300], 'loss': [6.94, 6.73, 6.53]},
2: {'iter': [100, 200, 300], 'loss': [6.33, 6.20, 6.07]},
...
}
"""
log_dict = dict()
with open(json_log, 'r') as log_file:
for line in log_file:
log = json.loads(line.strip())
# skip lines without `epoch` field
if 'epoch' not in log:
continue
epoch = log.pop('epoch')
if epoch not in log_dict:
log_dict[epoch] = defaultdict(list)
for k, v in log.items():
log_dict[epoch][k].append(v)
return log_dict
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/metrics.py
================================================
# GPL License
# Copyright (C) 2021 , UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import torch
import numpy as np
import math
import torch.nn as nn
def rgb2ycbcr(img, y_only=True):
"""metrics"""
img.astype(np.float32)
if y_only:
rlt = np.dot(img, [65.481, 128.553, 24.966]) / 255.0 + 16.0
return rlt
def quantize(img, rgb_range):
pixel_range = 255.0 / rgb_range
return img.mul(pixel_range).clamp(0, 255).round().div(pixel_range)
def calc_psnr(sr, hr, scale, rgb_range):
"""metrics"""
hr = np.float32(hr)
sr = np.float32(sr)
diff = (sr - hr) / rgb_range
# .reshape((1, 1, 3)) / 256#
gray_coeffs = np.array([65.738, 129.057, 25.064]).reshape((1, 3, 1, 1)) / 256
diff = np.multiply(diff, gray_coeffs).sum(1) # (1)
if hr.size == 1:
return 0
if scale != 1:
shave = scale
else:
shave = scale + 6
if scale == 1:
valid = diff
else:
valid = diff[..., shave:-shave, shave:-shave]
# valid = diff[shave:-shave, shave:-shave, ...]
# mse = np.mean(np.mean(pow(valid, 2), axis=[1, 2, 3]), axis=0)
mse = np.mean(pow(valid, 2))
if mse == 0:
return 100
try:
psnr = -10 * math.log10(mse)
except Exception:
print(mse)
return psnr
class PSNR_ycbcr(nn.Module):
def __init__(self):
super().__init__()
self.gray_coeffs = torch.tensor([65.738, 129.057, 25.064],
requires_grad=False).reshape((1, 3, 1, 1)) / 256
def quantize(self, img, rgb_range):
"""metrics"""
pixel_range = 255 / rgb_range
img = torch.multiply(img, pixel_range)
img = torch.clip(img, 0, 255)
img = torch.round(img) / pixel_range
return img
@torch.no_grad()
def forward(self, sr, hr, scale, rgb_range):
"""metrics"""
sr = self.quantize(sr, rgb_range)
gray_coeffs = self.gray_coeffs.to(sr.device)
hr = hr.float()
sr = sr.float()
diff = (sr - hr) / rgb_range
diff = torch.multiply(diff, gray_coeffs).sum(1)
if hr.size == 1:
return 0
if scale != 1:
shave = scale
else:
shave = scale + 6
if scale == 1:
valid = diff
else:
valid = diff[..., shave:-shave, shave:-shave]
mse = torch.mean(torch.pow(valid, 2))
return -10 * torch.log10(mse)
def sub_mean(x):
x = x * 255.0
red_channel_mean = 0.4488 * 255
green_channel_mean = 0.4371 * 255
blue_channel_mean = 0.4040 * 255
x[:, 0, :, :] -= red_channel_mean
x[:, 1, :, :] -= green_channel_mean
x[:, 2, :, :] -= blue_channel_mean
return x / 255.0
def add_mean(x):
x = x * 255.0
red_channel_mean = 0.4488 * 255
green_channel_mean = 0.4371 * 255
blue_channel_mean = 0.4040 * 255
x[:, 0, :, :] += red_channel_mean
x[:, 1, :, :] += green_channel_mean
x[:, 2, :, :] += blue_channel_mean
return x
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/optim.py
================================================
import torch
from torch import nn
import torch.optim as optim
import matplotlib.pyplot as plt
class lr_scheduler(object):
def __init__(self, lr, epochs):
self.epochs = epochs
self.lr = lr
self.lr_scheduler = None
# 六大学习率调整策略，lr = lr * gamma
'''
ReduceLROnPlateau:
mode(str)- 模式选择，有 min 和 max 两种模式， min 表示当指标不再降低(如监测loss)， max 表示当指标不再升高(如监测 accuracy)。
factor(float)- 学习率调整倍数(等同于其它方法的 gamma)，即学习率更新为 lr = lr * factor
patience(int)- 忍受该指标多少个 step 不变化，当忍无可忍时，调整学习率。
verbose(bool)- 是否打印学习率信息， print(‘Epoch {:5d}: reducing learning rate of group {} to {:.4e}.’.format(epoch, i, new_lr))
threshold_mode(str)- 选择判断指标是否达最优的模式，有两种模式， rel 和 abs。
当 threshold_mode == rel，并且 mode == max 时， dynamic_threshold = best * ( 1 +threshold )；
当 threshold_mode == rel，并且 mode == min 时， dynamic_threshold = best * ( 1 -threshold )；
当 threshold_mode == abs，并且 mode== max 时， dynamic_threshold = best + threshold ；
当 threshold_mode == rel，并且 mode == max 时， dynamic_threshold = best - threshold；
threshold(float)- 配合 threshold_mode 使用。
cooldown(int)- “冷却时间“，当调整学习率之后，让学习率调整策略冷静一下，让模型再训练一段时间，再重启监测模式。
min_lr(float or list)- 学习率下限，可为 float，或者 list，当有多个参数组时，可用 list 进行设置
'''
def set_optimizer(self, optimizer, lr_scheduler):
self.optimizer = optimizer
# self.lr_scheduler = lr_scheduler
# self.scheduler = []
if lr_scheduler == torch.optim.lr_scheduler.StepLR:
# 等间距阶段式衰减
self.lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.1)
elif lr_scheduler == optim.lr_scheduler.ReduceLROnPlateau:
# Reduce learning rate when validation accuarcy plateau.
self.lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', patience=5, verbose=True)
elif lr_scheduler == optim.lr_scheduler.MultiStepLR:
# milestones=[epoch1,epoch2,...] 阶段式衰减
self.lr_scheduler = optim.lr_scheduler.MultiStepLR(optimizer, [100, 200, 300],
gamma=0.5) # [50, 100, 150, 200, 250, 300, 350, 400], gamma=0.5)
elif lr_scheduler == optim.lr_scheduler.ExponentialLR:
# 指数衰减x, 0.1,0.01,0.001,...
self.lr_scheduler = optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.1)
elif lr_scheduler == optim.lr_scheduler.CosineAnnealingLR:
# Cosine annealing learning rate.
self.lr_scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=30, eta_min=1e-7)
elif lr_scheduler == optim.lr_scheduler.CyclicLR:
self.lr_scheduler = optim.lr_scheduler.CyclicLR(optimizer, base_lr=1e-3, max_lr=1e-4, step_size_down=30,
step_size_up=150, cycle_momentum=False)
elif lr_scheduler == optim.lr_scheduler.LambdaLR:
# 学习率 = 初始学习率 * lr_lambda(last_epoch）
curves = lambda epoch: epoch // 30
# lambda2 = lambda epoch: 0.95 ** epoch
# lr_lambda对应optimizer中的keys，model.parameters()就只有一个lambda函数
self.lr_scheduler = optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=[curves])
elif lr_scheduler == optim.lr_scheduler.CosineAnnealingWarmRestarts:
# To 初始周期
# T_mult 每次循环 周期改变倍数 T_0 = T_0*T_mult
# Learning rate warmup by 10 epochs.
self.lr_scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2, eta_min=0)
else:
print("self.lr_scheduler not in pytorch")
def adjust_2_learning_rate(self, epoch):
"""编写2种形式的学习率衰减策略的组合"""
param_groups = self.optimizer.param_groups
if epoch <= 5:
lr = [param_groups[0]['lr'] * 0.9]
for param_group, val in zip(param_groups, lr):
param_group['lr'] = val
else:
for param_group in param_groups:
if epoch % 5 == 0:
# 0.09 0.009 0.0009
param_group['lr'] *= 0.9
# print(param_group['lr'])
def adjust_1_learning_rate(self, epoch, mini_lr=1e-6):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
if self.optimizer.param_groups[0]["lr"] < mini_lr:
lr = 1e-5
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
return
if epoch <= 40: # 40 20 80
# lr = self.lr
lr = self.lr * (0.1 ** (epoch // 20))
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
return
elif epoch == 81: # 41
self.lr = self.optimizer.param_groups[0]["lr"]
# for param_group in self.optimizer.param_groups:
# param_group['lr'] = 1e-4
# if epoch >= 42 and epoch % 5 ==0:
if epoch >= 81:
lr = self.lr * (0.9 ** (epoch // 20))
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
return
elif epoch == 81:
lr = 1e-5
else:
lr = 1e-5
# self.lr = self.lr * (0.9 ** (epoch // 50))
# #if epoch <= 120:
# lr = self.lr * (0.9 ** (epoch // 50))
# elif epoch == 121:
# self.lr = self.optimizer.param_groups[0]["lr"]
# lr = self.lr * (0.9 ** (epoch // 50))
# else:
# lr = 0.01
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
def step(self, epoch):
# if not end:
# self.optimizer.step()
# else:
if self.lr_scheduler is None:
# self.optimizer.step()
self.adjust_1_learning_rate(epoch)
else:
# self.optimizer.step()
self.lr_scheduler.step(epoch)
# preprint lr_map
def get_lr_map(self, title, out_file=None, viz=False):
plt.figure()
lr = []
print("preprint lr_scheduler")
tmp = self.optimizer.param_groups[0]['lr']
if self.lr_scheduler is None:
for epoch in range(self.epochs):
self.step(epoch)
# TODO:按层绘制
# print(self.optimizer.param_groups[0]['lr'])
lr.append(self.optimizer.param_groups[0]['lr'])
else:
for epoch in range(self.epochs):
self.step(epoch)
try:
lr.append(self.lr_scheduler.get_last_lr())
# lr.append(self.lr_scheduler.get_lr())
except:
# ReduceLROnPlateau没有get_lr方法
lr.append(self.optimizer.param_groups[0]['lr'])
plt.plot(list(range(self.epochs)), lr)
plt.xlabel("epoch")
plt.ylabel("learning rate")
plt.title(title)
if out_file is not None:
plt.savefig(out_file)
if viz:
plt.show()
self.optimizer.param_groups[0]['lr'] = tmp
self.lr = tmp
def tune_param():
...
def partial_train(model, layers: list):
# forzen layers
for param in model.parameters():
if layers is not None and layers in param:
continue
param.requires_grad = False
# Replace the last fc layer
model.fc = nn.Linear(512, 100)
return model
if __name__ == "__main__":
from torchvision.models import AlexNet
import matplotlib.pyplot as plt
model = AlexNet(num_classes=2)
class LinearRegression(nn.Module):
def __init__(self):
super(LinearRegression, self).__init__()
self.linear1 = nn.Linear(1, 5) # input and output is 1 dimension
self.linear2 = nn.Linear(5, 1)
def forward(self, x):
out = self.linear1(x)
out = self.linear2(out)
return out
glm = LinearRegression()
optimizer = optim.SGD(params=glm.parameters(), lr=0.1)
epochs = 450
# 构造一个带warmup小学习率的optimizer，再上升到标准值，再正常周期下降
lrs = lr_scheduler(0.1, epochs)
# lrs.set_optimizer(optimizer, optim.lr_scheduler.MultiStepLR)
# lrs.get_lr_map("MultiStepLR")
# lrs.set_optimizer(optimizer, optim.lr_scheduler.ExponentialLR)
# lrs.get_lr_map("ExponentialLR")
# lrs.set_optimizer(optimizer, optim.lr_scheduler.StepLR)
# lrs.get_lr_map("StepLR")
# lrs.set_optimizer(optimizer, optim.lr_scheduler.CyclicLR)
# lrs.get_lr_map("CyclicLR")
# # lrs.set_optimizer(optimizer, optim.lr_scheduler.ReduceLROnPlateau)
# # lrs.get_lr_map("ReduceLROnPlateau")
lrs.set_optimizer(optimizer, None)
lrs.get_lr_map("LambdaLR")
# lrs.set_optimizer(optimizer, optim.lr_scheduler.CosineAnnealingLR)
# lrs.get_lr_map("CosineAnnealingLR")
# lrs.set_optimizer(optimizer, optim.lr_scheduler.CosineAnnealingWarmRestarts)
# lrs.get_lr_map("CosineAnnealingWarmRestarts")
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/option.py
================================================
# GPL License
# Copyright (C) UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import argparse
import platform
# import warnings
import os
from UDL.AutoDL import TaskDispatcher
from UDL.Basis.config import Config
import warnings
def common_cfg():
parser = argparse.ArgumentParser(description='PyTorch Training')
# * Logger
parser.add_argument('--use-log', default=True
, type=bool)
parser.add_argument('--log-dir', metavar='DIR', default='logs',
help='path to save log')
parser.add_argument('--tfb-dir', metavar='DIR', default=None,
help='useless in this script.')
parser.add_argument('--use-tfb', default=False, type=bool)
# * DDP
parser.add_argument(
'--launcher',
choices=['none', 'pytorch', 'slurm', 'mpi'],
default='none',
help='job launcher')
parser.add_argument('--local_rank', default=0, type=int,
help="host rank must be 0 and python -m torch.distributed.launch main.py need args.local_rank")
parser.add_argument('--backend', default='nccl', type=str, # gloo
help='distributed backend')
parser.add_argument('--dist-url', default='env://',
type=str, # 'tcp://224.66.41.62:23456'
help='url used to set up distributed training')
# * AMP
parser.add_argument('--amp', default=None, type=bool,
help="False is apex, besides True is torch1.6+, which has supports amp ops to reduce gpu memory and speed up training")
parser.add_argument('--amp-opt-level', type=str, default='O1', choices=['O0', 'O1', 'O2'],
help='mixed precision opt level, if O0, no amp is used')
# * Training
parser.add_argument('--accumulated-step', default=1, type=int)
parser.add_argument('--clip_max_norm', default=0, type=float,
help='gradient clipping max norm')
# * extra
parser.add_argument('--seed', default=10, type=int,
help='seed for initializing training. ')
parser.add_argument('--device', default='cuda',
help='device to use for training / testing')
parser.add_argument('--reg', type=bool, default=True,
help='loss with l2 reguliarization for nn.Conv2D, '
'which is very important for classical panshrapening!!! ')
parser.add_argument('--crop_batch_size', type=int, default=128,
help='input batch size for-'
' training')
parser.add_argument('--rgb_range', type=int, default=255,
help='maximum value of RGB')
parser.add_argument('--model_style', type=str, default=None,
help='model_style is used to recursive/cascade or GAN training')
parser.add_argument('--mode', type=str, default=None,
help='dataset file extension')
parser.add_argument('--task', type=str, default=None,
help='dataset file extension')
parser.add_argument('--arch', type=str, default='',
help='arch')
args = parser.parse_args()
args.global_rank = 0
args.once_epoch = False
args.reset_lr = False
args.amp_opt_level = 'O0' if args.amp == None else args.amp_opt_level
args.save_top_k = 5
args.save_print_freq = 10
args.start_epoch = 1
assert args.accumulated_step > 0
args.load_model_strict = True
args.resume_mode = 'best'
args.validate = False
args.gpu_ids = [0]
# args.workflow = []
return Config(args)
class panshaprening_cfg(TaskDispatcher, name='pansharpening'):
def __init__(self, cfg=None, arch=None):
super(panshaprening_cfg, self).__init__()
import UDL.pansharpening.configs
import UDL.pansharpening.models
if cfg is None:
cfg = common_cfg()
cfg.scale = [1]
if platform.system() == 'Linux':
cfg.data_dir = '/Datasets/pansharpening/DLPan'
if platform.system() == "Windows":
cfg.data_dir = 'D:/Datasets/pansharpening/DLPan'
cfg.best_prec1 = 10000
cfg.best_prec5 = 10000
cfg.metrics = 'loss'
cfg.task = "pansharpening"
cfg.save_fmt = "mat" # fmt is mat or not mat
cfg.taskhead = "pansharpening"
# * Importantly
warning = f"Note: FusionNet, DiCNN, PNN don't have high-pass filter"
warnings.warn(warning)
if arch is not None:
cfg = self.new(cfg=cfg, arch=cfg.arch)
self.merge_from_dict(cfg)
def nni_cfg(args):
if args.mode == 'nni':
import nni
tuner_params = nni.get_next_parameter()
print("launcher: nni is running. \n", tuner_params)
args.merge_from_dict(tuner_params)
return args
class get_cfg(TaskDispatcher, name='entrypoint'):
def __init__(self, task=None, arch=None):
super(get_cfg, self).__init__()
args = common_cfg()
# args.mode = 'nni'
if arch is not None:
args.arch = arch
if args.mode == 'nni':
args = nni_cfg(args)
# args.__delattr__('workflow')
if hasattr(args, 'task'):
cfg = TaskDispatcher.new(cfg=args, task=task, arch=args.arch)
cfg.merge_from_dict(args)
elif task in TaskDispatcher._task.keys():
cfg = TaskDispatcher.new(cfg=args, task=task, arch=args.arch)
cfg.merge_from_dict(args)
else:
raise ValueError(f"nni starter don't have task={task} but expected"
f"one of {super()._task.keys()} in TaskDispatcher")
# cfg.setdefault('workflow', [])
cfg = data_cfg(cfg)
print(cfg.pretty_text)
self.merge_from_dict(cfg)
def data_cfg(cfg):
if cfg.get('config', None) is not None:
if not os.path.isfile(cfg.config):
raise IOError(f"reading {cfg.config} failed")
cfg.merge_from_dict(cfg.fromfile(cfg.config))
if cfg.get('data', None) is not None and callable(cfg.data):
data_func = cfg.pop('data')
cfg.merge_from_dict(Config(data_func(cfg.data_dir)))
cfg.workflow = cfg.get('workflow', [])
if cfg.get('norm_cfg', None) is not None and cfg.launcher == 'none':
cfg.norm_cfg = 'BN'
# modify loading COCO from extern
# if hasattr(cfg, 'data'):
# cfg.data.train['ann_file'] = cfg.data.train['ann_file'].replace('data', cfg.data_dir)
# cfg.data.train['img_prefix'] = cfg.data.train['img_prefix'].replace('data', cfg.data_dir)
# cfg.data.val['ann_file'] = cfg.data.val['ann_file'].replace('data', cfg.data_dir)
# cfg.data.val['img_prefix'] = cfg.data.val['img_prefix'].replace('data', cfg.data_dir)
# cfg.samples_per_gpu = cfg.data.samples_per_gpu
# cfg.workers_per_gpu = cfg.data.workers_per_gpu
return cfg
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/postprocess.py
================================================
# GPL License
# Copyright (C) UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
from typing import Union, Optional, List, Tuple, Text, BinaryIO
from PIL import Image
import cv2
import os
import numpy as np
import io
import pathlib
import torch
import math
irange = range
def format_np_output(np_arr):
"""
This is a (kind of) bandaid fix to streamline saving procedure.
It converts all the outputs to the same format which is 3xWxH
with using sucecssive if clauses.
Args:
im_as_arr (Numpy array): Matrix of shape 1xWxH or WxH or 3xWxH
"""
# Phase/Case 1: The np arr only has 2 dimensions
# Result: Add a dimension at the beginning
if len(np_arr.shape) == 2:
np_arr = np.expand_dims(np_arr, axis=0)
# Phase/Case 2: Np arr has only 1 channel (assuming first dim is channel)
# Result: Repeat first channel and convert 1xWxH to 3xWxH
if np_arr.shape[0] == 1:
np_arr = np.repeat(np_arr, 3, axis=0)
# Phase/Case 3: Np arr is of shape 3xWxH
# Result: Convert it to WxHx3 in order to make it saveable by PIL
if np_arr.shape[0] == 3:
np_arr = np_arr.transpose(1, 2, 0)
# Phase/Case 4: NP arr is normalized between 0-1
# Result: Multiply with 255 and change type to make it saveable by PIL
if np.max(np_arr) <= 1:
np_arr = (np_arr * 255).astype(np.uint8)
return np_arr
def save_image(im, path):
"""
Saves a numpy matrix or PIL image as an image
Args:
im_as_arr (Numpy array): Matrix of shape DxWxH
path (str): Path to the image
"""
if isinstance(im, (np.ndarray, np.generic)):
im = format_np_output(im)
im = Image.fromarray(im)
im.save(path)
def norm_image(image, factor=255.):
"""
标准化图像
:param factor:
:param image: [H,W,C]
:return:
"""
image = image.copy()
image -= np.max(np.min(image), 0)
image /= np.max(image)
if factor == 255. or factor == 255:
image *= factor
return np.uint8(image)
else:
return image
def convert_to_grayscale(im_as_arr):
"""
Converts 3d image to grayscale
Args:
im_as_arr (numpy arr): RGB image with shape (D,W,H)
returns:
grayscale_im (numpy_arr): Grayscale image with shape (1,W,D)
"""
# grayscale_im = np.sum(np.abs(im_as_arr), axis=0)
# im_max = np.percentile(grayscale_im, 99)
# im_min = np.min(grayscale_im)
# grayscale_im = (np.clip((grayscale_im - im_min) / (im_max - im_min), 0, 1))
# grayscale_im = np.expand_dims(grayscale_im, axis=0)
# return grayscale_im
grayscale_im = np.sum(np.abs(im_as_arr), axis=-1)
im_max = np.percentile(grayscale_im, 99)
im_min = np.min(grayscale_im)
grayscale_im = (np.clip((grayscale_im - im_min) / (im_max - im_min), 0, 1))
grayscale_im = np.expand_dims(grayscale_im, axis=-1)
return grayscale_im
def apply_gradient_images(gradient, file_name, is_save=False):
"""
Exports the original gradient image
Args:
gradient (np arr): Numpy array of the gradient with shape (3, 224, 224)
file_name (str): File name to be exported
"""
if not os.path.exists('../results'):
os.makedirs('../results')
# Normalize
gradient = gradient - gradient.min()
gradient /= gradient.max()
# Save image
if is_save:
path_to_file = os.path.join('../results', file_name + '.jpg')
save_image(gradient, path_to_file)
return None
else:
return gradient
# misc_function
import matplotlib.cm as mpl_color_map
import copy
import PIL
def gen_colormap(input_image, feature, gradient, factor=255):
if feature.size(0) == 1:
feature = feature.squeeze(0)
if gradient.size(0) == 1:
gradient = gradient.squeeze(0)
gradient = gradient.cpu().data.numpy() # [C,H,W]
weight = np.mean(gradient, axis=(1, 2)) # [C]
feature = feature.cpu().data.numpy() # [C,H,W]
cam = feature * weight[:, np.newaxis, np.newaxis] # [C,H,W]
cam = np.sum(cam, axis=0) # [H,W]
cam = np.maximum(cam, 0) # ReLU
# 数值归一化
# cam -= np.min(cam)
# cam /= np.max(cam)
# cam = np.maximum(cam, 0)
cam = (cam - np.min(cam)) / (np.max(cam) - np.min(cam)) # Normalize between 0-1
cam = np.uint8(cam * factor) # Scale between 0-255 to visualize
cam = np.uint8(Image.fromarray(cam).resize((input_image.shape[2],
input_image.shape[3]), Image.ANTIALIAS)) / factor
return cam
def apply_colormap_on_image(org_im, activation, colormap_name):
"""
Apply heatmap on image
Args:
org_img (PIL img): Original image
activation_map (numpy arr): Activation map (grayscale) 0-255
colormap_name (str): Name of the colormap
"""
if not isinstance(org_im, np.ndarray):
org_im = org_im[0, :3, ...].permute(1, 2, 0)
org_im = org_im.cpu().numpy() * 255
org_im = PIL.Image.fromarray(org_im.astype(np.uint8))
else:
org_im = org_im * 255
org_im = PIL.Image.fromarray(org_im.astype(np.uint8))
# Get colormap
'''
'''
color_map = mpl_color_map.get_cmap(colormap_name)
no_trans_heatmap = color_map(activation)
# Change alpha channel in colormap to make sure original image is displayed
heatmap = copy.copy(no_trans_heatmap)
heatmap[..., 3] = 0.4
heatmap = Image.fromarray((heatmap * 255).astype(np.uint8))
heatmap = heatmap.resize(org_im.size, Image.ANTIALIAS)
no_trans_heatmap = Image.fromarray((no_trans_heatmap * 255).astype(np.uint8))
# Apply heatmap on image
heatmap_on_image = Image.new("RGBA", org_im.size)
heatmap_on_image = Image.alpha_composite(heatmap_on_image, org_im.convert('RGBA'))
heatmap_on_image = Image.alpha_composite(heatmap_on_image, heatmap)
return no_trans_heatmap, heatmap_on_image
def get_positive_negative_saliency(gradient):
"""
Generates positive and negative saliency maps based on the gradient
Args:
gradient (numpy arr): Gradient of the operation to visualize
returns:
pos_saliency ( )
"""
pos_saliency = (np.maximum(0, gradient) / gradient.max())
neg_saliency = (np.maximum(0, -gradient) / -gradient.min())
return pos_saliency, neg_saliency
# hook_test/Viz/main
def gen_grad_cam(image, feature, gradient):
if feature.size(0) == 1:
feature = feature.squeeze(0)
if gradient.size(0) == 1:
gradient = gradient.squeeze(0)
gradient = gradient # .cpu().data.numpy() # [C,H,W]
weight = torch.mean(gradient, dim=(1, 2)) # [C]
# feature = feature.cpu().data.numpy() # [C,H,W]
# cam = feature * weight[:, np.newaxis, np.newaxis]
cam = feature * weight[:, np.newaxis, np.newaxis] # [C,H,W]
cam = torch.maximum(cam, torch.zeros_like(cam)) # ReLU
cam = torch.sum(cam, dim=0) # [H,W]
# cam = torch.mean(feature, dim=0)
# cam = torch.maximum(cam, torch.zeros_like(cam)) # ReLU
# 数值归一化
cam -= torch.min(cam)
cam /= (torch.max(cam) - torch.min(cam) + 1e-8)
return cam.cpu().data.numpy()
def apply_heatmap(image, mask, factor=255):
"""
生成CAM图
:param image: [H,W,C],原始图像
:param mask: [H,W],范围0~1
:return: tuple(cam,heatmap)
"""
# mask转为heatmap
if not isinstance(image, np.ndarray):
image = image[0, :3, ...].permute(1, 2, 0)
image = image.cpu().numpy()
if not isinstance(mask, np.ndarray):
mask = mask.cpu().numpy()
# heatmaps = np.tile(np.zeros_like(mask)[..., np.newaxis], [1, 1, 1, 3])
# for c_idx in range(mask.shape[0]):
# c_mask = mask[c_idx, ..., np.newaxis]
# heatmap = cv2.applyColorMap(np.uint8(255 * c_mask), cv2.COLORMAP_JET)
# heatmaps[c_idx, ...] = np.float32(heatmap) / 255
# heatmaps = heatmaps[..., ::-1] # gbr to rgb
# mask转为heatmap
heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET)
heatmap = np.float32(heatmap) / 255
heatmap = heatmap[..., ::-1] # gbr to rgb
# 合并heatmap到原始图像
cam = cv2.resize(heatmap, image.shape[:2]) + np.float32(image)
return norm_image(cam, 2048), (heatmap * 255).astype(np.uint8)
# cam = heatmaps[np.newaxis, ...] + np.float32(image)
# return norm_image(cam), (heatmaps * 255).astype(np.uint8)
def showimage8(images, unnormlize=2047.0, first_channel=False):
assert images.shape[1] >= 3, print("input images format is not suitable")
if isinstance(images, torch.Tensor):
unnormlize = np.where(max(np.float(torch.max(images)), 1.0) > 1.0, 1.0, unnormlize)
if first_channel:
images = images.permute(1, 2, 0)
output = images[..., [0, 2, 4]] * torch.tensor(unnormlize)
output = torch.clamp(output, 0, 2047)
output = output.cpu().detach().numpy()
norm_image = linstretch(output)
return norm_image[:, :, ::-1]
def linstretch(images, tol=None):
'''
NM = N*M;
for i=1:3
b = reshape(double(uint16(ImageToView(:,:,i))),NM,1);
[hb,levelb] = hist(b,max(b)-min(b));
chb = cumsum(hb);#沿第一个非单一维运算。matlab矩阵顺序 HxWxC,列的累计和
t(1)=ceil(levelb(find(chb>NM*tol(i,1), 1 )));
t(2)=ceil(levelb(find(chb<NM*tol(i,2), 1, 'last' )));
%t(2) = 1;
b(b<t(1))=t(1);
b(b>t(2))=t(2);
b = (b-t(1))/(t(2)-t(1));
ImageToView(:,:,i) = reshape(b,N,M);
end
'''
# images = np.random.randn(64, 64, 3) * 2047.0
if tol is None:
tol = [0.01, 0.995]
if images.ndim == 3:
h, w, channels = images.shape
else:
images = np.expand_dims(images, axis=-1)
h, w, channels = images.shape
N = h * w
for c in range(channels):
image = np.float32(np.round(images[:, :, c])).reshape(N, 1)
hb, levelb = np.histogram(image, bins=math.ceil(image.max() - image.min()))
chb = np.cumsum(hb, 0)
levelb_center = levelb[:-1] + (levelb[1] - levelb[0]) / 2
lbc_min, lbc_max = levelb_center[chb > N * tol[0]][0], levelb_center[chb < N * tol[1]][-1]
image = np.clip(image, a_min=lbc_min, a_max=lbc_max)
image = (image - lbc_min) / (lbc_max - lbc_min)
images[..., c] = np.reshape(image, (h, w))
images = np.squeeze(images)
return images
def make_grid(
tensor: Union[torch.Tensor, List[torch.Tensor]],
mode: str = "grey",
nrow: int = 8,
padding: int = 2,
normalize: bool = False,
range: Optional[Tuple[int, int]] = None,
scale_each: bool = False,
pad_value: int = 0,
) -> torch.Tensor:
"""Make a grid of images.
Args:
tensor (Tensor or list): 4D mini-batch Tensor of shape (B x C x H x W)
or a list of images all of the same size.
mode (str, optional): 人为设定通道模式
nrow (int, optional): Number of images displayed in each row of the grid.
The final grid size is ``(B / nrow, nrow)``. Default: ``8``.
padding (int, optional): amount of padding. Default: ``2``.
normalize (bool, optional): If True, shift the image to the range (0, 1),
by the min and max values specified by :attr:`range`. Default: ``False``.
range (tuple, optional): tuple (min, max) where min and max are numbers,
then these numbers are used to normalize the image. By default, min and max
are computed from the tensor.
scale_each (bool, optional): If ``True``, scale each image in the batch of
images separately rather than the (min, max) over all images. Default: ``False``.
pad_value (float, optional): Value for the padded pixels. Default: ``0``.
Example:
See this notebook `here <https://gist.github.com/anonymous/bf16430f7750c023141c562f3e9f2a91>`_
"""
if not (torch.is_tensor(tensor) or
(isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))):
raise TypeError('tensor or list of tensors expected, got {}'.format(type(tensor)))
# if list of tensors, convert to a 4D mini-batch Tensor
if isinstance(tensor, list):
tensor = torch.stack(tensor, dim=0)
if tensor.dim() == 2: # single image H x W
tensor = tensor.unsqueeze(0)
if tensor.dim() == 3: # single image
if tensor.size(0) == 1: # if single-channel, convert to 3-channel
tensor = torch.cat((tensor, tensor, tensor), 0)
tensor = tensor.unsqueeze(0)
if tensor.dim() == 4 and tensor.size(1) == 1: # single-channel images
if mode == "RGB":
tensor = torch.cat((tensor, tensor, tensor), 1)
if normalize is True:
tensor = tensor.clone() # avoid modifying tensor in-place
if range is not None:
assert isinstance(range, tuple), \
"range has to be a tuple (min, max) if specified. min and max are numbers"
def norm_ip(img, min, max):
img.clamp_(min=min, max=max)
img.add_(-min).div_(max - min + 1e-5)
def norm_range(t, range):
if range is not None:
norm_ip(t, range[0], range[1])
else:
norm_ip(t, float(t.min()), float(t.max()))
if scale_each is True:
for t in tensor: # loop over mini-batch dimension
norm_range(t, range)
else:
norm_range(tensor, range)
if tensor.size(0) == 1:
return tensor.squeeze(0)
# make the mini-batch of images into a grid
nmaps = tensor.size(0)
xmaps = min(nrow, nmaps)
ymaps = int(math.ceil(float(nmaps) / xmaps))
height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding)
num_channels = tensor.size(1)
grid = tensor.new_full((num_channels, height * ymaps + padding, width * xmaps + padding), pad_value)
k = 0
for y in irange(ymaps):
for x in irange(xmaps):
if k >= nmaps:
break
# Tensor.copy_() is a valid method but seems to be missing from the stubs
# https://pytorch.org/docs/stable/tensors.html#torch.Tensor.copy_
grid.narrow(1, y * height + padding, height - padding).narrow( # type: ignore[attr-defined]
2, x * width + padding, width - padding
).copy_(tensor[k])
k = k + 1
return grid
def tensor_save_image(
tensor: Union[torch.Tensor, List[torch.Tensor]],
fp: Union[Text, pathlib.Path, BinaryIO],
nrow: int = 8,
padding: int = 2,
normalize: bool = False,
range: Optional[Tuple[int, int]] = None,
scale_each: bool = False,
pad_value: int = 0,
format: Optional[str] = None,
) -> None:
"""Save a given Tensor into an image file.
Args:
tensor (Tensor or list): Image to be saved. If given a mini-batch tensor,
saves the tensor as a grid of images by calling ``make_grid``.
fp (string or file object): A filename or a file object
format(Optional): If omitted, the format to use is determined from the filename extension.
If a file object was used instead of a filename, this parameter should always be used.
**kwargs: Other arguments are documented in ``make_grid``.
"""
from PIL import Image
grid = make_grid(tensor, nrow=nrow, padding=padding, pad_value=pad_value,
normalize=normalize, range=range, scale_each=scale_each)
# Add 0.5 after unnormalizing to [0, 255] to round to nearest integer
ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()
im = Image.fromarray(ndarr)
im.save(fp, format=format)
if __name__ == "__main__":
a = np.random.randn(3, 3)
linstretch(a)
================================================
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/python_sub_class.py
================================================
# GPL License
# Copyright (C) UESTC
# All Rights Reserved
# @Author : Xiao Wu, LiangJian Deng
# @reference:
import torch
from UDL.pansharpening.evaluation.ps_evaluate import analysis_accu, save_results
from UDL.Basis.config import Config
import warnings
import scipy.io as sio
class TaskDispatcher(Config):
_task = dict()
def __init_subclass__(cls, name='', **kwargs):
super().__init_subclass__(**kwargs)
if name != '':
cls._task[name] = cls
cls._name = name
# print(cls.__repr__, cls..__repr__)
else:
# warnings.warn(f'Creating a subclass of MetaModel {cls.__name__} with no name.')
cls._task[cls.__name__] = cls
cls._name = cls.__name__
def __new__(cls, *args, **kwargs):
if cls is TaskDispatcher:
task = kwargs.get('task')
try:
cls = cls._task[task]
except KeyError:
raise ValueError(f'Got task={task} but expected'
f'one of {cls._task.keys()}')
instance = super().__new__(cls)
return instance
# def __len__(self):
# return len(self._cfg_dict)
#
# def __getattr__(self, name):
# return getattr(self._cfg_dict, name)
#
# def __delattr__(self, name):
# return delattr(self._cfg_dict, name)
#
# def __getitem__(self, name):
# return self._cfg_dict.__getitem__(name)
#
# def __iter__(self):
# return iter(self._cfg_dict)
#
# def __repr__(self):
# return f'TaskDispatcher {self._cfg_dict.__repr__()}'
# def __setattr__(self, name, value):
# if isinstance(value, dict):
# value = ConfigDict(value)
# print("__setattr__")
# self._cfg_dict.__setattr__(name, value)
# def __setitem__(self, name, value):
# if isinstance(value, dict):
# value = ConfigDict(value)
# print("__setitem__")
# self._cfg_dict.__setitem__(name, value)
@classmethod
def new(cls, **kwargs):
# 需要从外部启动和从任务启动，但参数不同
key = 'mode'
value = kwargs.setdefault('mode', None)
print('111', value)
if value is None:
# 第二、三调用层进入此函数
key = 'task'
if kwargs.get('task', None):
# 二
value = kwargs.pop('task')
print('222', value)
elif kwargs.get('arch', None):
# 三
key = 'arch'
value = kwargs.pop('arch')
print('333', value)
else:
key = 'arch'
kwargs.pop('mode')
try:
cls = cls._task[value]
except KeyError:
warning = f'Got {key}={value} but expected ' \
f'one of {cls._task.keys()}'
warnings.warn(warning)
return Config()
return cls(**kwargs)
class ModelDispatcher(object):
_task = dict()
def __init_subclass__(cls, name='', **kwargs):
super().__init_subclass__(**kwargs)
if name != '':
cls._task[name] = cls
cls._name = name
# print(cls.__repr__, cls..__repr__)
else:
# warnings.warn(f'Creating a subclass of MetaModel {cls.__name__} with no name.')
cls._task[cls.__name__] = cls
cls._name = cls.__name__
def __new__(cls, *args, **kwargs):
if cls is ModelDispatcher:
task = kwargs.get('task')
try:
cls = cls._task[task]
except KeyError:
raise ValueError(f'Got task={task} but expected'
f'one of {cls._task.keys()}')
instance = super().__new__(cls)
return instance
@classmethod
def build_model(cls, cfg):
arch = cfg.arch
task = cfg.task
model_style = cfg.model_style
try:
# 获得PansharpeningModel,进行分发
cls = cls._task[task](None, None)
except KeyError:
raise ValueError(f'Got task={task} but expected '
gitextract_54ils51p/
├── .gitignore
├── 01-DL-toolbox(Pytorch)/
│ ├── LICENSE
│ ├── UDL/
│ │ ├── AutoDL/
│ │ │ ├── __init__.py
│ │ │ └── trainer.py
│ │ ├── Basis/
│ │ │ ├── auxiliary/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── base.py
│ │ │ │ ├── fp16_utils.py
│ │ │ │ ├── torchstat/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── __main__.py
│ │ │ │ │ ├── compute_flops.py
│ │ │ │ │ ├── compute_madd.py
│ │ │ │ │ ├── compute_memory.py
│ │ │ │ │ ├── model_hook.py
│ │ │ │ │ ├── reporter.py
│ │ │ │ │ ├── stat_tree.py
│ │ │ │ │ └── statistics.py
│ │ │ │ └── utils.py
│ │ │ ├── cal_ssim.py
│ │ │ ├── config.py
│ │ │ ├── criterion_metrics.py
│ │ │ ├── dist_utils.py
│ │ │ ├── kill_dist.sh
│ │ │ ├── launch.py
│ │ │ ├── logger.py
│ │ │ ├── metrics.py
│ │ │ ├── optim.py
│ │ │ ├── option.py
│ │ │ ├── postprocess.py
│ │ │ ├── python_sub_class.py
│ │ │ ├── slurm_train.sh
│ │ │ ├── snmn_d.sh
│ │ │ └── variance_sacling_initializer.py
│ │ ├── Data/
│ │ │ └── pansharpening/
│ │ │ ├── test_data/
│ │ │ │ └── readme-test.txt
│ │ │ ├── training_data/
│ │ │ │ └── readme-test.txt
│ │ │ └── validation_data/
│ │ │ └── readme-test.txt
│ │ ├── mmcv/
│ │ │ ├── CITATION.cff
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── Dockerfile
│ │ │ ├── Jenkinsfile
│ │ │ ├── LICENSE
│ │ │ ├── LICENSES.md
│ │ │ ├── MANIFEST.in
│ │ │ ├── README_zh-CN.md
│ │ │ ├── TERMINOLOGY.md
│ │ │ ├── docs/
│ │ │ │ ├── en/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── _static/
│ │ │ │ │ │ └── css/
│ │ │ │ │ │ └── readthedocs.css
│ │ │ │ │ ├── api.rst
│ │ │ │ │ ├── community/
│ │ │ │ │ │ └── pr.md
│ │ │ │ │ ├── compatibility.md
│ │ │ │ │ ├── conf.py
│ │ │ │ │ ├── deployment/
│ │ │ │ │ │ ├── mmcv_ops_definition.md
│ │ │ │ │ │ ├── onnx.md
│ │ │ │ │ │ ├── onnxruntime_custom_ops.md
│ │ │ │ │ │ ├── onnxruntime_op.md
│ │ │ │ │ │ ├── tensorrt_custom_ops.md
│ │ │ │ │ │ └── tensorrt_plugin.md
│ │ │ │ │ ├── faq.md
│ │ │ │ │ ├── get_started/
│ │ │ │ │ │ ├── build.md
│ │ │ │ │ │ ├── installation.md
│ │ │ │ │ │ ├── introduction.md
│ │ │ │ │ │ └── previous_versions.md
│ │ │ │ │ ├── index.rst
│ │ │ │ │ ├── make.bat
│ │ │ │ │ └── understand_mmcv/
│ │ │ │ │ ├── cnn.md
│ │ │ │ │ ├── config.md
│ │ │ │ │ ├── data_process.md
│ │ │ │ │ ├── io.md
│ │ │ │ │ ├── ops.md
│ │ │ │ │ ├── registry.md
│ │ │ │ │ ├── runner.md
│ │ │ │ │ ├── utils.md
│ │ │ │ │ └── visualization.md
│ │ │ │ └── zh_cn/
│ │ │ │ ├── Makefile
│ │ │ │ ├── _static/
│ │ │ │ │ └── css/
│ │ │ │ │ └── readthedocs.css
│ │ │ │ ├── api.rst
│ │ │ │ ├── community/
│ │ │ │ │ ├── contributing.md
│ │ │ │ │ └── pr.md
│ │ │ │ ├── compatibility.md
│ │ │ │ ├── conf.py
│ │ │ │ ├── deployment/
│ │ │ │ │ ├── onnx.md
│ │ │ │ │ ├── onnxruntime_custom_ops.md
│ │ │ │ │ ├── onnxruntime_op.md
│ │ │ │ │ ├── tensorrt_custom_ops.md
│ │ │ │ │ └── tensorrt_plugin.md
│ │ │ │ ├── faq.md
│ │ │ │ ├── get_started/
│ │ │ │ │ ├── build.md
│ │ │ │ │ ├── installation.md
│ │ │ │ │ ├── introduction.md
│ │ │ │ │ └── previous_versions.md
│ │ │ │ ├── index.rst
│ │ │ │ ├── make.bat
│ │ │ │ └── understand_mmcv/
│ │ │ │ ├── cnn.md
│ │ │ │ ├── config.md
│ │ │ │ ├── data_process.md
│ │ │ │ ├── io.md
│ │ │ │ ├── ops.md
│ │ │ │ ├── registry.md
│ │ │ │ ├── runner.md
│ │ │ │ ├── utils.md
│ │ │ │ └── visualization.md
│ │ │ ├── examples/
│ │ │ │ └── train.py
│ │ │ ├── mmcv/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── arraymisc/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── quantization.py
│ │ │ │ ├── cnn/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── alexnet.py
│ │ │ │ │ ├── bricks/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── activation.py
│ │ │ │ │ │ ├── context_block.py
│ │ │ │ │ │ ├── conv.py
│ │ │ │ │ │ ├── conv2d_adaptive_padding.py
│ │ │ │ │ │ ├── conv_module.py
│ │ │ │ │ │ ├── conv_ws.py
│ │ │ │ │ │ ├── depthwise_separable_conv_module.py
│ │ │ │ │ │ ├── drop.py
│ │ │ │ │ │ ├── generalized_attention.py
│ │ │ │ │ │ ├── hsigmoid.py
│ │ │ │ │ │ ├── hswish.py
│ │ │ │ │ │ ├── non_local.py
│ │ │ │ │ │ ├── norm.py
│ │ │ │ │ │ ├── padding.py
│ │ │ │ │ │ ├── plugin.py
│ │ │ │ │ │ ├── registry.py
│ │ │ │ │ │ ├── scale.py
│ │ │ │ │ │ ├── swish.py
│ │ │ │ │ │ ├── transformer.py
│ │ │ │ │ │ ├── upsample.py
│ │ │ │ │ │ └── wrappers.py
│ │ │ │ │ ├── builder.py
│ │ │ │ │ ├── resnet.py
│ │ │ │ │ ├── utils/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── flops_counter.py
│ │ │ │ │ │ ├── fuse_conv_bn.py
│ │ │ │ │ │ ├── sync_bn.py
│ │ │ │ │ │ └── weight_init.py
│ │ │ │ │ └── vgg.py
│ │ │ │ ├── engine/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── test.py
│ │ │ │ ├── fileio/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── file_client.py
│ │ │ │ │ ├── handlers/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── base.py
│ │ │ │ │ │ ├── json_handler.py
│ │ │ │ │ │ ├── pickle_handler.py
│ │ │ │ │ │ └── yaml_handler.py
│ │ │ │ │ ├── io.py
│ │ │ │ │ └── parse.py
│ │ │ │ ├── image/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── colorspace.py
│ │ │ │ │ ├── geometric.py
│ │ │ │ │ ├── io.py
│ │ │ │ │ ├── misc.py
│ │ │ │ │ └── photometric.py
│ │ │ │ ├── onnx/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── info.py
│ │ │ │ │ ├── onnx_utils/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── symbolic_helper.py
│ │ │ │ │ └── symbolic.py
│ │ │ │ ├── ops/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── active_rotated_filter.py
│ │ │ │ │ ├── assign_score_withk.py
│ │ │ │ │ ├── ball_query.py
│ │ │ │ │ ├── bbox.py
│ │ │ │ │ ├── border_align.py
│ │ │ │ │ ├── box_iou_rotated.py
│ │ │ │ │ ├── carafe.py
│ │ │ │ │ ├── cc_attention.py
│ │ │ │ │ ├── contour_expand.py
│ │ │ │ │ ├── convex_iou.py
│ │ │ │ │ ├── corner_pool.py
│ │ │ │ │ ├── correlation.py
│ │ │ │ │ ├── csrc/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── common/
│ │ │ │ │ │ │ ├── box_iou_rotated_utils.hpp
│ │ │ │ │ │ │ ├── cuda/
│ │ │ │ │ │ │ │ ├── active_rotated_filter_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── assign_score_withk_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── ball_query_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── bbox_overlaps_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── border_align_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── box_iou_rotated_cuda.cuh
│ │ │ │ │ │ │ │ ├── carafe_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── carafe_naive_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── common_cuda_helper.hpp
│ │ │ │ │ │ │ │ ├── convex_iou_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── correlation_cuda.cuh
│ │ │ │ │ │ │ │ ├── deform_conv_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── deform_roi_pool_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── furthest_point_sample_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── gather_points_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── group_points_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── iou3d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── knn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── masked_conv2d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── min_area_polygons_cuda.cuh
│ │ │ │ │ │ │ │ ├── modulated_deform_conv_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── ms_deform_attn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── nms_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── nms_rotated_cuda.cuh
│ │ │ │ │ │ │ │ ├── parrots_cudawarpfunction.cuh
│ │ │ │ │ │ │ │ ├── points_in_boxes_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── points_in_polygons_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── psamask_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── riroi_align_rotated_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roi_align_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roi_align_rotated_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roi_pool_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roiaware_pool3d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── roipoint_pool3d_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── rotated_feature_align_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── scatter_points_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── sigmoid_focal_loss_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── softmax_focal_loss_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── sync_bn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── three_interpolate_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── three_nn_cuda_kernel.cuh
│ │ │ │ │ │ │ │ ├── tin_shift_cuda_kernel.cuh
│ │ │ │ │ │ │ │ └── voxelization_cuda_kernel.cuh
│ │ │ │ │ │ │ ├── parrots_cpp_helper.hpp
│ │ │ │ │ │ │ ├── parrots_cuda_helper.hpp
│ │ │ │ │ │ │ ├── pytorch_cpp_helper.hpp
│ │ │ │ │ │ │ ├── pytorch_cuda_helper.hpp
│ │ │ │ │ │ │ └── pytorch_device_registry.hpp
│ │ │ │ │ │ ├── onnxruntime/
│ │ │ │ │ │ │ ├── corner_pool.h
│ │ │ │ │ │ │ ├── cpu/
│ │ │ │ │ │ │ │ ├── corner_pool.cpp
│ │ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ │ ├── gridSample.cpp
│ │ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ │ ├── onnxruntime_register.cpp
│ │ │ │ │ │ │ │ ├── reduce_ops.cpp
│ │ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ │ └── soft_nms.cpp
│ │ │ │ │ │ │ ├── deform_conv.h
│ │ │ │ │ │ │ ├── grid_sample.h
│ │ │ │ │ │ │ ├── modulated_deform_conv.h
│ │ │ │ │ │ │ ├── nms.h
│ │ │ │ │ │ │ ├── onnxruntime_register.h
│ │ │ │ │ │ │ ├── onnxruntime_session_options_config_keys.h
│ │ │ │ │ │ │ ├── ort_mmcv_utils.h
│ │ │ │ │ │ │ ├── reduce_ops.h
│ │ │ │ │ │ │ ├── roi_align.h
│ │ │ │ │ │ │ ├── roi_align_rotated.h
│ │ │ │ │ │ │ └── soft_nms.h
│ │ │ │ │ │ ├── parrots/
│ │ │ │ │ │ │ ├── active_rotated_filter.cpp
│ │ │ │ │ │ │ ├── active_rotated_filter_parrots.cpp
│ │ │ │ │ │ │ ├── active_rotated_filter_pytorch.h
│ │ │ │ │ │ │ ├── assign_score_withk.cpp
│ │ │ │ │ │ │ ├── assign_score_withk_parrots.cpp
│ │ │ │ │ │ │ ├── assign_score_withk_pytorch.h
│ │ │ │ │ │ │ ├── ball_query._parrots.cpp
│ │ │ │ │ │ │ ├── ball_query.cpp
│ │ │ │ │ │ │ ├── ball_query_pytorch.h
│ │ │ │ │ │ │ ├── bbox_overlaps.cpp
│ │ │ │ │ │ │ ├── bbox_overlaps_parrots.cpp
│ │ │ │ │ │ │ ├── bbox_overlaps_pytorch.h
│ │ │ │ │ │ │ ├── border_align.cpp
│ │ │ │ │ │ │ ├── border_align_parrots.cpp
│ │ │ │ │ │ │ ├── border_align_pytorch.h
│ │ │ │ │ │ │ ├── box_iou_rotated.cpp
│ │ │ │ │ │ │ ├── box_iou_rotated_parrots.cpp
│ │ │ │ │ │ │ ├── box_iou_rotated_pytorch.h
│ │ │ │ │ │ │ ├── carafe.cpp
│ │ │ │ │ │ │ ├── carafe_naive.cpp
│ │ │ │ │ │ │ ├── carafe_naive_parrots.cpp
│ │ │ │ │ │ │ ├── carafe_naive_pytorch.h
│ │ │ │ │ │ │ ├── carafe_parrots.cpp
│ │ │ │ │ │ │ ├── carafe_pytorch.h
│ │ │ │ │ │ │ ├── contour_expand.cpp
│ │ │ │ │ │ │ ├── contour_expand_parrots.cpp
│ │ │ │ │ │ │ ├── contour_expand_pytorch.h
│ │ │ │ │ │ │ ├── convex_iou.cpp
│ │ │ │ │ │ │ ├── convex_iou_parrots.cpp
│ │ │ │ │ │ │ ├── convex_iou_pytorch.h
│ │ │ │ │ │ │ ├── corner_pool.cpp
│ │ │ │ │ │ │ ├── corner_pool_parrots.cpp
│ │ │ │ │ │ │ ├── corner_pool_pytorch.h
│ │ │ │ │ │ │ ├── correlation.cpp
│ │ │ │ │ │ │ ├── correlation_parrots.cpp
│ │ │ │ │ │ │ ├── correlation_pytorch.h
│ │ │ │ │ │ │ ├── cudabind.cpp
│ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ ├── deform_conv_parrots.cpp
│ │ │ │ │ │ │ ├── deform_conv_pytorch.h
│ │ │ │ │ │ │ ├── deform_roi_pool.cpp
│ │ │ │ │ │ │ ├── deform_roi_pool_parrots.cpp
│ │ │ │ │ │ │ ├── deform_roi_pool_pytorch.h
│ │ │ │ │ │ │ ├── focal_loss.cpp
│ │ │ │ │ │ │ ├── focal_loss_parrots.cpp
│ │ │ │ │ │ │ ├── focal_loss_pytorch.h
│ │ │ │ │ │ │ ├── furthest_point_sample.cpp
│ │ │ │ │ │ │ ├── furthest_point_sample_parrots.cpp
│ │ │ │ │ │ │ ├── furthest_point_sample_pytorch.h
│ │ │ │ │ │ │ ├── fused_bias_leakyrelu.cpp
│ │ │ │ │ │ │ ├── fused_bias_parrots.cpp
│ │ │ │ │ │ │ ├── gather_points.cpp
│ │ │ │ │ │ │ ├── gather_points_parrots.cpp
│ │ │ │ │ │ │ ├── gather_points_pytorch.h
│ │ │ │ │ │ │ ├── group_points.cpp
│ │ │ │ │ │ │ ├── group_points_parrots.cpp
│ │ │ │ │ │ │ ├── group_points_pytorch.h
│ │ │ │ │ │ │ ├── info.cpp
│ │ │ │ │ │ │ ├── iou3d.cpp
│ │ │ │ │ │ │ ├── iou3d_parrots.cpp
│ │ │ │ │ │ │ ├── iou3d_pytorch.h
│ │ │ │ │ │ │ ├── knn.cpp
│ │ │ │ │ │ │ ├── knn_parrots.cpp
│ │ │ │ │ │ │ ├── knn_pytorch.h
│ │ │ │ │ │ │ ├── masked_conv2d.cpp
│ │ │ │ │ │ │ ├── masked_conv2d_parrots.cpp
│ │ │ │ │ │ │ ├── masked_conv2d_pytorch.h
│ │ │ │ │ │ │ ├── min_area_polygons.cpp
│ │ │ │ │ │ │ ├── min_area_polygons_parrots.cpp
│ │ │ │ │ │ │ ├── min_area_polygons_pytorch.h
│ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ ├── modulated_deform_conv_parrots.cpp
│ │ │ │ │ │ │ ├── modulated_deform_conv_pytorch.h
│ │ │ │ │ │ │ ├── ms_deform_attn.cpp
│ │ │ │ │ │ │ ├── ms_deform_attn_parrots.cpp
│ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ ├── nms_parrots.cpp
│ │ │ │ │ │ │ ├── nms_pytorch.h
│ │ │ │ │ │ │ ├── nms_rotated.cpp
│ │ │ │ │ │ │ ├── pixel_group.cpp
│ │ │ │ │ │ │ ├── pixel_group_parrots.cpp
│ │ │ │ │ │ │ ├── pixel_group_pytorch.h
│ │ │ │ │ │ │ ├── points_in_boxes.cpp
│ │ │ │ │ │ │ ├── points_in_boxes_parrots.cpp
│ │ │ │ │ │ │ ├── points_in_boxes_pytorch.h
│ │ │ │ │ │ │ ├── points_in_polygons.cpp
│ │ │ │ │ │ │ ├── points_in_polygons_parrots.cpp
│ │ │ │ │ │ │ ├── points_in_polygons_pytorch.h
│ │ │ │ │ │ │ ├── psamask.cpp
│ │ │ │ │ │ │ ├── psamask_parrots.cpp
│ │ │ │ │ │ │ ├── psamask_pytorch.h
│ │ │ │ │ │ │ ├── riroi_align_rotated.cpp
│ │ │ │ │ │ │ ├── riroi_align_rotated_parrots.cpp
│ │ │ │ │ │ │ ├── riroi_align_rotated_pytorch.h
│ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ ├── roi_align_parrots.cpp
│ │ │ │ │ │ │ ├── roi_align_pytorch.h
│ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ ├── roi_align_rotated_parrots.cpp
│ │ │ │ │ │ │ ├── roi_align_rotated_pytorch.h
│ │ │ │ │ │ │ ├── roi_pool.cpp
│ │ │ │ │ │ │ ├── roi_pool_parrots.cpp
│ │ │ │ │ │ │ ├── roi_pool_pytorch.h
│ │ │ │ │ │ │ ├── roiaware_pool3d.cpp
│ │ │ │ │ │ │ ├── roiaware_pool3d_parrots.cpp
│ │ │ │ │ │ │ ├── roiaware_pool3d_pytorch.h
│ │ │ │ │ │ │ ├── roipoint_pool3d.cpp
│ │ │ │ │ │ │ ├── roipoint_pool3d_parrots.cpp
│ │ │ │ │ │ │ ├── roipoint_pool3d_pytorch.h
│ │ │ │ │ │ │ ├── rotated_feature_align.cpp
│ │ │ │ │ │ │ ├── rotated_feature_align_parrots.cpp
│ │ │ │ │ │ │ ├── rotated_feature_align_pytorch.h
│ │ │ │ │ │ │ ├── sync_bn.cpp
│ │ │ │ │ │ │ ├── sync_bn_parrots.cpp
│ │ │ │ │ │ │ ├── sync_bn_pytorch.h
│ │ │ │ │ │ │ ├── three_interpolate.cpp
│ │ │ │ │ │ │ ├── three_interpolate_parrots.cpp
│ │ │ │ │ │ │ ├── three_interpolate_pytorch.h
│ │ │ │ │ │ │ ├── three_nn.cpp
│ │ │ │ │ │ │ ├── three_nn_parrots.cpp
│ │ │ │ │ │ │ ├── three_nn_pytorch.h
│ │ │ │ │ │ │ ├── tin_shift.cpp
│ │ │ │ │ │ │ ├── tin_shift_parrots.cpp
│ │ │ │ │ │ │ ├── tin_shift_pytorch.h
│ │ │ │ │ │ │ ├── upfirdn2d.cpp
│ │ │ │ │ │ │ ├── upfirdn2d_parrots.cpp
│ │ │ │ │ │ │ ├── voxelization.cpp
│ │ │ │ │ │ │ ├── voxelization_parrots.cpp
│ │ │ │ │ │ │ └── voxelization_pytorch.h
│ │ │ │ │ │ ├── pytorch/
│ │ │ │ │ │ │ ├── active_rotated_filter.cpp
│ │ │ │ │ │ │ ├── assign_score_withk.cpp
│ │ │ │ │ │ │ ├── ball_query.cpp
│ │ │ │ │ │ │ ├── bbox_overlaps.cpp
│ │ │ │ │ │ │ ├── border_align.cpp
│ │ │ │ │ │ │ ├── box_iou_rotated.cpp
│ │ │ │ │ │ │ ├── carafe.cpp
│ │ │ │ │ │ │ ├── carafe_naive.cpp
│ │ │ │ │ │ │ ├── contour_expand.cpp
│ │ │ │ │ │ │ ├── convex_iou.cpp
│ │ │ │ │ │ │ ├── corner_pool.cpp
│ │ │ │ │ │ │ ├── correlation.cpp
│ │ │ │ │ │ │ ├── cpu/
│ │ │ │ │ │ │ │ ├── active_rotated_filter.cpp
│ │ │ │ │ │ │ │ ├── box_iou_rotated.cpp
│ │ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ │ ├── nms_rotated.cpp
│ │ │ │ │ │ │ │ ├── pixel_group.cpp
│ │ │ │ │ │ │ │ ├── points_in_boxes.cpp
│ │ │ │ │ │ │ │ ├── psamask.cpp
│ │ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ │ └── voxelization.cpp
│ │ │ │ │ │ │ ├── cuda/
│ │ │ │ │ │ │ │ ├── active_rotated_filter_cuda.cu
│ │ │ │ │ │ │ │ ├── assign_score_withk_cuda.cu
│ │ │ │ │ │ │ │ ├── ball_query_cuda.cu
│ │ │ │ │ │ │ │ ├── bbox_overlaps_cuda.cu
│ │ │ │ │ │ │ │ ├── border_align_cuda.cu
│ │ │ │ │ │ │ │ ├── box_iou_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── carafe_cuda.cu
│ │ │ │ │ │ │ │ ├── carafe_naive_cuda.cu
│ │ │ │ │ │ │ │ ├── convex_iou.cu
│ │ │ │ │ │ │ │ ├── correlation_cuda.cu
│ │ │ │ │ │ │ │ ├── cudabind.cpp
│ │ │ │ │ │ │ │ ├── deform_conv_cuda.cu
│ │ │ │ │ │ │ │ ├── deform_roi_pool_cuda.cu
│ │ │ │ │ │ │ │ ├── focal_loss_cuda.cu
│ │ │ │ │ │ │ │ ├── furthest_point_sample_cuda.cu
│ │ │ │ │ │ │ │ ├── fused_bias_leakyrelu_cuda.cu
│ │ │ │ │ │ │ │ ├── gather_points_cuda.cu
│ │ │ │ │ │ │ │ ├── group_points_cuda.cu
│ │ │ │ │ │ │ │ ├── iou3d_cuda.cu
│ │ │ │ │ │ │ │ ├── knn_cuda.cu
│ │ │ │ │ │ │ │ ├── masked_conv2d_cuda.cu
│ │ │ │ │ │ │ │ ├── min_area_polygons.cu
│ │ │ │ │ │ │ │ ├── modulated_deform_conv_cuda.cu
│ │ │ │ │ │ │ │ ├── ms_deform_attn_cuda.cu
│ │ │ │ │ │ │ │ ├── nms_cuda.cu
│ │ │ │ │ │ │ │ ├── nms_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── points_in_boxes_cuda.cu
│ │ │ │ │ │ │ │ ├── points_in_polygons_cuda.cu
│ │ │ │ │ │ │ │ ├── psamask_cuda.cu
│ │ │ │ │ │ │ │ ├── riroi_align_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── roi_align_cuda.cu
│ │ │ │ │ │ │ │ ├── roi_align_rotated_cuda.cu
│ │ │ │ │ │ │ │ ├── roi_pool_cuda.cu
│ │ │ │ │ │ │ │ ├── roiaware_pool3d_cuda.cu
│ │ │ │ │ │ │ │ ├── roipoint_pool3d_cuda.cu
│ │ │ │ │ │ │ │ ├── rotated_feature_align_cuda.cu
│ │ │ │ │ │ │ │ ├── scatter_points_cuda.cu
│ │ │ │ │ │ │ │ ├── sync_bn_cuda.cu
│ │ │ │ │ │ │ │ ├── three_interpolate_cuda.cu
│ │ │ │ │ │ │ │ ├── three_nn_cuda.cu
│ │ │ │ │ │ │ │ ├── tin_shift_cuda.cu
│ │ │ │ │ │ │ │ ├── upfirdn2d_kernel.cu
│ │ │ │ │ │ │ │ └── voxelization_cuda.cu
│ │ │ │ │ │ │ ├── deform_conv.cpp
│ │ │ │ │ │ │ ├── deform_roi_pool.cpp
│ │ │ │ │ │ │ ├── focal_loss.cpp
│ │ │ │ │ │ │ ├── furthest_point_sample.cpp
│ │ │ │ │ │ │ ├── fused_bias_leakyrelu.cpp
│ │ │ │ │ │ │ ├── gather_points.cpp
│ │ │ │ │ │ │ ├── group_points.cpp
│ │ │ │ │ │ │ ├── info.cpp
│ │ │ │ │ │ │ ├── iou3d.cpp
│ │ │ │ │ │ │ ├── knn.cpp
│ │ │ │ │ │ │ ├── masked_conv2d.cpp
│ │ │ │ │ │ │ ├── min_area_polygons.cpp
│ │ │ │ │ │ │ ├── modulated_deform_conv.cpp
│ │ │ │ │ │ │ ├── ms_deform_attn.cpp
│ │ │ │ │ │ │ ├── nms.cpp
│ │ │ │ │ │ │ ├── nms_rotated.cpp
│ │ │ │ │ │ │ ├── pixel_group.cpp
│ │ │ │ │ │ │ ├── points_in_boxes.cpp
│ │ │ │ │ │ │ ├── points_in_polygons.cpp
│ │ │ │ │ │ │ ├── psamask.cpp
│ │ │ │ │ │ │ ├── pybind.cpp
│ │ │ │ │ │ │ ├── riroi_align_rotated.cpp
│ │ │ │ │ │ │ ├── roi_align.cpp
│ │ │ │ │ │ │ ├── roi_align_rotated.cpp
│ │ │ │ │ │ │ ├── roi_pool.cpp
│ │ │ │ │ │ │ ├── roiaware_pool3d.cpp
│ │ │ │ │ │ │ ├── roipoint_pool3d.cpp
│ │ │ │ │ │ │ ├── rotated_feature_align.cpp
│ │ │ │ │ │ │ ├── scatter_points.cpp
│ │ │ │ │ │ │ ├── sync_bn.cpp
│ │ │ │ │ │ │ ├── three_interpolate.cpp
│ │ │ │ │ │ │ ├── three_nn.cpp
│ │ │ │ │ │ │ ├── tin_shift.cpp
│ │ │ │ │ │ │ ├── upfirdn2d.cpp
│ │ │ │ │ │ │ └── voxelization.cpp
│ │ │ │ │ │ └── tensorrt/
│ │ │ │ │ │ ├── plugins/
│ │ │ │ │ │ │ ├── trt_corner_pool.cpp
│ │ │ │ │ │ │ ├── trt_corner_pool_kernel.cu
│ │ │ │ │ │ │ ├── trt_cuda_helper.cu
│ │ │ │ │ │ │ ├── trt_cummaxmin.cpp
│ │ │ │ │ │ │ ├── trt_cummaxmin_kernel.cu
│ │ │ │ │ │ │ ├── trt_deform_conv.cpp
│ │ │ │ │ │ │ ├── trt_deform_conv_kernel.cu
│ │ │ │ │ │ │ ├── trt_grid_sampler.cpp
│ │ │ │ │ │ │ ├── trt_grid_sampler_kernel.cu
│ │ │ │ │ │ │ ├── trt_instance_norm.cpp
│ │ │ │ │ │ │ ├── trt_modulated_deform_conv.cpp
│ │ │ │ │ │ │ ├── trt_modulated_deform_conv_kernel.cu
│ │ │ │ │ │ │ ├── trt_nms.cpp
│ │ │ │ │ │ │ ├── trt_nms_kernel.cu
│ │ │ │ │ │ │ ├── trt_plugin.cpp
│ │ │ │ │ │ │ ├── trt_roi_align.cpp
│ │ │ │ │ │ │ ├── trt_roi_align_kernel.cu
│ │ │ │ │ │ │ ├── trt_scatternd.cpp
│ │ │ │ │ │ │ └── trt_scatternd_kernel.cu
│ │ │ │ │ │ ├── trt_corner_pool.hpp
│ │ │ │ │ │ ├── trt_cuda_helper.cuh
│ │ │ │ │ │ ├── trt_cummaxmin.hpp
│ │ │ │ │ │ ├── trt_deform_conv.hpp
│ │ │ │ │ │ ├── trt_grid_sampler.hpp
│ │ │ │ │ │ ├── trt_instance_norm.hpp
│ │ │ │ │ │ ├── trt_modulated_deform_conv.hpp
│ │ │ │ │ │ ├── trt_nms.hpp
│ │ │ │ │ │ ├── trt_plugin.hpp
│ │ │ │ │ │ ├── trt_plugin_helper.hpp
│ │ │ │ │ │ ├── trt_roi_align.hpp
│ │ │ │ │ │ ├── trt_scatternd.hpp
│ │ │ │ │ │ └── trt_serialize.hpp
│ │ │ │ │ ├── deform_conv.py
│ │ │ │ │ ├── deform_roi_pool.py
│ │ │ │ │ ├── deprecated_wrappers.py
│ │ │ │ │ ├── focal_loss.py
│ │ │ │ │ ├── furthest_point_sample.py
│ │ │ │ │ ├── fused_bias_leakyrelu.py
│ │ │ │ │ ├── gather_points.py
│ │ │ │ │ ├── group_points.py
│ │ │ │ │ ├── info.py
│ │ │ │ │ ├── iou3d.py
│ │ │ │ │ ├── knn.py
│ │ │ │ │ ├── masked_conv.py
│ │ │ │ │ ├── merge_cells.py
│ │ │ │ │ ├── min_area_polygons.py
│ │ │ │ │ ├── modulated_deform_conv.py
│ │ │ │ │ ├── multi_scale_deform_attn.py
│ │ │ │ │ ├── nms.py
│ │ │ │ │ ├── pixel_group.py
│ │ │ │ │ ├── point_sample.py
│ │ │ │ │ ├── points_in_boxes.py
│ │ │ │ │ ├── points_in_polygons.py
│ │ │ │ │ ├── points_sampler.py
│ │ │ │ │ ├── psa_mask.py
│ │ │ │ │ ├── readme.md
│ │ │ │ │ ├── riroi_align_rotated.py
│ │ │ │ │ ├── roi_align.py
│ │ │ │ │ ├── roi_align_rotated.py
│ │ │ │ │ ├── roi_pool.py
│ │ │ │ │ ├── roiaware_pool3d.py
│ │ │ │ │ ├── roipoint_pool3d.py
│ │ │ │ │ ├── rotated_feature_align.py
│ │ │ │ │ ├── saconv.py
│ │ │ │ │ ├── scatter_points.py
│ │ │ │ │ ├── sync_bn.py
│ │ │ │ │ ├── three_interpolate.py
│ │ │ │ │ ├── three_nn.py
│ │ │ │ │ ├── tin_shift.py
│ │ │ │ │ ├── upfirdn2d.py
│ │ │ │ │ └── voxelize.py
│ │ │ │ ├── parallel/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── _functions.py
│ │ │ │ │ ├── collate.py
│ │ │ │ │ ├── data_container.py
│ │ │ │ │ ├── data_parallel.py
│ │ │ │ │ ├── distributed.py
│ │ │ │ │ ├── distributed_deprecated.py
│ │ │ │ │ ├── registry.py
│ │ │ │ │ ├── scatter_gather.py
│ │ │ │ │ └── utils.py
│ │ │ │ ├── readme.md
│ │ │ │ ├── runner/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── base_module.py
│ │ │ │ │ ├── base_runner.py
│ │ │ │ │ ├── builder.py
│ │ │ │ │ ├── checkpoint.py
│ │ │ │ │ ├── default_constructor.py
│ │ │ │ │ ├── dist_utils.py
│ │ │ │ │ ├── epoch_based_runner.py
│ │ │ │ │ ├── fp16_utils.py
│ │ │ │ │ ├── hooks/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── checkpoint.py
│ │ │ │ │ │ ├── closure.py
│ │ │ │ │ │ ├── ema.py
│ │ │ │ │ │ ├── evaluation.py
│ │ │ │ │ │ ├── hook.py
│ │ │ │ │ │ ├── iter_timer.py
│ │ │ │ │ │ ├── logger/
│ │ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ │ ├── base.py
│ │ │ │ │ │ │ ├── dvclive.py
│ │ │ │ │ │ │ ├── mlflow.py
│ │ │ │ │ │ │ ├── neptune.py
│ │ │ │ │ │ │ ├── pavi.py
│ │ │ │ │ │ │ ├── tensorboard.py
│ │ │ │ │ │ │ ├── text.py
│ │ │ │ │ │ │ └── wandb.py
│ │ │ │ │ │ ├── lr_updater.py
│ │ │ │ │ │ ├── memory.py
│ │ │ │ │ │ ├── momentum_updater.py
│ │ │ │ │ │ ├── nni_hook.py
│ │ │ │ │ │ ├── optimizer.py
│ │ │ │ │ │ ├── profiler.py
│ │ │ │ │ │ ├── sampler_seed.py
│ │ │ │ │ │ └── sync_buffer.py
│ │ │ │ │ ├── iter_based_runner.py
│ │ │ │ │ ├── log_buffer.py
│ │ │ │ │ ├── misc.py
│ │ │ │ │ ├── optimizer/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── builder.py
│ │ │ │ │ │ └── default_constructor.py
│ │ │ │ │ ├── priority.py
│ │ │ │ │ ├── record.py
│ │ │ │ │ └── utils.py
│ │ │ │ ├── tensorrt/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── init_plugins.py
│ │ │ │ │ ├── preprocess.py
│ │ │ │ │ └── tensorrt_utils.py
│ │ │ │ ├── utils/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── config.py
│ │ │ │ │ ├── env.py
│ │ │ │ │ ├── ext_loader.py
│ │ │ │ │ ├── hub.py
│ │ │ │ │ ├── logging.py
│ │ │ │ │ ├── misc.py
│ │ │ │ │ ├── parrots_jit.py
│ │ │ │ │ ├── parrots_wrapper.py
│ │ │ │ │ ├── path.py
│ │ │ │ │ ├── progressbar.py
│ │ │ │ │ ├── registry.py
│ │ │ │ │ ├── testing.py
│ │ │ │ │ ├── timer.py
│ │ │ │ │ ├── trace.py
│ │ │ │ │ └── version_utils.py
│ │ │ │ ├── version.py
│ │ │ │ ├── video/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── io.py
│ │ │ │ │ ├── optflow.py
│ │ │ │ │ └── processing.py
│ │ │ │ └── visualization/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── color.py
│ │ │ │ ├── image.py
│ │ │ │ └── optflow.py
│ │ │ ├── readme.md
│ │ │ ├── setup.cfg
│ │ │ ├── setup.py
│ │ │ └── tests/
│ │ │ ├── test_arraymisc.py
│ │ │ ├── test_cnn/
│ │ │ │ ├── test_build_layers.py
│ │ │ │ ├── test_context_block.py
│ │ │ │ ├── test_conv2d_adaptive_padding.py
│ │ │ │ ├── test_conv_module.py
│ │ │ │ ├── test_depthwise_seperable_conv_module.py
│ │ │ │ ├── test_flops_counter.py
│ │ │ │ ├── test_fuse_conv_bn.py
│ │ │ │ ├── test_generalized_attention.py
│ │ │ │ ├── test_hsigmoid.py
│ │ │ │ ├── test_hswish.py
│ │ │ │ ├── test_model_registry.py
│ │ │ │ ├── test_non_local.py
│ │ │ │ ├── test_revert_syncbn.py
│ │ │ │ ├── test_scale.py
│ │ │ │ ├── test_swish.py
│ │ │ │ ├── test_transformer.py
│ │ │ │ ├── test_weight_init.py
│ │ │ │ └── test_wrappers.py
│ │ │ ├── test_fileclient.py
│ │ │ ├── test_fileio.py
│ │ │ ├── test_image/
│ │ │ │ ├── test_colorspace.py
│ │ │ │ ├── test_geometric.py
│ │ │ │ ├── test_image_misc.py
│ │ │ │ ├── test_io.py
│ │ │ │ └── test_photometric.py
│ │ │ ├── test_load_model_zoo.py
│ │ │ ├── test_ops/
│ │ │ │ ├── test_active_rotated_filter.py
│ │ │ │ ├── test_assign_score_withk.py
│ │ │ │ ├── test_ball_query.py
│ │ │ │ ├── test_bbox.py
│ │ │ │ ├── test_bilinear_grid_sample.py
│ │ │ │ ├── test_border_align.py
│ │ │ │ ├── test_box_iou_rotated.py
│ │ │ │ ├── test_carafe.py
│ │ │ │ ├── test_cc_attention.py
│ │ │ │ ├── test_contour_expand.py
│ │ │ │ ├── test_convex_iou.py
│ │ │ │ ├── test_corner_pool.py
│ │ │ │ ├── test_correlation.py
│ │ │ │ ├── test_deform_conv.py
│ │ │ │ ├── test_deform_roi_pool.py
│ │ │ │ ├── test_focal_loss.py
│ │ │ │ ├── test_furthest_point_sample.py
│ │ │ │ ├── test_fused_bias_leakyrelu.py
│ │ │ │ ├── test_gather_points.py
│ │ │ │ ├── test_group_points.py
│ │ │ │ ├── test_info.py
│ │ │ │ ├── test_iou3d.py
│ │ │ │ ├── test_knn.py
│ │ │ │ ├── test_masked_conv2d.py
│ │ │ │ ├── test_merge_cells.py
│ │ │ │ ├── test_min_area_polygons.py
│ │ │ │ ├── test_modulated_deform_conv.py
│ │ │ │ ├── test_ms_deformable_attn.py
│ │ │ │ ├── test_nms.py
│ │ │ │ ├── test_nms_rotated.py
│ │ │ │ ├── test_onnx.py
│ │ │ │ ├── test_pixel_group.py
│ │ │ │ ├── test_points_in_polygons.py
│ │ │ │ ├── test_psa_mask.py
│ │ │ │ ├── test_riroi_align_rotated.py
│ │ │ │ ├── test_roi_align.py
│ │ │ │ ├── test_roi_align_rotated.py
│ │ │ │ ├── test_roi_pool.py
│ │ │ │ ├── test_roiaware_pool3d.py
│ │ │ │ ├── test_roipoint_pool3d.py
│ │ │ │ ├── test_rotated_feature_align.py
│ │ │ │ ├── test_saconv.py
│ │ │ │ ├── test_scatter_points.py
│ │ │ │ ├── test_syncbn.py
│ │ │ │ ├── test_tensorrt.py
│ │ │ │ ├── test_tensorrt_preprocess.py
│ │ │ │ ├── test_three_interpolate.py
│ │ │ │ ├── test_three_nn.py
│ │ │ │ ├── test_tin_shift.py
│ │ │ │ ├── test_upfirdn2d.py
│ │ │ │ └── test_voxelization.py
│ │ │ ├── test_parallel.py
│ │ │ ├── test_runner/
│ │ │ │ ├── test_basemodule.py
│ │ │ │ ├── test_checkpoint.py
│ │ │ │ ├── test_dist_utils.py
│ │ │ │ ├── test_eval_hook.py
│ │ │ │ ├── test_fp16.py
│ │ │ │ ├── test_hooks.py
│ │ │ │ ├── test_optimizer.py
│ │ │ │ ├── test_runner.py
│ │ │ │ └── test_utils.py
│ │ │ ├── test_utils/
│ │ │ │ ├── test_config.py
│ │ │ │ ├── test_env.py
│ │ │ │ ├── test_hub.py
│ │ │ │ ├── test_logging.py
│ │ │ │ ├── test_misc.py
│ │ │ │ ├── test_parrots_jit.py
│ │ │ │ ├── test_path.py
│ │ │ │ ├── test_progressbar.py
│ │ │ │ ├── test_registry.py
│ │ │ │ ├── test_testing.py
│ │ │ │ ├── test_timer.py
│ │ │ │ ├── test_trace.py
│ │ │ │ └── test_version_utils.py
│ │ │ ├── test_video/
│ │ │ │ ├── test_optflow.py
│ │ │ │ ├── test_processing.py
│ │ │ │ └── test_reader.py
│ │ │ └── test_visualization.py
│ │ ├── pansharpening/
│ │ │ ├── common/
│ │ │ │ ├── dataset.py
│ │ │ │ ├── dataset_hp.py
│ │ │ │ ├── evaluate.py
│ │ │ │ └── psdata.py
│ │ │ ├── configs/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── hook_configs.py
│ │ │ │ ├── option_bdpn.py
│ │ │ │ ├── option_dicnn.py
│ │ │ │ ├── option_drpnn.py
│ │ │ │ ├── option_fusionnet.py
│ │ │ │ ├── option_msdcnn.py
│ │ │ │ ├── option_pannet.py
│ │ │ │ └── option_pnn.py
│ │ │ ├── evaluation/
│ │ │ │ └── ps_evaluate.py
│ │ │ ├── models/
│ │ │ │ ├── APNN/
│ │ │ │ │ ├── data_qb.py
│ │ │ │ │ ├── data_single_read.py
│ │ │ │ │ ├── data_wv2.py
│ │ │ │ │ ├── data_wv3.py
│ │ │ │ │ ├── data_wv4.py
│ │ │ │ │ ├── evaluate.py
│ │ │ │ │ ├── main_pre_train_trainData_qb.py
│ │ │ │ │ ├── main_pre_train_trainData_wv2.py
│ │ │ │ │ ├── main_pre_train_trainData_wv3.py
│ │ │ │ │ ├── main_pre_train_trainData_wv4.py
│ │ │ │ │ ├── main_test_qb.py
│ │ │ │ │ ├── main_test_wv2.py
│ │ │ │ │ ├── main_test_wv3.py
│ │ │ │ │ ├── main_test_wv4.py
│ │ │ │ │ ├── model_qb.py
│ │ │ │ │ ├── model_wv2.py
│ │ │ │ │ ├── model_wv3.py
│ │ │ │ │ ├── model_wv4.py
│ │ │ │ │ ├── variance_sacling_initializer.py
│ │ │ │ │ └── wald_utilities.py
│ │ │ │ ├── BDPN/
│ │ │ │ │ ├── bdpn_main.py
│ │ │ │ │ ├── loss_utils.py
│ │ │ │ │ ├── main_train_wv3.py
│ │ │ │ │ └── model_bdpn.py
│ │ │ │ ├── DRPNN/
│ │ │ │ │ ├── drpnn_main.py
│ │ │ │ │ └── model_drpnn.py
│ │ │ │ ├── DiCNN/
│ │ │ │ │ ├── dicnn_main.py
│ │ │ │ │ └── model_dicnn.py
│ │ │ │ ├── FusionNet/
│ │ │ │ │ ├── fusionnet_main.py
│ │ │ │ │ ├── model_fusionnet.py
│ │ │ │ │ └── run_fusionnet.py
│ │ │ │ ├── MSDCNN/
│ │ │ │ │ ├── model_msdcnn.py
│ │ │ │ │ └── msdcnn_main.py
│ │ │ │ ├── PNN/
│ │ │ │ │ ├── model_pnn.py
│ │ │ │ │ └── pnn_main.py
│ │ │ │ ├── PanNet/
│ │ │ │ │ ├── model_pannet.py
│ │ │ │ │ └── pannet_main.py
│ │ │ │ └── __init__.py
│ │ │ ├── run_pansharpening.py
│ │ │ └── run_test_pansharpening.py
│ │ ├── pretrained-model/
│ │ │ ├── QB/
│ │ │ │ ├── bdpn.pth
│ │ │ │ ├── dicnn1.pth
│ │ │ │ ├── drpnn.pth
│ │ │ │ ├── fusionnet.pth
│ │ │ │ ├── msdcnn.pth
│ │ │ │ ├── panet.pth
│ │ │ │ ├── pnn.pth
│ │ │ │ └── readme.txt
│ │ │ ├── WV2/
│ │ │ │ ├── bdpn.pth
│ │ │ │ ├── dicnn1.pth
│ │ │ │ ├── drpnn.pth
│ │ │ │ ├── fusionnet.pth
│ │ │ │ ├── msdcnn.pth
│ │ │ │ ├── pannet.pth
│ │ │ │ ├── pnn.pth
│ │ │ │ └── readme.txt
│ │ │ ├── WV3/
│ │ │ │ ├── bdpn.pth
│ │ │ │ ├── dicnn1.pth
│ │ │ │ ├── drpnn.pth
│ │ │ │ ├── fusionnet.pth
│ │ │ │ ├── msdcnn.pth
│ │ │ │ ├── pannet.pth
│ │ │ │ └── pnn.pth
│ │ │ └── WV4/
│ │ │ ├── bdpn.pth
│ │ │ ├── dicnn1.pth
│ │ │ ├── drpnn.pth
│ │ │ ├── fusionnet.pth
│ │ │ ├── msdcnn.pth
│ │ │ ├── pannet.pth
│ │ │ ├── pnn.pth
│ │ │ └── readme.txt
│ │ ├── readme.md
│ │ └── results/
│ │ └── readme.txt
│ ├── readme.md
│ └── setup.py
├── 02-Test-toolbox-for-traditional-and-DL(Matlab)/
│ ├── 1_TestData/
│ │ ├── Datasets Testing/
│ │ │ └── Download link for WV3-NewYork test data.txt
│ │ ├── QB/
│ │ │ └── readme.txt
│ │ ├── WV2/
│ │ │ └── readme.txt
│ │ ├── WV3/
│ │ │ └── readme.txt
│ │ ├── WV4/
│ │ │ └── readme.txt
│ │ └── readme.txt
│ ├── 2_DL_Result/
│ │ ├── QB/
│ │ │ └── readme.txt
│ │ ├── WV2/
│ │ │ └── readme.txt
│ │ ├── WV3/
│ │ │ ├── APNN/
│ │ │ │ └── readme.txt
│ │ │ ├── BDPN/
│ │ │ │ └── readme.txt
│ │ │ ├── DRPNN/
│ │ │ │ └── readme.txt
│ │ │ ├── DiCNN1/
│ │ │ │ └── readme.txt
│ │ │ ├── Download link for the 8 DL methods on WV3 dataset.txt
│ │ │ ├── FusionNet/
│ │ │ │ └── readme.txt
│ │ │ ├── MSDCNN/
│ │ │ │ └── readme.txt
│ │ │ ├── PNN/
│ │ │ │ └── readme.txt
│ │ │ └── PanNet/
│ │ │ └── readme.txt
│ │ ├── WV4/
│ │ │ └── readme.txt
│ │ └── readme.txt
│ ├── 3_EPS/
│ │ ├── QB/
│ │ │ └── readme.txt
│ │ ├── WV2/
│ │ │ └── readme.txt
│ │ ├── WV3/
│ │ │ └── readme.txt
│ │ ├── WV4/
│ │ │ └── readme.txt
│ │ └── readme.txt
│ ├── AWLP/
│ │ └── AWLP.m
│ ├── Avg_RR_Assessment.tex
│ ├── BDSD/
│ │ ├── BDSD.m
│ │ ├── BDSD_PC.m
│ │ └── C_BDSD.m
│ ├── BT-H/
│ │ └── BroveyRegHazeMin.m
│ ├── Demo_Full_Resolution.m
│ ├── Demo_Reduced_Resolution.m
│ ├── FE-HPM/
│ │ ├── FE.m
│ │ └── FE_HPM.m
│ ├── FR_Assessment.tex
│ ├── GLP/
│ │ ├── GS2_GLP.m
│ │ ├── MTF_GLP.m
│ │ ├── MTF_GLP_FS.m
│ │ ├── MTF_GLP_HPM.m
│ │ ├── MTF_GLP_HPM_Haze_min.m
│ │ └── MTF_GLP_HPM_R.m
│ ├── GS/
│ │ ├── GS.m
│ │ ├── GSA.m
│ │ └── GS_Segm.m
│ ├── MF/
│ │ ├── MF_HG_Pansharpen.m
│ │ └── Pyr_Dec.m
│ ├── PRACS/
│ │ └── PRACS.m
│ ├── PWMBF/
│ │ ├── PWMBF.m
│ │ ├── compute_PhiTX.m
│ │ ├── compute_PhiX.m
│ │ ├── readme
│ │ └── rwt/
│ │ ├── AUTHORS
│ │ ├── CMakeLists.txt
│ │ ├── HACKING
│ │ ├── INSTALL
│ │ ├── LICENSE
│ │ ├── bin/
│ │ │ ├── HardTh.m
│ │ │ ├── SoftTh.m
│ │ │ ├── compile.m
│ │ │ ├── daubcqf.m
│ │ │ ├── denoise.m
│ │ │ ├── makesig.m
│ │ │ ├── mdwt.m
│ │ │ ├── mdwt.mexw64
│ │ │ ├── midwt.m
│ │ │ ├── midwt.mexw64
│ │ │ ├── mirdwt.m
│ │ │ ├── mirdwt.mexw64
│ │ │ ├── mrdwt.m
│ │ │ ├── mrdwt.mexw64
│ │ │ └── setopt.m
│ │ ├── dist/
│ │ │ ├── 2.01/
│ │ │ │ ├── INSTALL
│ │ │ │ ├── README
│ │ │ │ ├── RWT-2.01.tar.Z
│ │ │ │ └── doc/
│ │ │ │ └── index.html
│ │ │ └── 2.3/
│ │ │ ├── INSTALL
│ │ │ ├── INSTALL_PRECOMPILED
│ │ │ ├── LICENSE
│ │ │ └── README
│ │ ├── doc/
│ │ │ ├── CMakeLists.txt
│ │ │ └── Doxyfile.in
│ │ ├── lib/
│ │ │ ├── inc/
│ │ │ │ ├── rwt_init.h
│ │ │ │ ├── rwt_platform.h
│ │ │ │ └── rwt_transforms.h
│ │ │ └── src/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── dwt.c
│ │ │ ├── idwt.c
│ │ │ ├── init.c
│ │ │ ├── irdwt.c
│ │ │ ├── platform.c
│ │ │ └── rdwt.c
│ │ ├── mex/
│ │ │ ├── mdwt.c
│ │ │ ├── midwt.c
│ │ │ ├── mirdwt.c
│ │ │ └── mrdwt.c
│ │ ├── python/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── LICENSE.numpy
│ │ │ ├── numpy.i
│ │ │ ├── rwt.i
│ │ │ └── test_rwt.py
│ │ ├── readme
│ │ └── tests/
│ │ ├── matlab_xunit/
│ │ │ ├── Readme.html
│ │ │ ├── architecture/
│ │ │ │ ├── class_diagram_a.vsd
│ │ │ │ ├── class_diagram_b.vsd
│ │ │ │ ├── class_diagram_c.vsd
│ │ │ │ ├── html/
│ │ │ │ │ └── matlab_xunit_architecture.html
│ │ │ │ ├── matlab_xunit_architecture.m
│ │ │ │ └── testSample.m
│ │ │ ├── doc/
│ │ │ │ ├── +abc/
│ │ │ │ │ └── +tests/
│ │ │ │ │ ├── test_that.m
│ │ │ │ │ └── test_this.m
│ │ │ │ ├── +abc_tests/
│ │ │ │ │ ├── test_that.m
│ │ │ │ │ └── test_this.m
│ │ │ │ ├── exException.m
│ │ │ │ ├── exQuickStart.m
│ │ │ │ ├── exRunSpecificTest.m
│ │ │ │ ├── exRunTestsInADirectory.m
│ │ │ │ ├── exRunTestsInPackage.m
│ │ │ │ ├── exSilentRunning.m
│ │ │ │ ├── exSubfunctionTests.m
│ │ │ │ ├── exTestCase.m
│ │ │ │ ├── exTestCaseSearching.m
│ │ │ │ ├── exTestFixtures.m
│ │ │ │ ├── exTolerance.m
│ │ │ │ ├── example_quick_start/
│ │ │ │ │ ├── testFliplrMatrix.m
│ │ │ │ │ └── testFliplrVector.m
│ │ │ │ ├── example_subfunction_tests/
│ │ │ │ │ └── testFliplr.m
│ │ │ │ ├── examples_general/
│ │ │ │ │ ├── TestUsingTestCase.m
│ │ │ │ │ ├── testBadSinTest.m
│ │ │ │ │ ├── testCos.m
│ │ │ │ │ ├── testSetupExample.m
│ │ │ │ │ ├── testSin.m
│ │ │ │ │ └── testWithSetupError.m
│ │ │ │ ├── file_exchange_description.txt
│ │ │ │ ├── html/
│ │ │ │ │ ├── exException.html
│ │ │ │ │ ├── exQuickStart.html
│ │ │ │ │ ├── exRunSpecificTest.html
│ │ │ │ │ ├── exRunTestsInADirectory.html
│ │ │ │ │ ├── exRunTestsInPackage.html
│ │ │ │ │ ├── exSilentRunning.html
│ │ │ │ │ ├── exSubfunctionTests.html
│ │ │ │ │ ├── exTestCase.html
│ │ │ │ │ ├── exTestCaseSearching.html
│ │ │ │ │ ├── exTestFixtures.html
│ │ │ │ │ └── exTolerance.html
│ │ │ │ ├── index.html
│ │ │ │ ├── release-history.html
│ │ │ │ └── xunit_product_page.html
│ │ │ ├── license.txt
│ │ │ ├── obsolete/
│ │ │ │ ├── +mtest/
│ │ │ │ │ └── +utils/
│ │ │ │ │ ├── Contents.m
│ │ │ │ │ ├── compareFloats.m
│ │ │ │ │ ├── containsRegexp.m
│ │ │ │ │ ├── generateDoc.m
│ │ │ │ │ ├── isAlmostEqual.m
│ │ │ │ │ ├── isSetUpString.m
│ │ │ │ │ ├── isTearDownString.m
│ │ │ │ │ ├── isTestCaseSubclass.m
│ │ │ │ │ ├── isTestString.m
│ │ │ │ │ └── parseFloatAssertInputs.m
│ │ │ │ ├── assertAlmostEqual.m
│ │ │ │ ├── mtest.m
│ │ │ │ └── tests/
│ │ │ │ ├── MtestTest.m
│ │ │ │ ├── cwd_test/
│ │ │ │ │ ├── TestCaseSubclass.m
│ │ │ │ │ ├── testFoobar.m
│ │ │ │ │ └── testSubfunctions.m
│ │ │ │ ├── testAssertAlmostEqual.m
│ │ │ │ └── testIsAlmostEqual.m
│ │ │ ├── readme
│ │ │ ├── tests/
│ │ │ │ ├── +xunit/
│ │ │ │ │ └── +mocktests/
│ │ │ │ │ ├── +subpkg/
│ │ │ │ │ │ └── test_a_bit.m
│ │ │ │ │ ├── A.m
│ │ │ │ │ ├── B.m
│ │ │ │ │ ├── FooTest.m
│ │ │ │ │ ├── helper_that.m
│ │ │ │ │ ├── test_that.m
│ │ │ │ │ └── test_this.m
│ │ │ │ ├── Readme.m
│ │ │ │ ├── RuntestsTest.m
│ │ │ │ ├── TestCaseTest.m
│ │ │ │ ├── TestCaseWithAddPathTest.m
│ │ │ │ ├── TestFuncHandleTests.m
│ │ │ │ ├── TestRunLoggerTest.m
│ │ │ │ ├── TestSuiteTest.m
│ │ │ │ ├── ThrowsExceptionTest.m
│ │ │ │ ├── almost_black.tif
│ │ │ │ ├── black.tif
│ │ │ │ ├── cwd_test/
│ │ │ │ │ ├── TestCaseSubclass.m
│ │ │ │ │ ├── testFoobar.m
│ │ │ │ │ └── testSubfunctions.m
│ │ │ │ ├── dir1/
│ │ │ │ │ └── test_thatPasses.m
│ │ │ │ ├── dir2/
│ │ │ │ │ └── test_thatFails.m
│ │ │ │ ├── empty_file
│ │ │ │ ├── helper_classes/
│ │ │ │ │ ├── BadFixture.m
│ │ │ │ │ ├── Contents.m
│ │ │ │ │ ├── ExceptionNotThrownTest.m
│ │ │ │ │ ├── FailingTestCase.m
│ │ │ │ │ ├── LoggingTestCase.m
│ │ │ │ │ ├── NoTestMethods.m
│ │ │ │ │ ├── PassingExceptionTest.m
│ │ │ │ │ ├── TestsToBeDiscovered.m
│ │ │ │ │ ├── TwoPassingTests.m
│ │ │ │ │ ├── WrongExceptionThrownTest.m
│ │ │ │ │ ├── notTestString.m
│ │ │ │ │ ├── testFunctionHandlesA.m
│ │ │ │ │ ├── testFunctionHandlesB.m
│ │ │ │ │ ├── testFunctionHandlesC.m
│ │ │ │ │ ├── testFunctionHandlesD.m
│ │ │ │ │ ├── testFunctionHandlesE.m
│ │ │ │ │ ├── testFunctionHandlesTeardownNoSetup.m
│ │ │ │ │ └── testSimple.m
│ │ │ │ ├── testAssertEqual.m
│ │ │ │ ├── testAssertExceptionThrown.m
│ │ │ │ ├── testAssertFalse.m
│ │ │ │ ├── testAssertTrue.m
│ │ │ │ ├── testContainsRegexp.m
│ │ │ │ ├── testIsSetUpString.m
│ │ │ │ ├── testIsTearDownString.m
│ │ │ │ ├── testIsTestCaseSubclass.m
│ │ │ │ ├── testIsTestString.m
│ │ │ │ ├── testRuntestsWithDirectoryName.m
│ │ │ │ ├── test_TestSuiteInDir.m
│ │ │ │ ├── test_arrayToString.m
│ │ │ │ ├── test_assertElementsAlmostEqual.m
│ │ │ │ ├── test_assertFilesEqual.m
│ │ │ │ ├── test_assertVectorsAlmostEqual.m
│ │ │ │ ├── test_compareFloats.m
│ │ │ │ ├── test_comparisonMessage.m
│ │ │ │ ├── test_packageName.m
│ │ │ │ ├── test_parseFloatAssertInputs.m
│ │ │ │ └── test_stringToCellArray.m
│ │ │ └── xunit/
│ │ │ ├── +xunit/
│ │ │ │ └── +utils/
│ │ │ │ ├── Contents.m
│ │ │ │ ├── arrayToString.m
│ │ │ │ ├── compareFloats.m
│ │ │ │ ├── comparisonMessage.m
│ │ │ │ ├── containsRegexp.m
│ │ │ │ ├── generateDoc.m
│ │ │ │ ├── isAlmostEqual.m
│ │ │ │ ├── isSetUpString.m
│ │ │ │ ├── isTearDownString.m
│ │ │ │ ├── isTestCaseSubclass.m
│ │ │ │ ├── isTestString.m
│ │ │ │ ├── parseFloatAssertInputs.m
│ │ │ │ └── stringToCellArray.m
│ │ │ ├── CommandWindowTestRunDisplay.m
│ │ │ ├── Contents.m
│ │ │ ├── FunctionHandleTestCase.m
│ │ │ ├── TestCase.m
│ │ │ ├── TestCaseInDir.m
│ │ │ ├── TestCaseWithAddPath.m
│ │ │ ├── TestComponent.m
│ │ │ ├── TestComponentInDir.m
│ │ │ ├── TestRunDisplay.m
│ │ │ ├── TestRunLogger.m
│ │ │ ├── TestRunMonitor.m
│ │ │ ├── TestSuite.m
│ │ │ ├── TestSuiteInDir.m
│ │ │ ├── VerboseTestRunDisplay.m
│ │ │ ├── assertElementsAlmostEqual.m
│ │ │ ├── assertEqual.m
│ │ │ ├── assertExceptionThrown.m
│ │ │ ├── assertFalse.m
│ │ │ ├── assertFilesEqual.m
│ │ │ ├── assertTrue.m
│ │ │ ├── assertVectorsAlmostEqual.m
│ │ │ ├── initTestSuite.m
│ │ │ └── runtests.m
│ │ ├── octave/
│ │ │ ├── assertEqual.m
│ │ │ ├── assertVectorsAlmostEqual.m
│ │ │ ├── runtests.m
│ │ │ ├── test_denoise.m
│ │ │ ├── test_makesig.m
│ │ │ ├── test_mdwt.m
│ │ │ ├── test_midwt.m
│ │ │ ├── test_mirdwt.m
│ │ │ ├── test_mrdwt.m
│ │ │ └── test_setopt.m
│ │ ├── readme
│ │ ├── runtests.m
│ │ ├── test_daubcqf.m
│ │ ├── test_denoise.m
│ │ ├── test_makesig.m
│ │ ├── test_mdwt.m
│ │ ├── test_midwt.m
│ │ ├── test_mirdwt.m
│ │ ├── test_mrdwt.m
│ │ └── test_setopt.m
│ ├── Quality_Indices/
│ │ ├── D_lambda.m
│ │ ├── D_lambda_K.m
│ │ ├── D_s.m
│ │ ├── ERGAS.m
│ │ ├── HQNR.m
│ │ ├── Q.m
│ │ ├── QNR.m
│ │ ├── SAM.m
│ │ ├── SCC.m
│ │ ├── img_qi.m
│ │ ├── norm_blocco.m
│ │ ├── onion_mult.m
│ │ ├── onion_mult2D.m
│ │ ├── onions_quality.m
│ │ ├── q2n.m
│ │ └── ssim.m
│ ├── RR/
│ │ ├── RRpansharp.m
│ │ ├── manopt/
│ │ │ ├── CLA.txt
│ │ │ ├── COPYING.txt
│ │ │ ├── CREDITS.txt
│ │ │ ├── LICENSE.txt
│ │ │ ├── README.txt
│ │ │ ├── checkinstall/
│ │ │ │ └── basicexample.m
│ │ │ ├── examples/
│ │ │ │ ├── PCA_stochastic.m
│ │ │ │ ├── dominant_invariant_subspace.m
│ │ │ │ ├── dominant_invariant_subspace_complex.m
│ │ │ │ ├── elliptope_SDP.m
│ │ │ │ ├── elliptope_SDP_complex.m
│ │ │ │ ├── essential_svd.m
│ │ │ │ ├── generalized_eigenvalue_computation.m
│ │ │ │ ├── generalized_procrustes.m
│ │ │ │ ├── low_rank_dist_completion.m
│ │ │ │ ├── low_rank_matrix_completion.m
│ │ │ │ ├── low_rank_tensor_completion.m
│ │ │ │ ├── maxcut.m
│ │ │ │ ├── nonlinear_eigenspace.m
│ │ │ │ ├── packing_on_the_sphere.m
│ │ │ │ ├── positive_definite_karcher_mean.m
│ │ │ │ ├── radio_interferometric_calibration.m
│ │ │ │ ├── robust_pca.m
│ │ │ │ ├── shapefit_smoothed.m
│ │ │ │ ├── sparse_pca.m
│ │ │ │ ├── thomson_problem.m
│ │ │ │ └── truncated_svd.m
│ │ │ ├── importmanopt.m
│ │ │ ├── manopt/
│ │ │ │ ├── core/
│ │ │ │ │ ├── StoreDB.m
│ │ │ │ │ ├── applyStatsfun.m
│ │ │ │ │ ├── canGetApproxGradient.m
│ │ │ │ │ ├── canGetApproxHessian.m
│ │ │ │ │ ├── canGetCost.m
│ │ │ │ │ ├── canGetDirectionalDerivative.m
│ │ │ │ │ ├── canGetEuclideanGradient.m
│ │ │ │ │ ├── canGetGradient.m
│ │ │ │ │ ├── canGetHessian.m
│ │ │ │ │ ├── canGetLinesearch.m
│ │ │ │ │ ├── canGetPartialEuclideanGradient.m
│ │ │ │ │ ├── canGetPartialGradient.m
│ │ │ │ │ ├── canGetPrecon.m
│ │ │ │ │ ├── canGetSqrtPrecon.m
│ │ │ │ │ ├── canGetSubgradient.m
│ │ │ │ │ ├── getApproxGradient.m
│ │ │ │ │ ├── getApproxHessian.m
│ │ │ │ │ ├── getCost.m
│ │ │ │ │ ├── getCostGrad.m
│ │ │ │ │ ├── getDirectionalDerivative.m
│ │ │ │ │ ├── getEuclideanGradient.m
│ │ │ │ │ ├── getGlobalDefaults.m
│ │ │ │ │ ├── getGradient.m
│ │ │ │ │ ├── getGradientFD.m
│ │ │ │ │ ├── getHessian.m
│ │ │ │ │ ├── getHessianFD.m
│ │ │ │ │ ├── getLinesearch.m
│ │ │ │ │ ├── getPartialEuclideanGradient.m
│ │ │ │ │ ├── getPartialGradient.m
│ │ │ │ │ ├── getPrecon.m
│ │ │ │ │ ├── getSqrtPrecon.m
│ │ │ │ │ ├── getStore.m
│ │ │ │ │ ├── getSubgradient.m
│ │ │ │ │ ├── handle_light.m
│ │ │ │ │ ├── mergeOptions.m
│ │ │ │ │ ├── purgeStoredb.m
│ │ │ │ │ ├── setStore.m
│ │ │ │ │ └── stoppingcriterion.m
│ │ │ │ ├── manifolds/
│ │ │ │ │ ├── complexcircle/
│ │ │ │ │ │ ├── complexcirclefactory.m
│ │ │ │ │ │ └── realphasefactory.m
│ │ │ │ │ ├── essential/
│ │ │ │ │ │ ├── README_Essential.txt
│ │ │ │ │ │ ├── essential_costE2cost.m
│ │ │ │ │ │ ├── essential_egradE2egrad.m
│ │ │ │ │ │ ├── essential_ehessE2ehess.m
│ │ │ │ │ │ ├── essential_flat.m
│ │ │ │ │ │ ├── essential_hat3.m
│ │ │ │ │ │ ├── essential_sharp.m
│ │ │ │ │ │ ├── essentialfactory.m
│ │ │ │ │ │ └── privateessential/
│ │ │ │ │ │ ├── essential_closestRepresentative.m
│ │ │ │ │ │ ├── essential_distMinAngle.m
│ │ │ │ │ │ ├── essential_distMinAnglePair.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_base.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_computeDfBreak.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_dfNewton.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_discontinuityDistance.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_ft.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_ftFromQ.m
│ │ │ │ │ │ ├── essential_distMinAnglePair_test.m
│ │ │ │ │ │ └── modAngle.m
│ │ │ │ │ ├── euclidean/
│ │ │ │ │ │ ├── centeredmatrixfactory.m
│ │ │ │ │ │ ├── euclideancomplexfactory.m
│ │ │ │ │ │ ├── euclideanfactory.m
│ │ │ │ │ │ ├── shapefitfactory.m
│ │ │ │ │ │ ├── skewsymmetricfactory.m
│ │ │ │ │ │ └── symmetricfactory.m
│ │ │ │ │ ├── fixedrank/
│ │ │ │ │ │ ├── fixedrankMNquotientfactory.m
│ │ │ │ │ │ ├── fixedrankembeddedfactory.m
│ │ │ │ │ │ ├── fixedrankfactory_2factors.m
│ │ │ │ │ │ ├── fixedrankfactory_2factors_preconditioned.m
│ │ │ │ │ │ ├── fixedrankfactory_2factors_subspace_projection.m
│ │ │ │ │ │ ├── fixedrankfactory_3factors.m
│ │ │ │ │ │ └── fixedrankfactory_3factors_preconditioned.m
│ │ │ │ │ ├── fixedranktensors/
│ │ │ │ │ │ ├── fixedrankfactory_tucker_preconditioned.m
│ │ │ │ │ │ └── tucker2multiarray.m
│ │ │ │ │ ├── grassmann/
│ │ │ │ │ │ ├── grassmanncomplexfactory.m
│ │ │ │ │ │ ├── grassmannfactory.m
│ │ │ │ │ │ └── grassmanngeneralizedfactory.m
│ │ │ │ │ ├── multinomial/
│ │ │ │ │ │ └── multinomialfactory.m
│ │ │ │ │ ├── oblique/
│ │ │ │ │ │ ├── obliquecomplexfactory.m
│ │ │ │ │ │ └── obliquefactory.m
│ │ │ │ │ ├── rotations/
│ │ │ │ │ │ ├── randrot.m
│ │ │ │ │ │ ├── randskew.m
│ │ │ │ │ │ └── rotationsfactory.m
│ │ │ │ │ ├── specialeuclidean/
│ │ │ │ │ │ └── specialeuclideanfactory.m
│ │ │ │ │ ├── sphere/
│ │ │ │ │ │ ├── spherecomplexfactory.m
│ │ │ │ │ │ ├── spherefactory.m
│ │ │ │ │ │ └── spheresymmetricfactory.m
│ │ │ │ │ ├── stiefel/
│ │ │ │ │ │ ├── stiefelcomplexfactory.m
│ │ │ │ │ │ ├── stiefelfactory.m
│ │ │ │ │ │ ├── stiefelgeneralizedfactory.m
│ │ │ │ │ │ └── stiefelstackedfactory.m
│ │ │ │ │ └── symfixedrank/
│ │ │ │ │ ├── elliptopefactory.m
│ │ │ │ │ ├── spectrahedronfactory.m
│ │ │ │ │ ├── symfixedrankYYcomplexfactory.m
│ │ │ │ │ ├── symfixedrankYYfactory.m
│ │ │ │ │ └── sympositivedefinitefactory.m
│ │ │ │ ├── readme
│ │ │ │ ├── solvers/
│ │ │ │ │ ├── barzilaiborwein/
│ │ │ │ │ │ └── barzilaiborwein.m
│ │ │ │ │ ├── bfgs/
│ │ │ │ │ │ └── rlbfgs.m
│ │ │ │ │ ├── conjugategradient/
│ │ │ │ │ │ ├── conjugategradient.m
│ │ │ │ │ │ └── linear_conjugategradient.m
│ │ │ │ │ ├── gradientapproximations/
│ │ │ │ │ │ └── approxgradientFD.m
│ │ │ │ │ ├── hessianapproximations/
│ │ │ │ │ │ └── approxhessianFD.m
│ │ │ │ │ ├── linesearch/
│ │ │ │ │ │ ├── linesearch.m
│ │ │ │ │ │ ├── linesearch_adaptive.m
│ │ │ │ │ │ ├── linesearch_decrease.m
│ │ │ │ │ │ └── linesearch_hint.m
│ │ │ │ │ ├── neldermead/
│ │ │ │ │ │ ├── centroid.m
│ │ │ │ │ │ └── neldermead.m
│ │ │ │ │ ├── preconditioners/
│ │ │ │ │ │ └── preconhessiansolve.m
│ │ │ │ │ ├── pso/
│ │ │ │ │ │ └── pso.m
│ │ │ │ │ ├── steepestdescent/
│ │ │ │ │ │ └── steepestdescent.m
│ │ │ │ │ ├── stochasticgradient/
│ │ │ │ │ │ ├── stepsize_sg.m
│ │ │ │ │ │ └── stochasticgradient.m
│ │ │ │ │ └── trustregions/
│ │ │ │ │ ├── license for original GenRTR code.txt
│ │ │ │ │ ├── tCG.m
│ │ │ │ │ └── trustregions.m
│ │ │ │ └── tools/
│ │ │ │ ├── checkdiff.m
│ │ │ │ ├── checkgradient.m
│ │ │ │ ├── checkhessian.m
│ │ │ │ ├── checkretraction.m
│ │ │ │ ├── criticalpointfinder.m
│ │ │ │ ├── dexpm.m
│ │ │ │ ├── dfunm.m
│ │ │ │ ├── diagsum.m
│ │ │ │ ├── dlogm.m
│ │ │ │ ├── dsqrtm.m
│ │ │ │ ├── grammatrix.m
│ │ │ │ ├── hashmd5.m
│ │ │ │ ├── hessianextreme.m
│ │ │ │ ├── hessianmatrix.m
│ │ │ │ ├── hessianspectrum.m
│ │ │ │ ├── identify_linear_piece.m
│ │ │ │ ├── lincomb.m
│ │ │ │ ├── manoptsolve.m
│ │ │ │ ├── matrixlincomb.m
│ │ │ │ ├── multihconj.m
│ │ │ │ ├── multiherm.m
│ │ │ │ ├── multiprod.m
│ │ │ │ ├── multiprodmultitransp_license.txt
│ │ │ │ ├── multiscale.m
│ │ │ │ ├── multiskew.m
│ │ │ │ ├── multisqnorm.m
│ │ │ │ ├── multisym.m
│ │ │ │ ├── multitrace.m
│ │ │ │ ├── multitransp.m
│ │ │ │ ├── orthogonalize.m
│ │ │ │ ├── plotprofile.m
│ │ │ │ ├── powermanifold.m
│ │ │ │ ├── productmanifold.m
│ │ │ │ ├── smallestinconvexhull.m
│ │ │ │ ├── statsfunhelper.m
│ │ │ │ ├── surfprofile.m
│ │ │ │ ├── tangent2vec.m
│ │ │ │ ├── tangentorthobasis.m
│ │ │ │ ├── tangentspacefactory.m
│ │ │ │ └── tangentspherefactory.m
│ │ │ ├── manopt_version.m
│ │ │ └── readme
│ │ └── readme
│ ├── RR_Assessment.tex
│ ├── SR-D/
│ │ ├── CS.m
│ │ ├── Dict_Learn.m
│ │ ├── OMP.m
│ │ └── OMP_Rec_Detile.m
│ ├── TV/
│ │ └── TV_pansharpen.m
│ ├── Tools/
│ │ ├── LPfilter.m
│ │ ├── LPfilterGauss.m
│ │ ├── LPfilterPlusDec.m
│ │ ├── MTF.m
│ │ ├── MTF_PAN.m
│ │ ├── estimation_alpha.m
│ │ ├── genMTF.m
│ │ ├── gen_LP_image.m
│ │ ├── indexes_evaluation.m
│ │ ├── indexes_evaluation_FS.m
│ │ ├── indwt2_working.m
│ │ ├── interp23tap.m
│ │ ├── k_means_clustering.m
│ │ ├── matrix2latex.m
│ │ ├── ndwt2_working.m
│ │ ├── printAllImagesImWriteFR.m
│ │ ├── printAllImagesImWriteRR.m
│ │ ├── printImage.m
│ │ ├── rectangleonimage.m
│ │ ├── resize_images.m
│ │ ├── showImage4.m
│ │ ├── showImage4LR.m
│ │ ├── showImage4LR_zoomin.m
│ │ ├── showImage4_zoomin.m
│ │ ├── showImage8.m
│ │ ├── showImage8LR.m
│ │ ├── showImage8LR_zoomin.m
│ │ ├── showImage8_zoomin.m
│ │ ├── showImagesAll.m
│ │ ├── showImagesAllOld.m
│ │ ├── showPan.m
│ │ ├── showPan_zoomin.m
│ │ ├── tight_subplot.m
│ │ ├── viewimage.m
│ │ └── viewimage2.m
│ └── readme.md
├── 03-Data-Simulation(Matlab)/
│ ├── 01-DataSimu/
│ │ └── QB/
│ │ └── readme.md.txt
│ ├── Demo_DataSimu_qb.m
│ ├── imgs/
│ │ └── readme
│ └── segImg_new.m
├── LICENSE
├── README.md
└── docs/
├── en/
│ ├── DLPanToolbox/
│ │ ├── Evaluation.md
│ │ ├── Example.md
│ │ ├── PreProcess.md
│ │ └── Simulation.md
│ ├── Makefile
│ ├── _static/
│ │ └── css/
│ │ └── readthedocs.css
│ ├── _templates/
│ │ └── classtemplate.rst
│ ├── citation.md
│ ├── conf.py
│ ├── docutils.conf
│ ├── faq.md
│ ├── get_started/
│ │ ├── Installation.md
│ │ └── Introduction.md
│ ├── index.rst
│ ├── make.bat
│ └── switch_language.md
├── requirements.txt
├── run.sh
└── zh-cn/
├── DLPanToolbox/
│ ├── Evaluation.md
│ ├── Example.md
│ ├── PreProcess.md
│ └── Simulation.md
├── Makefile
├── _static/
│ └── css/
│ └── readthedocs.css
├── _templates/
│ └── classtemplate.rst
├── citation.md
├── conf.py
├── docutils.conf
├── faq.md
├── get_started/
│ ├── Installation.md
│ └── Introduction.md
├── index.rst
├── make.bat
├── related.md
└── switch_language.md
Showing preview only (335K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3551 symbols across 542 files)
FILE: 01-DL-toolbox(Pytorch)/UDL/AutoDL/__init__.py
function build_model (line 9) | def build_model(arch, task, cfg=None):
function getDataSession (line 19) | def getDataSession(cfg):
FILE: 01-DL-toolbox(Pytorch)/UDL/AutoDL/trainer.py
function trainer (line 40) | def trainer(cfg, logger,
function main (line 230) | def main(cfg):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/base.py
class DALIDataloader (line 4) | class DALIDataloader(DALIGenericIterator):
method __init__ (line 5) | def __init__(self, pipeline, size, batch_size, output_map=["data", "la...
method __next__ (line 12) | def __next__(self):
method __len__ (line 23) | def __len__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/fp16_utils.py
class tofp16 (line 7) | class tofp16(nn.Module):
method __init__ (line 14) | def __init__(self):
method forward (line 17) | def forward(self, input):
function BN_convert_float (line 21) | def BN_convert_float(module):
function network_to_half (line 33) | def network_to_half(network):
function convert_module (line 41) | def convert_module(module, dtype):
function convert_network (line 57) | def convert_network(network, dtype):
class FP16Model (line 70) | class FP16Model(nn.Module):
method __init__ (line 75) | def __init__(self, network):
method forward (line 79) | def forward(self, *inputs):
function backwards_debug_hook (line 84) | def backwards_debug_hook(grad):
function prep_param_lists (line 87) | def prep_param_lists(model, flat_master=False):
function model_grads_to_master_grads (line 128) | def model_grads_to_master_grads(model_params, master_params, flat_master...
function master_params_to_model_params (line 149) | def master_params_to_model_params(model_params, master_params, flat_mast...
function to_python_float (line 166) | def to_python_float(t):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/__main__.py
function arg (line 7) | def arg():
function main (line 18) | def main():
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_flops.py
function compute_flops (line 7) | def compute_flops(module, inp, out):
function compute_cGCN_flops (line 42) | def compute_cGCN_flops(module, inp, out):
function compute_sGCN_flops (line 62) | def compute_sGCN_flops(module, inp, out):
function compute_Conv2d_flops (line 79) | def compute_Conv2d_flops(module, inp, out):
function compute_BatchNorm2d_flops (line 104) | def compute_BatchNorm2d_flops(module, inp, out):
function compute_LayerNorm_flops (line 113) | def compute_LayerNorm_flops(module, inp, out):
function compute_ReLU_flops (line 124) | def compute_ReLU_flops(module, inp, out):
function compute_Pool2d_flops (line 135) | def compute_Pool2d_flops(module, inp, out):
function compute_Linear_flops (line 141) | def compute_Linear_flops(module, inp, out):
function compute_Upsample_flops (line 156) | def compute_Upsample_flops(module, inp, out):
function compute_MSA_flops (line 163) | def compute_MSA_flops(module, inp, out):
function compute_WindowAttention_flops (line 197) | def compute_WindowAttention_flops(module, inp, out):
function compute_XCA_flops (line 239) | def compute_XCA_flops(module, inp, out):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_madd.py
function compute_Conv2d_madd (line 8) | def compute_Conv2d_madd(module, inp, out):
function compute_ConvTranspose2d_madd (line 30) | def compute_ConvTranspose2d_madd(module, inp, out):
function compute_LayerNorm_madd (line 50) | def compute_LayerNorm_madd(module, inp, out):
function compute_BatchNorm2d_madd (line 66) | def compute_BatchNorm2d_madd(module, inp, out):
function compute_MaxPool2d_madd (line 79) | def compute_MaxPool2d_madd(module, inp, out):
function compute_AvgPool2d_madd (line 92) | def compute_AvgPool2d_madd(module, inp, out):
function compute_ReLU_madd (line 108) | def compute_ReLU_madd(module, inp, out):
function compute_Softmax_madd (line 117) | def compute_Softmax_madd(module, inp, out):
function compute_Linear_madd (line 130) | def compute_Linear_madd(module, inp, out):
function compute_Bilinear_madd (line 151) | def compute_Bilinear_madd(module, inp1, inp2, out):
function compute_madd (line 164) | def compute_madd(module, inp, out):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_memory.py
function compute_memory (line 6) | def compute_memory(module, inp, out):
function num_params (line 27) | def num_params(module):
function compute_ReLU_memory (line 31) | def compute_ReLU_memory(module, inp, out):
function compute_PReLU_memory (line 40) | def compute_PReLU_memory(module, inp, out):
function compute_Conv2d_memory (line 49) | def compute_Conv2d_memory(module, inp, out):
function compute_BatchNorm2d_memory (line 64) | def compute_BatchNorm2d_memory(module, inp, out):
function compute_LayerNorm_memory (line 73) | def compute_LayerNorm_memory(module, inp, out):
function compute_Linear_memory (line 86) | def compute_Linear_memory(module, inp, out):
function compute_Pool2d_memory (line 106) | def compute_Pool2d_memory(module, inp, out):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/model_hook.py
class ModelHook (line 12) | class ModelHook(object):
method __init__ (line 13) | def __init__(self, model, input_size, device="cuda", debug_layers=[]):
method _register_buffer (line 43) | def _register_buffer(module):
method _sub_module_call_hook (line 58) | def _sub_module_call_hook(self):
method _hook_model (line 187) | def _hook_model(self):
method clear_hooks (line 191) | def clear_hooks(self) -> None:
method retrieve_leaf_modules (line 215) | def retrieve_leaf_modules(self):
method debug_partial_layer (line 219) | def debug_partial_layer(self, target_keys):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/reporter.py
function round_value (line 9) | def round_value(value, binary=False):
function report_format (line 23) | def report_format(collected_nodes):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/stat_tree.py
class StatTree (line 4) | class StatTree(object):
method __init__ (line 5) | def __init__(self, root_node):
method get_same_level_max_node_depth (line 10) | def get_same_level_max_node_depth(self, query_node):
method update_stat_nodes_granularity (line 16) | def update_stat_nodes_granularity(self):
method get_collected_stat_nodes (line 25) | def get_collected_stat_nodes(self, debug_layers, query_granularity):
class StatNode (line 44) | class StatNode(object):
method __init__ (line 45) | def __init__(self, name=str(), mtype=str(), parent=None):
method name (line 64) | def name(self):
method name (line 68) | def name(self, name):
method mtype (line 72) | def mtype(self):
method mtype (line 76) | def mtype(self, mtype):
method granularity (line 80) | def granularity(self):
method granularity (line 84) | def granularity(self, g):
method depth (line 88) | def depth(self):
method input_shape (line 95) | def input_shape(self):
method input_shape (line 102) | def input_shape(self, input_shape):
method output_shape (line 107) | def output_shape(self):
method output_shape (line 114) | def output_shape(self, output_shape):
method parameter_quantity (line 119) | def parameter_quantity(self):
method parameter_quantity (line 127) | def parameter_quantity(self, parameter_quantity):
method inference_memory (line 132) | def inference_memory(self):
method inference_memory (line 139) | def inference_memory(self, inference_memory):
method MAdd (line 143) | def MAdd(self):
method MAdd (line 150) | def MAdd(self, MAdd):
method Flops (line 154) | def Flops(self):
method Flops (line 161) | def Flops(self, Flops):
method Memory (line 165) | def Memory(self):
method Memory (line 174) | def Memory(self, Memory):
method duration (line 179) | def duration(self):
method duration (line 186) | def duration(self, duration):
method find_child_index (line 189) | def find_child_index(self, child_name):
method add_child (line 198) | def add_child(self, node):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/statistics.py
function get_parent_node (line 8) | def get_parent_node(root_node, stat_node_name):
function convert_leaf_modules_to_stat_tree (line 21) | def convert_leaf_modules_to_stat_tree(leaf_modules):
class ModelStat (line 50) | class ModelStat(object):
method __init__ (line 51) | def __init__(self, model, input_size, query_granularity=1, debug_layer...
method _analyze_model (line 59) | def _analyze_model(self):
method show_report (line 67) | def show_report(self):
function stat (line 72) | def stat(model, input_size, query_granularity=1, debug_layers=["MSA", "S...
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/utils.py
function get_dist_info (line 17) | def get_dist_info():
function init_random_seed (line 26) | def init_random_seed(seed=None, device='cuda'):
function set_random_seed (line 58) | def set_random_seed(seed, deterministic=True):
function show_memory_info (line 86) | def show_memory_info(hint):
class AverageMeter (line 99) | class AverageMeter(object):
method __init__ (line 102) | def __init__(self, name=None, fmt=":f"):
method reset (line 107) | def reset(self):
method update (line 113) | def update(self, val, n=1):
class ProgressMeter (line 124) | class ProgressMeter(object):
method __init__ (line 125) | def __init__(self, num_batches, meters, prefix=""):
method display (line 130) | def display(self, batch):
method _get_batch_fmtstr (line 135) | def _get_batch_fmtstr(self, num_batches):
function accuracy (line 141) | def accuracy(output, target, topk=(1,)):
function is_dist_avail_and_initialized (line 168) | def is_dist_avail_and_initialized():
class SmoothedValue (line 176) | class SmoothedValue(object):
method __init__ (line 181) | def __init__(self, window_size=20, fmt=None, eval=False):
method reset (line 190) | def reset(self, window_size):
method update (line 197) | def update(self, value, n=1):
method synchronize_between_processes (line 204) | def synchronize_between_processes(self):
method median (line 220) | def median(self):
method std (line 225) | def std(self):
method max (line 238) | def max(self):
method __str__ (line 246) | def __str__(self):
class MetricLogger (line 261) | class MetricLogger(object):
method __init__ (line 265) | def __init__(self, logger=None, delimiter="\t", dist_print=0, window_s...
method update (line 273) | def update(self, **kwargs):
method update_dict (line 284) | def update_dict(self, kwargs: dict):
method __getattr__ (line 294) | def __getattr__(self, attr):
method __str__ (line 302) | def __str__(self):
method synchronize_between_processes (line 310) | def synchronize_between_processes(self):
method add_meter (line 314) | def add_meter(self, name, meter):
method clear (line 317) | def clear(self):
method log_every (line 320) | def log_every(self, iterable, print_freq, header=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/cal_ssim.py
function gaussian (line 12) | def gaussian(window_size, sigma):
function create_window (line 16) | def create_window(window_size, channel, sigma=1.5):
function _ssim (line 22) | def _ssim(img1, img2, window, window_size, channel, size_average = True):
class SSIM (line 44) | class SSIM(torch.nn.Module):
method __init__ (line 45) | def __init__(self, win_size=11, win_sigma=1.5, data_range=1, size_aver...
method forward (line 53) | def forward(self, img1, img2):
function ssim (line 72) | def ssim(img1, img2, win_size = 11, data_range=1, size_average = True):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/config.py
function import_modules_from_strings (line 28) | def import_modules_from_strings(imports, allow_failed_imports=False):
function check_file_exist (line 76) | def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
class ConfigDict (line 90) | class ConfigDict(Dict):
method __missing__ (line 92) | def __missing__(self, name):
method __getattr__ (line 95) | def __getattr__(self, name):
function add_args (line 108) | def add_args(parser, cfg, prefix=''):
class Config (line 127) | class Config:
method _validate_py_syntax (line 153) | def _validate_py_syntax(filename):
method _substitute_predefined_vars (line 164) | def _substitute_predefined_vars(filename, temp_config_name):
method _pre_substitute_base_vars (line 185) | def _pre_substitute_base_vars(filename, temp_config_name):
method _substitute_base_vars (line 204) | def _substitute_base_vars(cfg, base_var_dict, base_cfg):
method _file2dict (line 236) | def _file2dict(filename, use_predefined_variables=True):
method _merge_a_into_b (line 320) | def _merge_a_into_b(a, b, allow_list_keys=False):
method fromfile (line 374) | def fromfile(filename,
method fromstring (line 384) | def fromstring(cfg_str, file_format):
method auto_argparser (line 411) | def auto_argparser(description=None):
method fromargparse (line 423) | def fromargparse(args):
method merge_args2cfg (line 429) | def merge_args2cfg(self, args, allow_list_keys=True):
method __init__ (line 439) | def __init__(self, cfg_dict=None, cfg_text=None, filename=None):
method filename (line 463) | def filename(self):
method text (line 467) | def text(self):
method pretty_text (line 471) | def pretty_text(self):
method __repr__ (line 564) | def __repr__(self):
method __len__ (line 567) | def __len__(self):
method __getattr__ (line 570) | def __getattr__(self, name):
method __delattr__ (line 573) | def __delattr__(self, name):
method __getitem__ (line 576) | def __getitem__(self, name):
method __setattr__ (line 579) | def __setattr__(self, name, value):
method __setitem__ (line 584) | def __setitem__(self, name, value):
method __iter__ (line 589) | def __iter__(self):
method __getstate__ (line 592) | def __getstate__(self):
method __setstate__ (line 595) | def __setstate__(self, state):
method dump (line 601) | def dump(self, file=None):
method merge_from_dict (line 617) | def merge_from_dict(self, options, allow_list_keys=True):
class DictAction (line 664) | class DictAction(Action):
method _parse_int_float_bool (line 674) | def _parse_int_float_bool(val):
method _parse_iterable (line 688) | def _parse_iterable(val):
method __call__ (line 750) | def __call__(self, parser, namespace, values, option_string=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/criterion_metrics.py
class SetCriterion (line 11) | class SetCriterion(nn.Module):
method __init__ (line 18) | def __init__(self, losses, weight_dict):
method forward (line 32) | def forward(self, outputs, targets, *args, **kwargs):
method _parse_losses (line 59) | def _parse_losses(self, losses):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/dist_utils.py
function scaled_all_reduce (line 14) | def scaled_all_reduce(tensors):
function init_dist (line 37) | def init_dist(launcher, args, backend='nccl', **kwargs):
function get_dist_info (line 51) | def get_dist_info():
function _init_dist_pytorch (line 65) | def _init_dist_pytorch(backend, **kwargs):
function _init_dist_mpi (line 73) | def _init_dist_mpi(backend, **kwargs):
function _init_dist_slurm (line 81) | def _init_dist_slurm(backend, port=None, **kwargs):
function reduce_mean (line 117) | def reduce_mean(tensor, nprocs=None):
class MMDistributedDataParallel (line 130) | class MMDistributedDataParallel(DistributedDataParallel):
method __init__ (line 132) | def __init__(self, model, device_ids):
method reduce_mean (line 137) | def reduce_mean(self, tensor, nprocs=None):
method ddp_step (line 145) | def ddp_step(self, loss_dicts):
function dist_train_v1 (line 159) | def dist_train_v1(args, model):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/launch.py
function parse_args (line 110) | def parse_args():
function main (line 174) | def main():
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/logger.py
function get_root_logger (line 30) | def get_root_logger(name=None, cfg=None, cfg_name=None, log_level=loggin...
function create_logger (line 34) | def create_logger(cfg=None, cfg_name=None, dist_print=0, log_level=loggi...
function setup_logger (line 38) | def setup_logger(name, final_log_file, color=True):
function get_logger (line 101) | def get_logger(name=None, cfg=None, cfg_name=None, phase='train', log_le...
function print_log (line 184) | def print_log(msg, logger=None, level=logging.INFO):
function load_json_log (line 212) | def load_json_log(json_log):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/metrics.py
function rgb2ycbcr (line 12) | def rgb2ycbcr(img, y_only=True):
function quantize (line 20) | def quantize(img, rgb_range):
function calc_psnr (line 25) | def calc_psnr(sr, hr, scale, rgb_range):
class PSNR_ycbcr (line 56) | class PSNR_ycbcr(nn.Module):
method __init__ (line 58) | def __init__(self):
method quantize (line 63) | def quantize(self, img, rgb_range):
method forward (line 72) | def forward(self, sr, hr, scale, rgb_range):
function sub_mean (line 96) | def sub_mean(x):
function add_mean (line 107) | def add_mean(x):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/optim.py
class lr_scheduler (line 7) | class lr_scheduler(object):
method __init__ (line 9) | def __init__(self, lr, epochs):
method set_optimizer (line 31) | def set_optimizer(self, optimizer, lr_scheduler):
method adjust_2_learning_rate (line 68) | def adjust_2_learning_rate(self, epoch):
method adjust_1_learning_rate (line 82) | def adjust_1_learning_rate(self, epoch, mini_lr=1e-6):
method step (line 120) | def step(self, epoch):
method get_lr_map (line 132) | def get_lr_map(self, title, out_file=None, viz=False):
function tune_param (line 164) | def tune_param():
function partial_train (line 168) | def partial_train(model, layers: list):
class LinearRegression (line 187) | class LinearRegression(nn.Module):
method __init__ (line 188) | def __init__(self):
method forward (line 193) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/option.py
function common_cfg (line 14) | def common_cfg():
class panshaprening_cfg (line 88) | class panshaprening_cfg(TaskDispatcher, name='pansharpening'):
method __init__ (line 91) | def __init__(self, cfg=None, arch=None):
function nni_cfg (line 120) | def nni_cfg(args):
class get_cfg (line 128) | class get_cfg(TaskDispatcher, name='entrypoint'):
method __init__ (line 129) | def __init__(self, task=None, arch=None):
function data_cfg (line 155) | def data_cfg(cfg):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/postprocess.py
function format_np_output (line 19) | def format_np_output(np_arr):
function save_image (line 46) | def save_image(im, path):
function norm_image (line 59) | def norm_image(image, factor=255.):
function convert_to_grayscale (line 76) | def convert_to_grayscale(im_as_arr):
function apply_gradient_images (line 101) | def apply_gradient_images(gradient, file_name, is_save=False):
function gen_colormap (line 129) | def gen_colormap(input_image, feature, gradient, factor=255):
function apply_colormap_on_image (line 155) | def apply_colormap_on_image(org_im, activation, colormap_name):
function get_positive_negative_saliency (line 191) | def get_positive_negative_saliency(gradient):
function gen_grad_cam (line 207) | def gen_grad_cam(image, feature, gradient):
function apply_heatmap (line 231) | def apply_heatmap(image, mask, factor=255):
function showimage8 (line 262) | def showimage8(images, unnormlize=2047.0, first_channel=False):
function linstretch (line 277) | def linstretch(images, tol=None):
function make_grid (line 317) | def make_grid(
function tensor_save_image (line 414) | def tensor_save_image(
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/python_sub_class.py
class TaskDispatcher (line 12) | class TaskDispatcher(Config):
method __init_subclass__ (line 15) | def __init_subclass__(cls, name='', **kwargs):
method __new__ (line 27) | def __new__(cls, *args, **kwargs):
method new (line 71) | def new(cls, **kwargs):
class ModelDispatcher (line 103) | class ModelDispatcher(object):
method __init_subclass__ (line 106) | def __init_subclass__(cls, name='', **kwargs):
method __new__ (line 117) | def __new__(cls, *args, **kwargs):
method build_model (line 131) | def build_model(cls, cfg):
class PanSharpeningModel (line 166) | class PanSharpeningModel(ModelDispatcher, name='pansharpening'):
method __init__ (line 170) | def __init__(self, model=None, criterion=None):
method __init_subclass__ (line 178) | def __init_subclass__(cls, name='', **kwargs):
method l2_regularization (line 189) | def l2_regularization(self, loss_dict, weight_decay=1e-5, flag=False):
method train_step (line 207) | def train_step(self, *args, **kwargs):
method val_step (line 216) | def val_step(self, *args, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/Basis/variance_sacling_initializer.py
function truncated_normal_ (line 11) | def truncated_normal_(tensor, mean=0.0, std=1.0):
function variance_scaling_initializer (line 22) | def variance_scaling_initializer(tensor):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/examples/train.py
class Model (line 14) | class Model(nn.Module):
method __init__ (line 16) | def __init__(self):
method forward (line 26) | def forward(self, x):
method train_step (line 35) | def train_step(self, data, optimizer):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/arraymisc/quantization.py
function quantize (line 5) | def quantize(arr, min_val, max_val, levels, dtype=np.int64):
function dequantize (line 32) | def dequantize(arr, min_val, max_val, levels, dtype=np.float64):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/alexnet.py
class AlexNet (line 7) | class AlexNet(nn.Module):
method __init__ (line 14) | def __init__(self, num_classes=-1):
method init_weights (line 43) | def init_weights(self, pretrained=None):
method forward (line 54) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/activation.py
class Clamp (line 18) | class Clamp(nn.Module):
method __init__ (line 31) | def __init__(self, min=-1., max=1.):
method forward (line 36) | def forward(self, x):
class GELU (line 48) | class GELU(nn.Module):
method forward (line 70) | def forward(self, input):
function build_activation_layer (line 81) | def build_activation_layer(cfg):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/context_block.py
function last_zero_init (line 9) | def last_zero_init(m):
class ContextBlock (line 17) | class ContextBlock(nn.Module):
method __init__ (line 36) | def __init__(self,
method reset_parameters (line 75) | def reset_parameters(self):
method spatial_pool (line 85) | def spatial_pool(self, x):
method forward (line 111) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv.py
function build_conv_layer (line 12) | def build_conv_layer(cfg, *args, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv2d_adaptive_padding.py
class Conv2dAdaptivePadding (line 11) | class Conv2dAdaptivePadding(nn.Conv2d):
method __init__ (line 33) | def __init__(self,
method forward (line 45) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv_module.py
class ConvModule (line 16) | class ConvModule(nn.Module):
method __init__ (line 70) | def __init__(self,
method norm (line 169) | def norm(self):
method init_weights (line 175) | def init_weights(self):
method forward (line 196) | def forward(self, x, activate=True, norm=True):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv_ws.py
function conv_ws_2d (line 9) | def conv_ws_2d(input,
class ConvWS2d (line 26) | class ConvWS2d(nn.Conv2d):
method __init__ (line 28) | def __init__(self,
method forward (line 49) | def forward(self, x):
class ConvAWS2d (line 55) | class ConvAWS2d(nn.Conv2d):
method __init__ (line 78) | def __init__(self,
method _get_weight (line 101) | def _get_weight(self, weight):
method forward (line 109) | def forward(self, x):
method _load_from_state_dict (line 114) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/depthwise_separable_conv_module.py
class DepthwiseSeparableConvModule (line 7) | class DepthwiseSeparableConvModule(nn.Module):
method __init__ (line 48) | def __init__(self,
method forward (line 93) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/drop.py
function drop_path (line 9) | def drop_path(x, drop_prob=0., training=False):
class DropPath (line 28) | class DropPath(nn.Module):
method __init__ (line 39) | def __init__(self, drop_prob=0.1):
method forward (line 43) | def forward(self, x):
class Dropout (line 48) | class Dropout(nn.Dropout):
method __init__ (line 59) | def __init__(self, drop_prob=0.5, inplace=False):
function build_dropout (line 63) | def build_dropout(cfg, default_args=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/generalized_attention.py
class GeneralizedAttention (line 14) | class GeneralizedAttention(nn.Module):
method __init__ (line 47) | def __init__(self,
method get_position_embedding (line 166) | def get_position_embedding(self,
method forward (line 216) | def forward(self, x_input):
method init_weights (line 403) | def init_weights(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/hsigmoid.py
class HSigmoid (line 10) | class HSigmoid(nn.Module):
method __init__ (line 29) | def __init__(self, bias=3.0, divisor=6.0, min_value=0.0, max_value=1.0):
method forward (line 43) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/hswish.py
class HSwish (line 8) | class HSwish(nn.Module):
method __init__ (line 24) | def __init__(self, inplace=False):
method forward (line 28) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/non_local.py
class _NonLocalNd (line 12) | class _NonLocalNd(nn.Module, metaclass=ABCMeta):
method __init__ (line 35) | def __init__(self,
method init_weights (line 99) | def init_weights(self, std=0.01, zeros_init=True):
method gaussian (line 116) | def gaussian(self, theta_x, phi_x):
method embedded_gaussian (line 124) | def embedded_gaussian(self, theta_x, phi_x):
method dot_product (line 135) | def dot_product(self, theta_x, phi_x):
method concatenation (line 143) | def concatenation(self, theta_x, phi_x):
method forward (line 160) | def forward(self, x):
class NonLocal1d (line 214) | class NonLocal1d(_NonLocalNd):
method __init__ (line 226) | def __init__(self,
class NonLocal2d (line 246) | class NonLocal2d(_NonLocalNd):
method __init__ (line 260) | def __init__(self,
class NonLocal3d (line 279) | class NonLocal3d(_NonLocalNd):
method __init__ (line 291) | def __init__(self,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/norm.py
function infer_abbr (line 23) | def infer_abbr(class_type):
function build_norm_layer (line 72) | def build_norm_layer(cfg, num_features, postfix=''):
function is_norm (line 122) | def is_norm(layer, exclude=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/padding.py
function build_padding_layer (line 11) | def build_padding_layer(cfg, *args, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/plugin.py
function infer_abbr (line 12) | def infer_abbr(class_type):
function build_plugin_layer (line 55) | def build_plugin_layer(cfg, postfix='', **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/scale.py
class Scale (line 6) | class Scale(nn.Module):
method __init__ (line 16) | def __init__(self, scale=1.0):
method forward (line 20) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/swish.py
class Swish (line 9) | class Swish(nn.Module):
method __init__ (line 21) | def __init__(self):
method forward (line 24) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/transformer.py
function build_positional_encoding (line 37) | def build_positional_encoding(cfg, default_args=None):
function build_attention (line 42) | def build_attention(cfg, default_args=None):
function build_feedforward_network (line 47) | def build_feedforward_network(cfg, default_args=None):
function build_transformer_layer (line 52) | def build_transformer_layer(cfg, default_args=None):
function build_transformer_layer_sequence (line 57) | def build_transformer_layer_sequence(cfg, default_args=None):
class AdaptivePadding (line 62) | class AdaptivePadding(nn.Module):
method __init__ (line 97) | def __init__(self, kernel_size=1, stride=1, dilation=1, padding='corne...
method get_pad_shape (line 110) | def get_pad_shape(self, input_shape):
method forward (line 131) | def forward(self, x):
class PatchEmbed (line 152) | class PatchEmbed(BaseModule):
method __init__ (line 180) | def __init__(self,
method forward (line 252) | def forward(self, x):
class PatchMerging (line 276) | class PatchMerging(BaseModule):
method __init__ (line 308) | def __init__(self,
method forward (line 357) | def forward(self, x, input_size):
class MultiheadAttention (line 406) | class MultiheadAttention(BaseModule):
method __init__ (line 428) | def __init__(self,
method forward (line 460) | def forward(self,
class FFN (line 554) | class FFN(BaseModule):
method __init__ (line 582) | def __init__(self,
method forward (line 617) | def forward(self, x, identity=None):
class BaseTransformerLayer (line 631) | class BaseTransformerLayer(BaseModule):
method __init__ (line 667) | def __init__(self,
method forward (line 760) | def forward(self,
class TransformerLayerSequence (line 862) | class TransformerLayerSequence(BaseModule):
method __init__ (line 881) | def __init__(self, transformerlayers=None, num_layers=None, init_cfg=N...
method forward (line 897) | def forward(self,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/upsample.py
class PixelShufflePack (line 13) | class PixelShufflePack(nn.Module):
method __init__ (line 27) | def __init__(self, in_channels, out_channels, scale_factor,
method init_weights (line 41) | def init_weights(self):
method forward (line 44) | def forward(self, x):
function build_upsample_layer (line 50) | def build_upsample_layer(cfg, *args, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/wrappers.py
function obsolete_torch_version (line 24) | def obsolete_torch_version(torch_version, version_threshold):
class NewEmptyTensorOp (line 28) | class NewEmptyTensorOp(torch.autograd.Function):
method forward (line 31) | def forward(ctx, x, new_shape):
method backward (line 36) | def backward(ctx, grad):
class Conv2d (line 42) | class Conv2d(nn.Conv2d):
method forward (line 44) | def forward(self, x):
class Conv3d (line 63) | class Conv3d(nn.Conv3d):
method forward (line 65) | def forward(self, x):
class ConvTranspose2d (line 86) | class ConvTranspose2d(nn.ConvTranspose2d):
method forward (line 88) | def forward(self, x):
class ConvTranspose3d (line 109) | class ConvTranspose3d(nn.ConvTranspose3d):
method forward (line 111) | def forward(self, x):
class MaxPool2d (line 129) | class MaxPool2d(nn.MaxPool2d):
method forward (line 131) | def forward(self, x):
class MaxPool3d (line 147) | class MaxPool3d(nn.MaxPool3d):
method forward (line 149) | def forward(self, x):
class Linear (line 166) | class Linear(torch.nn.Linear):
method forward (line 168) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/builder.py
function build_model_from_cfg (line 6) | def build_model_from_cfg(cfg, registry, default_args=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/resnet.py
function conv3x3 (line 10) | def conv3x3(in_planes, out_planes, stride=1, dilation=1):
class BasicBlock (line 22) | class BasicBlock(nn.Module):
method __init__ (line 25) | def __init__(self,
method forward (line 45) | def forward(self, x):
class Bottleneck (line 64) | class Bottleneck(nn.Module):
method __init__ (line 67) | def __init__(self,
method forward (line 110) | def forward(self, x):
function make_res_layer (line 143) | def make_res_layer(block,
class ResNet (line 181) | class ResNet(nn.Module):
method __init__ (line 210) | def __init__(self,
method init_weights (line 265) | def init_weights(self, pretrained=None):
method forward (line 279) | def forward(self, x):
method train (line 295) | def train(self, mode=True):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/flops_counter.py
function get_model_complexity_info (line 37) | def get_model_complexity_info(model,
function flops_to_string (line 119) | def flops_to_string(flops, units='GFLOPs', precision=2):
function params_to_string (line 162) | def params_to_string(num_params, units=None, precision=2):
function print_model_with_flops (line 199) | def print_model_with_flops(model,
function get_model_parameters_number (line 308) | def get_model_parameters_number(model):
function add_flops_counting_methods (line 321) | def add_flops_counting_methods(net_main_module):
function compute_average_flops_cost (line 338) | def compute_average_flops_cost(self):
function start_flops_count (line 356) | def start_flops_count(self):
function stop_flops_count (line 379) | def stop_flops_count(self):
function reset_flops_count (line 390) | def reset_flops_count(self):
function empty_flops_counter_hook (line 401) | def empty_flops_counter_hook(module, input, output):
function upsample_flops_counter_hook (line 405) | def upsample_flops_counter_hook(module, input, output):
function relu_flops_counter_hook (line 414) | def relu_flops_counter_hook(module, input, output):
function linear_flops_counter_hook (line 419) | def linear_flops_counter_hook(module, input, output):
function pool_flops_counter_hook (line 426) | def pool_flops_counter_hook(module, input, output):
function norm_flops_counter_hook (line 431) | def norm_flops_counter_hook(module, input, output):
function deconv_flops_counter_hook (line 441) | def deconv_flops_counter_hook(conv_module, input, output):
function conv_flops_counter_hook (line 468) | def conv_flops_counter_hook(conv_module, input, output):
function batch_counter_hook (line 499) | def batch_counter_hook(module, input, output):
function add_batch_counter_variables_or_reset (line 511) | def add_batch_counter_variables_or_reset(module):
function add_batch_counter_hook_function (line 516) | def add_batch_counter_hook_function(module):
function remove_batch_counter_hook_function (line 524) | def remove_batch_counter_hook_function(module):
function add_flops_counter_variable_or_reset (line 530) | def add_flops_counter_variable_or_reset(module):
function is_supported_instance (line 540) | def is_supported_instance(module):
function remove_flops_counter_hook_function (line 546) | def remove_flops_counter_hook_function(module):
function get_modules_mapping (line 553) | def get_modules_mapping():
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/fuse_conv_bn.py
function _fuse_conv_bn (line 6) | def _fuse_conv_bn(conv, bn):
function fuse_conv_bn (line 27) | def fuse_conv_bn(module):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/sync_bn.py
class _BatchNormXd (line 6) | class _BatchNormXd(torch.nn.modules.batchnorm._BatchNorm):
method _check_input_dim (line 17) | def _check_input_dim(self, input):
function revert_sync_batchnorm (line 21) | def revert_sync_batchnorm(module):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/weight_init.py
function update_init_info (line 15) | def update_init_info(module, init_info):
function constant_init (line 47) | def constant_init(module, val, bias=0):
function xavier_init (line 54) | def xavier_init(module, gain=1, bias=0, distribution='normal'):
function normal_init (line 65) | def normal_init(module, mean=0, std=1, bias=0):
function trunc_normal_init (line 72) | def trunc_normal_init(module: nn.Module,
function uniform_init (line 84) | def uniform_init(module, a=0, b=1, bias=0):
function kaiming_init (line 91) | def kaiming_init(module,
function caffe2_xavier_init (line 109) | def caffe2_xavier_init(module, bias=0):
function bias_init_with_prob (line 121) | def bias_init_with_prob(prior_prob):
function _get_bases_name (line 127) | def _get_bases_name(m):
class BaseInit (line 131) | class BaseInit(object):
method __init__ (line 133) | def __init__(self, *, bias=0, bias_prob=None, layer=None):
method _get_init_info (line 156) | def _get_init_info(self):
class ConstantInit (line 162) | class ConstantInit(BaseInit):
method __init__ (line 174) | def __init__(self, val, **kwargs):
method __call__ (line 178) | def __call__(self, module):
method _get_init_info (line 193) | def _get_init_info(self):
class XavierInit (line 199) | class XavierInit(BaseInit):
method __init__ (line 216) | def __init__(self, gain=1, distribution='normal', **kwargs):
method __call__ (line 221) | def __call__(self, module):
method _get_init_info (line 236) | def _get_init_info(self):
class NormalInit (line 243) | class NormalInit(BaseInit):
method __init__ (line 259) | def __init__(self, mean=0, std=1, **kwargs):
method __call__ (line 264) | def __call__(self, module):
method _get_init_info (line 279) | def _get_init_info(self):
class TruncNormalInit (line 286) | class TruncNormalInit(BaseInit):
method __init__ (line 305) | def __init__(self,
method __call__ (line 317) | def __call__(self, module: nn.Module) -> None:
method _get_init_info (line 334) | def _get_init_info(self):
class UniformInit (line 341) | class UniformInit(BaseInit):
method __init__ (line 357) | def __init__(self, a=0, b=1, **kwargs):
method __call__ (line 362) | def __call__(self, module):
method _get_init_info (line 377) | def _get_init_info(self):
class KaimingInit (line 384) | class KaimingInit(BaseInit):
method __init__ (line 410) | def __init__(self,
method __call__ (line 422) | def __call__(self, module):
method _get_init_info (line 439) | def _get_init_info(self):
class Caffe2XavierInit (line 447) | class Caffe2XavierInit(KaimingInit):
method __init__ (line 450) | def __init__(self, **kwargs):
method __call__ (line 458) | def __call__(self, module):
class PretrainedInit (line 463) | class PretrainedInit(object):
method __init__ (line 477) | def __init__(self, checkpoint, prefix=None, map_location=None):
method __call__ (line 482) | def __call__(self, module):
method _get_init_info (line 505) | def _get_init_info(self):
function _initialize (line 510) | def _initialize(module, cfg, wholemodule=False):
function _initialize_override (line 519) | def _initialize_override(module, override, cfg):
function initialize (line 549) | def initialize(module, init_cfg):
function _no_grad_trunc_normal_ (line 622) | def _no_grad_trunc_normal_(tensor: Tensor, mean: float, std: float, a: f...
function trunc_normal_ (line 662) | def trunc_normal_(tensor: Tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/vgg.py
function conv3x3 (line 9) | def conv3x3(in_planes, out_planes, dilation=1):
function make_vgg_layer (line 19) | def make_vgg_layer(inplanes,
class VGG (line 37) | class VGG(nn.Module):
method __init__ (line 61) | def __init__(self,
method init_weights (line 125) | def init_weights(self, pretrained=None):
method forward (line 141) | def forward(self, x):
method train (line 159) | def train(self, mode=True):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/engine/test.py
function single_gpu_test (line 15) | def single_gpu_test(model, data_loader):
function multi_gpu_test (line 44) | def multi_gpu_test(model, data_loader, tmpdir=None, gpu_collect=False):
function collect_results_cpu (line 91) | def collect_results_cpu(result_part, size, tmpdir=None):
function collect_results_gpu (line 155) | def collect_results_gpu(result_part, size):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/file_client.py
class BaseStorageBackend (line 19) | class BaseStorageBackend(metaclass=ABCMeta):
method name (line 31) | def name(self):
method allow_symlink (line 35) | def allow_symlink(self):
method get (line 39) | def get(self, filepath):
method get_text (line 43) | def get_text(self, filepath):
class CephBackend (line 47) | class CephBackend(BaseStorageBackend):
method __init__ (line 60) | def __init__(self, path_mapping=None):
method get (line 73) | def get(self, filepath):
method get_text (line 82) | def get_text(self, filepath, encoding=None):
class PetrelBackend (line 86) | class PetrelBackend(BaseStorageBackend):
method __init__ (line 109) | def __init__(self,
method _map_path (line 122) | def _map_path(self, filepath: Union[str, Path]) -> str:
method _format_path (line 135) | def _format_path(self, filepath: str) -> str:
method get (line 148) | def get(self, filepath: Union[str, Path]) -> memoryview:
method get_text (line 165) | def get_text(self,
method put (line 180) | def put(self, obj: bytes, filepath: Union[str, Path]) -> None:
method put_text (line 191) | def put_text(self,
method remove (line 205) | def remove(self, filepath: Union[str, Path]) -> None:
method exists (line 221) | def exists(self, filepath: Union[str, Path]) -> bool:
method isdir (line 241) | def isdir(self, filepath: Union[str, Path]) -> bool:
method isfile (line 262) | def isfile(self, filepath: Union[str, Path]) -> bool:
method join_path (line 282) | def join_path(self, filepath: Union[str, Path],
method get_local_path (line 301) | def get_local_path(self, filepath: Union[str, Path]) -> Iterable[str]:
method list_dir_or_file (line 332) | def list_dir_or_file(self,
class MemcachedBackend (line 414) | class MemcachedBackend(BaseStorageBackend):
method __init__ (line 424) | def __init__(self, server_list_cfg, client_cfg, sys_path=None):
method get (line 441) | def get(self, filepath):
method get_text (line 448) | def get_text(self, filepath, encoding=None):
class LmdbBackend (line 452) | class LmdbBackend(BaseStorageBackend):
method __init__ (line 470) | def __init__(self,
method get (line 489) | def get(self, filepath):
method get_text (line 500) | def get_text(self, filepath, encoding=None):
class HardDiskBackend (line 504) | class HardDiskBackend(BaseStorageBackend):
method get (line 509) | def get(self, filepath: Union[str, Path]) -> bytes:
method get_text (line 522) | def get_text(self,
method put (line 539) | def put(self, obj: bytes, filepath: Union[str, Path]) -> None:
method put_text (line 554) | def put_text(self,
method remove (line 574) | def remove(self, filepath: Union[str, Path]) -> None:
method exists (line 582) | def exists(self, filepath: Union[str, Path]) -> bool:
method isdir (line 593) | def isdir(self, filepath: Union[str, Path]) -> bool:
method isfile (line 606) | def isfile(self, filepath: Union[str, Path]) -> bool:
method join_path (line 618) | def join_path(self, filepath: Union[str, Path],
method get_local_path (line 634) | def get_local_path(
method list_dir_or_file (line 639) | def list_dir_or_file(self,
class HTTPBackend (line 692) | class HTTPBackend(BaseStorageBackend):
method get (line 695) | def get(self, filepath):
method get_text (line 699) | def get_text(self, filepath, encoding='utf-8'):
method get_local_path (line 704) | def get_local_path(self, filepath: str) -> Iterable[str]:
class FileClient (line 730) | class FileClient:
method __new__ (line 788) | def __new__(cls, backend=None, prefix=None, **kwargs):
method name (line 824) | def name(self):
method allow_symlink (line 828) | def allow_symlink(self):
method parse_uri_prefix (line 832) | def parse_uri_prefix(uri: Union[str, Path]) -> Optional[str]:
method infer_client (line 859) | def infer_client(cls,
method _register_backend (line 887) | def _register_backend(cls, name, backend, force=False, prefixes=None):
method register_backend (line 923) | def register_backend(cls, name, backend=None, force=False, prefixes=No...
method get (line 977) | def get(self, filepath: Union[str, Path]) -> Union[bytes, memoryview]:
method get_text (line 995) | def get_text(self, filepath: Union[str, Path], encoding='utf-8') -> str:
method put (line 1008) | def put(self, obj: bytes, filepath: Union[str, Path]) -> None:
method put_text (line 1021) | def put_text(self, obj: str, filepath: Union[str, Path]) -> None:
method remove (line 1036) | def remove(self, filepath: Union[str, Path]) -> None:
method exists (line 1044) | def exists(self, filepath: Union[str, Path]) -> bool:
method isdir (line 1055) | def isdir(self, filepath: Union[str, Path]) -> bool:
method isfile (line 1068) | def isfile(self, filepath: Union[str, Path]) -> bool:
method join_path (line 1080) | def join_path(self, filepath: Union[str, Path],
method get_local_path (line 1096) | def get_local_path(self, filepath: Union[str, Path]) -> Iterable[str]:
method list_dir_or_file (line 1124) | def list_dir_or_file(self,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/base.py
class BaseFileHandler (line 5) | class BaseFileHandler(metaclass=ABCMeta):
method load_from_fileobj (line 13) | def load_from_fileobj(self, file, **kwargs):
method dump_to_fileobj (line 17) | def dump_to_fileobj(self, obj, file, **kwargs):
method dump_to_str (line 21) | def dump_to_str(self, obj, **kwargs):
method load_from_path (line 24) | def load_from_path(self, filepath, mode='r', **kwargs):
method dump_to_path (line 28) | def dump_to_path(self, obj, filepath, mode='w', **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/json_handler.py
function set_default (line 9) | def set_default(obj):
class JsonHandler (line 25) | class JsonHandler(BaseFileHandler):
method load_from_fileobj (line 27) | def load_from_fileobj(self, file):
method dump_to_fileobj (line 30) | def dump_to_fileobj(self, obj, file, **kwargs):
method dump_to_str (line 34) | def dump_to_str(self, obj, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/pickle_handler.py
class PickleHandler (line 7) | class PickleHandler(BaseFileHandler):
method load_from_fileobj (line 11) | def load_from_fileobj(self, file, **kwargs):
method load_from_path (line 14) | def load_from_path(self, filepath, **kwargs):
method dump_to_str (line 18) | def dump_to_str(self, obj, **kwargs):
method dump_to_fileobj (line 22) | def dump_to_fileobj(self, obj, file, **kwargs):
method dump_to_path (line 26) | def dump_to_path(self, obj, filepath, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/yaml_handler.py
class YamlHandler (line 12) | class YamlHandler(BaseFileHandler):
method load_from_fileobj (line 14) | def load_from_fileobj(self, file, **kwargs):
method dump_to_fileobj (line 18) | def dump_to_fileobj(self, obj, file, **kwargs):
method dump_to_str (line 22) | def dump_to_str(self, obj, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/io.py
function load (line 18) | def load(file, file_format=None, file_client_args=None, **kwargs):
function dump (line 69) | def dump(obj, file=None, file_format=None, file_client_args=None, **kwar...
function _register_handler (line 126) | def _register_handler(handler, file_formats):
function register_handler (line 145) | def register_handler(file_formats, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/parse.py
function list_from_file (line 8) | def list_from_file(filename,
function dict_from_file (line 55) | def dict_from_file(filename,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/colorspace.py
function imconvert (line 6) | def imconvert(img, src, dst):
function bgr2gray (line 22) | def bgr2gray(img, keepdim=False):
function rgb2gray (line 39) | def rgb2gray(img, keepdim=False):
function gray2bgr (line 56) | def gray2bgr(img):
function gray2rgb (line 70) | def gray2rgb(img):
function _convert_input_type_range (line 84) | def _convert_input_type_range(img):
function _convert_output_type_range (line 112) | def _convert_output_type_range(img, dst_type):
function rgb2ycbcr (line 143) | def rgb2ycbcr(img, y_only=False):
function bgr2ycbcr (line 177) | def bgr2ycbcr(img, y_only=False):
function ycbcr2rgb (line 211) | def ycbcr2rgb(img):
function ycbcr2bgr (line 243) | def ycbcr2bgr(img):
function convert_color_factory (line 275) | def convert_color_factory(src, dst):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/geometric.py
function _scale_size (line 16) | def _scale_size(size, scale):
function imresize (line 51) | def imresize(img,
function imresize_to_multiple (line 98) | def imresize_to_multiple(img,
function imresize_like (line 162) | def imresize_like(img,
function rescale_size (line 184) | def rescale_size(old_size, scale, return_scale=False):
function imrescale (line 221) | def imrescale(img,
function imflip (line 252) | def imflip(img, direction='horizontal'):
function imflip_ (line 272) | def imflip_(img, direction='horizontal'):
function imrotate (line 292) | def imrotate(img,
function bbox_clip (line 342) | def bbox_clip(bboxes, img_shape):
function bbox_scaling (line 360) | def bbox_scaling(bboxes, scale, clip_shape=None):
function imcrop (line 386) | def imcrop(img, bboxes, scale=1.0, pad_fill=None):
function impad (line 440) | def impad(img,
function impad_to_multiple (line 522) | def impad_to_multiple(img, divisor, pad_val=0):
function cutout (line 538) | def cutout(img, shape, pad_val=0):
function _get_shear_matrix (line 593) | def _get_shear_matrix(magnitude, direction='horizontal'):
function imshear (line 611) | def imshear(img,
function _get_translate_matrix (line 662) | def _get_translate_matrix(offset, direction='horizontal'):
function imtranslate (line 680) | def imtranslate(img,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/io.py
function use_backend (line 45) | def use_backend(backend):
function _jpegflag (line 71) | def _jpegflag(flag='color', channel_order='bgr'):
function _pillow2array (line 87) | def _pillow2array(img, flag='color', channel_order='bgr'):
function imread (line 142) | def imread(img_or_path,
function imfrombytes (line 210) | def imfrombytes(content, flag='color', channel_order='bgr', backend=None):
function imwrite (line 263) | def imwrite(img,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/misc.py
function tensor2imgs (line 12) | def tensor2imgs(tensor, mean=None, std=None, to_rgb=True):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/photometric.py
function imnormalize (line 9) | def imnormalize(img, mean, std, to_rgb=True):
function imnormalize_ (line 25) | def imnormalize_(img, mean, std, to_rgb=True):
function imdenormalize (line 48) | def imdenormalize(img, mean, std, to_bgr=True):
function iminvert (line 59) | def iminvert(img):
function solarize (line 71) | def solarize(img, thr=128):
function posterize (line 85) | def posterize(img, bits):
function adjust_color (line 100) | def adjust_color(img, alpha=1, beta=None, gamma=0):
function imequalize (line 131) | def imequalize(img):
function adjust_brightness (line 176) | def adjust_brightness(img, factor=1.):
function adjust_contrast (line 208) | def adjust_contrast(img, factor=1.):
function auto_contrast (line 238) | def auto_contrast(img, cutoff=0):
function adjust_sharpness (line 294) | def adjust_sharpness(img, factor=1., kernel=None):
function adjust_lighting (line 338) | def adjust_lighting(img, eigval, eigvec, alphastd=0.1, to_rgb=True):
function lut_transform (line 381) | def lut_transform(img, lut_table):
function clahe (line 405) | def clahe(img, clip_limit=40.0, tile_grid_size=(8, 8)):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/info.py
function is_custom_op_loaded (line 7) | def is_custom_op_loaded():
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/onnx_utils/symbolic_helper.py
function _parse_arg (line 22) | def _parse_arg(value, desc):
function _maybe_get_const (line 65) | def _maybe_get_const(value, desc):
function _maybe_get_scalar (line 71) | def _maybe_get_scalar(value):
function _get_const (line 78) | def _get_const(value, desc, arg_name):
function _unpack_list (line 87) | def _unpack_list(list_value):
function _is_packed_list (line 96) | def _is_packed_list(list_value):
function parse_args (line 101) | def parse_args(*arg_descriptors):
function _scalar (line 126) | def _scalar(x):
function _if_scalar_type_as (line 132) | def _if_scalar_type_as(g, self, tensor):
function _is_none (line 145) | def _is_none(x):
function _is_value (line 149) | def _is_value(x):
function _is_tensor_list (line 153) | def _is_tensor_list(x):
function _unimplemented (line 157) | def _unimplemented(op, msg):
function _try_get_scalar_type (line 162) | def _try_get_scalar_type(*args):
function _topk_helper (line 171) | def _topk_helper(g, input, k, dim, largest=True, sorted=False, out=None):
function _slice_helper (line 188) | def _slice_helper(g,
function _unsqueeze_helper (line 200) | def _unsqueeze_helper(g, input, dim):
function _interpolate_size_to_scales (line 205) | def _interpolate_size_to_scales(g, input, output_size, dim):
function _interpolate_get_scales_if_available (line 229) | def _interpolate_get_scales_if_available(g, scales):
function _get_interpolate_attributes (line 266) | def _get_interpolate_attributes(g, mode, args):
function _interpolate_get_scales (line 277) | def _interpolate_get_scales(g, scale_factor, dim):
function _size_helper (line 290) | def _size_helper(g, self, dim):
function _avgpool_helper (line 297) | def _avgpool_helper(tuple_fn, padding, kernel_size, stride, divisor_over...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/symbolic.py
function _interpolate (line 14) | def _interpolate(name, dim, interpolate_mode):
function topk (line 88) | def topk(g, self, k, dim, largest, sorted, out=None):
function masked_select (line 93) | def masked_select(g, self, mask):
function _prepare_onnx_paddings (line 99) | def _prepare_onnx_paddings(g, dim, pad):
function constant_pad_nd (line 131) | def constant_pad_nd(g, input, padding, value=None):
function reflection_pad (line 139) | def reflection_pad(g, input, padding):
function _avg_pool (line 150) | def _avg_pool(name, tuple_fn):
function _get_im2col_indices_along_dim (line 191) | def _get_im2col_indices_along_dim(g, input_d, kernel_size_d, dilation_d,
function _get_im2col_padded_input (line 228) | def _get_im2col_padded_input(g, input, padding_h, padding_w):
function _get_im2col_output_shape (line 238) | def _get_im2col_output_shape(g, input, kernel_h, kernel_w):
function size (line 253) | def size(g, self, dim=None):
function im2col (line 260) | def im2col(g, input, kernel_size, dilation, padding, stride):
function one_hot (line 289) | def one_hot(g, self, num_classes):
function softmax (line 296) | def softmax(g, input, dim, dtype=None):
function _adaptive_pool (line 324) | def _adaptive_pool(name, type, tuple_fn, fn=None):
function new_full (line 368) | def new_full(g,
function grid_sampler (line 385) | def grid_sampler(g,
function cummax (line 401) | def cummax(g, input, dim):
function cummin (line 406) | def cummin(g, input, dim):
function roll (line 411) | def roll(g, input, shifts, dims):
function register_extra_symbolics (line 469) | def register_extra_symbolics(opset=11):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/active_rotated_filter.py
class ActiveRotatedFilterFunction (line 13) | class ActiveRotatedFilterFunction(Function):
method forward (line 22) | def forward(ctx, input, indices):
method backward (line 44) | def backward(ctx, grad_out):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/assign_score_withk.py
class AssignScoreWithK (line 9) | class AssignScoreWithK(Function):
method forward (line 29) | def forward(ctx,
method backward (line 81) | def backward(ctx, grad_out):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/ball_query.py
class BallQuery (line 10) | class BallQuery(Function):
method forward (line 14) | def forward(ctx, min_radius: float, max_radius: float, sample_num: int,
method backward (line 52) | def backward(ctx, a=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/bbox.py
function bbox_overlaps (line 7) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', aligned=False, offset=0):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/border_align.py
class BorderAlignFunction (line 16) | class BorderAlignFunction(Function):
method symbolic (line 19) | def symbolic(g, input, boxes, pool_size):
method forward (line 24) | def forward(ctx, input, boxes, pool_size):
method backward (line 48) | def backward(ctx, grad_output):
class BorderAlign (line 65) | class BorderAlign(nn.Module):
method __init__ (line 88) | def __init__(self, pool_size):
method forward (line 92) | def forward(self, input, boxes):
method __repr__ (line 106) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/box_iou_rotated.py
function box_iou_rotated (line 7) | def box_iou_rotated(bboxes1,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/carafe.py
class CARAFENaiveFunction (line 17) | class CARAFENaiveFunction(Function):
method symbolic (line 20) | def symbolic(g, features, masks, kernel_size, group_size, scale_factor):
method forward (line 30) | def forward(ctx, features, masks, kernel_size, group_size, scale_factor):
method backward (line 58) | def backward(ctx, grad_output):
class CARAFENaive (line 84) | class CARAFENaive(Module):
method __init__ (line 86) | def __init__(self, kernel_size, group_size, scale_factor):
method forward (line 95) | def forward(self, features, masks):
class CARAFEFunction (line 100) | class CARAFEFunction(Function):
method symbolic (line 103) | def symbolic(g, features, masks, kernel_size, group_size, scale_factor):
method forward (line 113) | def forward(ctx, features, masks, kernel_size, group_size, scale_factor):
method backward (line 147) | def backward(ctx, grad_output):
class CARAFE (line 180) | class CARAFE(Module):
method __init__ (line 195) | def __init__(self, kernel_size, group_size, scale_factor):
method forward (line 204) | def forward(self, features, masks):
class CARAFEPack (line 210) | class CARAFEPack(nn.Module):
method __init__ (line 231) | def __init__(self,
method init_weights (line 259) | def init_weights(self):
method kernel_normalizer (line 265) | def kernel_normalizer(self, mask):
method feature_reassemble (line 278) | def feature_reassemble(self, x, mask):
method forward (line 282) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/cc_attention.py
function NEG_INF_DIAG (line 9) | def NEG_INF_DIAG(n, device):
class CrissCrossAttention (line 19) | class CrissCrossAttention(nn.Module):
method __init__ (line 44) | def __init__(self, in_channels):
method forward (line 52) | def forward(self, x):
method __repr__ (line 81) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/contour_expand.py
function contour_expand (line 10) | def contour_expand(kernel_mask, internal_kernel_label, min_kernel_area,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/convex_iou.py
function convex_giou (line 7) | def convex_giou(pointsets, polygons):
function convex_iou (line 29) | def convex_iou(pointsets, polygons):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/corner_pool.py
class TopPoolFunction (line 17) | class TopPoolFunction(Function):
method symbolic (line 20) | def symbolic(g, input):
method forward (line 26) | def forward(ctx, input):
method backward (line 32) | def backward(ctx, grad_output):
class BottomPoolFunction (line 38) | class BottomPoolFunction(Function):
method symbolic (line 41) | def symbolic(g, input):
method forward (line 47) | def forward(ctx, input):
method backward (line 53) | def backward(ctx, grad_output):
class LeftPoolFunction (line 59) | class LeftPoolFunction(Function):
method symbolic (line 62) | def symbolic(g, input):
method forward (line 68) | def forward(ctx, input):
method backward (line 74) | def backward(ctx, grad_output):
class RightPoolFunction (line 80) | class RightPoolFunction(Function):
method symbolic (line 83) | def symbolic(g, input):
method forward (line 89) | def forward(ctx, input):
method backward (line 95) | def backward(ctx, grad_output):
class CornerPool (line 101) | class CornerPool(nn.Module):
method __init__ (line 138) | def __init__(self, mode):
method forward (line 144) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/correlation.py
class CorrelationFunction (line 14) | class CorrelationFunction(Function):
method forward (line 17) | def forward(ctx,
method backward (line 63) | def backward(ctx, grad_output):
method _output_size (line 96) | def _output_size(ctx, input1):
class Correlation (line 114) | class Correlation(nn.Module):
method __init__ (line 167) | def __init__(self,
method forward (line 182) | def forward(self, input1: Tensor, input2: Tensor) -> Tensor:
method __repr__ (line 188) | def __repr__(self) -> str:
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/box_iou_rotated_utils.hpp
type RotatedBox (line 21) | struct RotatedBox {
type Point (line 26) | struct Point {
method HOST_DEVICE_INLINE (line 29) | HOST_DEVICE_INLINE Point operator+(const Point& p) const {
method HOST_DEVICE_INLINE (line 32) | HOST_DEVICE_INLINE Point& operator+=(const Point& p) {
method HOST_DEVICE_INLINE (line 37) | HOST_DEVICE_INLINE Point operator-(const Point& p) const {
method HOST_DEVICE_INLINE (line 40) | HOST_DEVICE_INLINE Point operator*(const T coeff) const {
function HOST_DEVICE_INLINE (line 46) | HOST_DEVICE_INLINE T dot_2d(const Point<T>& A, const Point<T>& B) {
function HOST_DEVICE_INLINE (line 51) | HOST_DEVICE_INLINE T cross_2d(const Point<T>& A, const Point<T>& B) {
function HOST_DEVICE_INLINE (line 56) | HOST_DEVICE_INLINE void get_rotated_vertices(const RotatedBox<T>& box,
function HOST_DEVICE_INLINE (line 77) | HOST_DEVICE_INLINE int get_intersection_points(const Point<T> (&pts1)[4],
function HOST_DEVICE_INLINE (line 157) | HOST_DEVICE_INLINE int convex_hull_graham(const Point<T> (&p)[24],
function HOST_DEVICE_INLINE (line 274) | HOST_DEVICE_INLINE T polygon_area(const Point<T> (&q)[24], const int& m) {
function HOST_DEVICE_INLINE (line 288) | HOST_DEVICE_INLINE T rotated_boxes_intersection(const RotatedBox<T>& box1,
function HOST_DEVICE_INLINE (line 314) | HOST_DEVICE_INLINE T single_box_iou_rotated(T const* const box1_raw,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/common_cuda_helper.hpp
function GET_BLOCKS (line 22) | inline int GET_BLOCKS(const int N, const int num_threads = THREADS_PER_B...
function __device__ (line 29) | __device__ T bilinear_interpolate(const T* input, const int height,
function __device__ (line 73) | __device__ void bilinear_interpolate_gradient(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/parrots_cuda_helper.hpp
function __device__ (line 65) | static __inline__ __device__ double atomicAdd(double* address, double va...
function __device__ (line 79) | static __inline__ __device__ float16 atomicAdd(float16* address, float16...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/pytorch_device_registry.hpp
function GetDeviceStr (line 15) | inline std::string GetDeviceStr(const at::Device& device) {
class DeviceRegistry (line 26) | class DeviceRegistry
class DeviceRegistry<Ret (*)(Args...), f> (line 29) | class DeviceRegistry<Ret (*)(Args...), f> {
method Register (line 35) | void Register(at::DeviceType device, FunctionType function) {
method FunctionType (line 39) | FunctionType Find(at::DeviceType device) const {
method DeviceRegistry (line 43) | static DeviceRegistry& instance() {
method DeviceRegistry (line 49) | DeviceRegistry() {
function GetFirstTensorDevice (line 62) | at::Device GetFirstTensorDevice(T&& t, Args&&... args) {
function GetFirstTensorDevice (line 68) | at::Device GetFirstTensorDevice(T&& t, Args&&... args) {
function CheckDeviceConsistency (line 74) | inline std::pair<int, at::Device> CheckDeviceConsistency(
function CheckDeviceConsistency (line 89) | std::pair<int, at::Device> CheckDeviceConsistency(const at::Device& device,
function CheckDeviceConsistency (line 103) | std::pair<int, at::Device> CheckDeviceConsistency(const at::Device& device,
function Dispatch (line 112) | auto Dispatch(const R& registry, const char* name, Args&&... args) {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/corner_pool.h
type MMCVCornerPoolKernel (line 8) | struct MMCVCornerPoolKernel {
type MMCVCornerPoolCustomOp (line 23) | struct MMCVCornerPoolCustomOp
function ONNXTensorElementDataType (line 32) | ONNXTensorElementDataType GetInputType(size_t) const {
function ONNXTensorElementDataType (line 37) | ONNXTensorElementDataType GetOutputType(size_t) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/corner_pool.cpp
function TopPoolForwardCPU (line 6) | void TopPoolForwardCPU(const float *input, float *output, const int batc...
function BottomPoolForwardCPU (line 27) | void BottomPoolForwardCPU(const float *input, float *output,
function LeftPoolForwardCPU (line 48) | void LeftPoolForwardCPU(const float *input, float *output, const int bat...
function RightPoolForwardCPU (line 69) | void RightPoolForwardCPU(const float *input, float *output,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/deform_conv.cpp
function gemm_ref_fp32_deform (line 9) | void gemm_ref_fp32_deform(const float *A, const float *B, const float *V,
function bilinear_interpolate (line 72) | float bilinear_interpolate(const float *src, const int64_t src_h,
function deformable_im2col (line 104) | void deformable_im2col(const float *input, const float *offset,
function deformable_conv_forward (line 148) | void deformable_conv_forward(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/gridSample.cpp
type GridSamplerInterpolation (line 25) | enum GridSamplerInterpolation { Bilinear = 0, Nearest = 1, Bicubic = 2 }
type GridSamplerPadding (line 26) | enum GridSamplerPadding { Zeros = 0, Border = 1, Reflection = 2 }
function scalar_t (line 29) | static inline scalar_t grid_sampler_unnormalize(scalar_t coord, int64_t ...
function scalar_t (line 40) | static inline scalar_t clip_coordinates(scalar_t in, int64_t clip_limit) {
function scalar_t (line 49) | static inline scalar_t reflect_coordinates(scalar_t in, int64_t twice_low,
function scalar_t (line 68) | static inline scalar_t compute_coordinates(scalar_t coord, int64_t size,
function scalar_t (line 86) | static inline scalar_t grid_sampler_compute_source_index(scalar_t coord,
function within_bounds_2d (line 95) | static inline bool within_bounds_2d(int64_t h, int64_t w, int64_t H,
function scalar_t (line 101) | static inline scalar_t get_value_bounded(const scalar_t *data, scalar_t x,
function scalar_t (line 119) | static inline scalar_t cubic_convolution1(scalar_t x, scalar_t A) {
function scalar_t (line 124) | static inline scalar_t cubic_convolution2(scalar_t x, scalar_t A) {
function get_cubic_upsample_coefficients (line 129) | static inline void get_cubic_upsample_coefficients(scalar_t coeffs[4],
function scalar_t (line 144) | static inline scalar_t cubic_interp1d(scalar_t x0, scalar_t x1, scalar_t...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/modulated_deform_conv.cpp
function bilinear_interpolate_2d (line 9) | float bilinear_interpolate_2d(const float *src, const int64_t src_h,
function deformable_im2col_2d (line 43) | void deformable_im2col_2d(const float *input, const float *offset,
function gemm_ref_fp32 (line 96) | void gemm_ref_fp32(const float *A, const float *B, const float *V,
function deformable_conv2d_ref_fp32 (line 158) | void deformable_conv2d_ref_fp32(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/reduce_ops.cpp
function maybe_wrap_dim (line 13) | static inline int64_t maybe_wrap_dim(int64_t dim, int64_t ndims) {
function get_dim_stride (line 21) | static inline int64_t get_dim_stride(const int64_t dim, const int64_t nd...
function get_dim_size (line 26) | static inline int64_t get_dim_size(const int64_t dim, const int64_t ndims,
function cummax_cummin_helper (line 34) | void cummax_cummin_helper(const T1 *input, T1 *output, T2 *indices,
function tensor_dim_apply3 (line 58) | void tensor_dim_apply3(const T1 *input, T1 *output, T2 *indices,
function CumMax_CumMin_CPU (line 105) | void CumMax_CumMin_CPU(const T1 *input, T1 *output, T2 *indices,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/roi_align.cpp
type PreCalc (line 7) | struct PreCalc {
function pre_calc_for_bilinear_interpolate (line 18) | void pre_calc_for_bilinear_interpolate(
function ROIAlignForwardCPU (line 105) | void ROIAlignForwardCPU(const int nthreads, const float *input,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/cpu/roi_align_rotated.cpp
type PreCalc (line 8) | struct PreCalc {
function pre_calc_for_bilinear_interpolate (line 19) | void pre_calc_for_bilinear_interpolate(
function ROIAlignRotatedForwardCPU (line 112) | void ROIAlignRotatedForwardCPU(const int nthreads, const float *input,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/deform_conv.h
type MMCVDeformConvKernel (line 7) | struct MMCVDeformConvKernel {
type MMCVDeformConvOp (line 29) | struct MMCVDeformConvOp
function ONNXTensorElementDataType (line 38) | ONNXTensorElementDataType GetInputType(size_t /*index*/) const {
function OrtCustomOpInputOutputCharacteristic (line 42) | OrtCustomOpInputOutputCharacteristic GetInputCharacteristic(
function ONNXTensorElementDataType (line 48) | ONNXTensorElementDataType GetOutputType(size_t /*index*/) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/grid_sample.h
type GridSampleKernel (line 7) | struct GridSampleKernel {
type GridSampleOp (line 23) | struct GridSampleOp
function ONNXTensorElementDataType (line 31) | ONNXTensorElementDataType GetInputType(size_t /*index*/) const {
function ONNXTensorElementDataType (line 36) | ONNXTensorElementDataType GetOutputType(size_t /*index*/) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/modulated_deform_conv.h
type MMCVModulatedDeformConvKernel (line 7) | struct MMCVModulatedDeformConvKernel {
type MMCVModulatedDeformConvOp (line 28) | struct MMCVModulatedDeformConvOp
function ONNXTensorElementDataType (line 38) | ONNXTensorElementDataType GetInputType(size_t /*index*/) const {
function OrtCustomOpInputOutputCharacteristic (line 42) | OrtCustomOpInputOutputCharacteristic GetInputCharacteristic(
function ONNXTensorElementDataType (line 52) | ONNXTensorElementDataType GetOutputType(size_t /*index*/) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/nms.h
type NmsKernel (line 7) | struct NmsKernel {
type NmsOp (line 22) | struct NmsOp
function ONNXTensorElementDataType (line 30) | ONNXTensorElementDataType GetInputType(size_t /*index*/) const {
function ONNXTensorElementDataType (line 35) | ONNXTensorElementDataType GetOutputType(size_t index) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/ort_mmcv_utils.h
function vector (line 8) | struct OrtTensorDimensions : std::vector<int64_t> {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/reduce_ops.h
type MMCVCumMaxKernel (line 7) | struct MMCVCumMaxKernel {
type MMCVCumMinKernel (line 26) | struct MMCVCumMinKernel {
type MMCVCumMaxCustomOp (line 45) | struct MMCVCumMaxCustomOp
function ONNXTensorElementDataType (line 54) | ONNXTensorElementDataType GetInputType(size_t) const {
function ONNXTensorElementDataType (line 59) | ONNXTensorElementDataType GetOutputType(size_t index) const {
type MMCVCumMinCustomOp (line 70) | struct MMCVCumMinCustomOp
function ONNXTensorElementDataType (line 79) | ONNXTensorElementDataType GetInputType(size_t) const {
function ONNXTensorElementDataType (line 84) | ONNXTensorElementDataType GetOutputType(size_t index) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/roi_align.h
type MMCVRoiAlignKernel (line 13) | struct MMCVRoiAlignKernel {
type MMCVRoiAlignCustomOp (line 40) | struct MMCVRoiAlignCustomOp
function ONNXTensorElementDataType (line 48) | ONNXTensorElementDataType GetInputType(size_t) const {
function ONNXTensorElementDataType (line 53) | ONNXTensorElementDataType GetOutputType(size_t) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/roi_align_rotated.h
type MMCVRoIAlignRotatedKernel (line 13) | struct MMCVRoIAlignRotatedKernel {
type MMCVRoIAlignRotatedCustomOp (line 39) | struct MMCVRoIAlignRotatedCustomOp
function ONNXTensorElementDataType (line 48) | ONNXTensorElementDataType GetInputType(size_t) const {
function ONNXTensorElementDataType (line 53) | ONNXTensorElementDataType GetOutputType(size_t) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/onnxruntime/soft_nms.h
type SoftNmsKernel (line 6) | struct SoftNmsKernel {
type SoftNmsOp (line 24) | struct SoftNmsOp
function ONNXTensorElementDataType (line 32) | ONNXTensorElementDataType GetInputType(size_t /*index*/) const {
function ONNXTensorElementDataType (line 37) | ONNXTensorElementDataType GetOutputType(size_t index) const {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/active_rotated_filter.cpp
function active_rotated_filter_forward_impl (line 8) | void active_rotated_filter_forward_impl(const Tensor input,
function active_rotated_filter_backward_impl (line 14) | void active_rotated_filter_backward_impl(const Tensor grad_out,
function active_rotated_filter_forward (line 20) | void active_rotated_filter_forward(const Tensor input, const Tensor indi...
function active_rotated_filter_backward (line 25) | void active_rotated_filter_backward(const Tensor grad_out, const Tensor ...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/active_rotated_filter_parrots.cpp
function active_rotated_filter_forward_cuda_parrots (line 10) | void active_rotated_filter_forward_cuda_parrots(
function active_rotated_filter_backward_cuda_parrots (line 19) | void active_rotated_filter_backward_cuda_parrots(
function active_rotated_filter_forward_cpu_parrots (line 29) | void active_rotated_filter_forward_cpu_parrots(
function active_rotated_filter_backward_cpu_parrots (line 38) | void active_rotated_filter_backward_cpu_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/assign_score_withk.cpp
function assign_score_withk_forward_impl (line 6) | void assign_score_withk_forward_impl(int B, int N0, int N1, int M, int K...
function assign_score_withk_backward_impl (line 15) | void assign_score_withk_backward_impl(
function assign_score_withk_forward (line 25) | void assign_score_withk_forward(const Tensor& points, const Tensor& cent...
function assign_score_withk_backward (line 33) | void assign_score_withk_backward(const Tensor& grad_out, const Tensor& p...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/assign_score_withk_parrots.cpp
function assign_score_withk_forward_cuda_parrots (line 11) | void assign_score_withk_forward_cuda_parrots(CudaContext& ctx,
function assign_score_withk_backward_cuda_parrots (line 36) | void assign_score_withk_backward_cuda_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/ball_query._parrots.cpp
function ball_query_parrots (line 11) | void ball_query_parrots(CudaContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/ball_query.cpp
function ball_query_forward_impl (line 7) | void ball_query_forward_impl(int b, int n, int m, float min_radius,
function ball_query_forward (line 15) | void ball_query_forward(Tensor new_xyz_tensor, Tensor xyz_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/bbox_overlaps.cpp
function bbox_overlaps_impl (line 5) | void bbox_overlaps_impl(const Tensor bboxes1, const Tensor bboxes2, Tens...
function bbox_overlaps (line 11) | void bbox_overlaps(const Tensor bboxes1, const Tensor bboxes2, Tensor ious,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/bbox_overlaps_parrots.cpp
function bbox_overlaps_parrots (line 15) | void bbox_overlaps_parrots(CudaContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/border_align.cpp
function border_align_forward_impl (line 5) | void border_align_forward_impl(const Tensor &input, const Tensor &boxes,
function border_align_backward_impl (line 12) | void border_align_backward_impl(const Tensor &grad_output, const Tensor ...
function border_align_forward (line 19) | void border_align_forward(const Tensor &input, const Tensor &boxes,
function border_align_backward (line 25) | void border_align_backward(const Tensor &grad_output, const Tensor &boxes,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/border_align_parrots.cpp
function border_align_forward_cuda_parrots (line 10) | void border_align_forward_cuda_parrots(CudaContext& ctx, const SSElement...
function border_align_backward_cuda_parrots (line 24) | void border_align_backward_cuda_parrots(CudaContext& ctx, const SSElemen...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/box_iou_rotated.cpp
function box_iou_rotated_impl (line 7) | void box_iou_rotated_impl(const Tensor boxes1, const Tensor boxes2, Tens...
function box_iou_rotated (line 16) | void box_iou_rotated(const Tensor boxes1, const Tensor boxes2, Tensor ious,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/box_iou_rotated_parrots.cpp
function box_iou_rotated_cpu_parrots (line 14) | void box_iou_rotated_cpu_parrots(HostContext& ctx, const SSElement& attr,
function box_iou_rotated_cuda_parrots (line 35) | void box_iou_rotated_cuda_parrots(CudaContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/carafe.cpp
function carafe_forward_impl (line 5) | void carafe_forward_impl(Tensor features, Tensor masks, Tensor rfeatures,
function carafe_backward_impl (line 12) | void carafe_backward_impl(Tensor top_grad, Tensor rfeatures, Tensor masks,
function carafe_forward (line 23) | void carafe_forward(Tensor features, Tensor masks, Tensor rfeatures,
function carafe_backward (line 30) | void carafe_backward(Tensor top_grad, Tensor rfeatures, Tensor masks,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/carafe_naive.cpp
function carafe_naive_forward_impl (line 5) | void carafe_naive_forward_impl(Tensor features, Tensor masks, Tensor out...
function carafe_naive_backward_impl (line 12) | void carafe_naive_backward_impl(Tensor top_grad, Tensor features, Tensor...
function carafe_naive_forward (line 21) | void carafe_naive_forward(Tensor features, Tensor masks, Tensor output,
function carafe_naive_backward (line 27) | void carafe_naive_backward(Tensor top_grad, Tensor features, Tensor masks,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/carafe_naive_parrots.cpp
function carafe_naive_forward_cuda_parrots (line 15) | void carafe_naive_forward_cuda_parrots(CudaContext& ctx, const SSElement...
function carafe_naive_backward_cuda_parrots (line 37) | void carafe_naive_backward_cuda_parrots(CudaContext& ctx, const SSElemen...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/carafe_parrots.cpp
function carafe_forward_cuda_parrots (line 16) | void carafe_forward_cuda_parrots(CudaContext& ctx, const SSElement& attr,
function carafe_backward_cuda_parrots (line 45) | void carafe_backward_cuda_parrots(CudaContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/contour_expand.cpp
class Point2d (line 10) | class Point2d {
method Point2d (line 15) | Point2d() : x(0), y(0) {}
method Point2d (line 16) | Point2d(int _x, int _y) : x(_x), y(_y) {}
function kernel_dilate (line 19) | void kernel_dilate(const uint8_t *data, IntArrayRef data_shape,
function contour_expand (line 89) | std::vector<std::vector<int>> contour_expand(Tensor kernel_mask,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/contour_expand_parrots.cpp
function contour_expand_parrots (line 12) | void contour_expand_parrots(T& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/convex_iou.cpp
function convex_iou_impl (line 7) | void convex_iou_impl(const Tensor pointsets, const Tensor polygons,
function convex_iou (line 12) | void convex_iou(const Tensor pointsets, const Tensor polygons, Tensor io...
function convex_giou_impl (line 16) | void convex_giou_impl(const Tensor pointsets, const Tensor polygons,
function convex_giou (line 21) | void convex_giou(const Tensor pointsets, const Tensor polygons, Tensor o...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/convex_iou_parrots.cpp
function convex_iou_forward_cuda_parrots (line 10) | void convex_iou_forward_cuda_parrots(CudaContext& ctx, const SSElement& ...
function convex_giou_forward_cuda_parrots (line 19) | void convex_giou_forward_cuda_parrots(CudaContext& ctx, const SSElement&...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/corner_pool.cpp
function Tensor (line 6) | Tensor bottom_pool_forward(Tensor input) {
function Tensor (line 23) | Tensor bottom_pool_backward(Tensor input, Tensor grad_output) {
function Tensor (line 65) | Tensor left_pool_forward(Tensor input) {
function Tensor (line 82) | Tensor left_pool_backward(Tensor input, Tensor grad_output) {
function Tensor (line 124) | Tensor right_pool_forward(Tensor input) {
function Tensor (line 141) | Tensor right_pool_backward(Tensor input, Tensor grad_output) {
function Tensor (line 183) | Tensor top_pool_forward(Tensor input) {
function Tensor (line 200) | Tensor top_pool_backward(Tensor input, Tensor grad_output) {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/corner_pool_parrots.cpp
function bottom_pool_forward_parrots (line 11) | void bottom_pool_forward_parrots(CudaContext& ctx, const SSElement& attr,
function bottom_pool_backward_parrots (line 20) | void bottom_pool_backward_parrots(CudaContext& ctx, const SSElement& attr,
function left_pool_forward_parrots (line 30) | void left_pool_forward_parrots(CudaContext& ctx, const SSElement& attr,
function left_pool_backward_parrots (line 39) | void left_pool_backward_parrots(CudaContext& ctx, const SSElement& attr,
function right_pool_forward_parrots (line 49) | void right_pool_forward_parrots(CudaContext& ctx, const SSElement& attr,
function right_pool_backward_parrots (line 58) | void right_pool_backward_parrots(CudaContext& ctx, const SSElement& attr,
function top_pool_forward_parrots (line 68) | void top_pool_forward_parrots(CudaContext& ctx, const SSElement& attr,
function top_pool_backward_parrots (line 77) | void top_pool_backward_parrots(CudaContext& ctx, const SSElement& attr,
function bottom_pool_forward_parrots_cpu (line 88) | void bottom_pool_forward_parrots_cpu(HostContext& ctx, const SSElement& ...
function bottom_pool_backward_parrots_cpu (line 97) | void bottom_pool_backward_parrots_cpu(HostContext& ctx, const SSElement&...
function left_pool_forward_parrots_cpu (line 107) | void left_pool_forward_parrots_cpu(HostContext& ctx, const SSElement& attr,
function left_pool_backward_parrots_cpu (line 116) | void left_pool_backward_parrots_cpu(HostContext& ctx, const SSElement& a...
function right_pool_forward_parrots_cpu (line 126) | void right_pool_forward_parrots_cpu(HostContext& ctx, const SSElement& a...
function right_pool_backward_parrots_cpu (line 135) | void right_pool_backward_parrots_cpu(HostContext& ctx, const SSElement& ...
function top_pool_forward_parrots_cpu (line 145) | void top_pool_forward_parrots_cpu(HostContext& ctx, const SSElement& attr,
function top_pool_backward_parrots_cpu (line 154) | void top_pool_backward_parrots_cpu(HostContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/correlation.cpp
function correlation_forward_impl (line 7) | void correlation_forward_impl(Tensor input1, Tensor input2, Tensor output,
function correlation_backward_impl (line 17) | void correlation_backward_impl(Tensor grad_output, Tensor input1, Tensor...
function correlation_forward (line 29) | void correlation_forward(Tensor input1, Tensor input2, Tensor output, in...
function correlation_backward (line 38) | void correlation_backward(Tensor grad_output, Tensor input1, Tensor input2,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/correlation_parrots.cpp
function correlation_forward_cuda_parrots (line 11) | void correlation_forward_cuda_parrots(CudaContext& ctx, const SSElement&...
function correlation_backward_cuda_parrots (line 41) | void correlation_backward_cuda_parrots(CudaContext& ctx, const SSElement...
function correlation_forward_cpu_parrots (line 74) | void correlation_forward_cpu_parrots(HostContext& ctx, const SSElement& ...
function correlation_backward_cpu_parrots (line 104) | void correlation_backward_cpu_parrots(HostContext& ctx, const SSElement&...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/cudabind.cpp
function assign_score_withk_forward_cuda (line 15) | void assign_score_withk_forward_cuda(int B, int N0, int N1, int M, int K...
function assign_score_withk_backward_cuda (line 24) | void assign_score_withk_backward_cuda(
function ball_query_forward_cuda (line 56) | void ball_query_forward_cuda(int b, int n, int m, float min_radius,
function bbox_overlaps_cuda (line 74) | void bbox_overlaps_cuda(const Tensor bboxes1, const Tensor bboxes2, Tens...
function border_align_forward_cuda (line 94) | void border_align_forward_cuda(const Tensor& input, const Tensor& boxes,
function border_align_backward_cuda (line 101) | void border_align_backward_cuda(const Tensor& grad_output, const Tensor&...
function carafe_forward_cuda (line 141) | void carafe_forward_cuda(Tensor features, Tensor masks, Tensor rfeatures,
function carafe_backward_cuda (line 149) | void carafe_backward_cuda(Tensor top_grad, Tensor rfeatures, Tensor masks,
function carafe_naive_forward_cuda (line 184) | void carafe_naive_forward_cuda(Tensor features, Tensor masks, Tensor out...
function carafe_naive_backward_cuda (line 191) | void carafe_naive_backward_cuda(Tensor top_grad, Tensor features, Tensor...
function correlation_forward_cuda (line 228) | void correlation_forward_cuda(Tensor input1, Tensor input2, Tensor output,
function correlation_backward_cuda (line 238) | void correlation_backward_cuda(Tensor grad_output, Tensor input1, Tensor...
function deform_roi_pool_forward_cuda (line 333) | void deform_roi_pool_forward_cuda(Tensor input, Tensor rois, Tensor offset,
function deform_roi_pool_backward_cuda (line 342) | void deform_roi_pool_backward_cuda(Tensor grad_output, Tensor input,
function sigmoid_focal_loss_forward_cuda (line 392) | void sigmoid_focal_loss_forward_cuda(Tensor input, Tensor target, Tensor...
function sigmoid_focal_loss_backward_cuda (line 398) | void sigmoid_focal_loss_backward_cuda(Tensor input, Tensor target,
function softmax_focal_loss_forward_cuda (line 405) | void softmax_focal_loss_forward_cuda(Tensor input, Tensor target, Tensor...
function softmax_focal_loss_backward_cuda (line 411) | void softmax_focal_loss_backward_cuda(Tensor input, Tensor target,
function furthest_point_sampling_forward_cuda (line 450) | void furthest_point_sampling_forward_cuda(Tensor points_tensor,
function furthest_point_sampling_with_dist_forward_cuda (line 459) | void furthest_point_sampling_with_dist_forward_cuda(Tensor points_tensor,
function gather_points_forward_cuda (line 505) | void gather_points_forward_cuda(int b, int c, int n, int npoints,
function gather_points_backward_cuda (line 511) | void gather_points_backward_cuda(int b, int c, int n, int npoints,
function group_points_forward_cuda (line 540) | void group_points_forward_cuda(int b, int c, int n, int npoints, int nsa...
function group_points_backward_cuda (line 547) | void group_points_backward_cuda(int b, int c, int n, int npoints, int ns...
function iou3d_boxes_overlap_bev_forward_cuda (line 588) | void iou3d_boxes_overlap_bev_forward_cuda(const int num_a, const Tensor ...
function iou3d_boxes_iou_bev_forward_cuda (line 595) | void iou3d_boxes_iou_bev_forward_cuda(const int num_a, const Tensor boxe...
function iou3d_nms_forward_cuda (line 602) | void iou3d_nms_forward_cuda(const Tensor boxes, unsigned long long* mask,
function iou3d_nms_normal_forward_cuda (line 607) | void iou3d_nms_normal_forward_cuda(const Tensor boxes, unsigned long lon...
function knn_forward_cuda (line 639) | void knn_forward_cuda(int b, int n, int m, int nsample, const Tensor xyz,
function masked_im2col_forward_cuda (line 661) | void masked_im2col_forward_cuda(const Tensor im, const Tensor mask_h_idx,
function masked_col2im_forward_cuda (line 671) | void masked_col2im_forward_cuda(const Tensor col, const Tensor mask_h_idx,
function Tensor (line 785) | Tensor nms_cuda(Tensor boxes, Tensor scores, float iou_threshold, int of...
function points_in_boxes_part_forward_cuda (line 802) | void points_in_boxes_part_forward_cuda(int batch_size, int boxes_num,
function points_in_boxes_all_forward_cuda (line 810) | void points_in_boxes_all_forward_cuda(int batch_size, int boxes_num,
function psamask_forward_cuda (line 844) | void psamask_forward_cuda(const int psa_type, const Tensor input, Tensor...
function psamask_backward_cuda (line 854) | void psamask_backward_cuda(const int psa_type, const Tensor grad_output,
function roi_align_forward_cuda (line 891) | void roi_align_forward_cuda(Tensor input, Tensor rois, Tensor output,
function roi_align_backward_cuda (line 901) | void roi_align_backward_cuda(Tensor grad_output, Tensor rois, Tensor arg...
function roi_align_rotated_forward_cuda (line 938) | void roi_align_rotated_forward_cuda(Tensor features, Tensor rois, Tensor...
function roi_align_rotated_backward_cuda (line 959) | void roi_align_rotated_backward_cuda(Tensor top_grad, Tensor rois,
function riroi_align_rotated_forward_cuda (line 1009) | void riroi_align_rotated_forward_cuda(Tensor features, Tensor rois,
function riroi_align_rotated_backward_cuda (line 1031) | void riroi_align_rotated_backward_cuda(Tensor top_grad, Tensor rois,
function roiaware_pool3d_forward_cuda (line 1081) | void roiaware_pool3d_forward_cuda(int boxes_num, int pts_num, int channels,
function roiaware_pool3d_backward_cuda (line 1093) | void roiaware_pool3d_backward_cuda(int boxes_num, int out_x, int out_y,
function roipoint_pool3d_forward_cuda (line 1128) | void roipoint_pool3d_forward_cuda(int batch_size, int pts_num, int boxes...
function roi_pool_forward_cuda (line 1157) | void roi_pool_forward_cuda(Tensor input, Tensor rois, Tensor output,
function roi_pool_backward_cuda (line 1164) | void roi_pool_backward_cuda(Tensor grad_output, Tensor rois, Tensor argmax,
function dynamic_point_to_voxel_forward_cuda (line 1192) | std::vector<torch::Tensor> dynamic_point_to_voxel_forward_cuda(
function dynamic_point_to_voxel_backward_cuda (line 1199) | void dynamic_point_to_voxel_backward_cuda(
function sync_bn_forward_mean_cuda (line 1247) | void sync_bn_forward_mean_cuda(const Tensor input, Tensor mean) {
function sync_bn_forward_var_cuda (line 1251) | void sync_bn_forward_var_cuda(const Tensor input, const Tensor mean,
function sync_bn_forward_output_cuda (line 1256) | void sync_bn_forward_output_cuda(const Tensor input, const Tensor mean,
function sync_bn_backward_param_cuda (line 1267) | void sync_bn_backward_param_cuda(const Tensor grad_output, const Tensor ...
function sync_bn_backward_data_cuda (line 1273) | void sync_bn_backward_data_cuda(const Tensor grad_output, const Tensor w...
function three_interpolate_forward_cuda (line 1322) | void three_interpolate_forward_cuda(int b, int c, int m, int n,
function three_interpolate_backward_cuda (line 1329) | void three_interpolate_backward_cuda(int b, int c, int n, int m,
function three_nn_forward_cuda (line 1352) | void three_nn_forward_cuda(int b, int n, int m, const Tensor unknown,
function tin_shift_forward_cuda (line 1367) | void tin_shift_forward_cuda(Tensor input, Tensor shift, Tensor output) {
function tin_shift_backward_cuda (line 1371) | void tin_shift_backward_cuda(Tensor grad_output, Tensor shift,
function hard_voxelize_forward_cuda (line 1404) | int hard_voxelize_forward_cuda(const at::Tensor& points, at::Tensor& vox...
function dynamic_voxelize_forward_cuda (line 1416) | void dynamic_voxelize_forward_cuda(const at::Tensor& points, at::Tensor&...
function rotated_feature_align_forward_cuda (line 1454) | void rotated_feature_align_forward_cuda(const Tensor features,
function rotated_feature_align_backward_cuda (line 1462) | void rotated_feature_align_backward_cuda(const Tensor top_grad,
function points_in_polygons_forward_cuda (line 1490) | void points_in_polygons_forward_cuda(const Tensor points, const Tensor p...
function min_area_polygons_cuda (line 1506) | void min_area_polygons_cuda(const Tensor pointsets, Tensor polygons) {
function active_rotated_filter_forward_cuda (line 1522) | void active_rotated_filter_forward_cuda(const Tensor input,
function active_rotated_filter_backward_cuda (line 1527) | void active_rotated_filter_backward_cuda(const Tensor grad_out,
function convex_iou_cuda (line 1549) | void convex_iou_cuda(const Tensor pointsets, const Tensor polygons,
function convex_giou_cuda (line 1554) | void convex_giou_cuda(const Tensor pointsets, const Tensor polygons,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/deform_conv.cpp
function deformable_im2col_impl (line 5) | void deformable_im2col_impl(Tensor data_im, Tensor data_offset,
function deformable_col2im_impl (line 19) | void deformable_col2im_impl(Tensor data_col, Tensor data_offset,
function deformable_col2im_coord_impl (line 33) | void deformable_col2im_coord_impl(
function deform_conv_shape_check (line 45) | void deform_conv_shape_check(at::Tensor input, at::Tensor offset,
function deform_conv_forward (line 140) | void deform_conv_forward(Tensor input, Tensor weight, Tensor offset,
function deform_conv_backward_input (line 260) | void deform_conv_backward_input(Tensor input, Tensor offset, Tensor grad...
function deform_conv_backward_parameters (line 392) | void deform_conv_backward_parameters(Tensor input, Tensor offset,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/deform_conv_parrots.cpp
function deform_conv_forward_cuda_parrots (line 11) | void deform_conv_forward_cuda_parrots(CudaContext& ctx, const SSElement&...
function deform_conv_backward_input_cuda_parrots (line 43) | void deform_conv_backward_input_cuda_parrots(CudaContext& ctx,
function deform_conv_backward_parameters_cuda_parrots (line 78) | void deform_conv_backward_parameters_cuda_parrots(
function deform_conv_forward_cpu_parrots (line 113) | void deform_conv_forward_cpu_parrots(HostContext& ctx, const SSElement& ...
function deform_conv_backward_input_cpu_parrots (line 145) | void deform_conv_backward_input_cpu_parrots(HostContext& ctx,
function deform_conv_backward_parameters_cpu_parrots (line 180) | void deform_conv_backward_parameters_cpu_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/deform_roi_pool.cpp
function deform_roi_pool_forward_impl (line 5) | void deform_roi_pool_forward_impl(Tensor input, Tensor rois, Tensor offset,
function deform_roi_pool_backward_impl (line 14) | void deform_roi_pool_backward_impl(Tensor grad_output, Tensor input,
function deform_roi_pool_forward (line 25) | void deform_roi_pool_forward(Tensor input, Tensor rois, Tensor offset,
function deform_roi_pool_backward (line 34) | void deform_roi_pool_backward(Tensor grad_output, Tensor input, Tensor r...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/deform_roi_pool_parrots.cpp
function deform_roi_pool_forward_cuda_parrots (line 16) | void deform_roi_pool_forward_cuda_parrots(CudaContext& ctx,
function deform_roi_pool_backward_cuda_parrots (line 50) | void deform_roi_pool_backward_cuda_parrots(CudaContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/focal_loss.cpp
function sigmoid_focal_loss_forward_impl (line 5) | void sigmoid_focal_loss_forward_impl(Tensor input, Tensor target, Tensor...
function sigmoid_focal_loss_backward_impl (line 11) | void sigmoid_focal_loss_backward_impl(Tensor input, Tensor target,
function softmax_focal_loss_forward_impl (line 18) | void softmax_focal_loss_forward_impl(Tensor input, Tensor target, Tensor...
function softmax_focal_loss_backward_impl (line 24) | void softmax_focal_loss_backward_impl(Tensor input, Tensor target,
function sigmoid_focal_loss_forward (line 32) | void sigmoid_focal_loss_forward(Tensor input, Tensor target, Tensor weight,
function sigmoid_focal_loss_backward (line 37) | void sigmoid_focal_loss_backward(Tensor input, Tensor target, Tensor wei...
function softmax_focal_loss_forward (line 43) | void softmax_focal_loss_forward(Tensor input, Tensor target, Tensor weight,
function softmax_focal_loss_backward (line 48) | void softmax_focal_loss_backward(Tensor input, Tensor target, Tensor wei...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/focal_loss_parrots.cpp
function sigmoid_focal_loss_forward_cuda_parrots (line 11) | void sigmoid_focal_loss_forward_cuda_parrots(CudaContext& ctx,
function sigmoid_focal_loss_backward_cuda_parrots (line 29) | void sigmoid_focal_loss_backward_cuda_parrots(
function softmax_focal_loss_forward_cuda_parrots (line 47) | void softmax_focal_loss_forward_cuda_parrots(CudaContext& ctx,
function softmax_focal_loss_backward_cuda_parrots (line 64) | void softmax_focal_loss_backward_cuda_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/furthest_point_sample.cpp
function furthest_point_sampling_forward_impl (line 7) | void furthest_point_sampling_forward_impl(Tensor points_tensor,
function furthest_point_sampling_with_dist_forward_impl (line 14) | void furthest_point_sampling_with_dist_forward_impl(Tensor points_tensor,
function furthest_point_sampling_forward (line 22) | void furthest_point_sampling_forward(Tensor points_tensor, Tensor temp_t...
function furthest_point_sampling_with_dist_forward (line 28) | void furthest_point_sampling_with_dist_forward(Tensor points_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/furthest_point_sample_parrots.cpp
function furthest_point_sample_forward_cuda_parrots (line 11) | void furthest_point_sample_forward_cuda_parrots(
function furthest_point_sampling_with_dist_forward_cuda_parrots (line 26) | void furthest_point_sampling_with_dist_forward_cuda_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/fused_bias_leakyrelu.cpp
function fused_bias_leakyrelu_op_impl (line 105) | torch::Tensor fused_bias_leakyrelu_op_impl(const torch::Tensor& input,
function fused_bias_leakyrelu (line 113) | torch::Tensor fused_bias_leakyrelu(const torch::Tensor& input,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/fused_bias_parrots.cpp
function fused_bias_leakyrelu_parrots (line 15) | void fused_bias_leakyrelu_parrots(CudaContext &ctx, const SSElement &attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/gather_points.cpp
function gather_points_forward_impl (line 4) | void gather_points_forward_impl(int b, int c, int n, int npoints,
function gather_points_backward_impl (line 11) | void gather_points_backward_impl(int b, int c, int n, int npoints,
function gather_points_forward (line 18) | void gather_points_forward(Tensor points_tensor, Tensor idx_tensor,
function gather_points_backward (line 25) | void gather_points_backward(Tensor grad_out_tensor, Tensor idx_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/gather_points_parrots.cpp
function gather_points_forward_cuda_parrots (line 11) | void gather_points_forward_cuda_parrots(CudaContext& ctx, const SSElemen...
function gather_points_backward_cuda_parrots (line 31) | void gather_points_backward_cuda_parrots(CudaContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/group_points.cpp
function group_points_forward_impl (line 8) | void group_points_forward_impl(int b, int c, int n, int npoints, int nsa...
function group_points_backward_impl (line 15) | void group_points_backward_impl(int b, int c, int n, int npoints, int ns...
function group_points_forward (line 22) | void group_points_forward(Tensor points_tensor, Tensor idx_tensor,
function group_points_backward (line 29) | void group_points_backward(Tensor grad_out_tensor, Tensor idx_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/group_points_parrots.cpp
function group_points_forward_cuda_parrots (line 11) | void group_points_forward_cuda_parrots(CudaContext& ctx, const SSElement...
function group_points_backward_cuda_parrots (line 31) | void group_points_backward_cuda_parrots(CudaContext& ctx, const SSElemen...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/info.cpp
function get_cudart_version (line 9) | int get_cudart_version() { return CUDART_VERSION; }
function get_compiling_cuda_version (line 13) | std::string get_compiling_cuda_version() {
function get_compiler_version (line 37) | std::string get_compiler_version() {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/iou3d.cpp
function iou3d_boxes_overlap_bev_forward_impl (line 15) | void iou3d_boxes_overlap_bev_forward_impl(const int num_a, const Tensor ...
function iou3d_boxes_iou_bev_forward_impl (line 22) | void iou3d_boxes_iou_bev_forward_impl(const int num_a, const Tensor boxe...
function iou3d_nms_forward_impl (line 29) | void iou3d_nms_forward_impl(const Tensor boxes, unsigned long long *mask,
function iou3d_nms_normal_forward_impl (line 35) | void iou3d_nms_normal_forward_impl(const Tensor boxes, unsigned long lon...
function iou3d_boxes_overlap_bev_forward (line 41) | void iou3d_boxes_overlap_bev_forward(Tensor boxes_a, Tensor boxes_b,
function iou3d_boxes_iou_bev_forward (line 54) | void iou3d_boxes_iou_bev_forward(Tensor boxes_a, Tensor boxes_b,
function iou3d_nms_forward (line 65) | void iou3d_nms_forward(Tensor boxes, Tensor keep, Tensor keep_num,
function iou3d_nms_normal_forward (line 109) | void iou3d_nms_normal_forward(Tensor boxes, Tensor keep, Tensor keep_num,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/iou3d_parrots.cpp
function iou3d_boxes_iou_bev_forward_cuda_parrots (line 11) | void iou3d_boxes_iou_bev_forward_cuda_parrots(
function iou3d_nms_forward_cuda_parrots (line 22) | void iou3d_nms_forward_cuda_parrots(CudaContext& ctx, const SSElement& a...
function iou3d_nms_normal_forward_cuda_parrots (line 36) | void iou3d_nms_normal_forward_cuda_parrots(CudaContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/knn.cpp
function knn_forward_impl (line 7) | void knn_forward_impl(int b, int n, int m, int nsample, const Tensor xyz,
function knn_forward (line 13) | void knn_forward(Tensor xyz_tensor, Tensor new_xyz_tensor, Tensor idx_te...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/knn_parrots.cpp
function knn_forward_cuda_parrots (line 11) | void knn_forward_cuda_parrots(CudaContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/masked_conv2d.cpp
function masked_im2col_forward_impl (line 5) | void masked_im2col_forward_impl(const Tensor im, const Tensor mask_h_idx,
function masked_col2im_forward_impl (line 13) | void masked_col2im_forward_impl(const Tensor col, const Tensor mask_h_idx,
function masked_im2col_forward (line 20) | void masked_im2col_forward(const Tensor im, const Tensor mask_h_idx,
function masked_col2im_forward (line 28) | void masked_col2im_forward(const Tensor col, const Tensor mask_h_idx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/masked_conv2d_parrots.cpp
function masked_im2col_forward_cuda_parrots (line 11) | void masked_im2col_forward_cuda_parrots(CudaContext& ctx, const SSElemen...
function masked_col2im_forward_cuda_parrots (line 33) | void masked_col2im_forward_cuda_parrots(CudaContext& ctx, const SSElemen...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/min_area_polygons.cpp
function min_area_polygons_impl (line 5) | void min_area_polygons_impl(const Tensor pointsets, Tensor polygons) {
function min_area_polygons (line 9) | void min_area_polygons(const Tensor pointsets, Tensor polygons) {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/min_area_polygons_parrots.cpp
function min_area_polygons_cuda_parrots (line 11) | void min_area_polygons_cuda_parrots(CudaContext& ctx, const SSElement& a...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/modulated_deform_conv.cpp
function modulated_deformable_im2col_impl (line 5) | void modulated_deformable_im2col_impl(
function modulated_deformable_col2im_impl (line 19) | void modulated_deformable_col2im_impl(
function modulated_deformable_col2im_coord_impl (line 33) | void modulated_deformable_col2im_coord_impl(
function modulated_deform_conv_forward (line 48) | void modulated_deform_conv_forward(
function modulated_deform_conv_backward (line 126) | void modulated_deform_conv_backward(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/modulated_deform_conv_parrots.cpp
function modulated_deform_conv_forward_cuda_parrots (line 11) | void modulated_deform_conv_forward_cuda_parrots(
function modulated_deform_conv_backward_cuda_parrots (line 46) | void modulated_deform_conv_backward_cuda_parrots(
function modulated_deform_conv_forward_cpu_parrots (line 87) | void modulated_deform_conv_forward_cpu_parrots(
function modulated_deform_conv_backward_cpu_parrots (line 122) | void modulated_deform_conv_backward_cpu_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/ms_deform_attn.cpp
function Tensor (line 15) | Tensor ms_deform_attn_impl_forward(const Tensor &value,
function ms_deform_attn_impl_backward (line 26) | void ms_deform_attn_impl_backward(
function Tensor (line 38) | Tensor ms_deform_attn_forward(const Tensor &value, const Tensor &spatial...
function ms_deform_attn_backward (line 48) | void ms_deform_attn_backward(const Tensor &value, const Tensor &spatial_...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/ms_deform_attn_parrots.cpp
function ms_deform_attn_forward_parrots (line 23) | void ms_deform_attn_forward_parrots(CudaContext &ctx, const SSElement &a...
function ms_deform_attn_backward_parrots (line 38) | void ms_deform_attn_backward_parrots(CudaContext &ctx, const SSElement &...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/nms.cpp
function Tensor (line 5) | Tensor nms_impl(Tensor boxes, Tensor scores, float iou_threshold, int of...
function Tensor (line 9) | Tensor softnms_impl(Tensor boxes, Tensor scores, Tensor dets,
function nms_match_impl (line 16) | std::vector<std::vector<int> > nms_match_impl(Tensor dets,
function Tensor (line 21) | Tensor nms(Tensor boxes, Tensor scores, float iou_threshold, int offset) {
function Tensor (line 25) | Tensor softnms(Tensor boxes, Tensor scores, Tensor dets, float iou_thres...
function nms_match (line 31) | std::vector<std::vector<int> > nms_match(Tensor dets, float iou_threshol...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/nms_parrots.cpp
function nms_parrots (line 12) | void nms_parrots(T& ctx, const SSElement& attr,
function softnms_parrots (line 31) | void softnms_parrots(T& ctx, const SSElement& attr,
function nms_match_parrots (line 54) | void nms_match_parrots(T& ctx, const SSElement& attr,
function nms_rotated_parrots (line 77) | void nms_rotated_parrots(T& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/nms_rotated.cpp
function Tensor (line 18) | Tensor nms_rotated(const Tensor dets, const Tensor scores, const Tensor ...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/pixel_group.cpp
function pixel_group_impl (line 7) | std::vector<std::vector<float>> pixel_group_impl(
function pixel_group (line 15) | std::vector<std::vector<float>> pixel_group(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/pixel_group_parrots.cpp
function pixel_group_parrots (line 12) | void pixel_group_parrots(T& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/points_in_boxes.cpp
function points_in_boxes_part_forward_impl (line 4) | void points_in_boxes_part_forward_impl(int batch_size, int boxes_num,
function points_in_boxes_all_forward_impl (line 12) | void points_in_boxes_all_forward_impl(int batch_size, int boxes_num,
function points_in_boxes_part_forward (line 20) | void points_in_boxes_part_forward(Tensor boxes_tensor, Tensor pts_tensor,
function points_in_boxes_all_forward (line 34) | void points_in_boxes_all_forward(Tensor boxes_tensor, Tensor pts_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/points_in_boxes_parrots.cpp
function points_in_boxes_part_forward_cuda_parrots (line 11) | void points_in_boxes_part_forward_cuda_parrots(
function points_in_boxes_all_forward_cuda_parrots (line 23) | void points_in_boxes_all_forward_cuda_parrots(
function points_in_boxes_forward_cpu_parrots (line 48) | void points_in_boxes_forward_cpu_parrots(HostContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/points_in_polygons.cpp
function points_in_polygons_forward_impl (line 4) | void points_in_polygons_forward_impl(const Tensor points, const Tensor p...
function points_in_polygons_forward (line 11) | void points_in_polygons_forward(Tensor points, Tensor polygons, Tensor o...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/points_in_polygons_parrots.cpp
function points_in_polygons_cuda_parrots (line 11) | void points_in_polygons_cuda_parrots(CudaContext& ctx, const SSElement& ...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/psamask.cpp
function psamask_forward_impl (line 7) | void psamask_forward_impl(const int psa_type, const Tensor input, Tensor...
function psamask_backward_impl (line 17) | void psamask_backward_impl(const int psa_type, const Tensor grad_output,
function psamask_forward (line 27) | void psamask_forward(const Tensor input, Tensor output, const int psa_type,
function psamask_backward (line 35) | void psamask_backward(Tensor grad_output, const Tensor grad_input,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/psamask_parrots.cpp
function psamask_forward_cuda_parrots (line 10) | void psamask_forward_cuda_parrots(CudaContext &ctx, const SSElement &attr,
function psamask_backward_cuda_parrots (line 31) | void psamask_backward_cuda_parrots(CudaContext &ctx, const SSElement &attr,
function psamask_forward_cpu_parrots (line 54) | void psamask_forward_cpu_parrots(HostContext &ctx, const SSElement &attr,
function psamask_backward_cpu_parrots (line 75) | void psamask_backward_cpu_parrots(HostContext &ctx, const SSElement &attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/riroi_align_rotated.cpp
function riroi_align_rotated_forward_impl (line 5) | void riroi_align_rotated_forward_impl(Tensor features, Tensor rois,
function riroi_align_rotated_backward_impl (line 15) | void riroi_align_rotated_backward_impl(Tensor top_grad, Tensor rois,
function riroi_align_rotated_forward (line 25) | void riroi_align_rotated_forward(Tensor features, Tensor rois, Tensor ou...
function riroi_align_rotated_backward (line 34) | void riroi_align_rotated_backward(Tensor top_grad, Tensor rois,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/riroi_align_rotated_parrots.cpp
function riroi_align_rotated_forward_cuda_parrots (line 10) | void riroi_align_rotated_forward_cuda_parrots(
function riroi_align_rotated_backward_cuda_parrots (line 36) | void riroi_align_rotated_backward_cuda_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roi_align.cpp
function roi_align_forward_impl (line 5) | void roi_align_forward_impl(Tensor input, Tensor rois, Tensor output,
function roi_align_backward_impl (line 15) | void roi_align_backward_impl(Tensor grad_output, Tensor rois, Tensor arg...
function roi_align_forward (line 25) | void roi_align_forward(Tensor input, Tensor rois, Tensor output,
function roi_align_backward (line 34) | void roi_align_backward(Tensor grad_output, Tensor rois, Tensor argmax_y,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roi_align_parrots.cpp
function roi_align_forward_cuda_parrots (line 10) | void roi_align_forward_cuda_parrots(CudaContext& ctx, const SSElement& a...
function roi_align_backward_cuda_parrots (line 38) | void roi_align_backward_cuda_parrots(CudaContext& ctx, const SSElement& ...
function roi_align_forward_cpu_parrots (line 67) | void roi_align_forward_cpu_parrots(HostContext& ctx, const SSElement& attr,
function roi_align_backward_cpu_parrots (line 95) | void roi_align_backward_cpu_parrots(HostContext& ctx, const SSElement& a...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roi_align_rotated.cpp
function roi_align_rotated_forward_impl (line 5) | void roi_align_rotated_forward_impl(Tensor features, Tensor rois, Tensor...
function roi_align_rotated_backward_impl (line 14) | void roi_align_rotated_backward_impl(Tensor top_grad, Tensor rois,
function roi_align_rotated_forward (line 24) | void roi_align_rotated_forward(Tensor input, Tensor rois, Tensor output,
function roi_align_rotated_backward (line 33) | void roi_align_rotated_backward(Tensor top_grad, Tensor rois,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roi_align_rotated_parrots.cpp
function roi_align_rotated_forward_cuda_parrots (line 10) | void roi_align_rotated_forward_cuda_parrots(CudaContext& ctx,
function roi_align_rotated_backward_cuda_parrots (line 37) | void roi_align_rotated_backward_cuda_parrots(CudaContext& ctx,
function roi_align_rotated_forward_cpu_parrots (line 65) | void roi_align_rotated_forward_cpu_parrots(HostContext& ctx,
function roi_align_rotated_backward_cpu_parrots (line 92) | void roi_align_rotated_backward_cpu_parrots(HostContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roi_pool.cpp
function roi_pool_forward_impl (line 5) | void roi_pool_forward_impl(Tensor input, Tensor rois, Tensor output,
function roi_pool_backward_impl (line 12) | void roi_pool_backward_impl(Tensor grad_output, Tensor rois, Tensor argmax,
function roi_pool_forward (line 19) | void roi_pool_forward(Tensor input, Tensor rois, Tensor output, Tensor a...
function roi_pool_backward (line 26) | void roi_pool_backward(Tensor grad_output, Tensor rois, Tensor argmax,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roi_pool_parrots.cpp
function roi_pool_forward_cuda_parrots (line 10) | void roi_pool_forward_cuda_parrots(CudaContext& ctx, const SSElement& attr,
function roi_pool_backward_cuda_parrots (line 30) | void roi_pool_backward_cuda_parrots(CudaContext& ctx, const SSElement& a...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roiaware_pool3d.cpp
function roiaware_pool3d_forward_impl (line 4) | void roiaware_pool3d_forward_impl(int boxes_num, int pts_num, int channels,
function roiaware_pool3d_backward_impl (line 16) | void roiaware_pool3d_backward_impl(int boxes_num, int out_x, int out_y,
function roiaware_pool3d_forward (line 27) | void roiaware_pool3d_forward(Tensor rois, Tensor pts, Tensor pts_feature,
function roiaware_pool3d_backward (line 54) | void roiaware_pool3d_backward(Tensor pts_idx_of_voxels, Tensor argmax,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roiaware_pool3d_parrots.cpp
function roiaware_pool3d_forward_cuda_parrots (line 11) | void roiaware_pool3d_forward_cuda_parrots(CudaContext& ctx,
function roiaware_pool3d_backward_cuda_parrots (line 29) | void roiaware_pool3d_backward_cuda_parrots(CudaContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roipoint_pool3d.cpp
function roipoint_pool3d_forward_impl (line 12) | void roipoint_pool3d_forward_impl(int batch_size, int pts_num, int boxes...
function roipoint_pool3d_forward (line 23) | void roipoint_pool3d_forward(Tensor xyz, Tensor boxes3d, Tensor pts_feat...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/roipoint_pool3d_parrots.cpp
function roipoint_pool3d_forward_cuda_parrots (line 11) | void roipoint_pool3d_forward_cuda_parrots(CudaContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/rotated_feature_align.cpp
function rotated_feature_align_forward_impl (line 8) | void rotated_feature_align_forward_impl(const Tensor features,
function rotated_feature_align_backward_impl (line 16) | void rotated_feature_align_backward_impl(const Tensor top_grad,
function rotated_feature_align_forward (line 24) | void rotated_feature_align_forward(const Tensor features,
function rotated_feature_align_backward (line 32) | void rotated_feature_align_backward(const Tensor top_grad,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/rotated_feature_align_parrots.cpp
function rotated_feature_align_forward_cuda_parrots (line 10) | void rotated_feature_align_forward_cuda_parrots(
function rotated_feature_align_backward_cuda_parrots (line 27) | void rotated_feature_align_backward_cuda_parrots(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/sync_bn.cpp
function sync_bn_forward_mean_impl (line 5) | void sync_bn_forward_mean_impl(const Tensor input, Tensor mean) {
function sync_bn_forward_var_impl (line 9) | void sync_bn_forward_var_impl(const Tensor input, const Tensor mean,
function sync_bn_forward_output_impl (line 14) | void sync_bn_forward_output_impl(const Tensor input, const Tensor mean,
function sync_bn_backward_param_impl (line 25) | void sync_bn_backward_param_impl(const Tensor grad_output, const Tensor ...
function sync_bn_backward_data_impl (line 31) | void sync_bn_backward_data_impl(const Tensor grad_output, const Tensor w...
function sync_bn_forward_mean (line 39) | void sync_bn_forward_mean(const Tensor input, Tensor mean) {
function sync_bn_forward_var (line 43) | void sync_bn_forward_var(const Tensor input, const Tensor mean, Tensor v...
function sync_bn_forward_output (line 47) | void sync_bn_forward_output(const Tensor input, const Tensor mean,
function sync_bn_backward_param (line 58) | void sync_bn_backward_param(const Tensor grad_output, const Tensor norm,
function sync_bn_backward_data (line 63) | void sync_bn_backward_data(const Tensor grad_output, const Tensor weight,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/sync_bn_parrots.cpp
function sync_bn_forward_mean_cuda_parrots (line 10) | void sync_bn_forward_mean_cuda_parrots(CudaContext& ctx, const SSElement...
function sync_bn_forward_var_cuda_parrots (line 18) | void sync_bn_forward_var_cuda_parrots(CudaContext& ctx, const SSElement&...
function sync_bn_forward_output_cuda_parrots (line 27) | void sync_bn_forward_output_cuda_parrots(CudaContext& ctx,
function sync_bn_backward_param_cuda_parrots (line 54) | void sync_bn_backward_param_cuda_parrots(CudaContext& ctx,
function sync_bn_backward_data_cuda_parrots (line 65) | void sync_bn_backward_data_cuda_parrots(CudaContext& ctx, const SSElemen...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/three_interpolate.cpp
function three_interpolate_forward_impl (line 7) | void three_interpolate_forward_impl(int b, int c, int m, int n,
function three_interpolate_backward_impl (line 14) | void three_interpolate_backward_impl(int b, int c, int n, int m,
function three_interpolate_forward (line 21) | void three_interpolate_forward(Tensor points_tensor, Tensor idx_tensor,
function three_interpolate_backward (line 28) | void three_interpolate_backward(Tensor grad_out_tensor, Tensor idx_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/three_interpolate_parrots.cpp
function three_interpolate_forward_cuda_parrots (line 11) | void three_interpolate_forward_cuda_parrots(CudaContext& ctx,
function three_interpolate_backward_cuda_parrots (line 33) | void three_interpolate_backward_cuda_parrots(CudaContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/three_nn.cpp
function three_nn_forward_impl (line 7) | void three_nn_forward_impl(int b, int n, int m, const Tensor unknown,
function three_nn_forward (line 13) | void three_nn_forward(Tensor unknown_tensor, Tensor known_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/three_nn_parrots.cpp
function three_nn_forward_cuda_parrots (line 11) | void three_nn_forward_cuda_parrots(CudaContext& ctx, const SSElement& attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/tin_shift.cpp
function tin_shift_forward_impl (line 5) | void tin_shift_forward_impl(Tensor input, Tensor shift, Tensor output) {
function tin_shift_backward_impl (line 9) | void tin_shift_backward_impl(Tensor grad_output, Tensor shift,
function tin_shift_forward (line 14) | void tin_shift_forward(Tensor input, Tensor shift, Tensor output) {
function tin_shift_backward (line 18) | void tin_shift_backward(Tensor grad_output, Tensor shift, Tensor grad_in...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/tin_shift_parrots.cpp
function tin_shift_forward_cuda_parrots (line 10) | void tin_shift_forward_cuda_parrots(CudaContext &ctx, const SSElement &a...
function tin_shift_backward_cuda_parrots (line 19) | void tin_shift_backward_cuda_parrots(CudaContext &ctx, const SSElement &...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/upfirdn2d.cpp
function upfirdn2d_op_impl (line 105) | torch::Tensor upfirdn2d_op_impl(const torch::Tensor& input,
function upfirdn2d (line 113) | torch::Tensor upfirdn2d(const torch::Tensor& input, const torch::Tensor&...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/upfirdn2d_parrots.cpp
function upfirdn2d_parrots (line 14) | void upfirdn2d_parrots(CudaContext &ctx, const SSElement &attr,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/voxelization.cpp
function hard_voxelize_forward_impl (line 5) | int hard_voxelize_forward_impl(const at::Tensor &points, at::Tensor &vox...
function dynamic_voxelize_forward_impl (line 17) | void dynamic_voxelize_forward_impl(const at::Tensor &points, at::Tensor ...
function hard_voxelize_forward (line 25) | void hard_voxelize_forward(const at::Tensor &points,
function dynamic_voxelize_forward (line 44) | void dynamic_voxelize_forward(const at::Tensor &points,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/parrots/voxelization_parrots.cpp
function hard_voxelize_forward_cuda_parrots (line 11) | void hard_voxelize_forward_cuda_parrots(CudaContext& ctx, const SSElemen...
function dynamic_voxelize_forward_cuda_parrots (line 34) | void dynamic_voxelize_forward_cuda_parrots(CudaContext& ctx,
function hard_voxelize_forward_cpu_parrots (line 50) | void hard_voxelize_forward_cpu_parrots(HostContext& ctx, const SSElement...
function dynamic_voxelize_forward_cpu_parrots (line 73) | void dynamic_voxelize_forward_cpu_parrots(HostContext& ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/active_rotated_filter.cpp
function active_rotated_filter_forward_impl (line 8) | void active_rotated_filter_forward_impl(const Tensor input,
function active_rotated_filter_backward_impl (line 14) | void active_rotated_filter_backward_impl(const Tensor grad_out,
function active_rotated_filter_forward (line 20) | void active_rotated_filter_forward(const Tensor input, const Tensor indi...
function active_rotated_filter_backward (line 25) | void active_rotated_filter_backward(const Tensor grad_out, const Tensor ...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/assign_score_withk.cpp
function assign_score_withk_forward_impl (line 6) | void assign_score_withk_forward_impl(int B, int N0, int N1, int M, int K...
function assign_score_withk_backward_impl (line 15) | void assign_score_withk_backward_impl(
function assign_score_withk_forward (line 25) | void assign_score_withk_forward(const Tensor& points, const Tensor& cent...
function assign_score_withk_backward (line 33) | void assign_score_withk_backward(const Tensor& grad_out, const Tensor& p...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/ball_query.cpp
function ball_query_forward_impl (line 7) | void ball_query_forward_impl(int b, int n, int m, float min_radius,
function ball_query_forward (line 15) | void ball_query_forward(Tensor new_xyz_tensor, Tensor xyz_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/bbox_overlaps.cpp
function bbox_overlaps_impl (line 5) | void bbox_overlaps_impl(const Tensor bboxes1, const Tensor bboxes2, Tens...
function bbox_overlaps (line 11) | void bbox_overlaps(const Tensor bboxes1, const Tensor bboxes2, Tensor ious,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/border_align.cpp
function border_align_forward_impl (line 5) | void border_align_forward_impl(const Tensor &input, const Tensor &boxes,
function border_align_backward_impl (line 12) | void border_align_backward_impl(const Tensor &grad_output, const Tensor ...
function border_align_forward (line 19) | void border_align_forward(const Tensor &input, const Tensor &boxes,
function border_align_backward (line 25) | void border_align_backward(const Tensor &grad_output, const Tensor &boxes,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/box_iou_rotated.cpp
function box_iou_rotated_impl (line 7) | void box_iou_rotated_impl(const Tensor boxes1, const Tensor boxes2, Tens...
function box_iou_rotated (line 16) | void box_iou_rotated(const Tensor boxes1, const Tensor boxes2, Tensor ious,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/carafe.cpp
function carafe_forward_impl (line 5) | void carafe_forward_impl(Tensor features, Tensor masks, Tensor rfeatures,
function carafe_backward_impl (line 12) | void carafe_backward_impl(Tensor top_grad, Tensor rfeatures, Tensor masks,
function carafe_forward (line 23) | void carafe_forward(Tensor features, Tensor masks, Tensor rfeatures,
function carafe_backward (line 30) | void carafe_backward(Tensor top_grad, Tensor rfeatures, Tensor masks,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/carafe_naive.cpp
function carafe_naive_forward_impl (line 5) | void carafe_naive_forward_impl(Tensor features, Tensor masks, Tensor out...
function carafe_naive_backward_impl (line 12) | void carafe_naive_backward_impl(Tensor top_grad, Tensor features, Tensor...
function carafe_naive_forward (line 21) | void carafe_naive_forward(Tensor features, Tensor masks, Tensor output,
function carafe_naive_backward (line 27) | void carafe_naive_backward(Tensor top_grad, Tensor features, Tensor masks,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/contour_expand.cpp
class Point2d (line 10) | class Point2d {
method Point2d (line 15) | Point2d() : x(0), y(0) {}
method Point2d (line 16) | Point2d(int _x, int _y) : x(_x), y(_y) {}
function kernel_dilate (line 19) | void kernel_dilate(const uint8_t *data, IntArrayRef data_shape,
function contour_expand (line 89) | std::vector<std::vector<int>> contour_expand(Tensor kernel_mask,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/convex_iou.cpp
function convex_iou_impl (line 7) | void convex_iou_impl(const Tensor pointsets, const Tensor polygons,
function convex_iou (line 12) | void convex_iou(const Tensor pointsets, const Tensor polygons, Tensor io...
function convex_giou_impl (line 16) | void convex_giou_impl(const Tensor pointsets, const Tensor polygons,
function convex_giou (line 21) | void convex_giou(const Tensor pointsets, const Tensor polygons, Tensor o...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/corner_pool.cpp
function Tensor (line 6) | Tensor bottom_pool_forward(Tensor input) {
function Tensor (line 23) | Tensor bottom_pool_backward(Tensor input, Tensor grad_output) {
function Tensor (line 65) | Tensor left_pool_forward(Tensor input) {
function Tensor (line 82) | Tensor left_pool_backward(Tensor input, Tensor grad_output) {
function Tensor (line 124) | Tensor right_pool_forward(Tensor input) {
function Tensor (line 141) | Tensor right_pool_backward(Tensor input, Tensor grad_output) {
function Tensor (line 183) | Tensor top_pool_forward(Tensor input) {
function Tensor (line 200) | Tensor top_pool_backward(Tensor input, Tensor grad_output) {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/correlation.cpp
function correlation_forward_impl (line 7) | void correlation_forward_impl(Tensor input1, Tensor input2, Tensor output,
function correlation_backward_impl (line 17) | void correlation_backward_impl(Tensor grad_output, Tensor input1, Tensor...
function correlation_forward (line 29) | void correlation_forward(Tensor input1, Tensor input2, Tensor output, in...
function correlation_backward (line 38) | void correlation_backward(Tensor grad_output, Tensor input1, Tensor input2,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/active_rotated_filter.cpp
function active_rotated_filter_forward_cpu_kernel (line 8) | void active_rotated_filter_forward_cpu_kernel(
function active_rotated_filter_backward_cpu_kernel (line 35) | void active_rotated_filter_backward_cpu_kernel(
function ActiveRotatedFilterForwardCPULauncher (line 63) | void ActiveRotatedFilterForwardCPULauncher(const Tensor input,
function ActiveRotatedFilterBackwardCPULauncher (line 82) | void ActiveRotatedFilterBackwardCPULauncher(const Tensor grad_out,
function active_rotated_filter_forward_cpu (line 101) | void active_rotated_filter_forward_cpu(const Tensor input, const Tensor ...
function active_rotated_filter_backward_cpu (line 106) | void active_rotated_filter_backward_cpu(const Tensor grad_out,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/box_iou_rotated.cpp
function box_iou_rotated_cpu_kernel (line 9) | void box_iou_rotated_cpu_kernel(const Tensor boxes1, const Tensor boxes2,
function box_iou_rotated_cpu (line 31) | void box_iou_rotated_cpu(const Tensor boxes1, const Tensor boxes2, Tenso...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/deform_conv.cpp
function T (line 6) | T deformable_im2col_bilinear_cpu(const T *input, const int data_width,
function T (line 40) | T get_gradient_weight_cpu(T argmax_h, T argmax_w, const int h, const int w,
function T (line 66) | T get_coordinate_weight_cpu(T argmax_h, T argmax_w, const int height,
function deformable_im2col_cpu_kernel (line 114) | void deformable_im2col_cpu_kernel(
function deformable_col2im_cpu_kernel (line 167) | void deformable_col2im_cpu_kernel(
function deformable_col2im_coord_cpu_kernel (line 224) | void deformable_col2im_coord_cpu_kernel(
function deformable_im2col_cpu (line 291) | void deformable_im2col_cpu(Tensor data_im, Tensor data_offset,
function deformable_col2im_cpu (line 318) | void deformable_col2im_cpu(Tensor data_col, Tensor data_offset,
function deformable_col2im_coord_cpu (line 349) | void deformable_col2im_coord_cpu(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/modulated_deform_conv.cpp
function T (line 6) | T dmcn_im2col_bilinear_cpu(const T *input, const int data_width,
function T (line 36) | T dmcn_get_gradient_weight_cpu(T argmax_h, T argmax_w, const int h, cons...
function T (line 62) | T dmcn_get_coordinate_weight_cpu(T argmax_h, T argmax_w, const int height,
function modulated_deformable_im2col_cpu_kernel (line 110) | void modulated_deformable_im2col_cpu_kernel(
function modulated_deformable_col2im_cpu_kernel (line 171) | void modulated_deformable_col2im_cpu_kernel(
function modulated_deformable_col2im_coord_cpu_kernel (line 234) | void modulated_deformable_col2im_coord_cpu_kernel(
function modulated_deformable_im2col_cpu (line 322) | void modulated_deformable_im2col_cpu(
function modulated_deformable_col2im_cpu (line 348) | void modulated_deformable_col2im_cpu(
function modulated_deformable_col2im_coord_cpu (line 374) | void modulated_deformable_col2im_coord_cpu(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/nms.cpp
function Tensor (line 5) | Tensor nms_cpu(Tensor boxes, Tensor scores, float iou_threshold, int off...
function Tensor (line 59) | Tensor softnms_cpu(Tensor boxes, Tensor scores, Tensor dets,
function nms_match_cpu (line 168) | std::vector<std::vector<int> > nms_match_cpu(Tensor dets, float iou_thre...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/nms_rotated.cpp
function Tensor (line 8) | Tensor nms_rotated_cpu_kernel(const Tensor dets, const Tensor scores,
function Tensor (line 59) | Tensor nms_rotated_cpu(const Tensor dets, const Tensor scores,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/pixel_group.cpp
function estimate_confidence (line 7) | std::vector<std::vector<float>> estimate_confidence(int32_t* label,
function pixel_group_cpu (line 37) | std::vector<std::vector<float>> pixel_group_cpu(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/points_in_boxes.cpp
function lidar_to_local_coords_cpu (line 3) | inline void lidar_to_local_coords_cpu(float shift_x, float shift_y, floa...
function check_pt_in_box3d_cpu (line 10) | inline int check_pt_in_box3d_cpu(const float *pt, const float *box3d,
function points_in_boxes_cpu_forward (line 28) | void points_in_boxes_cpu_forward(Tensor boxes_tensor, Tensor pts_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/psamask.cpp
function psamask_collect_forward (line 14) | void psamask_collect_forward(const int num_, const int h_feature,
function psamask_distribute_forward (line 51) | void psamask_distribute_forward(const int num_, const int h_feature,
function psamask_collect_backward (line 88) | void psamask_collect_backward(const int num_, const int h_feature,
function psamask_distribute_backward (line 124) | void psamask_distribute_backward(const int num_, const int h_feature,
function psamask_forward_cpu (line 160) | void psamask_forward_cpu(const int psa_type, const Tensor input, Tensor ...
function psamask_backward_cpu (line 173) | void psamask_backward_cpu(const int psa_type, const Tensor grad_output,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/roi_align.cpp
type PreCalc (line 12) | struct PreCalc {
function pre_calc_for_bilinear_interpolate (line 24) | void pre_calc_for_bilinear_interpolate(
function ROIAlignForward (line 111) | void ROIAlignForward(const int nthreads, const T* input, const T* rois,
function bilinear_interpolate_gradient (line 217) | void bilinear_interpolate_gradient(const int height, const int width, T ...
function add (line 266) | inline void add(T* address, const T& val) {
function ROIAlignBackward (line 271) | void ROIAlignBackward(const int nthreads, const T* grad_output, const T*...
function ROIAlignForwardCPULauncher (line 384) | void ROIAlignForwardCPULauncher(Tensor input, Tensor rois, Tensor output,
function ROIAlignBackwardCPULauncher (line 405) | void ROIAlignBackwardCPULauncher(Tensor grad_output, Tensor rois,
function roi_align_forward_cpu (line 434) | void roi_align_forward_cpu(Tensor input, Tensor rois, Tensor output,
function roi_align_backward_cpu (line 443) | void roi_align_backward_cpu(Tensor grad_output, Tensor rois, Tensor argm...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/roi_align_rotated.cpp
type PreCalc (line 12) | struct PreCalc {
function pre_calc_for_bilinear_interpolate (line 24) | void pre_calc_for_bilinear_interpolate(
function ROIAlignRotatedForward (line 116) | void ROIAlignRotatedForward(const int nthreads, const T* input,
function bilinear_interpolate_gradient (line 215) | void bilinear_interpolate_gradient(const int height, const int width, T ...
function add (line 268) | inline void add(T* address, const T& val) {
function ROIAlignRotatedBackward (line 273) | void ROIAlignRotatedBackward(
function ROIAlignRotatedForwardCPULauncher (line 374) | void ROIAlignRotatedForwardCPULauncher(Tensor input, Tensor rois, Tensor...
function ROIAlignRotatedBackwardCPULauncher (line 393) | void ROIAlignRotatedBackwardCPULauncher(Tensor grad_output, Tensor rois,
function roi_align_rotated_forward_cpu (line 419) | void roi_align_rotated_forward_cpu(Tensor input, Tensor rois, Tensor out...
function roi_align_rotated_backward_cpu (line 428) | void roi_align_rotated_backward_cpu(Tensor top_grad, Tensor rois,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cpu/voxelization.cpp
function dynamic_voxelize_forward_cpu_kernel (line 6) | void dynamic_voxelize_forward_cpu_kernel(
function hard_voxelize_forward_cpu_kernel (line 39) | void hard_voxelize_forward_cpu_kernel(
function dynamic_voxelize_forward_cpu (line 90) | void dynamic_voxelize_forward_cpu(const at::Tensor& points, at::Tensor& ...
function hard_voxelize_forward_cpu (line 115) | int hard_voxelize_forward_cpu(const at::Tensor& points, at::Tensor& voxels,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/cuda/cudabind.cpp
function assign_score_withk_forward_cuda (line 15) | void assign_score_withk_forward_cuda(int B, int N0, int N1, int M, int K...
function assign_score_withk_backward_cuda (line 24) | void assign_score_withk_backward_cuda(
function ball_query_forward_cuda (line 56) | void ball_query_forward_cuda(int b, int n, int m, float min_radius,
function bbox_overlaps_cuda (line 74) | void bbox_overlaps_cuda(const Tensor bboxes1, const Tensor bboxes2, Tens...
function border_align_forward_cuda (line 94) | void border_align_forward_cuda(const Tensor& input, const Tensor& boxes,
function border_align_backward_cuda (line 101) | void border_align_backward_cuda(const Tensor& grad_output, const Tensor&...
function carafe_forward_cuda (line 141) | void carafe_forward_cuda(Tensor features, Tensor masks, Tensor rfeatures,
function carafe_backward_cuda (line 149) | void carafe_backward_cuda(Tensor top_grad, Tensor rfeatures, Tensor masks,
function carafe_naive_forward_cuda (line 184) | void carafe_naive_forward_cuda(Tensor features, Tensor masks, Tensor out...
function carafe_naive_backward_cuda (line 191) | void carafe_naive_backward_cuda(Tensor top_grad, Tensor features, Tensor...
function correlation_forward_cuda (line 228) | void correlation_forward_cuda(Tensor input1, Tensor input2, Tensor output,
function correlation_backward_cuda (line 238) | void correlation_backward_cuda(Tensor grad_output, Tensor input1, Tensor...
function deform_roi_pool_forward_cuda (line 333) | void deform_roi_pool_forward_cuda(Tensor input, Tensor rois, Tensor offset,
function deform_roi_pool_backward_cuda (line 342) | void deform_roi_pool_backward_cuda(Tensor grad_output, Tensor input,
function sigmoid_focal_loss_forward_cuda (line 392) | void sigmoid_focal_loss_forward_cuda(Tensor input, Tensor target, Tensor...
function sigmoid_focal_loss_backward_cuda (line 398) | void sigmoid_focal_loss_backward_cuda(Tensor input, Tensor target,
function softmax_focal_loss_forward_cuda (line 405) | void softmax_focal_loss_forward_cuda(Tensor input, Tensor target, Tensor...
function softmax_focal_loss_backward_cuda (line 411) | void softmax_focal_loss_backward_cuda(Tensor input, Tensor target,
function furthest_point_sampling_forward_cuda (line 450) | void furthest_point_sampling_forward_cuda(Tensor points_tensor,
function furthest_point_sampling_with_dist_forward_cuda (line 459) | void furthest_point_sampling_with_dist_forward_cuda(Tensor points_tensor,
function gather_points_forward_cuda (line 505) | void gather_points_forward_cuda(int b, int c, int n, int npoints,
function gather_points_backward_cuda (line 511) | void gather_points_backward_cuda(int b, int c, int n, int npoints,
function group_points_forward_cuda (line 540) | void group_points_forward_cuda(int b, int c, int n, int npoints, int nsa...
function group_points_backward_cuda (line 547) | void group_points_backward_cuda(int b, int c, int n, int npoints, int ns...
function iou3d_boxes_overlap_bev_forward_cuda (line 588) | void iou3d_boxes_overlap_bev_forward_cuda(const int num_a, const Tensor ...
function iou3d_boxes_iou_bev_forward_cuda (line 595) | void iou3d_boxes_iou_bev_forward_cuda(const int num_a, const Tensor boxe...
function iou3d_nms_forward_cuda (line 602) | void iou3d_nms_forward_cuda(const Tensor boxes, unsigned long long* mask,
function iou3d_nms_normal_forward_cuda (line 607) | void iou3d_nms_normal_forward_cuda(const Tensor boxes, unsigned long lon...
function knn_forward_cuda (line 639) | void knn_forward_cuda(int b, int n, int m, int nsample, const Tensor xyz,
function masked_im2col_forward_cuda (line 661) | void masked_im2col_forward_cuda(const Tensor im, const Tensor mask_h_idx,
function masked_col2im_forward_cuda (line 671) | void masked_col2im_forward_cuda(const Tensor col, const Tensor mask_h_idx,
function Tensor (line 785) | Tensor nms_cuda(Tensor boxes, Tensor scores, float iou_threshold, int of...
function points_in_boxes_part_forward_cuda (line 802) | void points_in_boxes_part_forward_cuda(int batch_size, int boxes_num,
function points_in_boxes_all_forward_cuda (line 810) | void points_in_boxes_all_forward_cuda(int batch_size, int boxes_num,
function psamask_forward_cuda (line 844) | void psamask_forward_cuda(const int psa_type, const Tensor input, Tensor...
function psamask_backward_cuda (line 854) | void psamask_backward_cuda(const int psa_type, const Tensor grad_output,
function roi_align_forward_cuda (line 891) | void roi_align_forward_cuda(Tensor input, Tensor rois, Tensor output,
function roi_align_backward_cuda (line 901) | void roi_align_backward_cuda(Tensor grad_output, Tensor rois, Tensor arg...
function roi_align_rotated_forward_cuda (line 938) | void roi_align_rotated_forward_cuda(Tensor features, Tensor rois, Tensor...
function roi_align_rotated_backward_cuda (line 959) | void roi_align_rotated_backward_cuda(Tensor top_grad, Tensor rois,
function riroi_align_rotated_forward_cuda (line 1009) | void riroi_align_rotated_forward_cuda(Tensor features, Tensor rois,
function riroi_align_rotated_backward_cuda (line 1031) | void riroi_align_rotated_backward_cuda(Tensor top_grad, Tensor rois,
function roiaware_pool3d_forward_cuda (line 1081) | void roiaware_pool3d_forward_cuda(int boxes_num, int pts_num, int channels,
function roiaware_pool3d_backward_cuda (line 1093) | void roiaware_pool3d_backward_cuda(int boxes_num, int out_x, int out_y,
function roipoint_pool3d_forward_cuda (line 1128) | void roipoint_pool3d_forward_cuda(int batch_size, int pts_num, int boxes...
function roi_pool_forward_cuda (line 1157) | void roi_pool_forward_cuda(Tensor input, Tensor rois, Tensor output,
function roi_pool_backward_cuda (line 1164) | void roi_pool_backward_cuda(Tensor grad_output, Tensor rois, Tensor argmax,
function dynamic_point_to_voxel_forward_cuda (line 1192) | std::vector<torch::Tensor> dynamic_point_to_voxel_forward_cuda(
function dynamic_point_to_voxel_backward_cuda (line 1199) | void dynamic_point_to_voxel_backward_cuda(
function sync_bn_forward_mean_cuda (line 1247) | void sync_bn_forward_mean_cuda(const Tensor input, Tensor mean) {
function sync_bn_forward_var_cuda (line 1251) | void sync_bn_forward_var_cuda(const Tensor input, const Tensor mean,
function sync_bn_forward_output_cuda (line 1256) | void sync_bn_forward_output_cuda(const Tensor input, const Tensor mean,
function sync_bn_backward_param_cuda (line 1267) | void sync_bn_backward_param_cuda(const Tensor grad_output, const Tensor ...
function sync_bn_backward_data_cuda (line 1273) | void sync_bn_backward_data_cuda(const Tensor grad_output, const Tensor w...
function three_interpolate_forward_cuda (line 1322) | void three_interpolate_forward_cuda(int b, int c, int m, int n,
function three_interpolate_backward_cuda (line 1329) | void three_interpolate_backward_cuda(int b, int c, int n, int m,
function three_nn_forward_cuda (line 1352) | void three_nn_forward_cuda(int b, int n, int m, const Tensor unknown,
function tin_shift_forward_cuda (line 1367) | void tin_shift_forward_cuda(Tensor input, Tensor shift, Tensor output) {
function tin_shift_backward_cuda (line 1371) | void tin_shift_backward_cuda(Tensor grad_output, Tensor shift,
function hard_voxelize_forward_cuda (line 1404) | int hard_voxelize_forward_cuda(const at::Tensor& points, at::Tensor& vox...
function dynamic_voxelize_forward_cuda (line 1416) | void dynamic_voxelize_forward_cuda(const at::Tensor& points, at::Tensor&...
function rotated_feature_align_forward_cuda (line 1454) | void rotated_feature_align_forward_cuda(const Tensor features,
function rotated_feature_align_backward_cuda (line 1462) | void rotated_feature_align_backward_cuda(const Tensor top_grad,
function points_in_polygons_forward_cuda (line 1490) | void points_in_polygons_forward_cuda(const Tensor points, const Tensor p...
function min_area_polygons_cuda (line 1506) | void min_area_polygons_cuda(const Tensor pointsets, Tensor polygons) {
function active_rotated_filter_forward_cuda (line 1522) | void active_rotated_filter_forward_cuda(const Tensor input,
function active_rotated_filter_backward_cuda (line 1527) | void active_rotated_filter_backward_cuda(const Tensor grad_out,
function convex_iou_cuda (line 1549) | void convex_iou_cuda(const Tensor pointsets, const Tensor polygons,
function convex_giou_cuda (line 1554) | void convex_giou_cuda(const Tensor pointsets, const Tensor polygons,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/deform_conv.cpp
function deformable_im2col_impl (line 5) | void deformable_im2col_impl(Tensor data_im, Tensor data_offset,
function deformable_col2im_impl (line 19) | void deformable_col2im_impl(Tensor data_col, Tensor data_offset,
function deformable_col2im_coord_impl (line 33) | void deformable_col2im_coord_impl(
function deform_conv_shape_check (line 45) | void deform_conv_shape_check(at::Tensor input, at::Tensor offset,
function deform_conv_forward (line 140) | void deform_conv_forward(Tensor input, Tensor weight, Tensor offset,
function deform_conv_backward_input (line 260) | void deform_conv_backward_input(Tensor input, Tensor offset, Tensor grad...
function deform_conv_backward_parameters (line 392) | void deform_conv_backward_parameters(Tensor input, Tensor offset,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/deform_roi_pool.cpp
function deform_roi_pool_forward_impl (line 5) | void deform_roi_pool_forward_impl(Tensor input, Tensor rois, Tensor offset,
function deform_roi_pool_backward_impl (line 14) | void deform_roi_pool_backward_impl(Tensor grad_output, Tensor input,
function deform_roi_pool_forward (line 25) | void deform_roi_pool_forward(Tensor input, Tensor rois, Tensor offset,
function deform_roi_pool_backward (line 34) | void deform_roi_pool_backward(Tensor grad_output, Tensor input, Tensor r...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/focal_loss.cpp
function sigmoid_focal_loss_forward_impl (line 5) | void sigmoid_focal_loss_forward_impl(Tensor input, Tensor target, Tensor...
function sigmoid_focal_loss_backward_impl (line 11) | void sigmoid_focal_loss_backward_impl(Tensor input, Tensor target,
function softmax_focal_loss_forward_impl (line 18) | void softmax_focal_loss_forward_impl(Tensor input, Tensor target, Tensor...
function softmax_focal_loss_backward_impl (line 24) | void softmax_focal_loss_backward_impl(Tensor input, Tensor target,
function sigmoid_focal_loss_forward (line 32) | void sigmoid_focal_loss_forward(Tensor input, Tensor target, Tensor weight,
function sigmoid_focal_loss_backward (line 37) | void sigmoid_focal_loss_backward(Tensor input, Tensor target, Tensor wei...
function softmax_focal_loss_forward (line 43) | void softmax_focal_loss_forward(Tensor input, Tensor target, Tensor weight,
function softmax_focal_loss_backward (line 48) | void softmax_focal_loss_backward(Tensor input, Tensor target, Tensor wei...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/furthest_point_sample.cpp
function furthest_point_sampling_forward_impl (line 7) | void furthest_point_sampling_forward_impl(Tensor points_tensor,
function furthest_point_sampling_with_dist_forward_impl (line 14) | void furthest_point_sampling_with_dist_forward_impl(Tensor points_tensor,
function furthest_point_sampling_forward (line 22) | void furthest_point_sampling_forward(Tensor points_tensor, Tensor temp_t...
function furthest_point_sampling_with_dist_forward (line 28) | void furthest_point_sampling_with_dist_forward(Tensor points_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/fused_bias_leakyrelu.cpp
function fused_bias_leakyrelu_op_impl (line 105) | torch::Tensor fused_bias_leakyrelu_op_impl(const torch::Tensor& input,
function fused_bias_leakyrelu (line 113) | torch::Tensor fused_bias_leakyrelu(const torch::Tensor& input,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/gather_points.cpp
function gather_points_forward_impl (line 4) | void gather_points_forward_impl(int b, int c, int n, int npoints,
function gather_points_backward_impl (line 11) | void gather_points_backward_impl(int b, int c, int n, int npoints,
function gather_points_forward (line 18) | void gather_points_forward(Tensor points_tensor, Tensor idx_tensor,
function gather_points_backward (line 25) | void gather_points_backward(Tensor grad_out_tensor, Tensor idx_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/group_points.cpp
function group_points_forward_impl (line 8) | void group_points_forward_impl(int b, int c, int n, int npoints, int nsa...
function group_points_backward_impl (line 15) | void group_points_backward_impl(int b, int c, int n, int npoints, int ns...
function group_points_forward (line 22) | void group_points_forward(Tensor points_tensor, Tensor idx_tensor,
function group_points_backward (line 29) | void group_points_backward(Tensor grad_out_tensor, Tensor idx_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/info.cpp
function get_cudart_version (line 9) | int get_cudart_version() { return CUDART_VERSION; }
function get_compiling_cuda_version (line 13) | std::string get_compiling_cuda_version() {
function get_compiler_version (line 37) | std::string get_compiler_version() {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/iou3d.cpp
function iou3d_boxes_overlap_bev_forward_impl (line 15) | void iou3d_boxes_overlap_bev_forward_impl(const int num_a, const Tensor ...
function iou3d_boxes_iou_bev_forward_impl (line 22) | void iou3d_boxes_iou_bev_forward_impl(const int num_a, const Tensor boxe...
function iou3d_nms_forward_impl (line 29) | void iou3d_nms_forward_impl(const Tensor boxes, unsigned long long *mask,
function iou3d_nms_normal_forward_impl (line 35) | void iou3d_nms_normal_forward_impl(const Tensor boxes, unsigned long lon...
function iou3d_boxes_overlap_bev_forward (line 41) | void iou3d_boxes_overlap_bev_forward(Tensor boxes_a, Tensor boxes_b,
function iou3d_boxes_iou_bev_forward (line 54) | void iou3d_boxes_iou_bev_forward(Tensor boxes_a, Tensor boxes_b,
function iou3d_nms_forward (line 65) | void iou3d_nms_forward(Tensor boxes, Tensor keep, Tensor keep_num,
function iou3d_nms_normal_forward (line 109) | void iou3d_nms_normal_forward(Tensor boxes, Tensor keep, Tensor keep_num,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/knn.cpp
function knn_forward_impl (line 7) | void knn_forward_impl(int b, int n, int m, int nsample, const Tensor xyz,
function knn_forward (line 13) | void knn_forward(Tensor xyz_tensor, Tensor new_xyz_tensor, Tensor idx_te...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/masked_conv2d.cpp
function masked_im2col_forward_impl (line 5) | void masked_im2col_forward_impl(const Tensor im, const Tensor mask_h_idx,
function masked_col2im_forward_impl (line 13) | void masked_col2im_forward_impl(const Tensor col, const Tensor mask_h_idx,
function masked_im2col_forward (line 20) | void masked_im2col_forward(const Tensor im, const Tensor mask_h_idx,
function masked_col2im_forward (line 28) | void masked_col2im_forward(const Tensor col, const Tensor mask_h_idx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/min_area_polygons.cpp
function min_area_polygons_impl (line 5) | void min_area_polygons_impl(const Tensor pointsets, Tensor polygons) {
function min_area_polygons (line 9) | void min_area_polygons(const Tensor pointsets, Tensor polygons) {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/modulated_deform_conv.cpp
function modulated_deformable_im2col_impl (line 5) | void modulated_deformable_im2col_impl(
function modulated_deformable_col2im_impl (line 19) | void modulated_deformable_col2im_impl(
function modulated_deformable_col2im_coord_impl (line 33) | void modulated_deformable_col2im_coord_impl(
function modulated_deform_conv_forward (line 48) | void modulated_deform_conv_forward(
function modulated_deform_conv_backward (line 126) | void modulated_deform_conv_backward(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/ms_deform_attn.cpp
function Tensor (line 15) | Tensor ms_deform_attn_impl_forward(const Tensor &value,
function ms_deform_attn_impl_backward (line 26) | void ms_deform_attn_impl_backward(
function Tensor (line 38) | Tensor ms_deform_attn_forward(const Tensor &value, const Tensor &spatial...
function ms_deform_attn_backward (line 48) | void ms_deform_attn_backward(const Tensor &value, const Tensor &spatial_...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/nms.cpp
function Tensor (line 5) | Tensor nms_impl(Tensor boxes, Tensor scores, float iou_threshold, int of...
function Tensor (line 9) | Tensor softnms_impl(Tensor boxes, Tensor scores, Tensor dets,
function nms_match_impl (line 16) | std::vector<std::vector<int> > nms_match_impl(Tensor dets,
function Tensor (line 21) | Tensor nms(Tensor boxes, Tensor scores, float iou_threshold, int offset) {
function Tensor (line 25) | Tensor softnms(Tensor boxes, Tensor scores, Tensor dets, float iou_thres...
function nms_match (line 31) | std::vector<std::vector<int> > nms_match(Tensor dets, float iou_threshol...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/nms_rotated.cpp
function Tensor (line 18) | Tensor nms_rotated(const Tensor dets, const Tensor scores, const Tensor ...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/pixel_group.cpp
function pixel_group_impl (line 7) | std::vector<std::vector<float>> pixel_group_impl(
function pixel_group (line 15) | std::vector<std::vector<float>> pixel_group(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/points_in_boxes.cpp
function points_in_boxes_part_forward_impl (line 4) | void points_in_boxes_part_forward_impl(int batch_size, int boxes_num,
function points_in_boxes_all_forward_impl (line 12) | void points_in_boxes_all_forward_impl(int batch_size, int boxes_num,
function points_in_boxes_part_forward (line 20) | void points_in_boxes_part_forward(Tensor boxes_tensor, Tensor pts_tensor,
function points_in_boxes_all_forward (line 34) | void points_in_boxes_all_forward(Tensor boxes_tensor, Tensor pts_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/points_in_polygons.cpp
function points_in_polygons_forward_impl (line 4) | void points_in_polygons_forward_impl(const Tensor points, const Tensor p...
function points_in_polygons_forward (line 11) | void points_in_polygons_forward(Tensor points, Tensor polygons, Tensor o...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/psamask.cpp
function psamask_forward_impl (line 7) | void psamask_forward_impl(const int psa_type, const Tensor input, Tensor...
function psamask_backward_impl (line 17) | void psamask_backward_impl(const int psa_type, const Tensor grad_output,
function psamask_forward (line 27) | void psamask_forward(const Tensor input, Tensor output, const int psa_type,
function psamask_backward (line 35) | void psamask_backward(Tensor grad_output, const Tensor grad_input,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/pybind.cpp
function PYBIND11_MODULE (line 378) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/riroi_align_rotated.cpp
function riroi_align_rotated_forward_impl (line 5) | void riroi_align_rotated_forward_impl(Tensor features, Tensor rois,
function riroi_align_rotated_backward_impl (line 15) | void riroi_align_rotated_backward_impl(Tensor top_grad, Tensor rois,
function riroi_align_rotated_forward (line 25) | void riroi_align_rotated_forward(Tensor features, Tensor rois, Tensor ou...
function riroi_align_rotated_backward (line 34) | void riroi_align_rotated_backward(Tensor top_grad, Tensor rois,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/roi_align.cpp
function roi_align_forward_impl (line 5) | void roi_align_forward_impl(Tensor input, Tensor rois, Tensor output,
function roi_align_backward_impl (line 15) | void roi_align_backward_impl(Tensor grad_output, Tensor rois, Tensor arg...
function roi_align_forward (line 25) | void roi_align_forward(Tensor input, Tensor rois, Tensor output,
function roi_align_backward (line 34) | void roi_align_backward(Tensor grad_output, Tensor rois, Tensor argmax_y,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/roi_align_rotated.cpp
function roi_align_rotated_forward_impl (line 5) | void roi_align_rotated_forward_impl(Tensor features, Tensor rois, Tensor...
function roi_align_rotated_backward_impl (line 14) | void roi_align_rotated_backward_impl(Tensor top_grad, Tensor rois,
function roi_align_rotated_forward (line 24) | void roi_align_rotated_forward(Tensor input, Tensor rois, Tensor output,
function roi_align_rotated_backward (line 33) | void roi_align_rotated_backward(Tensor top_grad, Tensor rois,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/roi_pool.cpp
function roi_pool_forward_impl (line 5) | void roi_pool_forward_impl(Tensor input, Tensor rois, Tensor output,
function roi_pool_backward_impl (line 12) | void roi_pool_backward_impl(Tensor grad_output, Tensor rois, Tensor argmax,
function roi_pool_forward (line 19) | void roi_pool_forward(Tensor input, Tensor rois, Tensor output, Tensor a...
function roi_pool_backward (line 26) | void roi_pool_backward(Tensor grad_output, Tensor rois, Tensor argmax,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/roiaware_pool3d.cpp
function roiaware_pool3d_forward_impl (line 4) | void roiaware_pool3d_forward_impl(int boxes_num, int pts_num, int channels,
function roiaware_pool3d_backward_impl (line 16) | void roiaware_pool3d_backward_impl(int boxes_num, int out_x, int out_y,
function roiaware_pool3d_forward (line 27) | void roiaware_pool3d_forward(Tensor rois, Tensor pts, Tensor pts_feature,
function roiaware_pool3d_backward (line 54) | void roiaware_pool3d_backward(Tensor pts_idx_of_voxels, Tensor argmax,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/roipoint_pool3d.cpp
function roipoint_pool3d_forward_impl (line 12) | void roipoint_pool3d_forward_impl(int batch_size, int pts_num, int boxes...
function roipoint_pool3d_forward (line 23) | void roipoint_pool3d_forward(Tensor xyz, Tensor boxes3d, Tensor pts_feat...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/rotated_feature_align.cpp
function rotated_feature_align_forward_impl (line 8) | void rotated_feature_align_forward_impl(const Tensor features,
function rotated_feature_align_backward_impl (line 16) | void rotated_feature_align_backward_impl(const Tensor top_grad,
function rotated_feature_align_forward (line 24) | void rotated_feature_align_forward(const Tensor features,
function rotated_feature_align_backward (line 32) | void rotated_feature_align_backward(const Tensor top_grad,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/scatter_points.cpp
function dynamic_point_to_voxel_forward_impl (line 7) | std::vector<torch::Tensor> dynamic_point_to_voxel_forward_impl(
function dynamic_point_to_voxel_backward_impl (line 14) | void dynamic_point_to_voxel_backward_impl(
function reduce_t (line 24) | inline reduce_t convert_reduce_type(const std::string &reduce_type) {
function dynamic_point_to_voxel_forward (line 36) | std::vector<torch::Tensor> dynamic_point_to_voxel_forward(
function dynamic_point_to_voxel_backward (line 43) | void dynamic_point_to_voxel_backward(torch::Tensor &grad_feats,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/sync_bn.cpp
function sync_bn_forward_mean_impl (line 5) | void sync_bn_forward_mean_impl(const Tensor input, Tensor mean) {
function sync_bn_forward_var_impl (line 9) | void sync_bn_forward_var_impl(const Tensor input, const Tensor mean,
function sync_bn_forward_output_impl (line 14) | void sync_bn_forward_output_impl(const Tensor input, const Tensor mean,
function sync_bn_backward_param_impl (line 25) | void sync_bn_backward_param_impl(const Tensor grad_output, const Tensor ...
function sync_bn_backward_data_impl (line 31) | void sync_bn_backward_data_impl(const Tensor grad_output, const Tensor w...
function sync_bn_forward_mean (line 39) | void sync_bn_forward_mean(const Tensor input, Tensor mean) {
function sync_bn_forward_var (line 43) | void sync_bn_forward_var(const Tensor input, const Tensor mean, Tensor v...
function sync_bn_forward_output (line 47) | void sync_bn_forward_output(const Tensor input, const Tensor mean,
function sync_bn_backward_param (line 58) | void sync_bn_backward_param(const Tensor grad_output, const Tensor norm,
function sync_bn_backward_data (line 63) | void sync_bn_backward_data(const Tensor grad_output, const Tensor weight,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/three_interpolate.cpp
function three_interpolate_forward_impl (line 7) | void three_interpolate_forward_impl(int b, int c, int m, int n,
function three_interpolate_backward_impl (line 14) | void three_interpolate_backward_impl(int b, int c, int n, int m,
function three_interpolate_forward (line 21) | void three_interpolate_forward(Tensor points_tensor, Tensor idx_tensor,
function three_interpolate_backward (line 28) | void three_interpolate_backward(Tensor grad_out_tensor, Tensor idx_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/three_nn.cpp
function three_nn_forward_impl (line 7) | void three_nn_forward_impl(int b, int n, int m, const Tensor unknown,
function three_nn_forward (line 13) | void three_nn_forward(Tensor unknown_tensor, Tensor known_tensor,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/tin_shift.cpp
function tin_shift_forward_impl (line 5) | void tin_shift_forward_impl(Tensor input, Tensor shift, Tensor output) {
function tin_shift_backward_impl (line 9) | void tin_shift_backward_impl(Tensor grad_output, Tensor shift,
function tin_shift_forward (line 14) | void tin_shift_forward(Tensor input, Tensor shift, Tensor output) {
function tin_shift_backward (line 18) | void tin_shift_backward(Tensor grad_output, Tensor shift, Tensor grad_in...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/upfirdn2d.cpp
function upfirdn2d_op_impl (line 105) | torch::Tensor upfirdn2d_op_impl(const torch::Tensor& input,
function upfirdn2d (line 113) | torch::Tensor upfirdn2d(const torch::Tensor& input, const torch::Tensor&...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/pytorch/voxelization.cpp
function hard_voxelize_forward_impl (line 5) | int hard_voxelize_forward_impl(const at::Tensor &points, at::Tensor &vox...
function dynamic_voxelize_forward_impl (line 17) | void dynamic_voxelize_forward_impl(const at::Tensor &points, at::Tensor ...
function hard_voxelize_forward (line 25) | void hard_voxelize_forward(const at::Tensor &points,
function dynamic_voxelize_forward (line 44) | void dynamic_voxelize_forward(const at::Tensor &points,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/plugins/trt_instance_norm.cpp
function cudnnStatus_t (line 15) | cudnnStatus_t convert_trt2cudnn_dtype(nvinfer1::DataType trt_dtype,
function DimsExprs (line 53) | DimsExprs InstanceNormalizationDynamic::getOutputDimensions(
function IPluginV2DynamicExt (line 148) | IPluginV2DynamicExt* InstanceNormalizationDynamic::clone() const {
function PluginFieldCollection (line 209) | const PluginFieldCollection*
function IPluginV2DynamicExt (line 214) | IPluginV2DynamicExt* InstanceNormalizationDynamicCreator::createPlugin(
function IPluginV2DynamicExt (line 231) | IPluginV2DynamicExt* InstanceNormalizationDynamicCreator::deserializePlu...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/plugins/trt_plugin.cpp
function initLibMMCVInferPlugins (line 26) | bool initLibMMCVInferPlugins() { return true; }
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_corner_pool.hpp
type TRT_CORNER_POOL_TYPE (line 8) | enum TRT_CORNER_POOL_TYPE {
class CornerPoolPluginDynamic (line 16) | class CornerPoolPluginDynamic : public nvinfer1::IPluginV2DynamicExt {
method CornerPoolPluginDynamic (line 24) | CornerPoolPluginDynamic() = delete;
class CornerPoolPluginDynamicCreator (line 84) | class CornerPoolPluginDynamicCreator : public nvinfer1::IPluginCreator {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_cummaxmin.hpp
type TRT_CUMCMPTYPE (line 8) | enum TRT_CUMCMPTYPE { TRT_CUMMAX = 0, TRT_CUMMIN = 1 }
class CumMaxMinPluginDynamic (line 11) | class CumMaxMinPluginDynamic : public nvinfer1::IPluginV2DynamicExt {
method CumMaxMinPluginDynamic (line 19) | CumMaxMinPluginDynamic() = delete;
class CumMaxMinPluginDynamicCreator (line 80) | class CumMaxMinPluginDynamicCreator : public nvinfer1::IPluginCreator {
class CumMaxPluginDynamicCreator (line 109) | class CumMaxPluginDynamicCreator : public CumMaxMinPluginDynamicCreator {
class CumMinPluginDynamicCreator (line 116) | class CumMinPluginDynamicCreator : public CumMaxMinPluginDynamicCreator {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_deform_conv.hpp
class DeformableConvPluginDynamic (line 11) | class DeformableConvPluginDynamic : public nvinfer1::IPluginV2DynamicExt {
method DeformableConvPluginDynamic (line 23) | DeformableConvPluginDynamic() = delete;
class DeformableConvPluginDynamicCreator (line 92) | class DeformableConvPluginDynamicCreator : public nvinfer1::IPluginCreat...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_grid_sampler.hpp
type mmcv (line 11) | namespace mmcv {
type GridSamplerInterpolation (line 12) | enum class GridSamplerInterpolation { Bilinear, Nearest }
type GridSamplerPadding (line 13) | enum class GridSamplerPadding { Zeros, Border, Reflection }
class GridSamplerDynamic (line 16) | class GridSamplerDynamic : public nvinfer1::IPluginV2DynamicExt {
method GridSamplerDynamic (line 23) | GridSamplerDynamic() = delete;
class GridSamplerDynamicCreator (line 82) | class GridSamplerDynamicCreator : public nvinfer1::IPluginCreator {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_instance_norm.hpp
class InstanceNormalizationDynamic (line 16) | class InstanceNormalizationDynamic final
method InstanceNormalizationDynamic (line 24) | InstanceNormalizationDynamic() = delete;
class InstanceNormalizationDynamicCreator (line 92) | class InstanceNormalizationDynamicCreator : public nvinfer1::IPluginCrea...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_modulated_deform_conv.hpp
class ModulatedDeformableConvPluginDynamic (line 11) | class ModulatedDeformableConvPluginDynamic
method ModulatedDeformableConvPluginDynamic (line 24) | ModulatedDeformableConvPluginDynamic() = delete;
class ModulatedDeformableConvPluginDynamicCreator (line 93) | class ModulatedDeformableConvPluginDynamicCreator
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_nms.hpp
class NonMaxSuppressionDynamic (line 11) | class NonMaxSuppressionDynamic : public nvinfer1::IPluginV2DynamicExt {
method NonMaxSuppressionDynamic (line 20) | NonMaxSuppressionDynamic() = delete;
class NonMaxSuppressionDynamicCreator (line 81) | class NonMaxSuppressionDynamicCreator : public nvinfer1::IPluginCreator {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_plugin_helper.hpp
type mmcv (line 7) | namespace mmcv {
type TensorDesc (line 11) | struct TensorDesc {
function getElementSize (line 17) | inline unsigned int getElementSize(nvinfer1::DataType t) {
function getAlignedSize (line 35) | inline size_t getAlignedSize(size_t origin_size, size_t aligned_number...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_roi_align.hpp
class RoIAlignPluginDynamic (line 11) | class RoIAlignPluginDynamic : public nvinfer1::IPluginV2DynamicExt {
method RoIAlignPluginDynamic (line 20) | RoIAlignPluginDynamic() = delete;
class RoIAlignPluginDynamicCreator (line 82) | class RoIAlignPluginDynamicCreator : public nvinfer1::IPluginCreator {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_scatternd.hpp
class ONNXScatterNDDynamic (line 11) | class ONNXScatterNDDynamic : public nvinfer1::IPluginV2DynamicExt {
method ONNXScatterNDDynamic (line 17) | ONNXScatterNDDynamic() = delete;
class ONNXScatterNDDynamicCreator (line 72) | class ONNXScatterNDDynamicCreator : public nvinfer1::IPluginCreator {
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/tensorrt/trt_serialize.hpp
type Serializer (line 25) | struct Serializer {}
type Serializer<T, typename std::enable_if<std::is_arithmetic<T>::value ||
std::is_enum<T>::value ||
std::is_pod<T>::value>::type> (line 28) | struct Serializer<T, typename std::enable_if<std::is_arithmetic<T>::valu...
method serialized_size (line 31) | static size_t serialized_size(T const& value) { return sizeof(T); }
method serialize (line 32) | static void serialize(void** buffer, T const& value) {
method deserialize (line 36) | static void deserialize(void const** buffer, size_t* buffer_size, T* v...
type Serializer<const char*> (line 45) | struct Serializer<const char*> {
method serialized_size (line 46) | static size_t serialized_size(const char* value) { return strlen(value...
method serialize (line 47) | static void serialize(void** buffer, const char* value) {
method deserialize (line 51) | static void deserialize(void const** buffer, size_t* buffer_size,
type Serializer<std::vector<T>,
typename std::enable_if<std::is_arithmetic<T>::value ||
std::is_enum<T>::value ||
std::is_pod<T>::value>::type> (line 62) | struct Serializer<std::vector<T>,
method serialized_size (line 66) | static size_t serialized_size(std::vector<T> const& value) {
method serialize (line 69) | static void serialize(void** buffer, std::vector<T> const& value) {
method deserialize (line 75) | static void deserialize(void const** buffer, size_t* buffer_size,
function serialized_size (line 91) | inline size_t serialized_size(T const& value) {
function serialize_value (line 96) | inline void serialize_value(void** buffer, T const& value) {
function deserialize_value (line 101) | inline void deserialize_value(void const** buffer, size_t* buffer_size,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/deform_conv.py
class DeformConv2dFunction (line 22) | class DeformConv2dFunction(Function):
method symbolic (line 25) | def symbolic(g,
method forward (line 50) | def forward(ctx,
method backward (line 114) | def backward(ctx, grad_output):
method _output_size (line 173) | def _output_size(ctx, input, weight):
class DeformConv2d (line 192) | class DeformConv2d(nn.Module):
method __init__ (line 228) | def __init__(self,
method reset_parameters (line 269) | def reset_parameters(self):
method forward (line 276) | def forward(self, x: Tensor, offset: Tensor) -> Tensor:
method __repr__ (line 315) | def __repr__(self):
class DeformConv2dPack (line 331) | class DeformConv2dPack(DeformConv2d):
method __init__ (line 358) | def __init__(self, *args, **kwargs):
method init_offset (line 370) | def init_offset(self):
method forward (line 374) | def forward(self, x):
method _load_from_state_dict (line 380) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/deform_roi_pool.py
class DeformRoIPoolFunction (line 13) | class DeformRoIPoolFunction(Function):
method symbolic (line 16) | def symbolic(g, input, rois, offset, output_size, spatial_scale,
method forward (line 30) | def forward(ctx,
method backward (line 67) | def backward(ctx, grad_output):
class DeformRoIPool (line 92) | class DeformRoIPool(nn.Module):
method __init__ (line 94) | def __init__(self,
method forward (line 105) | def forward(self, input, rois, offset=None):
class DeformRoIPoolPack (line 111) | class DeformRoIPoolPack(DeformRoIPool):
method __init__ (line 113) | def __init__(self,
method forward (line 138) | def forward(self, input, rois):
class ModulatedDeformRoIPoolPack (line 152) | class ModulatedDeformRoIPoolPack(DeformRoIPool):
method __init__ (line 154) | def __init__(self,
method forward (line 190) | def forward(self, input, rois):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/deprecated_wrappers.py
class Conv2d_deprecated (line 9) | class Conv2d_deprecated(Conv2d):
method __init__ (line 11) | def __init__(self, *args, **kwargs):
class ConvTranspose2d_deprecated (line 19) | class ConvTranspose2d_deprecated(ConvTranspose2d):
method __init__ (line 21) | def __init__(self, *args, **kwargs):
class MaxPool2d_deprecated (line 29) | class MaxPool2d_deprecated(MaxPool2d):
method __init__ (line 31) | def __init__(self, *args, **kwargs):
class Linear_deprecated (line 39) | class Linear_deprecated(Linear):
method __init__ (line 41) | def __init__(self, *args, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/focal_loss.py
class SigmoidFocalLossFunction (line 15) | class SigmoidFocalLossFunction(Function):
method symbolic (line 18) | def symbolic(g, input, target, gamma, alpha, weight, reduction):
method forward (line 29) | def forward(ctx,
method backward (line 66) | def backward(ctx, grad_output):
class SigmoidFocalLoss (line 88) | class SigmoidFocalLoss(nn.Module):
method __init__ (line 90) | def __init__(self, gamma, alpha, weight=None, reduction='mean'):
method forward (line 97) | def forward(self, input, target):
method __repr__ (line 101) | def __repr__(self):
class SoftmaxFocalLossFunction (line 109) | class SoftmaxFocalLossFunction(Function):
method symbolic (line 112) | def symbolic(g, input, target, gamma, alpha, weight, reduction):
method forward (line 123) | def forward(ctx,
method backward (line 171) | def backward(ctx, grad_output):
class SoftmaxFocalLoss (line 194) | class SoftmaxFocalLoss(nn.Module):
method __init__ (line 196) | def __init__(self, gamma, alpha, weight=None, reduction='mean'):
method forward (line 203) | def forward(self, input, target):
method __repr__ (line 207) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/furthest_point_sample.py
class FurthestPointSampling (line 12) | class FurthestPointSampling(Function):
method forward (line 17) | def forward(ctx, points_xyz: torch.Tensor,
method backward (line 46) | def backward(xyz, a=None):
class FurthestPointSamplingWithDist (line 50) | class FurthestPointSamplingWithDist(Function):
method forward (line 55) | def forward(ctx, points_dist: torch.Tensor,
method backward (line 79) | def backward(xyz, a=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/fused_bias_leakyrelu.py
class FusedBiasLeakyReLUFunctionBackward (line 108) | class FusedBiasLeakyReLUFunctionBackward(Function):
method forward (line 116) | def forward(ctx, grad_output, out, negative_slope, scale):
method backward (line 142) | def backward(ctx, gradgrad_input, gradgrad_bias):
class FusedBiasLeakyReLUFunction (line 160) | class FusedBiasLeakyReLUFunction(Function):
method forward (line 163) | def forward(ctx, input, bias, negative_slope, scale):
method backward (line 181) | def backward(ctx, grad_output):
class FusedBiasLeakyReLU (line 190) | class FusedBiasLeakyReLU(nn.Module):
method __init__ (line 214) | def __init__(self, num_channels, negative_slope=0.2, scale=2**0.5):
method forward (line 221) | def forward(self, input):
function fused_bias_leakyrelu (line 226) | def fused_bias_leakyrelu(input, bias, negative_slope=0.2, scale=2**0.5):
function bias_leakyrelu_ref (line 259) | def bias_leakyrelu_ref(x, bias, negative_slope=0.2, scale=2**0.5):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/gather_points.py
class GatherPoints (line 10) | class GatherPoints(Function):
method forward (line 14) | def forward(ctx, features: torch.Tensor,
method backward (line 40) | def backward(ctx, grad_out):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/group_points.py
class QueryAndGroup (line 16) | class QueryAndGroup(nn.Module):
method __init__ (line 39) | def __init__(self,
method forward (line 67) | def forward(self, points_xyz, center_xyz, features=None):
class GroupAll (line 138) | class GroupAll(nn.Module):
method __init__ (line 145) | def __init__(self, use_xyz: bool = True):
method forward (line 149) | def forward(self,
class GroupingOperation (line 177) | class GroupingOperation(Function):
method forward (line 181) | def forward(ctx, features: torch.Tensor,
method backward (line 213) | def backward(ctx,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/info.py
function get_compiler_version (line 10) | def get_compiler_version():
function get_compiling_cuda_version (line 13) | def get_compiling_cuda_version():
function get_compiler_version (line 20) | def get_compiler_version():
function get_compiling_cuda_version (line 23) | def get_compiling_cuda_version():
function get_onnxruntime_op_path (line 27) | def get_onnxruntime_op_path():
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/iou3d.py
function boxes_iou_bev (line 12) | def boxes_iou_bev(boxes_a, boxes_b):
function nms_bev (line 31) | def nms_bev(boxes, scores, thresh, pre_max_size=None, post_max_size=None):
function nms_normal_bev (line 67) | def nms_normal_bev(boxes, scores, thresh):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/knn.py
class KNN (line 9) | class KNN(Function):
method forward (line 19) | def forward(ctx,
method backward (line 74) | def backward(ctx, a=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/masked_conv.py
class MaskedConv2dFunction (line 16) | class MaskedConv2dFunction(Function):
method symbolic (line 19) | def symbolic(g, features, mask, weight, bias, padding, stride):
method forward (line 30) | def forward(ctx, features, mask, weight, bias, padding=0, stride=1):
method backward (line 78) | def backward(ctx, grad_output):
class MaskedConv2d (line 85) | class MaskedConv2d(nn.Conv2d):
method __init__ (line 92) | def __init__(self,
method forward (line 105) | def forward(self, input, mask=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/merge_cells.py
class BaseMergeCell (line 11) | class BaseMergeCell(nn.Module):
method __init__ (line 43) | def __init__(self,
method _build_input_conv (line 78) | def _build_input_conv(self, channel, conv_cfg, norm_cfg):
method _binary_op (line 89) | def _binary_op(self, x1, x2):
method _resize (line 92) | def _resize(self, x, size):
method forward (line 103) | def forward(self, x1, x2, out_size=None):
class SumCell (line 121) | class SumCell(BaseMergeCell):
method __init__ (line 123) | def __init__(self, in_channels, out_channels, **kwargs):
method _binary_op (line 126) | def _binary_op(self, x1, x2):
class ConcatCell (line 130) | class ConcatCell(BaseMergeCell):
method __init__ (line 132) | def __init__(self, in_channels, out_channels, **kwargs):
method _binary_op (line 136) | def _binary_op(self, x1, x2):
class GlobalPoolingCell (line 141) | class GlobalPoolingCell(BaseMergeCell):
method __init__ (line 143) | def __init__(self, in_channels=None, out_channels=None, **kwargs):
method _binary_op (line 147) | def _binary_op(self, x1, x2):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/min_area_polygons.py
function min_area_polygons (line 7) | def min_area_polygons(pointsets):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/modulated_deform_conv.py
class ModulatedDeformConv2dFunction (line 19) | class ModulatedDeformConv2dFunction(Function):
method symbolic (line 22) | def symbolic(g, input, offset, mask, weight, bias, stride, padding,
method forward (line 37) | def forward(ctx,
method backward (line 98) | def backward(ctx, grad_output):
method _output_size (line 138) | def _output_size(ctx, input, weight):
class ModulatedDeformConv2d (line 157) | class ModulatedDeformConv2d(nn.Module):
method __init__ (line 161) | def __init__(self,
method init_weights (line 193) | def init_weights(self):
method forward (line 202) | def forward(self, x, offset, mask):
class ModulatedDeformConv2dPack (line 210) | class ModulatedDeformConv2dPack(ModulatedDeformConv2d):
method __init__ (line 229) | def __init__(self, *args, **kwargs):
method init_weights (line 241) | def init_weights(self):
method forward (line 247) | def forward(self, x):
method _load_from_state_dict (line 257) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/multi_scale_deform_attn.py
class MultiScaleDeformableAttnFunction (line 20) | class MultiScaleDeformableAttnFunction(Function):
method forward (line 23) | def forward(ctx, value, value_spatial_shapes, value_level_start_index,
method backward (line 61) | def backward(ctx, grad_output):
function multi_scale_deformable_attn_pytorch (line 92) | def multi_scale_deformable_attn_pytorch(value, value_spatial_shapes,
class MultiScaleDeformableAttention (line 153) | class MultiScaleDeformableAttention(BaseModule):
method __init__ (line 180) | def __init__(self,
method init_weights (line 228) | def init_weights(self):
method forward (line 250) | def forward(self,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/nms.py
class NMSop (line 14) | class NMSop(torch.autograd.Function):
method forward (line 17) | def forward(ctx, bboxes, scores, iou_threshold, offset, score_threshold,
method symbolic (line 36) | def symbolic(g, bboxes, scores, iou_threshold, offset, score_threshold,
class SoftNMSop (line 82) | class SoftNMSop(torch.autograd.Function):
method forward (line 85) | def forward(ctx, boxes, scores, iou_threshold, sigma, min_score, method,
method symbolic (line 100) | def symbolic(g, boxes, scores, iou_threshold, sigma, min_score, method,
function nms (line 118) | def nms(boxes, scores, iou_threshold, offset=0, score_threshold=0, max_n...
function soft_nms (line 181) | def soft_nms(boxes,
function batched_nms (line 260) | def batched_nms(boxes, scores, idxs, nms_cfg, class_agnostic=False):
function nms_match (line 358) | def nms_match(dets, iou_threshold):
function nms_rotated (line 395) | def nms_rotated(dets, scores, iou_threshold, labels=None, clockwise=True):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/pixel_group.py
function pixel_group (line 10) | def pixel_group(score, mask, embedding, kernel_label, kernel_contour,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/point_sample.py
function bilinear_grid_sample (line 12) | def bilinear_grid_sample(im, grid, align_corners=False):
function is_in_onnx_export_without_custom_ops (line 88) | def is_in_onnx_export_without_custom_ops():
function normalize (line 95) | def normalize(grid):
function denormalize (line 108) | def denormalize(grid):
function generate_grid (line 121) | def generate_grid(num_grid, size, device):
function rel_roi_point_to_abs_img_point (line 142) | def rel_roi_point_to_abs_img_point(rois, rel_roi_points):
function get_shape_from_feature_map (line 173) | def get_shape_from_feature_map(x):
function abs_img_point_to_rel_img_point (line 192) | def abs_img_point_to_rel_img_point(abs_img_points, img, spatial_scale=1.):
function rel_roi_point_to_rel_img_point (line 223) | def rel_roi_point_to_rel_img_point(rois,
function point_sample (line 250) | def point_sample(input, points, align_corners=False, **kwargs):
class SimpleRoIAlign (line 286) | class SimpleRoIAlign(nn.Module):
method __init__ (line 288) | def __init__(self, output_size, spatial_scale, aligned=True):
method forward (line 306) | def forward(self, features, rois):
method __repr__ (line 342) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/points_in_boxes.py
function points_in_boxes_part (line 11) | def points_in_boxes_part(points, boxes):
function points_in_boxes_cpu (line 59) | def points_in_boxes_cpu(points, boxes):
function points_in_boxes_all (line 97) | def points_in_boxes_all(points, boxes):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/points_in_polygons.py
function points_in_polygons (line 8) | def points_in_polygons(points, polygons):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/points_sampler.py
function calc_square_dist (line 11) | def calc_square_dist(point_feat_a, point_feat_b, norm=True):
function get_sampler_cls (line 37) | def get_sampler_cls(sampler_type):
class PointsSampler (line 60) | class PointsSampler(nn.Module):
method __init__ (line 74) | def __init__(self,
method forward (line 92) | def forward(self, points_xyz, features):
class DFPSSampler (line 134) | class DFPSSampler(nn.Module):
method __init__ (line 137) | def __init__(self):
method forward (line 140) | def forward(self, points, features, npoint):
class FFPSSampler (line 146) | class FFPSSampler(nn.Module):
method __init__ (line 149) | def __init__(self):
method forward (line 152) | def forward(self, points, features, npoint):
class FSSampler (line 163) | class FSSampler(nn.Module):
method __init__ (line 166) | def __init__(self):
method forward (line 169) | def forward(self, points, features, npoint):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/psa_mask.py
class PSAMaskFunction (line 12) | class PSAMaskFunction(Function):
method symbolic (line 15) | def symbolic(g, input, psa_type, mask_size):
method forward (line 23) | def forward(ctx, input, psa_type, mask_size):
method backward (line 48) | def backward(ctx, grad_output):
class PSAMask (line 72) | class PSAMask(nn.Module):
method __init__ (line 74) | def __init__(self, psa_type, mask_size=None):
method forward (line 85) | def forward(self, input):
method __repr__ (line 88) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/riroi_align_rotated.py
class RiRoIAlignRotatedFunction (line 11) | class RiRoIAlignRotatedFunction(Function):
method forward (line 14) | def forward(ctx,
method backward (line 57) | def backward(ctx, grad_output):
class RiRoIAlignRotated (line 92) | class RiRoIAlignRotated(nn.Module):
method __init__ (line 113) | def __init__(self,
method forward (line 127) | def forward(self, features, rois):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/roi_align.py
class RoIAlignFunction (line 14) | class RoIAlignFunction(Function):
method symbolic (line 17) | def symbolic(g, input, rois, output_size, spatial_scale, sampling_ratio,
method forward (line 64) | def forward(ctx,
method backward (line 110) | def backward(ctx, grad_output):
class RoIAlign (line 133) | class RoIAlign(nn.Module):
method __init__ (line 176) | def __init__(self,
method forward (line 192) | def forward(self, input, rois):
method __repr__ (line 215) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/roi_align_rotated.py
class RoIAlignRotatedFunction (line 11) | class RoIAlignRotatedFunction(Function):
method symbolic (line 14) | def symbolic(g, features, rois, out_size, spatial_scale, sample_num,
method forward (line 39) | def forward(ctx,
method backward (line 82) | def backward(ctx, grad_output):
class RoIAlignRotated (line 116) | class RoIAlignRotated(nn.Module):
method __init__ (line 159) | def __init__(self,
method forward (line 173) | def forward(self, features, rois):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/roi_pool.py
class RoIPoolFunction (line 14) | class RoIPoolFunction(Function):
method symbolic (line 17) | def symbolic(g, input, rois, output_size, spatial_scale):
method forward (line 26) | def forward(ctx, input, rois, output_size, spatial_scale=1.0):
method backward (line 52) | def backward(ctx, grad_output):
class RoIPool (line 71) | class RoIPool(nn.Module):
method __init__ (line 73) | def __init__(self, output_size, spatial_scale=1.0):
method forward (line 79) | def forward(self, input, rois):
method __repr__ (line 82) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/roiaware_pool3d.py
class RoIAwarePool3d (line 13) | class RoIAwarePool3d(nn.Module):
method __init__ (line 28) | def __init__(self, out_size, max_pts_per_voxel=128, mode='max'):
method forward (line 37) | def forward(self, rois, pts, pts_feature):
class RoIAwarePool3dFunction (line 55) | class RoIAwarePool3dFunction(Function):
method forward (line 58) | def forward(ctx, rois, pts, pts_feature, out_size, max_pts_per_voxel,
method backward (line 111) | def backward(ctx, grad_out):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/roipoint_pool3d.py
class RoIPointPool3d (line 9) | class RoIPointPool3d(nn.Module):
method __init__ (line 20) | def __init__(self, num_sampled_points=512):
method forward (line 24) | def forward(self, points, point_features, boxes3d):
class RoIPointPool3dFunction (line 41) | class RoIPointPool3dFunction(Function):
method forward (line 44) | def forward(ctx, points, point_features, boxes3d, num_sampled_points=5...
method backward (line 76) | def backward(ctx, grad_out):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/rotated_feature_align.py
class RotatedFeatureAlignFunction (line 13) | class RotatedFeatureAlignFunction(Function):
method forward (line 24) | def forward(ctx, features, best_rbboxes, spatial_scale, points):
method backward (line 53) | def backward(ctx, grad_output):
function rotated_feature_align (line 77) | def rotated_feature_align(features,
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/saconv.py
class SAConv2d (line 12) | class SAConv2d(ConvAWS2d):
method __init__ (line 38) | def __init__(self,
method init_weights (line 82) | def init_weights(self):
method forward (line 91) | def forward(self, x):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/scatter_points.py
class _DynamicScatter (line 14) | class _DynamicScatter(Function):
method forward (line 17) | def forward(ctx, feats, coors, reduce_type='max'):
method backward (line 45) | def backward(ctx, grad_voxel_feats, grad_voxel_coors=None):
class DynamicScatter (line 60) | class DynamicScatter(nn.Module):
method __init__ (line 76) | def __init__(self, voxel_size, point_cloud_range, average_points: bool):
method forward_single (line 83) | def forward_single(self, points, coors):
method forward (line 100) | def forward(self, points, coors):
method __repr__ (line 131) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/sync_bn.py
class SyncBatchNormFunction (line 19) | class SyncBatchNormFunction(Function):
method symbolic (line 22) | def symbolic(g, input, running_mean, running_var, weight, bias, momentum,
method forward (line 38) | def forward(self, input, running_mean, running_var, weight, bias, mome...
method backward (line 129) | def backward(self, grad_output):
class SyncBatchNorm (line 159) | class SyncBatchNorm(Module):
method __init__ (line 193) | def __init__(self,
method reset_running_stats (line 230) | def reset_running_stats(self):
method reset_parameters (line 236) | def reset_parameters(self):
method forward (line 242) | def forward(self, input):
method __repr__ (line 270) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/three_interpolate.py
class ThreeInterpolate (line 12) | class ThreeInterpolate(Function):
method forward (line 20) | def forward(ctx, features: torch.Tensor, indices: torch.Tensor,
method backward (line 48) | def backward(
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/three_nn.py
class ThreeNN (line 11) | class ThreeNN(Function):
method forward (line 19) | def forward(ctx, target: torch.Tensor,
method backward (line 47) | def backward(ctx, a=None, b=None):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/tin_shift.py
class TINShiftFunction (line 17) | class TINShiftFunction(Function):
method forward (line 20) | def forward(ctx, input, shift):
method backward (line 35) | def backward(ctx, grad_output):
class TINShift (line 48) | class TINShift(nn.Module):
method forward (line 60) | def forward(self, input, shift):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/upfirdn2d.py
class UpFirDn2dBackward (line 108) | class UpFirDn2dBackward(Function):
method forward (line 111) | def forward(ctx, grad_output, kernel, grad_kernel, up, down, pad, g_pad,
method backward (line 152) | def backward(ctx, gradgrad_input):
class UpFirDn2d (line 177) | class UpFirDn2d(Function):
method forward (line 180) | def forward(ctx, input, kernel, up, down, pad):
method backward (line 225) | def backward(ctx, grad_output):
function upfirdn2d (line 243) | def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)):
function upfirdn2d_native (line 290) | def upfirdn2d_native(input, kernel, up_x, up_y, down_x, down_y, pad_x0, ...
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/voxelize.py
class _Voxelization (line 13) | class _Voxelization(Function):
method forward (line 16) | def forward(ctx,
class Voxelization (line 83) | class Voxelization(nn.Module):
method __init__ (line 101) | def __init__(self,
method forward (line 128) | def forward(self, input):
method __repr__ (line 137) | def __repr__(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/parallel/_functions.py
function scatter (line 6) | def scatter(input, devices, streams=None):
function synchronize_stream (line 31) | def synchronize_stream(output, devices, streams):
function get_input_device (line 48) | def get_input_device(input):
class Scatter (line 61) | class Scatter:
method forward (line 64) | def forward(target_gpus, input):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/parallel/collate.py
function collate (line 11) | def collate(batch, samples_per_gpu=1):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/parallel/data_container.py
function assert_tensor_type (line 7) | def assert_tensor_type(func):
class DataContainer (line 20) | class DataContainer:
method __init__ (line 37) | def __init__(self,
method __repr__ (line 50) | def __repr__(self):
method __len__ (line 53) | def __len__(self):
method data (line 57) | def data(self):
method datatype (line 61) | def datatype(self):
method cpu_only (line 68) | def cpu_only(self):
method stack (line 72) | def stack(self):
method padding_value (line 76) | def padding_value(self):
method pad_dims (line 80) | def pad_dims(self):
method size (line 84) | def size(self, *args, **kwargs):
method dim (line 88) | def dim(self):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/parallel/data_parallel.py
class MMDataParallel (line 9) | class MMDataParallel(DataParallel):
method __init__ (line 34) | def __init__(self, *args, dim=0, **kwargs):
method forward (line 41) | def forward(self, *inputs, **kwargs):
method scatter (line 55) | def scatter(self, inputs, kwargs, device_ids):
method train_step (line 58) | def train_step(self, *inputs, **kwargs):
method val_step (line 80) | def val_step(self, *inputs, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/parallel/distributed.py
class MMDistributedDataParallel (line 11) | class MMDistributedDataParallel(DistributedDataParallel):
method to_kwargs (line 21) | def to_kwargs(self, inputs, kwargs, device_id):
method scatter (line 26) | def scatter(self, inputs, kwargs, device_ids):
method train_step (line 29) | def train_step(self, *inputs, **kwargs):
method val_step (line 72) | def val_step(self, *inputs, **kwargs):
FILE: 01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/parallel/distributed_deprecated.py
class MMDistributedDataParallel (line 14) | class MMDistributedDataParallel(nn.Module):
method __init__ (line 16) | def __init__(self,
method _dist_broadcast_coalesced (line 29) | def _dist_broadcast_coalesced(self, tensors, buffer_size):
method _sync_params (line 37) | def _sync_params(self):
method scatter (line 52) | def scatter(self, inputs, kwargs, device_ids):
method forward (line 55) | def forward(self, *inputs, **kw
Condensed preview — 1396 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (6,369K chars).
[
{
"path": ".gitignore",
"chars": 109,
"preview": "*.log\n*.pyc\n*.xml\n*.json\n*.mat\n*.eps\n*.cpython-37.pyc\n/DLPan-Toolbox/01-DL-toolbox(Pytorch)/results/*\n/bak/*\n"
},
{
"path": "01-DL-toolbox(Pytorch)/LICENSE",
"chars": 18072,
"preview": "GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundati"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/AutoDL/__init__.py",
"chars": 739,
"preview": "# GPL License\n# Copyright (C) 2021 , UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nfrom"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/AutoDL/trainer.py",
"chars": 9632,
"preview": "# GPL License\n# Copyright (C) UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nimport argp"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/__init__.py",
"chars": 134,
"preview": "from ..auxiliary.utils import AverageMeter, accuracy, MetricLogger, SmoothedValue, set_random_seed, init_random_seed, sh"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/base.py",
"chars": 1058,
"preview": "from nvidia.dali.plugin.pytorch import DALIGenericIterator\n\n\nclass DALIDataloader(DALIGenericIterator):\n def __init__"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/fp16_utils.py",
"chars": 7127,
"preview": "import torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nfrom torch._utils import _flatten_dense_tensors, "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/__init__.py",
"chars": 650,
"preview": "__copyright__ = 'Copyright (C) 2018 Swall0w'\n__version__ = '0.0.7'\n__author__ = 'Swall0w'\n__url__ = 'https://github.com/"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/__main__.py",
"chars": 1108,
"preview": "from torchstat import stat\nimport argparse\nimport importlib.util\nimport torch\n\n\ndef arg():\n parser = argparse.Argumen"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_flops.py",
"chars": 9022,
"preview": "import torch.nn as nn\nimport torch\nimport numpy as np\nimport inspect\n\n\ndef compute_flops(module, inp, out):\n # print("
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_madd.py",
"chars": 5898,
"preview": "\"\"\"\ncompute Multiply-Adds(MAdd) of each leaf module\n\"\"\"\n\nimport torch.nn as nn\n\n\ndef compute_Conv2d_madd(module, inp, ou"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/compute_memory.py",
"chars": 3904,
"preview": "import torch.nn as nn\nimport torch\nimport numpy as np\n\n\ndef compute_memory(module, inp, out):\n if isinstance(module, "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/model_hook.py",
"chars": 9869,
"preview": "import time\nfrom collections import OrderedDict\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom functools imp"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/reporter.py",
"chars": 3668,
"preview": "import pandas as pd\n\n\npd.set_option('display.width', 1000)\npd.set_option('display.max_rows', 10000)\npd.set_option('displ"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/stat_tree.py",
"chars": 5697,
"preview": "import queue\n\n\nclass StatTree(object):\n def __init__(self, root_node):\n assert isinstance(root_node, StatNode)"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/torchstat/statistics.py",
"chars": 3290,
"preview": "import torch\nimport torch.nn as nn\nfrom torchstat import ModelHook\nfrom collections import OrderedDict\nfrom torchstat im"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/auxiliary/utils.py",
"chars": 11586,
"preview": "import os\nimport datetime\nimport torch\nimport psutil\nfrom collections import defaultdict, deque\nimport time\nimport sys\ns"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/cal_ssim.py",
"chars": 2885,
"preview": "# GPL License\n# Copyright (C) UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nimport torc"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/config.py",
"chars": 28265,
"preview": "# Copyright (c) Open-MMLab. All rights reserved.\n# GPL License\n# Copyright (C) UESTC\n# All Rights Reserved\n# @Author : "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/criterion_metrics.py",
"chars": 4022,
"preview": "# GPL License\n# Copyright (C) 2021 , UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nfrom"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/dist_utils.py",
"chars": 6443,
"preview": "import os\nimport subprocess\nimport torch\nfrom torch import nn\nimport torch.multiprocessing as mp\nfrom torch import distr"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/kill_dist.sh",
"chars": 67,
"preview": "kill -9 $(ps aux | grep main.py | grep -v grep | awk '{print $2}')\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/launch.py",
"chars": 14583,
"preview": "r\"\"\"\n`torch.distributed.launch` is a module that spawns up multiple distributed\ntraining processes on each of the traini"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/logger.py",
"chars": 8508,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n# GPL License\n# Copyright (C) 2021 , UESTC\n# All Rights Reserved\n# @Auth"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/metrics.py",
"chars": 3054,
"preview": "# GPL License\n# Copyright (C) 2021 , UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nimpo"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/optim.py",
"chars": 9023,
"preview": "import torch\nfrom torch import nn\nimport torch.optim as optim\nimport matplotlib.pyplot as plt\n\n\nclass lr_scheduler(objec"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/option.py",
"chars": 7051,
"preview": "# GPL License\n# Copyright (C) UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nimport argp"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/postprocess.py",
"chars": 15828,
"preview": "# GPL License\n# Copyright (C) UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nfrom typing"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/python_sub_class.py",
"chars": 7197,
"preview": "# GPL License\n# Copyright (C) UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nimport torc"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/slurm_train.sh",
"chars": 1104,
"preview": "#!/usr/bin/env bash\n\nset -x\n\n#cd projects/derain\n\nPARTITION=defq\nJOB_NAME=task\n#CONFIG=$3\n#WORK_DIR=$4\nGPUS=${GPUS:-16}\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/snmn_d.sh",
"chars": 64,
"preview": "python -m launch --nproc_per_node 8 --master_port 27890 main.py\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Basis/variance_sacling_initializer.py",
"chars": 3088,
"preview": "# GPL License\n# Copyright (C) 2021 , UESTC\n# All Rights Reserved\n# @Author : Xiao Wu, LiangJian Deng\n# @reference:\nimpo"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Data/pansharpening/test_data/readme-test.txt",
"chars": 0,
"preview": ""
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Data/pansharpening/training_data/readme-test.txt",
"chars": 0,
"preview": ""
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/Data/pansharpening/validation_data/readme-test.txt",
"chars": 0,
"preview": ""
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/CITATION.cff",
"chars": 254,
"preview": "cff-version: 1.2.0\nmessage: \"If you use this software, please cite it as below.\"\nauthors:\n - name: \"MMCV Contributors\"\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/CONTRIBUTING.md",
"chars": 2574,
"preview": "## Contributing to OpenMMLab\n\nAll kinds of contributions are welcome, including but not limited to the following.\n\n- Fix"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/Dockerfile",
"chars": 67,
"preview": "FROM python:3.7\n\nWORKDIR /mmcv\n\nCOPY . /mmcv\n\nRUN pip install -e .\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/Jenkinsfile",
"chars": 2279,
"preview": "def docker_images = [\"registry.cn-hangzhou.aliyuncs.com/sensetime/openmmlab:cuda10.1-cudnn7-devel-ubuntu18.04-py37-pt1.3"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/LICENSE",
"chars": 11413,
"preview": "Copyright (c) OpenMMLab. All rights reserved\n\n Apache License\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/LICENSES.md",
"chars": 983,
"preview": "# Licenses for special operations\n\nIn this file, we list the operations with other licenses instead of Apache 2.0. Users"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/MANIFEST.in",
"chars": 423,
"preview": "include requirements/runtime.txt\ninclude mmcv/model_zoo/open_mmlab.json mmcv/model_zoo/deprecated.json mmcv/model_zoo/mm"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/README_zh-CN.md",
"chars": 12733,
"preview": "<div align=\"center\">\n <img src=\"https://raw.githubusercontent.com/open-mmlab/mmcv/master/docs/en/mmcv-logo.png\" width=\""
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/TERMINOLOGY.md",
"chars": 621,
"preview": "# English-Chinese terminology comparison (英汉术语对照)\n\nThis document is used as a reference for English-Chinese terminology "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/Makefile",
"chars": 581,
"preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHI"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/_static/css/readthedocs.css",
"chars": 137,
"preview": ".header-logo {\n background-image: url(\"../image/mmcv-logo.png\");\n background-size: 85px 40px;\n height: 40px;\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/api.rst",
"chars": 580,
"preview": "fileio\n-------\n.. automodule:: mmcv.fileio\n :members:\n\nimage\n------\n.. automodule:: mmcv.image\n :members:\n\nvideo\n-"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/community/pr.md",
"chars": 3658,
"preview": "## Pull Request (PR)\n\n### What is PR\n\n`PR` is the abbreviation of `Pull Request`. Here's the definition of `PR` in the ["
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/compatibility.md",
"chars": 5536,
"preview": "### v1.3.18\n\nSome ops have different implementations on different devices. Lots of macros and type checks are scattered "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/conf.py",
"chars": 6269,
"preview": "#\n# Configuration file for the Sphinx documentation builder.\n#\n# This file does only contain a selection of the most com"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/deployment/mmcv_ops_definition.md",
"chars": 27455,
"preview": "# MMCV Operators\n\nTo make custom operators in MMCV more standard, precise definitions of each operator are listed in thi"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/deployment/onnx.md",
"chars": 422,
"preview": "## Introduction of mmcv.onnx module\n\n### register_extra_symbolics\n\nSome extra symbolic functions need to be registered b"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/deployment/onnxruntime_custom_ops.md",
"chars": 16290,
"preview": "## ONNX Runtime Custom Ops\n\n<!-- TOC -->\n\n- [ONNX Runtime Custom Ops](#onnx-runtime-custom-ops)\n - [SoftNMS](#softnms)\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/deployment/onnxruntime_op.md",
"chars": 5340,
"preview": "## ONNX Runtime Deployment\n\n### Introduction of ONNX Runtime\n\n**ONNX Runtime** is a cross-platform inferencing and train"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/deployment/tensorrt_custom_ops.md",
"chars": 16973,
"preview": "## TensorRT Custom Ops\n\n<!-- TOC -->\n\n- [TensorRT Custom Ops](#tensorrt-custom-ops)\n - [MMCVRoIAlign](#mmcvroialign)\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/deployment/tensorrt_plugin.md",
"chars": 7165,
"preview": "## TensorRT Deployment\n\n<!-- TOC -->\n\n- [TensorRT Deployment](#tensorrt-deployment)\n - [Introduction](#introduction)\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/faq.md",
"chars": 7600,
"preview": "## Frequently Asked Questions\n\nWe list some common troubles faced by many users and their corresponding solutions here.\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/get_started/build.md",
"chars": 7300,
"preview": "## Build MMCV from source\n\n### Build on Linux or macOS\n\nAfter cloning the repo with\n\n```bash\ngit clone https://github.co"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/get_started/installation.md",
"chars": 10605,
"preview": "## Installation\n\nThere are two versions of MMCV:\n\n- **mmcv-full**: comprehensive, with full features and various CUDA op"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/get_started/introduction.md",
"chars": 2313,
"preview": "## Introduction\n\nMMCV is a foundational library for computer vision research and supports many\nresearch projects as belo"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/get_started/previous_versions.md",
"chars": 1107,
"preview": "## OTHER VERSIONS OF PYTORCH BUILT FOR MMCV-FULL\n\nWe no longer provide `mmcv-full` packages compiled under lower version"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/index.rst",
"chars": 1187,
"preview": "Welcome to MMCV's documentation!\n================================\n\nYou can switch between Chinese and English documents "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/make.bat",
"chars": 752,
"preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/cnn.md",
"chars": 20041,
"preview": "## CNN\n\nWe provide some building bricks for CNNs, including layer building, module bundles and weight initialization.\n\n#"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/config.md",
"chars": 4490,
"preview": "## Config\n\n`Config` class is used for manipulating config and config files. It supports\nloading configs from multiple fi"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/data_process.md",
"chars": 7251,
"preview": "## Data Process\n\n### Image\n\nThis module provides some image processing methods, which requires `opencv` to be installed."
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/io.md",
"chars": 6718,
"preview": "## File IO\n\nThis module provides two universal API to load and dump files of different formats.\n\n```{note}\nSince v1.3.16"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/ops.md",
"chars": 734,
"preview": "## CUDA ops\n\nWe implement common CUDA ops used in detection, segmentation, etc.\n\n- ActiveRotatedFilter\n- AssignScoreWith"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/registry.md",
"chars": 6575,
"preview": "## Registry\n\nMMCV implements [registry](https://github.com/open-mmlab/mmcv/blob/master/mmcv/utils/registry.py) to manage"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/runner.md",
"chars": 7511,
"preview": "## Runner\n\nThe runner class is designed to manage the training. It eases the training process with less code demanded fr"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/utils.md",
"chars": 1611,
"preview": "## Utils\n\n### ProgressBar\n\nIf you want to apply a method to a list of items and track the progress, `track_progress`\nis "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/en/understand_mmcv/visualization.md",
"chars": 527,
"preview": "## Visualization\n\n`mmcv` can show images and annotations (currently supported types include bounding boxes).\n\n```python\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/Makefile",
"chars": 581,
"preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHI"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/_static/css/readthedocs.css",
"chars": 137,
"preview": ".header-logo {\n background-image: url(\"../image/mmcv-logo.png\");\n background-size: 85px 40px;\n height: 40px;\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/api.rst",
"chars": 580,
"preview": "fileio\n-------\n.. automodule:: mmcv.fileio\n :members:\n\nimage\n------\n.. automodule:: mmcv.image\n :members:\n\nvideo\n-"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/community/contributing.md",
"chars": 1756,
"preview": "## 贡献代码\n\n欢迎任何类型的贡献，包括但不限于\n\n- 修改拼写错误或代码错误\n- 添加文档或将文档翻译成其他语言\n- 添加新功能和新组件\n\n### 工作流\n| 详细工作流见 [拉取请求](pr.md)\n1. 复刻并拉取最新的 OpenM"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/community/pr.md",
"chars": 2117,
"preview": "## 拉取请求\n\n### 什么是拉取请求？\n\n`拉取请求` (Pull Request), [GitHub 官方文档](https://docs.github.com/en/github/collaborating-with-pull-re"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/compatibility.md",
"chars": 5088,
"preview": "### v1.3.18\n\n部分自定义算子对于不同的设备有不同实现，为此添加的大量宏命令与类型检查使得代码变得难以维护。例如：\n\n```c++\n if (input.device().is_cuda()) {\n#ifdef MMCV_WIT"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/conf.py",
"chars": 6347,
"preview": "#\n# Configuration file for the Sphinx documentation builder.\n#\n# This file does only contain a selection of the most com"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/deployment/onnx.md",
"chars": 245,
"preview": "## MMCV中ONNX模块简介 (实验性)\n\n### register_extra_symbolics\n\n在将PyTorch模型导出成ONNX时，需要注册额外的符号函数\n\n#### 范例\n\n```python\nimport mmcv\nfr"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/deployment/onnxruntime_custom_ops.md",
"chars": 8693,
"preview": "## ONNX Runtime自定义算子\n\n<!-- TOC -->\n\n- [ONNX Runtime自定义算子](#onnx-runtime自定义算子)\n - [SoftNMS](#softnms)\n - [描述](#描述)\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/deployment/onnxruntime_op.md",
"chars": 4278,
"preview": "## MMCV中的ONNX Runtime自定义算子\n\n### ONNX Runtime介绍\n\n**ONNX Runtime**是一个跨平台的推理与训练加速器，适配许多常用的机器学习/深度神经网络框架。请访问[github](https:/"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/deployment/tensorrt_custom_ops.md",
"chars": 11146,
"preview": "## TensorRT自定义算子\n\n<!-- TOC -->\n\n- [TensorRT自定义算子](#tensorrt自定义算子)\n - [MMCVRoIAlign](#mmcvroialign)\n - [描述](#描述)\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/deployment/tensorrt_plugin.md",
"chars": 5662,
"preview": "## MMCV中的TensorRT自定义算子 (实验性)\n\n<!-- TOC -->\n\n- [MMCV中的TensorRT自定义算子 (实验性)](#mmcv中的tensorrt自定义算子-实验性)\n - [介绍](#介绍)\n - [M"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/faq.md",
"chars": 5283,
"preview": "## 常见问题\n\n在这里我们列出了用户经常遇到的问题以及对应的解决方法。如果您遇到了其他常见的问题，并且知道可以帮到大家的解决办法，\n欢迎随时丰富这个列表。\n\n### 安装问题\n\n- KeyError: \"xxx: 'yyy is not "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/get_started/build.md",
"chars": 5141,
"preview": "## 从源码编译 MMCV\n\n### 在 Linux 或者 macOS 上编译 MMCV\n\n克隆算法库\n\n```bash\ngit clone https://github.com/open-mmlab/mmcv.git\ncd mmcv\n``"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/get_started/installation.md",
"chars": 9112,
"preview": "## 安装 MMCV\n\nMMCV 有两个版本：\n\n- **mmcv-full**: 完整版，包含所有的特性以及丰富的开箱即用的 CUDA 算子。注意完整版本可能需要更长时间来编译。\n- **mmcv**: 精简版，不包含 CUDA 算子但包"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/get_started/introduction.md",
"chars": 1624,
"preview": "## 介绍 MMCV\n\nMMCV 是一个面向计算机视觉的基础库，它支持了很多开源项目，例如：\n\n- [MIM](https://github.com/open-mmlab/mim): OpenMMLab 项目、算法、模型的统一入口\n- [M"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/get_started/previous_versions.md",
"chars": 1001,
"preview": "\n## 其他版本的 PyTorch\n\n我们不再提供在较低的 `PyTorch` 版本下编译的 `mmcv-full` 包，但为了您的方便，您可以在下面找到它们。\n\n### PyTorch 1.4\n\n| 1.0.0 <= mmcv_versi"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/index.rst",
"chars": 1091,
"preview": "欢迎来到 MMCV 的中文文档！\n=============================\n\n您可以在页面左下角切换中英文文档。\n\n.. toctree::\n :maxdepth: 2\n :caption: 介绍与安装\n\n g"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/make.bat",
"chars": 752,
"preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/cnn.md",
"chars": 17109,
"preview": "## 卷积神经网络\n\n我们为卷积神经网络提供了一些构建模块，包括层构建、模块组件和权重初始化。\n\n### 网络层的构建\n\n在运行实验时，我们可能需要尝试同属一种类型但不同配置的层，但又不希望每次都修改代码。于是我们提供一些层构建方法，可以从"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/config.md",
"chars": 2896,
"preview": "## 配置\n\n`Config` 类用于操作配置文件，它支持从多种文件格式中加载配置，包括 **python**, **json** 和 **yaml**。\n它提供了类似字典对象的接口来获取和设置值。\n\n以配置文件 `test.py` 为例\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/data_process.md",
"chars": 4983,
"preview": "## 数据处理\n\n### 图像\n\n图像模块提供了一些图像预处理的函数，该模块依赖 `opencv` 。\n\n#### 读取/保存/显示\n\n使用 `imread` 和 `imwrite` 函数可以读取和保存图像。\n\n```python\nimpo"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/io.md",
"chars": 5407,
"preview": "## 文件输入输出\n\n文件输入输出模块提供了两个通用的 API 接口用于读取和保存不同格式的文件。\n\n```{note}\n在 v1.3.16 及之后的版本中，IO 模块支持从不同后端读取数据并支持将数据至不同后端。更多细节请访问 PR [#"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/ops.md",
"chars": 681,
"preview": "## CUDA 算子\n\nMMCV 提供了检测、分割等任务中常用的 CUDA 算子\n\n- ActiveRotatedFilter\n- AssignScoreWithK\n- BallQuery\n- BBoxOverlaps\n- CARAFE\n-"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/registry.md",
"chars": 4521,
"preview": "## 注册器\nMMCV 使用 [注册器](https://github.com/open-mmlab/mmcv/blob/master/mmcv/utils/registry.py) 来管理具有相似功能的不同模块, 例如, 检测器中的主干网"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/runner.md",
"chars": 4467,
"preview": "## 执行器\n\n执行器模块负责模型训练过程调度，主要目的是让用户使用更少的代码以及灵活可配置方式开启训练。其具备如下核心特性:\n\n- 支持以 `EpochBasedRunner` 和 `IterBasedRunner` 为单位的迭代模式以满"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/utils.md",
"chars": 1176,
"preview": "## 辅助函数\n\n### 进度条\n\n如果你想跟踪函数批处理任务的进度，可以使用 `track_progress` 。它能以进度条的形式展示任务的完成情况以及剩余任务所需的时间（内部实现为for循环）。\n\n```python\nimport m"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/docs/zh_cn/understand_mmcv/visualization.md",
"chars": 370,
"preview": "## 可视化\n\n`mmcv` 可以展示图像以及标注（目前只支持标注框）\n\n```python\n# 展示图像文件\nmmcv.imshow('a.jpg')\n\n# 展示已加载的图像\nimg = np.random.rand(100, 100, "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/examples/train.py",
"chars": 2813,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport torchvision.transf"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/__init__.py",
"chars": 352,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n# flake8: noqa\nfrom .arraymisc import *\nfrom .fileio import *\nfrom .imag"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/arraymisc/__init__.py",
"chars": 133,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .quantization import dequantize, quantize\n\n__all__ = ['quantize', '"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/arraymisc/quantization.py",
"chars": 1824,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport numpy as np\n\n\ndef quantize(arr, min_val, max_val, levels, dtype=n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/__init__.py",
"chars": 2438,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .alexnet import AlexNet\n# yapf: disable\nfrom .bricks import (ACTIVA"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/alexnet.py",
"chars": 1990,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport logging\n\nimport torch.nn as nn\n\n\nclass AlexNet(nn.Module):\n \"\""
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/__init__.py",
"chars": 1732,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .activation import build_activation_layer\nfrom .context_block impor"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/activation.py",
"chars": 2489,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/context_block.py",
"chars": 4681,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nfrom torch import nn\n\nfrom ..utils import constant_init, ka"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv.py",
"chars": 1446,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom torch import nn\n\nfrom .registry import CONV_LAYERS\n\nCONV_LAYERS.reg"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv2d_adaptive_padding.py",
"chars": 2514,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport math\n\nfrom torch import nn\nfrom torch.nn import functional as F\n\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv_module.py",
"chars": 8740,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport warnings\n\nimport torch.nn as nn\n\nfrom mmcv.utils import _BatchNor"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/conv_ws.py",
"chars": 5417,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/depthwise_separable_conv_module.py",
"chars": 4142,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch.nn as nn\n\nfrom .conv_module import ConvModule\n\n\nclass Depth"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/drop.py",
"chars": 2152,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\n\nfrom mmcv import build_from_cfg\nfrom"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/generalized_attention.py",
"chars": 15996,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport math\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimpor"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/hsigmoid.py",
"chars": 1546,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport warnings\n\nimport torch.nn as nn\n\nfrom .registry import ACTIVATION"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/hswish.py",
"chars": 651,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch.nn as nn\n\nfrom .registry import ACTIVATION_LAYERS\n\n\n@ACTIVA"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/non_local.py",
"chars": 11012,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom abc import ABCMeta\n\nimport torch\nimport torch.nn as nn\n\nfrom ..util"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/norm.py",
"chars": 5111,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport inspect\n\nimport torch.nn as nn\n\nfrom mmcv.utils import is_tuple_o"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/padding.py",
"chars": 1127,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch.nn as nn\n\nfrom .registry import PADDING_LAYERS\n\nPADDING_LAY"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/plugin.py",
"chars": 2505,
"preview": "import inspect\nimport platform\n\nfrom .registry import PLUGIN_LAYERS\n\nif platform.system() == 'Windows':\n import regex"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/registry.py",
"chars": 638,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom mmcv.utils import Registry\n\nCONV_LAYERS = Registry('conv layer')\nNO"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/scale.py",
"chars": 577,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\n\n\nclass Scale(nn.Module):\n \"\"\"A le"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/swish.py",
"chars": 485,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\n\nfrom .registry import ACTIVATION_LAY"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/transformer.py",
"chars": 37145,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport copy\nimport math\nimport warnings\nfrom typing import Sequence\n\nimp"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/upsample.py",
"chars": 2878,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ..utils impo"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/bricks/wrappers.py",
"chars": 6961,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nr\"\"\"Modified from https://github.com/facebookresearch/detectron2/blob/ma"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/builder.py",
"chars": 1089,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom ..runner import Sequential\nfrom ..utils import Registry, build_from"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/resnet.py",
"chars": 9955,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport logging\n\nimport torch.nn as nn\nimport torch.utils.checkpoint as c"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/__init__.py",
"chars": 1023,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .flops_counter import get_model_complexity_info\nfrom .fuse_conv_bn "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/flops_counter.py",
"chars": 22079,
"preview": "# Modified from flops-counter.pytorch by Vladislav Sovrasov\n# original repo: https://github.com/sovrasov/flops-counter.p"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/fuse_conv_bn.py",
"chars": 1881,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\n\n\ndef _fuse_conv_bn(conv, bn):\n \"\""
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/sync_bn.py",
"chars": 2299,
"preview": "import torch\n\nimport mmcv\n\n\nclass _BatchNormXd(torch.nn.modules.batchnorm._BatchNorm):\n \"\"\"A general BatchNorm layer "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/utils/weight_init.py",
"chars": 25961,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport copy\nimport math\nimport warnings\n\nimport numpy as np\nimport torch"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/cnn/vgg.py",
"chars": 6053,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport logging\n\nimport torch.nn as nn\n\nfrom .utils import constant_init,"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/engine/__init__.py",
"chars": 266,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .test import (collect_results_cpu, collect_results_gpu, multi_gpu_t"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/engine/test.py",
"chars": 7148,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport os.path as osp\nimport pickle\nimport shutil\nimport tempfile\nimport"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/__init__.py",
"chars": 478,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .file_client import BaseStorageBackend, FileClient\nfrom .handlers i"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/file_client.py",
"chars": 41865,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport inspect\nimport os\nimport os.path as osp\nimport re\nimport tempfile"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/__init__.py",
"chars": 278,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .base import BaseFileHandler\nfrom .json_handler import JsonHandler\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/base.py",
"chars": 993,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom abc import ABCMeta, abstractmethod\n\n\nclass BaseFileHandler(metaclas"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/json_handler.py",
"chars": 1068,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport json\n\nimport numpy as np\n\nfrom .base import BaseFileHandler\n\n\ndef"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/pickle_handler.py",
"chars": 817,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport pickle\n\nfrom .base import BaseFileHandler\n\n\nclass PickleHandler(B"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/handlers/yaml_handler.py",
"chars": 665,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport yaml\n\ntry:\n from yaml import CLoader as Loader, CDumper as Dum"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/io.py",
"chars": 5520,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom io import BytesIO, StringIO\nfrom pathlib import Path\n\nfrom ..utils "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/fileio/parse.py",
"chars": 3458,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n\nfrom io import StringIO\n\nfrom .file_client import FileClient\n\n\ndef list"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/__init__.py",
"chars": 1725,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .colorspace import (bgr2gray, bgr2hls, bgr2hsv, bgr2rgb, bgr2ycbcr,"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/colorspace.py",
"chars": 9891,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport cv2\nimport numpy as np\n\n\ndef imconvert(img, src, dst):\n \"\"\"Con"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/geometric.py",
"chars": 25170,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport numbers\n\nimport cv2\nimport numpy as np\n\nfrom ..utils import to_2t"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/io.py",
"chars": 11645,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport io\nimport os.path as osp\nimport warnings\nfrom pathlib import Path"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/misc.py",
"chars": 1934,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport numpy as np\n\nimport mmcv\n\ntry:\n import torch\nexcept ImportErro"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/image/photometric.py",
"chars": 14999,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport cv2\nimport numpy as np\n\nfrom ..utils import is_tuple_of\nfrom .col"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/__init__.py",
"chars": 196,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .info import is_custom_op_loaded\nfrom .symbolic import register_ext"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/info.py",
"chars": 590,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport os\n\nimport torch\n\n\ndef is_custom_op_loaded():\n flag = False\n "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/onnx_utils/__init__.py",
"chars": 48,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/onnx_utils/symbolic_helper.py",
"chars": 11172,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n\"\"\"Modified from https://github.com/pytorch/pytorch.\"\"\"\nimport warnings\n"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/onnx/symbolic.py",
"chars": 19124,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n\"\"\"Modified from https://github.com/pytorch/pytorch.\"\"\"\nimport os\n\nimpor"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/__init__.py",
"chars": 5018,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom .active_rotated_filter import active_rotated_filter\nfrom .assign_sc"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/active_rotated_filter.py",
"chars": 2101,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nfrom torch.autograd import Function\nfrom torch.autograd.fun"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/assign_score_withk.py",
"chars": 4552,
"preview": "from torch.autograd import Function\n\nfrom ..utils import ext_loader\n\next_module = ext_loader.load_ext(\n '_ext', ['ass"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/ball_query.py",
"chars": 1719,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nfrom torch.autograd import Function\n\nfrom ..utils import ex"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/bbox.py",
"chars": 2591,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom ..utils import ext_loader\n\next_module = ext_loader.load_ext('_ext',"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/border_align.py",
"chars": 3703,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\n# modified from\n# https://github.com/Megvii-BaseDetection/cvpods/blob/ma"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/box_iou_rotated.py",
"chars": 5173,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom ..utils import ext_loader\n\next_module = ext_loader.load_ext('_ext',"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/carafe.py",
"chars": 9899,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/cc_attention.py",
"chars": 3046,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/contour_expand.py",
"chars": 1794,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport numpy as np\nimport torch\n\nfrom ..utils import ext_loader\n\next_mod"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/convex_iou.py",
"chars": 1673,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nfrom ..utils import ext_loader\n\next_module = ext_loader.load_ext('_ext',"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/corner_pool.py",
"chars": 4757,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nfrom torch import nn\nfrom torch.autograd import Function\n\nf"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/correlation.py",
"chars": 6697,
"preview": "# Copyright (c) OpenMMLab. All rights reserved.\nimport torch\nfrom torch import Tensor, nn\nfrom torch.autograd import Fun"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/README.md",
"chars": 5170,
"preview": "# Code Structure of CUDA operators\n\nThis folder contains all non-python code for MMCV custom ops. Please follow the same"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/box_iou_rotated_utils.hpp",
"chars": 10273,
"preview": "// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n// modified from\n// https://github.com/facebookr"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/active_rotated_filter_cuda_kernel.cuh",
"chars": 2227,
"preview": "// Copyright (c) OpenMMLab. All rights reserved.\n// Modified from\n// https://github.com/csuhan/s2anet/blob/master/mmdet/"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/assign_score_withk_cuda_kernel.cuh",
"chars": 4594,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef ASSIGN_SCORE_WITHK_CUDA_KERNEL_CUH\n#define ASSIGN_SCORE_WITHK_CU"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/ball_query_cuda_kernel.cuh",
"chars": 1746,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n// Modified from\n// https://github.com/sshaoshuai/Pointnet2.PyTorch/tree"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/bbox_overlaps_cuda_kernel.cuh",
"chars": 2804,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef BBOX_OVERLAPS_CUDA_KERNEL_CUH\n#define BBOX_OVERLAPS_CUDA_KERNEL_"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/border_align_cuda_kernel.cuh",
"chars": 6913,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n// modified from\n// https://github.com/Megvii-BaseDetection/cvpods/blob/"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/box_iou_rotated_cuda.cuh",
"chars": 2459,
"preview": "// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n// modified from\n// https://github.com/facebookr"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/carafe_cuda_kernel.cuh",
"chars": 12426,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef CARAFE_CUDA_KERNEL_CUH\n#define CARAFE_CUDA_KERNEL_CUH\n\n#ifdef MM"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/carafe_naive_cuda_kernel.cuh",
"chars": 4363,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef CARAFE_NAIVE_CUDA_KERNEL_CUH\n#define CARAFE_NAIVE_CUDA_KERNEL_CU"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/common_cuda_helper.hpp",
"chars": 3329,
"preview": "#ifndef COMMON_CUDA_HELPER\n#define COMMON_CUDA_HELPER\n\n#include <cuda.h>\n\n#define CUDA_1D_KERNEL_LOOP(i, n) "
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/convex_iou_cuda_kernel.cuh",
"chars": 23369,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef CONVEX_IOU_CUDA_KERNEL_CUH\n#define CONVEX_IOU_CUDA_KERNEL_CUH\n\n#"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/correlation_cuda.cuh",
"chars": 7477,
"preview": "// Copyright (c) OpenMMLab. All rights reserved.\n// Modified from\n// https://github.com/ClementPinard/Pytorch-Correlatio"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/deform_conv_cuda_kernel.cuh",
"chars": 15470,
"preview": "/*!\n ******************* BEGIN Caffe Copyright Notice and Disclaimer\n *****************\n *\n * COPYRIGHT\n *\n * All contri"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/deform_roi_pool_cuda_kernel.cuh",
"chars": 7888,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef DEFORM_ROI_POOL_CUDA_KERNEL_CUH\n#define DEFORM_ROI_POOL_CUDA_KER"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/furthest_point_sample_cuda_kernel.cuh",
"chars": 4212,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef FURTHEST_POINT_SAMPLE_CUDA_KERNEL_CUH\n#define FURTHEST_POINT_SAM"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/gather_points_cuda_kernel.cuh",
"chars": 1708,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef GATHER_POINTS_CUDA_KERNEL_CUH\n#define GATHER_POINTS_CUDA_KERNEL_"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/group_points_cuda_kernel.cuh",
"chars": 2384,
"preview": "// Copyright (c) OpenMMLab. All rights reserved.\n// Modified from\n// https://github.com/sshaoshuai/Pointnet2.PyTorch/tre"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/iou3d_cuda_kernel.cuh",
"chars": 12922,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef IOU3D_CUDA_KERNEL_CUH\n#define IOU3D_CUDA_KERNEL_CUH\n\n#ifdef MMCV"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/knn_cuda_kernel.cuh",
"chars": 2462,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n// Modified from\n// https://github.com/CVMI-Lab/PAConv/tree/main/scene_s"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/masked_conv2d_cuda_kernel.cuh",
"chars": 2409,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef MASKED_CONV2D_CUDA_KERNEL_CUH\n#define MASKED_CONV2D_CUDA_KERNEL_"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/min_area_polygons_cuda.cuh",
"chars": 7743,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef MIN_AREA_POLYGONS_CUDA_KERNEL_CUH\n#define MIN_AREA_POLYGONS_CUDA"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/modulated_deform_conv_cuda_kernel.cuh",
"chars": 17255,
"preview": "/*!\n ******************* BEGIN Caffe Copyright Notice and Disclaimer\n *****************\n *\n * COPYRIGHT\n *\n * All contri"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/ms_deform_attn_cuda_kernel.cuh",
"chars": 33075,
"preview": "/*!\n**************************************************************************************************\n* Deformable DETR"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/nms_cuda_kernel.cuh",
"chars": 2680,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef NMS_CUDA_KERNEL_CUH\n#define NMS_CUDA_KERNEL_CUH\n\n#include <float"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/nms_rotated_cuda.cuh",
"chars": 5172,
"preview": "// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n// modified from\n// https://github.com/facebookr"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/parrots_cudawarpfunction.cuh",
"chars": 3424,
"preview": "/*\n * Copyright (c) 2019, SenseTime.\n */\n\n#ifndef INCLUDE_PARROTS_DARRAY_CUDAWARPFUNCTION_CUH_\n#define INCLUDE_PARROTS_D"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/points_in_boxes_cuda_kernel.cuh",
"chars": 3334,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef POINT_IN_BOXES_CUDA_KERNEL_CUH\n#define POINT_IN_BOXES_CUDA_KERNE"
},
{
"path": "01-DL-toolbox(Pytorch)/UDL/mmcv/mmcv/ops/csrc/common/cuda/points_in_polygons_cuda_kernel.cuh",
"chars": 1994,
"preview": "// Copyright (c) OpenMMLab. All rights reserved\n#ifndef POINTS_IN_POLYGONS_CUDA_KERNEL_CUH\n#define POINTS_IN_POLYGONS_CU"
}
]
// ... and 1196 more files (download for full content)
About this extraction
This page contains the full source code of the liangjiandeng/DLPan-Toolbox GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1396 files (5.7 MB), approximately 1.6M tokens, and a symbol index with 3551 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.