From 962db72b4710856387241ff0ecad66a5aadf6817 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 11 Feb 2022 03:02:24 +0000 Subject: [PATCH 1/5] chore(deps): bump protobuf in /LeNetWithS3Pooling/training Bumps [protobuf](https://github.com/protocolbuffers/protobuf) from 3.10.0 to 3.15.0. - [Release notes](https://github.com/protocolbuffers/protobuf/releases) - [Changelog](https://github.com/protocolbuffers/protobuf/blob/master/generate_changelog.py) - [Commits](https://github.com/protocolbuffers/protobuf/compare/v3.10.0...v3.15.0) --- updated-dependencies: - dependency-name: protobuf dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- LeNetWithS3Pooling/training/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LeNetWithS3Pooling/training/requirements.txt b/LeNetWithS3Pooling/training/requirements.txt index ed194c68..e430cb49 100644 --- a/LeNetWithS3Pooling/training/requirements.txt +++ b/LeNetWithS3Pooling/training/requirements.txt @@ -1,6 +1,6 @@ numpy==1.16.5 Pillow>=6.2.2 -protobuf==3.10.0 +protobuf==3.15.0 six==1.12.0 summary==0.2.0 termcolor==1.1.0 From e187417fedaf91e335328ef40b006b2891db0ab1 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 21 Jun 2022 23:50:08 +0000 Subject: [PATCH 2/5] chore(deps): bump numpy in /LeNetWithS3Pooling/training Bumps [numpy](https://github.com/numpy/numpy) from 1.16.5 to 1.22.0. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst) - [Commits](https://github.com/numpy/numpy/compare/v1.16.5...v1.22.0) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- LeNetWithS3Pooling/training/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LeNetWithS3Pooling/training/requirements.txt b/LeNetWithS3Pooling/training/requirements.txt index ed194c68..b04da3ca 100644 --- a/LeNetWithS3Pooling/training/requirements.txt +++ b/LeNetWithS3Pooling/training/requirements.txt @@ -1,4 +1,4 @@ -numpy==1.16.5 +numpy==1.22.0 Pillow>=6.2.2 protobuf==3.10.0 six==1.12.0 From 893e5557549027521690dde2ef3673c8cd629361 Mon Sep 17 00:00:00 2001 From: "John Yang (SW-TEGRA)" Date: Fri, 26 Aug 2022 23:18:47 -0700 Subject: [PATCH 3/5] add DEST implementation --- DEST/LICENSE | 62 +++ DEST/README.md | 178 +++++++++ DEST/configs/train_kitti_dest.yaml | 43 ++ DEST/models/SelfSupModel_dest.py | 100 +++++ DEST/models/SemiSupModel_dest.py | 112 ++++++ DEST/models/SfmModel_dest.py | 130 ++++++ DEST/models/__init__.py | 1 + DEST/networks/DEST/DEST_EncDec.py | 203 ++++++++++ DEST/networks/DEST/__init__.py | 0 DEST/networks/DEST/simplified_attention.py | 321 +++++++++++++++ .../DEST/simplified_joint_attention.py | 267 +++++++++++++ DEST/networks/DESTNet.py | 138 +++++++ DEST/networks/__init__.py | 0 DEST/resources/attentions.png | Bin 0 -> 167779 bytes DEST/semseg/cityscapes_1024x1024_repeat.py | 57 +++ DEST/semseg/dest_head.py | 53 +++ DEST/semseg/dest_simpatt-b0.py | 36 ++ ...st_simpatt-b0_1024x1024_160k_cityscapes.py | 76 ++++ ...st_simpatt-b1_1024x1024_160k_cityscapes.py | 76 ++++ ...st_simpatt-b2_1024x1024_160k_cityscapes.py | 76 ++++ ...st_simpatt-b3_1024x1024_160k_cityscapes.py | 77 ++++ ...st_simpatt-b4_1024x1024_160k_cityscapes.py | 77 ++++ ...st_simpatt-b5_1024x1024_160k_cityscapes.py | 77 ++++ DEST/semseg/schedule_160k_adamw.py | 9 + DEST/semseg/simplified_attention_mmseg.py | 378 ++++++++++++++++++ 25 files changed, 2547 insertions(+) create mode 100644 DEST/LICENSE create mode 100644 DEST/README.md create mode 100644 DEST/configs/train_kitti_dest.yaml create mode 100644 DEST/models/SelfSupModel_dest.py create mode 100644 DEST/models/SemiSupModel_dest.py create mode 100644 DEST/models/SfmModel_dest.py create mode 100644 DEST/models/__init__.py create mode 100644 DEST/networks/DEST/DEST_EncDec.py create mode 100644 DEST/networks/DEST/__init__.py create mode 100644 DEST/networks/DEST/simplified_attention.py create mode 100644 DEST/networks/DEST/simplified_joint_attention.py create mode 100644 DEST/networks/DESTNet.py create mode 100644 DEST/networks/__init__.py create mode 100644 DEST/resources/attentions.png create mode 100644 DEST/semseg/cityscapes_1024x1024_repeat.py create mode 100644 DEST/semseg/dest_head.py create mode 100644 DEST/semseg/dest_simpatt-b0.py create mode 100644 DEST/semseg/dest_simpatt-b0_1024x1024_160k_cityscapes.py create mode 100644 DEST/semseg/dest_simpatt-b1_1024x1024_160k_cityscapes.py create mode 100644 DEST/semseg/dest_simpatt-b2_1024x1024_160k_cityscapes.py create mode 100644 DEST/semseg/dest_simpatt-b3_1024x1024_160k_cityscapes.py create mode 100644 DEST/semseg/dest_simpatt-b4_1024x1024_160k_cityscapes.py create mode 100644 DEST/semseg/dest_simpatt-b5_1024x1024_160k_cityscapes.py create mode 100644 DEST/semseg/schedule_160k_adamw.py create mode 100644 DEST/semseg/simplified_attention_mmseg.py diff --git a/DEST/LICENSE b/DEST/LICENSE new file mode 100644 index 00000000..20c1a5a1 --- /dev/null +++ b/DEST/LICENSE @@ -0,0 +1,62 @@ +NVIDIA Source Code License for DEST + +1. Definitions + +“Licensor” means any person or entity that distributes its Work. + +“Work” means (a) the original work of authorship made available under this license, which may include software, +documentation, or other files, and (b) any additions to or derivative works thereof that are made available +under this license. + +The terms “reproduce,” “reproduction,” “derivative works,” and “distribution” have the meaning +as provided under U.S. copyright law; provided, however, that for the purposes of this license, derivative works +shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work. + +Works are “made available” under this license by including in or with the Work either (a) a copyright notice +referencing the applicability of this license to the Work, or (b) a copy of this license. + +2. License Grant + +2.1 Copyright Grant. Subject to the terms and conditions of this license, each Licensor grants to you a perpetual, +worldwide, non-exclusive, royalty-free, copyright license to use, reproduce, prepare derivative works of, publicly +display, publicly perform, sublicense and distribute its Work and any resulting derivative works in any form. + +3. Limitations + +3.1 Redistribution. You may reproduce or distribute the Work only if (a) you do so under this license, (b) +you include a complete copy of this license with your distribution, and (c) you retain without modification any +copyright, patent, trademark, or attribution notices that are present in the Work. + +3.2 Derivative Works. You may specify that additional or different terms apply to the use, reproduction, and +distribution of your derivative works of the Work (“Your Terms”) only if (a) Your Terms provide that the use +limitation in Section 3.3 applies to your derivative works, and (b) you identify the specific derivative works that +are subject to Your Terms. Notwithstanding Your Terms, this license (including the redistribution requirements in +Section 3.1) will continue to apply to the Work itself. + +3.3 Use Limitation. The Work and any derivative works thereof only may be used or intended for use +non-commercially. Notwithstanding the foregoing, NVIDIA Corporation and its affiliates may use the Work and any +derivative works commercially. As used herein, “non-commercially” means for research or evaluation purposes only. + +3.4 Patent Claims. If you bring or threaten to bring a patent claim against any Licensor (including any claim, +cross-claim or counterclaim in a lawsuit) to enforce any patents that you allege are infringed by any Work, then +your rights under this license from such Licensor (including the grant in Section 2.1) will terminate immediately. + +3.5 Trademarks. This license does not grant any rights to use any Licensor's or its affiliates' names, logos, +or trademarks, except as necessary to reproduce the notices described in this license. + +3.6 Termination. If you violate any term of this license, then your rights under this license (including the grant +in Section 2.1) will terminate immediately. + +4. Disclaimer of Warranty. + +THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING +WARRANTIES OR CONDITIONS OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT. YOU BEAR +THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE. + +5. Limitation of Liability. + +EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), +CONTRACT, OR OTHERWISE SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, +INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK +(INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR +MALFUNCTION, OR ANY OTHER DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. diff --git a/DEST/README.md b/DEST/README.md new file mode 100644 index 00000000..89db2d89 --- /dev/null +++ b/DEST/README.md @@ -0,0 +1,178 @@ +# DEST: Depth Estimation with Simplified Transformer + + +
+ +
+ +***[DEST: Depth Estimation with Simplified Transformer](https://arxiv.org/abs/2204.13791)***
+John Yang, Le An, Anurag Dixit, Jinkyu Koo, Su Inn Park +CVPR Workshop on [Transformers For Vision](https://sites.google.com/view/t4v-cvpr22), 2022 + +DEST leverages a simplified design of attention block in the transformer that is GPU friendly. Compared to state-of-the-art methods, our model achieves over 80% reduction in terms of model size and computation, while being more accurate and faster. The proposed model was validated on both depth esitimation and semantic segmentation tasks. This repository contains the official Pytorch model implementation and training configuration which can be adapted to your traing workflow. + +
+ +## Monocular Depth Estimation +For depth estimation, we employ the same setup as that in [PackNet-sfm](https://github.com/TRI-ML/packnet-sfm). For details on environment preparation, data download, and training/evaluation scripts, please refer to the original repo for details. + +### Prerequistes + +Run the following commands + +```bash +git clone https://github.com/TRI-ML/packnet-sfm.git +cd packnet-sfm + +cp path/to/DEST/configs/train_kitti_dest.yaml configs/ +cp path/to/DEST/models/*_dest.py packnet_sfm/models/ +cp path/to/DEST/networks/DESTNet.py packnet_sfm/networks/depth/ +mkdir packnet_sfm/networks/DEST +cp path/to/DEST/networks/DEST/*.py packnet_sfm/networks/DEST/ +``` + +in order to place DEST and its config file within the [PackNet-sfm](https://github.com/TRI-ML/packnet-sfm) implementation as shown below: + +```yaml +packnet-sfm + ├ configs + │ ... + │ └ train_kitti_dest.yaml + ├ packnet_sfm + │ ... + │ ├ models + │ │ ... + │ │ ├ SfmModel_dest.py + │ │ ├ SemiSupModel_dest.py + │ │ └ SelfSupModel_dest.py + │ ├ networks + │ │ ... + │ │ ├ depth + │ │ │ ... + │ │ │ └ DESTNet.py + │ │ └ DEST + │ │ ├ __init__.py + │ │ ├ DEST_EncDec.py + │ │ ├ simplified_attention.py + │ │ └ simplified_joint_attention.py +... +``` + +### Modifications to make on PackNet repo +Our work quires ```timm``` library, so please add the following line in `docker/Dockerfile`. + +```bash +RUN pip install timm +``` + +Before building the docker image, we also need to adjust the Python version, CUDNN version, NCCL version, etc. in the Dockerfile according to our machine. Note that the minimum supported Python version is 3.7. Base images can be found from [dockerhub](https://hub.docker.com/r/nvidia/cuda/tags?page=1&ordering=last_updated): + +After properly configuring Dockerfile, please follow [the instructions](https://github.com/TRI-ML/packnet-sfm#install) to build your docker image. + +Also, due to [the issues from the PackNet repository](https://github.com/TRI-ML/packnet-sfm/issues/107) during evalution, +you need to edit the lines of L295, L302 from the file `packnet-sfm/packnet_sfm/models/model_wrapper.py`. + +Change lines +``` +[L295] depth = inv2depth(inv_depths[0]) +... +[L301] inv_depth_pp = post_process_inv_depth( +[L302] inv_depths[0], inv_depths_flipped[0], method='mean') +``` +to +``` +[L295] depth = inv2depth(inv_depths) +... +[L301] inv_depth_pp = post_process_inv_depth( +[L302] inv_depths, inv_depths_flipped, method='mean') +``` + + +### Training + +To train DEST from scratch on KITTI dataset, run the following command: +```bash +python scripts/train.py configs/train_kitti_dest.yaml +``` + +### Evaluation +For the evaluation of DEST model on KITTI dataset, run the following: + +```bash +python scripts/eval.py --checkpoint [--config ] +``` + +For inference on a single image or folder: +You can also directly run inference on a single image or folder: + +```bash +python scripts/infer.py --checkpoint --input --output [--image_shape ] +``` + +
+ +## Semantic Segmentation +For semantic segmentation, our implementation can be readily integrated into [OpenMMLab Semantic Segmentation Toolbox and Benchmark](https://github.com/open-mmlab/mmsegmentation) implementation for training and evaluation. + +Please refer to their instruction for [installations](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/get_started.md#installation) and [dataset preparatation](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/dataset_prepare.md#prepare-datasets). +Our DEST is trained/evaluated on [CityScapes Dataset](https://www.cityscapes-dataset.com/login/). + +### Prerequisites +In order to follow MMSegmentation instructions for training, refer to the files that are located at ```DEST/semseg/``` and +re-locate the files within the MMSegmentation repository by running the following commands: +```bash +git clone https://github.com/open-mmlab/mmsegmentation.git # first clone the MMSegmentation env +cd mmsegmentation +mkdir configs/dest/ + +cp path/to/DEST/semseg/dest_simpatt-b0.py configs/_base_/models/ +cp path/to/DEST/semseg/schedule_160k_adamw.py configs/_base_/schedules/ +cp path/to/DEST/semseg/cityscapes_1024x1024_repeat.py configs/_base_/datasets/ +cp path/to/DEST/semseg/dest_simpatt-*_1024x1024_160k_cityscapes.py configs/dest/ +cp path/to/DEST/semseg/simplified_attention_mmseg.py mmseg/models/backbones/ +cp path/to/DEST/semseg/dest_head.py mmseg/models/decode_heads/ +``` + +You now need to include DEST in their library +```bash +echo 'from .simplified_attention_mmseg import SimplifiedTransformer' >> mmseg/models/backbones/__init__.py +echo 'from .dest_head import DestHead' >> mmseg/models/decode_heads/__init__.py +``` + +Then, you can start training/evaluating with a desired configuration of DEST. + +### Training +Example: train DEST-B1 on CityScapes Dataset: + +```bash +# Single-gpu training +python tools/train.py configs/dest/dest_simpatt-b1_1024x1024_160k_cityscapes.py +# Multi-gpu training +./tools/dist_train.sh configs/dest/dest_simpatt-b1_1024x1024_160k_cityscapes.py +``` + +### Evaluation +After training, you can evaluate the trained model (e.g. DEST-B1) + +```bash +# Single-gpu testing +python tools/test.py configs/dest/dest_simpatt-b1_1024x1024_160k_cityscapes.py /path/to/checkpoint_file +# Multi-gpu testing +./tools/dist_test.sh configs/dest/dest_simpatt-b1_1024x1024_160k_cityscapes.py /path/to/checkpoint_file +# Multi-gpu, multi-scale testing +tools/dist_test.sh configs/dest/dest_simpatt-b1_1024x1024_160k_cityscapes.py /path/to/checkpoint_file --aug-test +``` + + +## License +The provided code can be used for research or other non-commercial purposes. For details please check the [LICENSE](LICENSE) file. + +## Citation +``` +@article{YangDEST, + title={Depth Estimation with Simplified Transformer}, + author={Yang, John and An, Le and Dixit, Anurag and Koo, Jinkyu and Park, Su Inn}, + journal={arXiv preprint arXiv:2204.13791}, + year={2022} +} +``` diff --git a/DEST/configs/train_kitti_dest.yaml b/DEST/configs/train_kitti_dest.yaml new file mode 100644 index 00000000..1719fcdc --- /dev/null +++ b/DEST/configs/train_kitti_dest.yaml @@ -0,0 +1,43 @@ +model: + name: 'SelfSupModel_dest' + optimizer: + name: 'Adam' + depth: + lr: 0.000007 + pose: + lr: 0.00001 + scheduler: + name: 'StepLR' + step_size: 10 + gamma: 0.5 + depth_net: + name: 'DESTNet' + version: '1A' + pose_net: + name: 'PoseNet' + params: + crop: 'garg' + min_depth: 0.0 + max_depth: 80.0 +datasets: + augmentation: + image_shape: (192, 640) + train: + batch_size: 10 + num_workers: 12 + dataset: ['KITTI'] + path: ['data/datasets/KITTI_raw'] + split: ['data_splits/eigen_zhou_files.txt'] + depth_type: ['velodyne'] + repeat: [5] + validation: + dataset: ['KITTI'] + path: ['data/datasets/KITTI_raw'] + split: ['data_splits/eigen_val_files.txt', + 'data_splits/eigen_test_files.txt'] + depth_type: ['velodyne'] + test: + dataset: ['KITTI'] + path: ['data/datasets/KITTI_raw'] + split: ['data_splits/eigen_test_files.txt'] + depth_type: ['velodyne'] diff --git a/DEST/models/SelfSupModel_dest.py b/DEST/models/SelfSupModel_dest.py new file mode 100644 index 00000000..a05664fa --- /dev/null +++ b/DEST/models/SelfSupModel_dest.py @@ -0,0 +1,100 @@ +# Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +import torch +from packnet_sfm.models.SfmModel_dest import SfmModel_dest +from packnet_sfm.losses.multiview_photometric_loss import MultiViewPhotometricLoss +from packnet_sfm.models.model_utils import merge_outputs + + +class SelfSupModel_dest(SfmModel_dest): + """ + Model that inherits a depth and pose network from SfmModel and + includes the photometric loss for self-supervised training. + + Parameters + ---------- + kwargs : dict + Extra parameters + """ + def __init__(self, **kwargs): + # Initializes SfmModel + super().__init__(**kwargs) + # Initializes the photometric loss + self._photometric_loss = MultiViewPhotometricLoss(**kwargs) + + @property + def logs(self): + """Return logs.""" + return { + **super().logs, + **self._photometric_loss.logs + } + + + def self_supervised_loss(self, image, ref_images, inv_depths, poses, + intrinsics, return_logs=False, progress=0.0): + """ + Calculates the self-supervised photometric loss. + + Parameters + ---------- + image : torch.Tensor [B,3,H,W] + Original image + ref_images : list of torch.Tensor [B,3,H,W] + Reference images from context + inv_depths : torch.Tensor [B,1,H,W] + Predicted inverse depth maps from the original image + poses : list of Pose + List containing predicted poses between original and context images + intrinsics : torch.Tensor [B,3,3] + Camera intrinsics + return_logs : bool + True if logs are stored + progress : + Training progress percentage + + Returns + ------- + output : dict + Dictionary containing a "loss" scalar a "metrics" dictionary + """ + return self._photometric_loss( + image, ref_images, inv_depths, intrinsics, intrinsics, poses, + return_logs=return_logs, progress=progress) + + + def forward(self, batch, return_logs=False, progress=0.0): + """ + Processes a batch. + + Parameters + ---------- + batch : dict + Input batch + return_logs : bool + True if logs are stored + progress : + Training progress percentage + + Returns + ------- + output : dict + Dictionary containing a "loss" scalar and different metrics and predictions + for logging and downstream usage. + """ + # Calculate predicted depth and pose output + output = super().forward(batch, return_logs=return_logs) + if not self.training: + # If not training, no need for self-supervised loss + return output + else: + # Otherwise, calculate self-supervised loss + self_sup_output = self.self_supervised_loss( + batch['rgb_original'], batch['rgb_context_original'], + output['inv_depths'], output['poses'], batch['intrinsics'], + return_logs=return_logs, progress=progress) + # Return loss and metrics + return { + 'loss': self_sup_output['loss'], + **merge_outputs(output, self_sup_output), + } diff --git a/DEST/models/SemiSupModel_dest.py b/DEST/models/SemiSupModel_dest.py new file mode 100644 index 00000000..5dfb092a --- /dev/null +++ b/DEST/models/SemiSupModel_dest.py @@ -0,0 +1,112 @@ +# Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +import torch + +from packnet_sfm.models.SelfSupModel_dest import SfmModel_dest, SelfSupModel_dest +from packnet_sfm.losses.supervised_loss import SupervisedLoss +from packnet_sfm.models.model_utils import merge_outputs +from packnet_sfm.utils.depth import depth2inv + + +class SemiSupModel_dest(SelfSupModel_dest): + """ + Model that inherits a depth and pose networks, plus the self-supervised loss from + SelfSupModel and includes a supervised loss for semi-supervision. + + Parameters + ---------- + supervised_loss_weight : float + Weight for the supervised loss + kwargs : dict + Extra parameters + """ + def __init__(self, supervised_loss_weight=0.9, **kwargs): + # Initializes SelfSupModel + super().__init__(**kwargs) + # If supervision weight is 0.0, use SelfSupModel directly + assert 0. < supervised_loss_weight <= 1., "Model requires (0, 1] supervision" + # Store weight and initializes supervised loss + self.supervised_loss_weight = supervised_loss_weight + self._supervised_loss = SupervisedLoss(**kwargs) + + # Pose network is only required if there is self-supervision + if self.supervised_loss_weight == 1: + self._network_requirements.remove('pose_net') + # GT depth is only required if there is supervision + if self.supervised_loss_weight > 0: + self._train_requirements.append('gt_depth') + + @property + def logs(self): + """Return logs.""" + return { + **super().logs, + **self._supervised_loss.logs + } + + def supervised_loss(self, inv_depths, gt_inv_depths, + return_logs=False, progress=0.0): + """ + Calculates the supervised loss. + + Parameters + ---------- + inv_depths : torch.Tensor [B,1,H,W] + Predicted inverse depth maps from the original image + gt_inv_depths : torch.Tensor [B,1,H,W] + Ground-truth inverse depth maps from the original image + return_logs : bool + True if logs are stored + progress : + Training progress percentage + + Returns + ------- + output : dict + Dictionary containing a "loss" scalar a "metrics" dictionary + """ + return self._supervised_loss( + inv_depths, gt_inv_depths, + return_logs=return_logs, progress=progress) + + def forward(self, batch, return_logs=False, progress=0.0): + """ + Processes a batch. + + Parameters + ---------- + batch : dict + Input batch + return_logs : bool + True if logs are stored + progress : + Training progress percentage + + Returns + ------- + output : dict + Dictionary containing a "loss" scalar and different metrics and predictions + for logging and downstream usage. + """ + if not self.training: + # If not training, no need for self-supervised loss + return SfmModel_deptr.forward(self, batch) + else: + if self.supervised_loss_weight == 1.: + # If no self-supervision, no need to calculate loss + self_sup_output = SfmModel_deptr.forward(self, batch) + loss = torch.tensor([0.]).type_as(batch['rgb']) + else: + # Otherwise, calculate and weight self-supervised loss + self_sup_output = SelfSupModel_deptr.forward(self, batch) + loss = (1.0 - self.supervised_loss_weight) * self_sup_output['loss'] + # Calculate and weight supervised loss + sup_output = self.supervised_loss( + self_sup_output['inv_depths'], depth2inv(batch['depth']), + return_logs=return_logs, progress=progress) + loss += self.supervised_loss_weight * sup_output['loss'] + # Merge and return outputs + return { + 'loss': loss, + **merge_outputs(self_sup_output, sup_output), + } diff --git a/DEST/models/SfmModel_dest.py b/DEST/models/SfmModel_dest.py new file mode 100644 index 00000000..380f90bd --- /dev/null +++ b/DEST/models/SfmModel_dest.py @@ -0,0 +1,130 @@ +# Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +import random +import torch.nn as nn +from packnet_sfm.geometry.pose import Pose +from packnet_sfm.models.base_model import BaseModel +from packnet_sfm.models.model_utils import flip_batch_input, flip_output, upsample_output +from packnet_sfm.utils.misc import filter_dict + + +class SfmModel_dest(BaseModel): + """ + Model class encapsulating a pose and depth networks. + + Parameters + ---------- + depth_net : nn.Module + Depth network to be used + pose_net : nn.Module + Pose network to be used + rotation_mode : str + Rotation mode for the pose network + flip_lr_prob : float + Probability of flipping when using the depth network + upsample_depth_maps : bool + True if depth map scales are upsampled to highest resolution + kwargs : dict + Extra parameters + """ + def __init__(self, depth_net=None, pose_net=None, + rotation_mode='euler', flip_lr_prob=0.0, + upsample_depth_maps=False, **kwargs): + super().__init__() + self.depth_net = depth_net + self.pose_net = pose_net + self.rotation_mode = rotation_mode + self.flip_lr_prob = flip_lr_prob + self.upsample_depth_maps = upsample_depth_maps + self.mse_loss = nn.MSELoss(reduction='mean') + self._network_requirements = [ + 'depth_net', + 'pose_net', + ] + + def add_depth_net(self, depth_net): + """Add a depth network to the model""" + self.depth_net = depth_net + + def add_pose_net(self, pose_net): + """Add a pose network to the model""" + self.pose_net = pose_net + + def depth_net_flipping(self, batch, flip): + """ + Runs depth net with the option of flipping + + Parameters + ---------- + batch : dict + Input batch + flip : bool + True if the flip is happening + + Returns + ------- + output : dict + Dictionary with depth network output (e.g. 'inv_depths' and 'uncertainty') + """ + # Which keys are being passed to the depth network + batch_input = {key: batch[key] for key in filter_dict(batch, self._input_keys)} + if flip: + # Run depth network with flipped inputs + output = self.depth_net(**flip_batch_input(batch_input)) + # Flip output back if training + output = flip_output(output) + else: + # Run depth network + output = self.depth_net(**batch_input) + return output + + def compute_depth_net(self, batch, force_flip=False): + """Computes inverse depth maps from single images""" + # Randomly flip and estimate inverse depth maps + flag_flip_lr = random.random() < self.flip_lr_prob if self.training else force_flip + output = self.depth_net_flipping(batch, flag_flip_lr) + # If upsampling depth maps at training time + if self.training and self.upsample_depth_maps: + output = upsample_output(output, mode='nearest', align_corners=None) + # Return inverse depth maps + return output + + def compute_pose_net(self, image, contexts): + """Compute poses from image and a sequence of context images""" + pose_vec = self.depth_net.pose(image, contexts) + # print('pose_vec.shape', pose_vec.size()) + return [Pose.from_vec(pose_vec[:, i], self.rotation_mode) + for i in range(pose_vec.shape[1])] + + + + def forward(self, batch, return_logs=False, force_flip=False): + """ + Processes a batch. + + Parameters + ---------- + batch : dict + Input batch + return_logs : bool + True if logs are stored + force_flip : bool + If true, force batch flipping for inverse depth calculation + + Returns + ------- + output : dict + Dictionary containing the output of depth and pose networks + """ + # Generate inverse depth predictions + depth_output = self.compute_depth_net(batch, force_flip=force_flip) + + # Generate pose predictions if available + pose_output = None + if 'rgb_context' in batch : + pose_output = self.compute_pose_net(batch['rgb'], batch['rgb_context']) + # Return output dictionary + return { + **depth_output, + 'poses': pose_output, + } diff --git a/DEST/models/__init__.py b/DEST/models/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/DEST/models/__init__.py @@ -0,0 +1 @@ + diff --git a/DEST/networks/DEST/DEST_EncDec.py b/DEST/networks/DEST/DEST_EncDec.py new file mode 100644 index 00000000..3bcc954b --- /dev/null +++ b/DEST/networks/DEST/DEST_EncDec.py @@ -0,0 +1,203 @@ +# Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +from functools import partial +import torch +from torch import nn + +from packnet_sfm.networks.DEST.simplified_attention import SimplifiedTransformer as SimpTR +from packnet_sfm.networks.DEST.simplified_joint_attention import SimplifiedJointTransformer as SimpTR_Joint + + +def exists(val): + return val is not None + +def cast_tuple(val, depth): + return val if isinstance(val, tuple) else (val,) * depth + + +class DEST_Encoder_Decoder(nn.Module): + def __init__( + self, + *, + img_size=(192, 640), + dims=(32, 64, 160, 256), + heads=(1, 2, 4, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(2, 2, 2, 2), + channels=3, + decoder_dim=128, + num_classes=64, + semseg=False + ): + super().__init__() + dims, heads, ff_expansion, reduction_ratio, num_layers = map(partial(cast_tuple, depth = 4), (dims, heads, ff_expansion, reduction_ratio, num_layers)) + assert all([*map(lambda t: len(t) == 4, (dims, heads, ff_expansion, reduction_ratio, num_layers))]), 'only four stages are allowed, all keyword arguments must be either a single value or a tuple of 4 values' + + self.dest_encoder = SimpTR( + img_size=img_size, in_chans=channels, num_classes=num_classes, + embed_dims=dims, num_heads=heads, mlp_ratios=ff_expansion, qkv_bias=True, qk_scale=None, drop_rate=0, + drop_path_rate=0.1, attn_drop_rate=0., norm_layer=nn.LayerNorm, depths=num_layers, sr_ratios=reduction_ratio) + + self.dims = dims + self.fuse_conv1 = nn.Sequential(nn.Conv2d(dims[-1], dims[-1], 1), nn.ReLU(inplace=True)) + self.fuse_conv2 = nn.Sequential(nn.Conv2d(dims[-2], dims[-2], 1), nn.ReLU(inplace=True)) + self.fuse_conv3 = nn.Sequential(nn.Conv2d(dims[-3], dims[-3], 1), nn.ReLU(inplace=True)) + self.fuse_conv4 = nn.Sequential(nn.Conv2d(dims[-4], dims[-4], 1), nn.ReLU(inplace=True)) + + self.upsample = nn.ModuleList([nn.Sequential(nn.Upsample(scale_factor=2, mode='nearest'))]*len(dims)) + + self.fused_1 = nn.Sequential(nn.ReflectionPad2d(1), nn.Conv2d(dims[-1], dims[-1], 3), nn.ReLU(inplace=True)) + self.fused_2 = nn.Sequential(nn.ReflectionPad2d(1), nn.Conv2d(dims[-2] + dims[-1], dims[-2], 3), nn.ReLU(inplace=True)) + self.fused_3 = nn.Sequential(nn.ReflectionPad2d(1), nn.Conv2d(dims[-3] + dims[-2], dims[-3], 3), nn.ReLU(inplace=True)) + self.fused_4 = nn.Sequential(nn.ReflectionPad2d(1), nn.Conv2d(dims[-4] + dims[-3], dims[-4], 3), nn.ReLU(inplace=True)) + self.fused_5 = nn.Sequential(nn.Upsample(scale_factor=2, mode='nearest'), + nn.Conv2d(dims[-4], dims[-4], 1), + nn.ReLU(True)) + self.semseg = semseg + + def dest_decoder(self, lay_out): + fused_1 = self.fuse_conv1(lay_out[-1]) + fused_1 = self.upsample[-1](fused_1) + fused_1 = self.fused_1(fused_1) + fused_2 = torch.cat([fused_1, self.fuse_conv2(lay_out[-2])], 1) + + fused_2 = self.upsample[-2](fused_2) + fused_2 = self.fused_2(fused_2) + fused_3 = torch.cat([fused_2, self.fuse_conv3(lay_out[-3])], 1) + + fused_3 = self.upsample[-3](fused_3) + fused_3 = self.fused_3(fused_3) + fused_4 = torch.cat([fused_3, self.fuse_conv4(lay_out[-4])], 1) + + fused_4 = self.upsample[-4](fused_4) + fused_4 = self.fused_4(fused_4) + + if self.semseg: + return fused_4 + + fused_5 = self.fused_5(fused_4) + return fused_5, fused_4, fused_3, fused_2 + + def forward(self, x): + layer_outputs, ref_feat = self.dest_encoder(x) + + out = self.dest_decoder(layer_outputs) + + return out, layer_outputs, ref_feat + +def DEST_Pose( + img_size=(192, 640), + dims = (32, 64, 160, 256), + heads = (1, 2, 5, 8), + ff_expansion = (8, 8, 8, 8), + reduction_ratio = (8, 4, 2, 1), + num_layers = (2, 2, 2, 2), + channels=3, + num_classes=512, + connectivity=True): + + dims, heads, ff_expansion, reduction_ratio, num_layers = map(partial(cast_tuple, depth = 4), (dims, heads, ff_expansion, reduction_ratio, num_layers)) + assert all([*map(lambda t: len(t) == 4, (dims, heads, ff_expansion, reduction_ratio, num_layers))]), 'only four stages are allowed, all keyword arguments must be either a single value or a tuple of 4 values' + + + if connectivity : + model = SimpTR_Joint( + img_size=img_size, in_chans=channels, num_classes=num_classes, + embed_dims=dims, num_heads=heads, mlp_ratios=ff_expansion, qkv_bias=True, qk_scale=None, drop_rate=0., + drop_path_rate=0.1, attn_drop_rate= 0., norm_layer=nn.LayerNorm, depths=num_layers, sr_ratios=reduction_ratio) + else: + model = SimpTR( + img_size=img_size, in_chans=channels, num_classes=num_classes, + embed_dims=dims, num_heads=heads, mlp_ratios=ff_expansion, qkv_bias=True, qk_scale=None, drop_rate=0., + drop_path_rate=0.1, attn_drop_rate= 0., norm_layer=nn.LayerNorm, depths=num_layers, sr_ratios=reduction_ratio) + + return num_classes, model + + + +def SimpleTR_B0(img_size=(192, 640), num_out_ch=64, semseg=False): + model = DEST_Encoder_Decoder( + img_size=img_size, + dims=(32, 64, 160, 256), + heads=(1, 2, 5, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(2, 2, 2, 2), + channels=3, + decoder_dim=256, + num_classes=num_out_ch, + semseg=semseg) + return num_out_ch, model + +def SimpleTR_B1(img_size=(192, 640), num_out_ch=256, semseg=False): + model = DEST_Encoder_Decoder( + img_size=img_size, + dims=(64, 128, 250, 320), + heads=(1, 2, 5, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(2, 2, 2, 2), + channels=3, + decoder_dim=num_out_ch, + num_classes=num_out_ch, + semseg=semseg) + return num_out_ch, model + +def SimpleTR_B2(img_size=(192, 640), num_out_ch=256, semseg=False): + model = DEST_Encoder_Decoder( + img_size=img_size, + dims=(64, 128, 250, 320), + heads=(1, 2, 5, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(3, 3, 6, 3), + channels=3, + decoder_dim=num_out_ch, + num_classes=num_out_ch, + semseg=semseg) + return num_out_ch, model + + +def SimpleTR_B3(img_size=(192, 640), num_out_ch=256, semseg=False): + model = DEST_Encoder_Decoder( + img_size=img_size, + dims=(64, 128, 250, 320), + heads=(1, 2, 5, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(3, 6, 8, 3), + channels=3, + decoder_dim=512, + num_classes=256, + semseg=semseg) + return num_out_ch, model + +def SimpleTR_B4(img_size=(192, 640), num_out_ch=512, semseg=False): + model = DEST_Encoder_Decoder( + img_size=img_size, + dims=(64, 128, 250, 320), + heads=(1, 2, 5, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(3, 8, 12, 5), + channels=3, + decoder_dim=num_out_ch, + num_classes=num_out_ch, + semseg=semseg) + return num_out_ch, model + +def SimpleTR_B5(img_size=(192, 640), num_out_ch=512, semseg=False): + model = DEST_Encoder_Decoder( + img_size=img_size, + dims=(64, 128, 250, 320), + heads=(1, 2, 5, 8), + ff_expansion=(8, 8, 4, 4), + reduction_ratio=(8, 4, 2, 1), + num_layers=(3, 10, 16, 5), + channels=3, + decoder_dim=num_out_ch, + num_classes=num_out_ch, + semseg=semseg) + return num_out_ch, model + diff --git a/DEST/networks/DEST/__init__.py b/DEST/networks/DEST/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/DEST/networks/DEST/simplified_attention.py b/DEST/networks/DEST/simplified_attention.py new file mode 100644 index 00000000..f02d9e6c --- /dev/null +++ b/DEST/networks/DEST/simplified_attention.py @@ -0,0 +1,321 @@ +# Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +import math +import torch +import torch.nn as nn +from timm.models.layers import DropPath, to_2tuple, trunc_normal_ + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.ReLU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + + self.fc1 = nn.Conv1d(in_features, hidden_features, 1) + self.dwconv = DWConv(hidden_features) + self.act = nn.ReLU() + self.fc2 = nn.Conv1d(hidden_features, out_features, 1) + self.drop = nn.Dropout(drop) + + self.norm1 = nn.BatchNorm1d(hidden_features) + self.norm2 = nn.BatchNorm1d(hidden_features) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Conv1d): + trunc_normal_(m.weight, std=.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x, H, W): + x = self.fc1(x) + x = self.norm1(x) + x = self.dwconv(x, H, W) + x = self.norm2(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class Attention_MaxPool(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1): + super().__init__() + assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}." + + self.dim = dim + self.num_heads = num_heads + head_dim = dim // num_heads + + self.scale = qk_scale or head_dim ** -0.5 + + self.q = nn.Conv1d(dim, dim, 1, bias=qkv_bias) + self.k = nn.Conv1d(dim, dim, 1, bias=qkv_bias) + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Conv1d(dim, dim, 1) + self.proj_drop = nn.Dropout(proj_drop) + + self.sr_ratio = sr_ratio + if sr_ratio > 1: + self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio) + self.norm = nn.BatchNorm1d(dim) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + elif isinstance(m, nn.Conv1d): + trunc_normal_(m.weight, std=.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x, H, W): + B, C, N = x.shape + q = self.q(x) + q = q.reshape(B, self.num_heads, C // self.num_heads, N) + q = q.permute(0, 1, 3, 2) + + if self.sr_ratio > 1: + x_ = x.reshape(B, C, H, W) + x_ = self.sr(x_).reshape(B, C, -1) + x_ = self.norm(x_) + k = self.k(x_).reshape(B, self.num_heads, C // self.num_heads, -1) + else: + k = self.k(x).reshape(B, self.num_heads, C // self.num_heads, -1) + + v = torch.mean(x, 2, True).repeat(1, 1, self.num_heads).transpose(-2, -1) + + attn = (q @ k) * self.scale + attn, _ = torch.max(attn, -1) + + out = (attn.transpose(-2, -1) @ v) + out = out.transpose(-2, -1) + out = self.proj(out) + return out + +class Block(nn.Module): + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., act_layer=nn.ReLU, norm_layer=nn.LayerNorm, sr_ratio=1): + super().__init__() + self.norm1 = nn.BatchNorm1d(dim) + self.norm2 = nn.BatchNorm1d(dim) + + self.attn = Attention_MaxPool(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, sr_ratio=sr_ratio) + + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def forward(self, x, H, W): + x = x + self.drop_path(self.attn(self.norm1(x), H, W)) + x = x + self.drop_path(self.mlp(self.norm2(x), H, W)) + return x + + +class OverlapPatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=(224,224), patch_size=7, stride=4, in_chans=3, embed_dim=768): + super().__init__() + patch_size = to_2tuple(patch_size) + + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = img_size[0] // patch_size[0] * img_size[1] // patch_size[1] + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride, + padding=(patch_size[0] // 2, patch_size[1] // 2)) + + self.norm = nn.BatchNorm2d(embed_dim) + + self.H = (img_size[0] - patch_size[0] + 2 * (patch_size[0] // 2)) / stride + 1 + self.W = (img_size[1] - patch_size[1] + 2 * (patch_size[1] // 2)) / stride + 1 + self.feat_shape = (int(self.H), int(self.W)) + self.N = int(self.feat_shape[0] * self.feat_shape[1]) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def forward(self, x): + x = self.proj(x) + _, _, H, W = x.shape + x = self.norm(x) + x = x.flatten(2) + return x, H, W + + +class SimplifiedTransformer(nn.Module): + def __init__(self, img_size=(224,224), patch_size=16, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512], + num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0., + attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm, + depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1] + ): + super().__init__() + self.num_classes = num_classes + self.depths = depths + self.embed_dims = embed_dims + self.sr_ratios = sr_ratios + self.num_layers = depths + + # patch_embed + self.patch_embed1 = OverlapPatchEmbed(img_size=img_size, patch_size=7, stride=4, in_chans=in_chans, + embed_dim=embed_dims[0]) + self.patch_embed2 = OverlapPatchEmbed(img_size=(img_size[0] // 4, img_size[1] // 4), patch_size=3, stride=2, in_chans=embed_dims[0], + embed_dim=embed_dims[1]) + self.patch_embed3 = OverlapPatchEmbed(img_size=(img_size[0] // 8, img_size[1] // 8), patch_size=3, stride=2, in_chans=embed_dims[1], + embed_dim=embed_dims[2]) + self.patch_embed4 = OverlapPatchEmbed(img_size=(img_size[0] // 16, img_size[1] // 16), patch_size=3, stride=2, in_chans=embed_dims[2], + embed_dim=embed_dims[3]) + + # encoder + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule + cur = 0 + self.block1 = nn.ModuleList([Block( + dim=embed_dims[0], num_heads=num_heads[0], mlp_ratio=mlp_ratios[0], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[0]) + for i in range(depths[0])]) + + cur += depths[0] + self.block2 = nn.ModuleList([Block( + dim=embed_dims[1], num_heads=num_heads[1], mlp_ratio=mlp_ratios[1], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[1]) + for i in range(depths[1])]) + + cur += depths[1] + self.block3 = nn.ModuleList([Block( + dim=embed_dims[2], num_heads=num_heads[2], mlp_ratio=mlp_ratios[2], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[2]) + for i in range(depths[2])]) + + cur += depths[2] + self.block4 = nn.ModuleList([Block( + dim=embed_dims[3], num_heads=num_heads[3], mlp_ratio=mlp_ratios[3], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[3]) + for i in range(depths[3])]) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.GroupNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'} + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=''): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, x): + + B = x.shape[0] + outs = [] + ref_feat = {'1': [], '2': [], '3': [], '4': [],} + + # stage 1 + x, H, W = self.patch_embed1(x) + for i, blk in enumerate(self.block1): + x = blk(x, H, W) + ref_feat['1'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + # stage 2 + x, H, W = self.patch_embed2(x) + for i, blk in enumerate(self.block2): + x = blk(x, H, W) + ref_feat['2'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + # stage 3 + x, H, W = self.patch_embed3(x) + for i, blk in enumerate(self.block3): + x = blk(x, H, W) + ref_feat['3'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + # stage 4 + x, H, W = self.patch_embed4(x) + for i, blk in enumerate(self.block4): + x = blk(x, H, W) + ref_feat['4'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + return outs, ref_feat + + def forward(self, x): + x, ref_feat = self.forward_features(x) + return x, ref_feat + + +class DWConv(nn.Module): + def __init__(self, dim=768): + super(DWConv, self).__init__() + self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim) + + def forward(self, x, H, W): + B, C, N = x.shape + x = x.reshape(B, C, H, W) + x = self.dwconv(x) + x = x.flatten(2) + return x + diff --git a/DEST/networks/DEST/simplified_joint_attention.py b/DEST/networks/DEST/simplified_joint_attention.py new file mode 100644 index 00000000..680c2b18 --- /dev/null +++ b/DEST/networks/DEST/simplified_joint_attention.py @@ -0,0 +1,267 @@ +# Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +import torch +import torch.nn as nn +from timm.models.layers import DropPath, trunc_normal_ + +import math + +from packnet_sfm.networks.DEST.simplified_attention import OverlapPatchEmbed, Mlp, Attention_MaxPool + + +class Attention_Joint_MaxPool(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1): + super().__init__() + assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}." + + self.dim = dim + + self.num_heads = num_heads + head_dim = dim // num_heads + + self.scale = qk_scale or head_dim ** -0.5 + + self.q = nn.Conv1d(dim, dim, 1, bias=qkv_bias) + self.k = nn.Conv1d(dim, dim, 1, bias=qkv_bias) + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Conv1d(dim, dim, 1) + self.proj_drop = nn.Dropout(proj_drop) + + self.norm2 = nn.BatchNorm1d(self.dim) + + self.sr_ratio = sr_ratio + if sr_ratio > 1: + self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio) + self.norm = nn.BatchNorm1d(dim) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + elif isinstance(m, nn.Conv1d): + trunc_normal_(m.weight, std=.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x, y, H, W): + B, C, N = x.shape + + q = self.q(x) + q = q.reshape(B, self.num_heads, C // self.num_heads, N) + q = q.permute(0, 1, 3, 2) + + if self.sr_ratio > 1: + x_ = x.reshape(B, C, H, W) + x_ = self.sr(x_).reshape(B, C, -1) + x_ = self.norm(x_) + k = self.k(x_).reshape(B, self.num_heads, C // self.num_heads, -1) + else: + k = self.k(x).reshape(B, self.num_heads, C // self.num_heads, -1) + + v = torch.mean(x, 2, True).repeat(1, 1, self.num_heads).transpose(-2, -1) + + + attn = (q @ k) * self.scale + + attn, _ = torch.max(attn, -1) + + out = (attn.transpose(-2, -1) @ v) + out = out.transpose(-2, -1) + + out = self.proj(out) + + return out + + +class JointBlock(nn.Module): + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., act_layer=nn.ReLU, norm_layer=nn.LayerNorm, sr_ratio=1): + super().__init__() + self.norm0 = nn.BatchNorm1d(dim) + self.norm1_ref = nn.BatchNorm1d(dim) + self.norm1_src = nn.BatchNorm1d(dim) + self.norm2 = nn.BatchNorm1d(dim) + + self.attn_joint = Attention_Joint_MaxPool(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, sr_ratio=sr_ratio) + + # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + + def forward(self, ref_feat, src_feat, H, W): + src_feat = src_feat + self.drop_path(self.attn_joint(self.norm1_ref(ref_feat), self.norm1_src(src_feat), H, W)) + src_feat = src_feat + self.drop_path(self.mlp(self.norm2(src_feat), H, W)) + return src_feat + + + +class SimplifiedJointTransformer(nn.Module): + def __init__(self, img_size=(224,224), patch_size=16, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512], + num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0., + attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm, + depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1]): + super().__init__() + self.num_classes = num_classes + self.depths = depths + self.embed_dims = embed_dims + self.sr_ratios = sr_ratios + + # patch_embed + self.patch_embed1 = OverlapPatchEmbed(img_size=img_size, patch_size=7, stride=4, in_chans=in_chans, + embed_dim=embed_dims[0]) + self.patch_embed2 = OverlapPatchEmbed(img_size=(img_size[0] // 4, img_size[1] // 4), patch_size=3, stride=2, in_chans=embed_dims[0], + embed_dim=embed_dims[1]) + self.patch_embed3 = OverlapPatchEmbed(img_size=(img_size[0] // 8, img_size[1] // 8), patch_size=3, stride=2, in_chans=embed_dims[1], + embed_dim=embed_dims[2]) + self.patch_embed4 = OverlapPatchEmbed(img_size=(img_size[0] // 16, img_size[1] // 16), patch_size=3, stride=2, in_chans=embed_dims[2], + embed_dim=embed_dims[3]) + + # encoder + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule + cur = 0 + self.block1 = nn.ModuleList([JointBlock( + dim=embed_dims[0], num_heads=num_heads[0], mlp_ratio=mlp_ratios[0], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[0]) + for i in range(depths[0])]) + self.norm1 = nn.BatchNorm1d(self.patch_embed1.N) + + + cur += depths[0] + self.block2 = nn.ModuleList([JointBlock( + dim=embed_dims[1], num_heads=num_heads[1], mlp_ratio=mlp_ratios[1], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[1]) + for i in range(depths[1])]) + self.norm2 = nn.BatchNorm1d(self.patch_embed2.N) + + cur += depths[1] + self.block3 = nn.ModuleList([JointBlock( + dim=embed_dims[2], num_heads=num_heads[2], mlp_ratio=mlp_ratios[2], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[2]) + for i in range(depths[2])]) + self.norm3 = nn.BatchNorm1d(self.patch_embed3.N) + + cur += depths[2] + self.block4 = nn.ModuleList([JointBlock( + dim=embed_dims[3], num_heads=num_heads[3], mlp_ratio=mlp_ratios[3], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[3]) + for i in range(depths[3])]) + self.norm4 = nn.BatchNorm1d(self.patch_embed4.N) + + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + + def reset_drop_path(self, drop_path_rate): + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(self.depths))] + cur = 0 + for i in range(self.depths[0]): + self.block1[i].drop_path.drop_prob = dpr[cur + i] + + cur += self.depths[0] + for i in range(self.depths[1]): + self.block2[i].drop_path.drop_prob = dpr[cur + i] + + cur += self.depths[1] + for i in range(self.depths[2]): + self.block3[i].drop_path.drop_prob = dpr[cur + i] + + cur += self.depths[2] + for i in range(self.depths[3]): + self.block4[i].drop_path.drop_prob = dpr[cur + i] + + def freeze_patch_emb(self): + self.patch_embed1.requires_grad = False + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'} # has pos_embed may be better + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=''): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, ref_feat, x): + B = x.shape[0] + + # stage 1 + x, H, W = self.patch_embed1(x) + for i, blk in enumerate(self.block1): + if i > len(ref_feat['1']) - 1 : i = -1 + x = blk(ref_feat['1'][i], x, H, W) + x = self.norm1(x.transpose(-2, -1)).transpose(-2, -1) + x = x.reshape(B, -1, H, W).contiguous() + + # stage 2 + x, H, W = self.patch_embed2(x) + for i, blk in enumerate(self.block2): + if i > len(ref_feat['2']) -1: i=-1 + x = blk(ref_feat['2'][i], x, H, W) + x = self.norm2(x.transpose(-2, -1)).transpose(-2, -1) + x = x.reshape(B, -1, H, W).contiguous() + + # stage 3 + x, H, W = self.patch_embed3(x) + for i, blk in enumerate(self.block3): + if i > len(ref_feat['3']) -1: i = -1 + x = blk(ref_feat['3'][i], x, H, W) + x = self.norm3(x.transpose(-2, -1)).transpose(-2, -1) + x = x.reshape(B, -1, H, W).contiguous() + + # stage 4 + x, H, W = self.patch_embed4(x) + for i, blk in enumerate(self.block4): + if i > len(ref_feat['4'])-1: i = -1 + x = blk(ref_feat['4'][i], x, H, W) + x = self.norm4(x.transpose(-2, -1)).transpose(-2, -1) + x = x.reshape(B, -1, H, W).contiguous() + return x + + def forward(self, ref_feat, x): + return self.forward_features(ref_feat, x) + diff --git a/DEST/networks/DESTNet.py b/DEST/networks/DESTNet.py new file mode 100644 index 00000000..71f4b603 --- /dev/null +++ b/DEST/networks/DESTNet.py @@ -0,0 +1,138 @@ +import math +import torch +import torch.nn as nn +from packnet_sfm.networks.DEST.DEST_EncDec import DEST_Pose, SimpleTR_B0, SimpleTR_B1, SimpleTR_B2, SimpleTR_B3, SimpleTR_B4, SimpleTR_B5 + + +class InvDepth(nn.Module): + """Inverse depth layer""" + def __init__(self, in_channels, out_channels=1, min_depth=0.5): + """ + Initializes an InvDepth object. + + Parameters + ---------- + in_channels : int + Number of input channels + out_channels : int + Number of output channels + min_depth : float + Minimum depth value to calculate + """ + super().__init__() + self.min_depth = min_depth + self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1) + self.pad = nn.ConstantPad2d([1] * 4, value=0) + self.activ = nn.Sigmoid() + self.scale = torch.tensor([self.min_depth]) + def forward(self, x): + """Runs the InvDepth layer.""" + x = self.conv1(self.pad(x)) + return self.activ(x) / self.min_depth + + +class DESTNet(nn.Module): + def __init__(self, model='B3', nb_ref_imgs=2, img_size=(192, 640)): + """ + Defines the size of DEST model + + Parameters + ---------- + model : string + The size of DEST can be selected: 'B0' | 'B1' | 'B2' | 'B3' | 'B4' | 'B5' + nb_ref_imgs : int + Number of reference images for Pose-Net + img_size : tuple + Input image size (H, W) + """ + super().__init__() + self.nb_ref_imgs = nb_ref_imgs + self.connectivity = True + + if model == 'B0': + self.num_out_ch, self.dest = SimpleTR_B0(img_size=img_size) + elif model == 'B1': + self.num_out_ch, self.dest = SimpleTR_B1(img_size=img_size) + elif model == 'B2': + self.num_out_ch, self.dest = SimpleTR_B2(img_size=img_size) + elif model == 'B3': + self.num_out_ch, self.dest = SimpleTR_B3(img_size=img_size) + elif model == 'B4': + self.num_out_ch, self.dest = SimpleTR_B4(img_size=img_size) + elif model == 'B5': + self.num_out_ch, self.dest = SimpleTR_B5(img_size=img_size) + + self.disp1_layer = InvDepth(self.dest.dims[-4]) + self.disp2_layer = InvDepth(self.dest.dims[-4]) + self.disp3_layer = InvDepth(self.dest.dims[-3]) + self.disp4_layer = InvDepth(self.dest.dims[-2]) + + num_out_ch, self.dest_pose = DEST_Pose(dims=self.dest.dest_encoder.embed_dims, channels=16, + num_layers=self.dest.dest_encoder.depths, + reduction_ratio=self.dest.dest_encoder.sr_ratios, + connectivity=self.connectivity) + + self.pose_pred = nn.Sequential(nn.Conv2d(self.dest.dest_encoder.embed_dims[3], 6 * self.nb_ref_imgs, kernel_size=1, padding=0)) + self.channel_reduction_pose = nn.Sequential(nn.Conv2d(9, 16, kernel_size=3, padding=0), + nn.BatchNorm2d(16), + nn.Tanh()) + + def measure_Complexity(self, input_size=(3, 192, 640), mode='Depth'): + input_shape = input_size + + if mode == 'Depth': + model = Dummy_net_depth(self.dest, self.disp1_layer).eval() + macs, params = get_model_complexity_info(model.cpu(), + input_shape, as_strings=True, + print_per_layer_stat=False, verbose=False) + print('{:<30} {:<8}'.format('%sNet Computational complexity: ' % mode, macs)) + print('{:<30} {:<8}'.format('%sNet Number of parameters: ' % mode, params)) + + + def forward(self, rgb): + """ + Runs the network and returns inverse depth maps + (4 scales if training and 1 if not). + """ + out, _, self.ref_feat = self.dest(rgb) + + x = self.disp1_layer(out[0]) + if self.training: + x2 = self.disp2_layer(out[1]) + x3 = self.disp3_layer(out[2]) + x4 = self.disp4_layer(out[3]) + + if self.training: + return {'inv_depths': [x, x2, x3, x4]} + else: + return {'inv_depths': x } + + def pose(self, image, context): + assert (len(context) == self.nb_ref_imgs) + input_ = [image] + input_.extend(context) + input_ = torch.cat(input_, 1) + + return self._poseNet(input_) + + def _poseNet(self, x_src): + x_src = self.channel_reduction_pose(x_src) + + if self.connectivity: + x = self.dest_pose(self.ref_feat, x_src) + else : + x = self.dest_pose(x_src) + + pose = self.pose_pred(x) + pose = pose.mean(3).mean(2) + pose = 0.01 * pose.view(pose.size(0), self.nb_ref_imgs, 6) + return pose + + + def reshape(self, ref_featss, b_): + for i, e_dim in enumerate(self.dest.dest_encoder.embed_dims): + ref_featss[i] = ref_featss[i].reshape(b_, -1, e_dim).repeat((1+self.nb_ref_imgs), 1, 1) + return ref_featss + + + diff --git a/DEST/networks/__init__.py b/DEST/networks/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/DEST/resources/attentions.png b/DEST/resources/attentions.png new file mode 100644 index 0000000000000000000000000000000000000000..5dd8814b681e03dc40fd8151e78f42fb01e47c9b GIT binary patch literal 167779 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%0DXl``?9;> zUy4hpP&fXMZFb}x7K)W5sq<2Ow=Z_{vhI9af&1H#35)JA!>*$?ik>!|j zCW-M82PcfU>==d=5??~nFY$##QG`Q}zB~bj;VL(})mLVeDSqI~j8(xudxp@_5Fija z1N=HB0fDTxHvX%e3E&1>01Ff@IRo@Ea6+bEPc-!O^ng|oD*a-HXt)gj@ z$A=$4vy$Ee2uQ=JQ3Q-CydY4O zd4iUDpuhhgklmO9IhQsg?&}!}LeD=~p_a{r1GUh`S%T%mSsz&nkK?*ypSJ)hKsk$n zOU$fB=m2m)ytx0Jph2#mR_!j^a|QV^)$s4u)tQ^OFkav8zxzao2*14c2H=s+nNzyJ zaw#DOrmdqt4gp~ ziwA*tn)_a_6)Xrg2k2BENmhFLFp$q#EYz0#r_=1qS&ajoR7a`)+l0ok@7ti}qb|&k zOHy%avDJo|YM#e~>WAlCx0*8qYP(Qo|5P%AMvdW-+qxW?KsWIw7di~{x0Eq

Iy8G%!UD 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 z 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 1: + self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio) + if sync_norm : + norm_cfg = dict(type='SyncBN', requires_grad=True) + self.norm1_name, norm1 = build_norm_layer(norm_cfg, dim, postfix=1) + self.add_module(self.norm1_name, norm1) + else : + self.norm1 = nn.BatchNorm1d(dim) + self.apply(self._init_weights) + + @property + def norm1(self): + """nn.Module: normalization layer after the first convolution layer""" + return getattr(self, self.norm1_name) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + elif isinstance(m, nn.Conv1d): + trunc_normal_(m.weight, std=.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x, H, W): + B, C, N = x.shape + q = self.q(x) + q = q.reshape(B, self.num_heads, C // self.num_heads, N) + q = q.permute(0, 1, 3, 2) + + if self.sr_ratio > 1: + x_ = x.reshape(B, C, H, W) + x_ = self.sr(x_).reshape(B, C, -1) + x_ = self.norm1(x_) + k = self.k(x_).reshape(B, self.num_heads, C // self.num_heads, -1) + else: + k = self.k(x).reshape(B, self.num_heads, C // self.num_heads, -1) + + v = torch.mean(x, 2, True).repeat(1, 1, self.num_heads).transpose(-2, -1) + + attn = (q @ k) * self.scale + attn, _ = torch.max(attn, -1) + + out = (attn.transpose(-2, -1) @ v) + out = out.transpose(-2, -1) + + out = self.proj(out) + + return out + + + +class Block(nn.Module): + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., act_layer=nn.ReLU, norm_layer=nn.LayerNorm, sr_ratio=1, sync_norm=True): + super().__init__() + if sync_norm : + norm_cfg = dict(type='SyncBN', requires_grad=True) + self.norm1_name, norm1 = build_norm_layer(norm_cfg, dim, postfix=1) + self.norm2_name, norm2 = build_norm_layer(norm_cfg, dim, postfix=2) + self.add_module(self.norm1_name, norm1) + self.add_module(self.norm2_name, norm2) + else : + self.norm1 = nn.BatchNorm1d(dim) + self.norm2 = nn.BatchNorm1d(dim) + + self.attn = Attention_MaxPool(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, sr_ratio=sr_ratio) + + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + @property + def norm1(self): + return getattr(self, self.norm1_name) + + @property + def norm2(self): + return getattr(self, self.norm2_name) + + def forward(self, x, H, W): + x = x + self.drop_path(self.attn(self.norm1(x), H, W)) + x = x + self.drop_path(self.mlp(self.norm2(x), H, W)) + return x + + +class OverlapPatchEmbed(BaseModule): + """ Image to Patch Embedding """ + def __init__(self, img_size=(224,224), patch_size=7, stride=4, in_chans=3, embed_dim=768, sync_norm=True): + super().__init__() + patch_size = to_2tuple(patch_size) + + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = img_size[0] // patch_size[0] * img_size[1] // patch_size[1] + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride, + padding=(patch_size[0] // 2, patch_size[1] // 2)) + + self.H = (img_size[0] - patch_size[0] + 2 * (patch_size[0] // 2)) / stride + 1 + self.W = (img_size[1] - patch_size[1] + 2 * (patch_size[1] // 2)) / stride + 1 + self.feat_shape = (int(self.H), int(self.W)) + self.N = int(self.feat_shape[0] * self.feat_shape[1]) + + if sync_norm: + norm_cfg = dict(type='SyncBN', requires_grad=True) + self.norm1_name, norm1 = build_norm_layer(norm_cfg, embed_dim, postfix=1) + self.add_module(self.norm1_name, norm1) + else : + self.norm1 = nn.BatchNorm2d(embed_dim) + + self.apply(self._init_weights) + + @property + def norm1(self): + """nn.Module: normalization layer after the first convolution layer""" + return getattr(self, self.norm1_name) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def forward(self, x): + x = self.proj(x) + _, _, H, W = x.shape + x = self.norm1(x) + x = x.flatten(2) + return x, H, W + + +@BACKBONES.register_module() +class SimplifiedTransformer(nn.Module): + def __init__(self, img_size=(224,224), patch_size=16, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512], + num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0., + attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm, + depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1], sync_norm=True + ): + super().__init__() + self.num_classes = num_classes + self.depths = depths + self.embed_dims = embed_dims + self.sr_ratios = sr_ratios + self.num_layers = depths + + # patch_embed + self.patch_embed1 = OverlapPatchEmbed(img_size=img_size, patch_size=7, stride=4, in_chans=in_chans, + embed_dim=embed_dims[0], sync_norm=sync_norm) + self.patch_embed2 = OverlapPatchEmbed(img_size=(img_size[0] // 4, img_size[1] // 4), patch_size=3, stride=2, in_chans=embed_dims[0], + embed_dim=embed_dims[1], sync_norm=sync_norm) + self.patch_embed3 = OverlapPatchEmbed(img_size=(img_size[0] // 8, img_size[1] // 8), patch_size=3, stride=2, in_chans=embed_dims[1], + embed_dim=embed_dims[2], sync_norm=sync_norm) + self.patch_embed4 = OverlapPatchEmbed(img_size=(img_size[0] // 16, img_size[1] // 16), patch_size=3, stride=2, in_chans=embed_dims[2], + embed_dim=embed_dims[3], sync_norm=sync_norm) + + # encoder + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule + cur = 0 + self.block1 = nn.ModuleList([Block( + dim=embed_dims[0], num_heads=num_heads[0], mlp_ratio=mlp_ratios[0], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[0], sync_norm=sync_norm) + for i in range(depths[0])]) + + cur += depths[0] + self.block2 = nn.ModuleList([Block( + dim=embed_dims[1], num_heads=num_heads[1], mlp_ratio=mlp_ratios[1], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[1], sync_norm=sync_norm) + for i in range(depths[1])]) + + cur += depths[1] + self.block3 = nn.ModuleList([Block( + dim=embed_dims[2], num_heads=num_heads[2], mlp_ratio=mlp_ratios[2], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[2], sync_norm=sync_norm) + for i in range(depths[2])]) + + cur += depths[2] + self.block4 = nn.ModuleList([Block( + dim=embed_dims[3], num_heads=num_heads[3], mlp_ratio=mlp_ratios[3], qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer, + sr_ratio=sr_ratios[3], sync_norm=sync_norm) + for i in range(depths[3])]) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.GroupNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'} + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=''): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, x): + + B = x.shape[0] + outs = [] + ref_feat = {'1': [], '2': [], '3': [], '4': [],} + + # stage 1 + x, H, W = self.patch_embed1(x) + for i, blk in enumerate(self.block1): + x = blk(x, H, W) + ref_feat['1'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + # stage 2 + x, H, W = self.patch_embed2(x) + for i, blk in enumerate(self.block2): + x = blk(x, H, W) + ref_feat['2'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + # stage 3 + x, H, W = self.patch_embed3(x) + for i, blk in enumerate(self.block3): + x = blk(x, H, W) + ref_feat['3'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + # stage 4 + x, H, W = self.patch_embed4(x) + for i, blk in enumerate(self.block4): + x = blk(x, H, W) + ref_feat['4'].append(x) + x = x.reshape(B, -1, H, W).contiguous() + outs.append(x) + + return outs, ref_feat + + def forward(self, x): + x, ref_feat = self.forward_features(x) + return x, ref_feat + + +class DWConv(nn.Module): + def __init__(self, dim=768): + super(DWConv, self).__init__() + self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim) + + def forward(self, x, H, W): + B, C, N = x.shape + x = x.reshape(B, C, H, W) + x = self.dwconv(x) + x = x.flatten(2) + return x + From d0eca5e0384977ba4b58ffc5ce75c31202c04a20 Mon Sep 17 00:00:00 2001 From: "John Yang (SW-TEGRA)" Date: Thu, 8 Dec 2022 18:14:03 -0800 Subject: [PATCH 4/5] typo semsmeg DEST-B4 --- DEST/semseg/dest_simpatt-b4_1024x1024_160k_cityscapes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DEST/semseg/dest_simpatt-b4_1024x1024_160k_cityscapes.py b/DEST/semseg/dest_simpatt-b4_1024x1024_160k_cityscapes.py index 767711ea..77aec70a 100644 --- a/DEST/semseg/dest_simpatt-b4_1024x1024_160k_cityscapes.py +++ b/DEST/semseg/dest_simpatt-b4_1024x1024_160k_cityscapes.py @@ -53,7 +53,7 @@ drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1, - depths=[3, 6, 8, 3], + depths=[3, 8, 12, 5], sr_ratios=[8, 4, 2, 1]), decode_head=dict( type='DestHead', From 0c8dd0a38a76506353ceec2e0ec509c8b0225226 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 27 Jan 2023 01:11:53 +0000 Subject: [PATCH 5/5] chore(deps): bump onnx from 1.6.0 to 1.13.0 in /LeNetWithS3Pooling/utils Bumps [onnx](https://github.com/onnx/onnx) from 1.6.0 to 1.13.0. - [Release notes](https://github.com/onnx/onnx/releases) - [Changelog](https://github.com/onnx/onnx/blob/main/docs/Changelog.md) - [Commits](https://github.com/onnx/onnx/compare/v1.6.0...v1.13.0) --- updated-dependencies: - dependency-name: onnx dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- LeNetWithS3Pooling/utils/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LeNetWithS3Pooling/utils/requirements.txt b/LeNetWithS3Pooling/utils/requirements.txt index b2dd15d1..aeeac506 100644 --- a/LeNetWithS3Pooling/utils/requirements.txt +++ b/LeNetWithS3Pooling/utils/requirements.txt @@ -1,2 +1,2 @@ -onnx==1.6.0 +onnx==1.13.0 torch==1.3.0