diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..d8982a411bc9f819feb81b78d941ef3bcad7a93b 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +torch_cache/facebookresearch_dinov2_main/docs/Cell-DINO.png filter=lfs diff=lfs merge=lfs -text +torch_cache/facebookresearch_dinov2_main/docs/ChannelAdaptiveDINO.png filter=lfs diff=lfs merge=lfs -text diff --git a/Qwen-Image-vae-2d/config.json b/Qwen-Image-vae-2d/config.json new file mode 100644 index 0000000000000000000000000000000000000000..2239f41daebf483ee9b100d0227780cc7a779440 --- /dev/null +++ b/Qwen-Image-vae-2d/config.json @@ -0,0 +1,57 @@ +{ + "_class_name": "AutoencoderKLQwenImage2D", + "_diffusers_version": "0.35.0", + "attn_scales": [], + "base_dim": 96, + "dim_mult": [ + 1, + 2, + 4, + 4 + ], + "dropout": 0.0, + "latents_mean": [ + -0.7571, + -0.7089, + -0.9113, + 0.1075, + -0.1745, + 0.9653, + -0.1517, + 1.5508, + 0.4134, + -0.0715, + 0.5517, + -0.3632, + -0.1922, + -0.9497, + 0.2503, + -0.2921 + ], + "latents_std": [ + 2.8184, + 1.4541, + 2.3275, + 2.6558, + 1.2196, + 1.7708, + 2.6052, + 2.0743, + 3.2687, + 2.1526, + 2.8652, + 1.5579, + 1.6382, + 1.1253, + 2.8251, + 1.916 + ], + "non_linearity": "silu", + "num_res_blocks": 2, + "temperal_downsample": [ + false, + true, + true + ], + "z_dim": 16 +} diff --git a/Qwen-Image-vae-2d/diffusion_pytorch_model.safetensors b/Qwen-Image-vae-2d/diffusion_pytorch_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..489eeb4b8958feb48c309e6d652157cf5cb0c783 --- /dev/null +++ b/Qwen-Image-vae-2d/diffusion_pytorch_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1dd2c67f3f29734d48709513ed181d4f351966d76ba95f77a5cff8e1daf547fa +size 178418892 diff --git a/VOSR_0.5B_ms/args.json b/VOSR_0.5B_ms/args.json new file mode 100644 index 0000000000000000000000000000000000000000..c0cb10a1ba9a731c88d1e7c827cc2e8aeff89fc7 --- /dev/null +++ b/VOSR_0.5B_ms/args.json @@ -0,0 +1,26 @@ +{ + "resolution": 512, + "patch_size": 2, + "mlp_ratio": 4, + "use_qknorm": true, + "use_swiglu": true, + "use_rope": true, + "use_rmsnorm": true, + "wo_shift": false, + "dim": 1024, + "depth": 28, + "num_heads": 16, + "ae_type": "sd2", + "ae_path": "preset/ckpts/stable-diffusion-2-1-base", + "time_dist": ["uniform", 0, 1.0], + "cfg_ratio": 0.1, + "cfg_scale": 2.0, + "dinov2_size": 448, + "enc_type": "dinov2b", + "enc_dim": 768, + "layer_dinov2b_list": [8], + "interp_type": "lin", + "encdim_ratio": 3, + "weak_cond_strength_aelq_list": [0.05, 0.25], + "cond_strength_aelq_list": [5, 1] +} diff --git a/VOSR_0.5B_ms/checkpoints/ema_model.safetensors b/VOSR_0.5B_ms/checkpoints/ema_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..35537cea0c7874aa5d71a5ba83b31a215a66d885 --- /dev/null +++ b/VOSR_0.5B_ms/checkpoints/ema_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec453a1ad84fee401494982f5079febb220f0a14311d8f00948e427251d5dbff +size 1943086064 diff --git a/VOSR_0.5B_os/args.json b/VOSR_0.5B_os/args.json new file mode 100644 index 0000000000000000000000000000000000000000..ecdaf43507aa279bd945b88bff6b0fe745afdde9 --- /dev/null +++ b/VOSR_0.5B_os/args.json @@ -0,0 +1,30 @@ +{ + "resolution": 512, + "patch_size": 2, + "mlp_ratio": 4, + "use_qknorm": true, + "use_swiglu": true, + "use_rope": true, + "use_rmsnorm": true, + "wo_shift": false, + "dim": 1024, + "depth": 28, + "num_heads": 16, + "ae_type": "sd2", + "ae_path": "preset/ckpts/stable-diffusion-2-1-base", + "time_dist": ["uniform", 0, 1.0], + "cfg_ratio": 0.1, + "cfg_scale": 0.5, + "dinov2_size": 448, + "enc_type": "dinov2b", + "enc_dim": 768, + "layer_dinov2b_list": [8], + "interp_type": "lin", + "encdim_ratio": 3, + "weak_cond_strength_aelq_list": [0.05, 0.25], + "weak_cond_strength_aelq": 0.1, + "cond_strength_aelq_list": [5, 1], + "t_start": 0, + "t_end": 1, + "distill_type": "rcgm" +} diff --git a/VOSR_0.5B_os/checkpoints/ema_model.safetensors b/VOSR_0.5B_os/checkpoints/ema_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5c0a77cb1c431cc6e615669e29c9d17cf5376056 --- /dev/null +++ b/VOSR_0.5B_os/checkpoints/ema_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45b6687b4ce59fa3451300f9e0fdcaf2e729c15e65f444af210a7851dfa13203 +size 1948337520 diff --git a/VOSR_1.4B_ms/args.json b/VOSR_1.4B_ms/args.json new file mode 100644 index 0000000000000000000000000000000000000000..fbb150762648ad625f34216aa4572b67b2802bb5 --- /dev/null +++ b/VOSR_1.4B_ms/args.json @@ -0,0 +1,26 @@ +{ + "resolution": 512, + "patch_size": 2, + "mlp_ratio": 4, + "use_qknorm": true, + "use_swiglu": true, + "use_rope": true, + "use_rmsnorm": true, + "wo_shift": false, + "dim": 1536, + "depth": 36, + "num_heads": 24, + "ae_type": "qwen", + "ae_path": "preset/ckpts/Qwen-Image-vae-2d", + "time_dist": ["uniform", 0, 1.0], + "cfg_ratio": 0.1, + "cfg_scale": 2.0, + "dinov2_size": 448, + "enc_type": "dinov2l", + "enc_dim": 1024, + "layer_dinov2b_list": [17], + "interp_type": "lin", + "encdim_ratio": 3, + "weak_cond_strength_aelq_list": [0.05, 0.25], + "cond_strength_aelq_list": [5, 1] +} diff --git a/VOSR_1.4B_ms/checkpoints/ema_model.safetensors b/VOSR_1.4B_ms/checkpoints/ema_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..01ea5e346b7d3f75c9d15afaad63288fe95924f4 --- /dev/null +++ b/VOSR_1.4B_ms/checkpoints/ema_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3123e4bf6337af0545fae31f180b3f240ac8d7d3125021495a8da8d55c422f95 +size 5576385424 diff --git a/VOSR_1.4B_os/args.json b/VOSR_1.4B_os/args.json new file mode 100644 index 0000000000000000000000000000000000000000..fb66a6538b76cc34265c3ce3420e077565adfc77 --- /dev/null +++ b/VOSR_1.4B_os/args.json @@ -0,0 +1,30 @@ +{ + "resolution": 512, + "patch_size": 2, + "mlp_ratio": 4, + "use_qknorm": true, + "use_swiglu": true, + "use_rope": true, + "use_rmsnorm": true, + "wo_shift": false, + "dim": 1536, + "depth": 36, + "num_heads": 24, + "ae_type": "qwen", + "ae_path": "preset/ckpts/Qwen-Image-vae-2d", + "time_dist": ["uniform", 0, 1.0], + "cfg_ratio": 0.1, + "cfg_scale": 0.5, + "dinov2_size": 448, + "enc_type": "dinov2l", + "enc_dim": 1024, + "layer_dinov2b_list": [17], + "interp_type": "lin", + "encdim_ratio": 3, + "weak_cond_strength_aelq_list": [0.05, 0.25], + "weak_cond_strength_aelq": 0.1, + "cond_strength_aelq_list": [5, 1], + "t_start": 0, + "t_end": 1, + "distill_type": "rcgm" +} diff --git a/VOSR_1.4B_os/checkpoints/ema_model.safetensors b/VOSR_1.4B_os/checkpoints/ema_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..ae33c1455d830cc92178090d75ac75aa3de37c38 --- /dev/null +++ b/VOSR_1.4B_os/checkpoints/ema_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d65f95580c4a04badf646d20aa2482ae9a61d9f5cc7bd278ad8e1a37321fbf5d +size 5587408152 diff --git a/sd21_lwdecoder.pth b/sd21_lwdecoder.pth new file mode 100644 index 0000000000000000000000000000000000000000..22f9ee0a5ed7517002ce37694d51d5968bd0c3f4 --- /dev/null +++ b/sd21_lwdecoder.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a326a5e5c4a2445ce970987695979f3d5e5413d39b98c73a2ddac0055d2cdf59 +size 52086482 diff --git a/stable-diffusion-2-1-base/vae/config.json b/stable-diffusion-2-1-base/vae/config.json new file mode 100644 index 0000000000000000000000000000000000000000..1560d8222c55187b683632da3a2ab1cbd180c767 --- /dev/null +++ b/stable-diffusion-2-1-base/vae/config.json @@ -0,0 +1,29 @@ +{ + "_class_name": "AutoencoderKL", + "_diffusers_version": "0.10.0.dev0", + "act_fn": "silu", + "block_out_channels": [ + 128, + 256, + 512, + 512 + ], + "down_block_types": [ + "DownEncoderBlock2D", + "DownEncoderBlock2D", + "DownEncoderBlock2D", + "DownEncoderBlock2D" + ], + "in_channels": 3, + "latent_channels": 4, + "layers_per_block": 2, + "norm_num_groups": 32, + "out_channels": 3, + "sample_size": 768, + "up_block_types": [ + "UpDecoderBlock2D", + "UpDecoderBlock2D", + "UpDecoderBlock2D", + "UpDecoderBlock2D" + ] +} diff --git a/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.bin b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.bin new file mode 100644 index 0000000000000000000000000000000000000000..ba36f34d64ad3be997b7cab94b0b9acd61272851 --- /dev/null +++ b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b4889b6b1d4ce7ae320a02dedaeff1780ad77d415ea0d744b476155c6377ddc +size 334707217 diff --git a/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.fp16.bin b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.fp16.bin new file mode 100644 index 0000000000000000000000000000000000000000..7bd1e43876a5e4710cd00271a03076e03ff557aa --- /dev/null +++ b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.fp16.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44915add42092106e70bffac475aae4283b5e8167a8a0c5f55ccc667ee4ebeb5 +size 167405651 diff --git a/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.fp16.safetensors b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.fp16.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9a75e3c8e7cf4387be816cdebb751fbd5fc4e1e2 --- /dev/null +++ b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.fp16.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e4c08995484ee61270175e9e7a072b66a6e4eeb5f0c266667fe1f45b90daf9a +size 167335342 diff --git a/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.safetensors b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..90464d67ac7303d0ee4696334df13da130a948ea --- /dev/null +++ b/stable-diffusion-2-1-base/vae/diffusion_pytorch_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1d993488569e928462932c8c38a0760b874d166399b14414135bd9c42df5815 +size 334643276 diff --git a/torch_cache/checkpoints/LPIPS_v0.1_alex-df73285e.pth b/torch_cache/checkpoints/LPIPS_v0.1_alex-df73285e.pth new file mode 100644 index 0000000000000000000000000000000000000000..fa4067abc5d4da16a7204fd94776506e4868030e --- /dev/null +++ b/torch_cache/checkpoints/LPIPS_v0.1_alex-df73285e.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0 +size 6009 diff --git a/torch_cache/checkpoints/alexnet-owt-7be5be79.pth b/torch_cache/checkpoints/alexnet-owt-7be5be79.pth new file mode 100644 index 0000000000000000000000000000000000000000..779e66b9c31e9a0b60a3f1530626d98f2d898c60 --- /dev/null +++ b/torch_cache/checkpoints/alexnet-owt-7be5be79.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02 +size 244408911 diff --git a/torch_cache/checkpoints/dinov2_vitb14_pretrain.pth b/torch_cache/checkpoints/dinov2_vitb14_pretrain.pth new file mode 100644 index 0000000000000000000000000000000000000000..d34296dd581613275b958eb6ac8ad5ce10f24055 --- /dev/null +++ b/torch_cache/checkpoints/dinov2_vitb14_pretrain.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b8b82f85de91b424aded121c7e1dcc2b7bc6d0adeea651bf73a13307fad8c73 +size 346378731 diff --git a/torch_cache/checkpoints/dinov2_vitl14_pretrain.pth b/torch_cache/checkpoints/dinov2_vitl14_pretrain.pth new file mode 100644 index 0000000000000000000000000000000000000000..63169925c99527025469fa26f9a6bb98069c87ef --- /dev/null +++ b/torch_cache/checkpoints/dinov2_vitl14_pretrain.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d5383ea8f4877b2472eb973e0fd72d557c7da5d3611bd527ceeb1d7162cbf428 +size 1217586395 diff --git a/torch_cache/checkpoints/musiq_koniq_ckpt-e95806b9.pth b/torch_cache/checkpoints/musiq_koniq_ckpt-e95806b9.pth new file mode 100644 index 0000000000000000000000000000000000000000..81cbd42d6c8b20ff2fc9535aa4ba47d7a0d201ee --- /dev/null +++ b/torch_cache/checkpoints/musiq_koniq_ckpt-e95806b9.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e95806b9eae5f3814c410f574ba8e552362bd5bc63d758ed5b97860f5d6185aa +size 108610983 diff --git a/torch_cache/facebookresearch_dinov2_main/.github/workflows/lint.yaml b/torch_cache/facebookresearch_dinov2_main/.github/workflows/lint.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fccde30bf66d90178fdcad2bd167bc12afc734d9 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/.github/workflows/lint.yaml @@ -0,0 +1,38 @@ +name: Lint + +on: + push: + branches: + - main + pull_request: + branches: + - main + +jobs: + run-linters: + name: Run linters + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v3 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: 3.9 + cache: 'pip' + cache-dependency-path: '**/requirements*.txt' + - name: Install Python (development) dependencies + run: | + pip install -r requirements-dev.txt + - name: Run flake8 + run: | + flake8 + - name: Run black + if: always() + run: | + black --check dinov2 + - name: Run pylint + if: always() + run: | + pylint --exit-zero dinov2 diff --git a/torch_cache/facebookresearch_dinov2_main/.gitignore b/torch_cache/facebookresearch_dinov2_main/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..8d0cb834b21304574c51b568e7325faeb4404275 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/.gitignore @@ -0,0 +1,11 @@ +build/ +dist/ +*.egg-info/ +**/__pycache__/ + +**/.ipynb_checkpoints +**/.ipynb_checkpoints/** + +*.swp + +.vscode/ diff --git a/torch_cache/facebookresearch_dinov2_main/CODE_OF_CONDUCT.md b/torch_cache/facebookresearch_dinov2_main/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000000000000000000000000000000000..ad756270428cffe88b95f0b1f7d8aaf40dddb9db --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/CODE_OF_CONDUCT.md @@ -0,0 +1,80 @@ +# Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to make participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic +address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a +professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies within all project spaces, and it also applies when +an individual is representing the project or its community in public spaces. +Examples of representing a project or community include using an official +project e-mail address, posting via an official social media account, or acting +as an appointed representative at an online or offline event. Representation of +a project may be further defined and clarified by project maintainers. + +This Code of Conduct also applies outside the project spaces when there is a +reasonable belief that an individual's behavior may have a negative impact on +the project or its community. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at . All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq diff --git a/torch_cache/facebookresearch_dinov2_main/CONTRIBUTING.md b/torch_cache/facebookresearch_dinov2_main/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..dd4bb72c671ea5f74cef97beb3707747f28655a6 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/CONTRIBUTING.md @@ -0,0 +1,31 @@ +# Contributing to DINOv2 +We want to make contributing to this project as easy and transparent as +possible. + +## Pull Requests +We actively welcome your pull requests. + +1. Fork the repo and create your branch from `main`. +2. If you've added code that should be tested, add tests. +3. If you've changed APIs, update the documentation. +4. Ensure the test suite passes. +5. Make sure your code lints. +6. If you haven't already, complete the Contributor License Agreement ("CLA"). + +## Contributor License Agreement ("CLA") +In order to accept your pull request, we need you to submit a CLA. You only need +to do this once to work on any of Meta's open source projects. + +Complete your CLA here: + +## Issues +We use GitHub issues to track public bugs. Please ensure your description is +clear and has sufficient instructions to be able to reproduce the issue. + +Meta has a [bounty program](https://www.facebook.com/whitehat/) for the safe +disclosure of security bugs. In those cases, please go through the process +outlined on that page and do not file a public issue. + +## License +By contributing to DINOv2, you agree that your contributions will be licensed +under the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/LICENSE b/torch_cache/facebookresearch_dinov2_main/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..8d25ce0dae02f5f20b19c3114bbb8879be419486 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/LICENSE @@ -0,0 +1,203 @@ + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. 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 and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/torch_cache/facebookresearch_dinov2_main/LICENSE_CELL_DINO_CODE b/torch_cache/facebookresearch_dinov2_main/LICENSE_CELL_DINO_CODE new file mode 100644 index 0000000000000000000000000000000000000000..304971eb515a35d363ad9dd991698dbefb922ac5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/LICENSE_CELL_DINO_CODE @@ -0,0 +1,395 @@ +Attribution 4.0 International + +======================================================================= + +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= + +Creative Commons Attribution 4.0 International Public License + +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution 4.0 International Public License ("Public License"). To the +extent this Public License may be interpreted as a contract, You are +granted the Licensed Rights in consideration of Your acceptance of +these terms and conditions, and the Licensor grants You such rights in +consideration of benefits the Licensor receives from making the +Licensed Material available under these terms and conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Adapter's License means the license You apply to Your Copyright + and Similar Rights in Your contributions to Adapted Material in + accordance with the terms and conditions of this Public License. + + c. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + + d. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + e. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + f. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + g. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + h. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + i. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + j. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + k. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part; and + + b. produce, reproduce, and Share Adapted Material. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. + + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). + + b. Other rights. + + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. + + 2. Patent and trademark rights are not licensed under this + Public License. + + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties. + + +Section 3 -- License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. + + a. Attribution. + + 1. If You Share the Licensed Material (including in modified + form), You must: + + a. retain the following if it is supplied by the Licensor + with the Licensed Material: + + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of + warranties; + + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; + + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and + + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. + + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. + + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. + + 4. If You Share Adapted Material You produce, the Adapter's + License You apply must not prevent recipients of the Adapted + Material from complying with this Public License. + + +Section 4 -- Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: + + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database; + + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material; and + + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. + + +Section 5 -- Disclaimer of Warranties and Limitation of Liability. + + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. + + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. + + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. + + +Section 6 -- Term and Termination. + + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. + + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: + + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or + + 2. upon express reinstatement by the Licensor. + + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. + + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. + + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. + + +Section 7 -- Other Terms and Conditions. + + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. + + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. + + +Section 8 -- Interpretation. + + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. + + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. + + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. + + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. + + +======================================================================= + +Creative Commons is not a party to its public +licenses. Notwithstanding, Creative Commons may elect to apply one of +its public licenses to material it publishes and in those instances +will be considered the “Licensor.” The text of the Creative Commons +public licenses is dedicated to the public domain under the CC0 Public +Domain Dedication. Except for the limited purpose of indicating that +material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the +public licenses. + +Creative Commons may be contacted at creativecommons.org. \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/LICENSE_CELL_DINO_MODELS b/torch_cache/facebookresearch_dinov2_main/LICENSE_CELL_DINO_MODELS new file mode 100644 index 0000000000000000000000000000000000000000..d959cd387b076b4235e1d30a92d94a8edfb839ed --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/LICENSE_CELL_DINO_MODELS @@ -0,0 +1,124 @@ +FAIR Noncommercial Research License +v1 Last Updated: August 18, 2025 + +“Acceptable Use Policy” means the FAIR Acceptable Use Policy, applicable to Research Materials, that is incorporated into this Agreement. + +“Agreement” means the terms and conditions for use, reproduction, distribution and modification of the Research Materials set forth herein. + + +“Documentation” means the specifications, manuals and documentation accompanying +Research Materials distributed by Meta. + + +“Licensee” or “you” means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf. + + +“Meta” or “we” means Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) and Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland). + +“Noncommercial Research Uses” means noncommercial research use cases related to research, development, education, processing, or analysis and in each case, is not primarily intended for commercial advantage or monetary compensation to you or others. + +“Research Materials” means, collectively, Documentation and the models, software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code, demonstration materials and other elements of the foregoing distributed by Meta and made available under this Agreement. + +By clicking “I Accept” below or by using or distributing any portion or element of the Research Materials, you agree to be bound by this Agreement. + + +1. License Rights and Redistribution. + + +a. Grant of Rights. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the Research Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Research Materials. + +b. Redistribution and Use. + i. You will not use the Research Materials or any outputs or results of the Research Materials in connection with any commercial uses or for any uses other than Noncommercial Research Uses; + + +ii. Distribution of Research Materials, and any derivative works thereof, are subject to the terms of this Agreement. If you distribute or make the Research Materials, or any derivative works thereof, available to a third party, you may only do so under the terms of this Agreement. You shall also provide a copy of this Agreement to such third party. + + +iii. If you submit for publication the results of research you perform on, using, or otherwise in connection with Research Materials, you must acknowledge the use of Research Materials in your publication. + + +iv. Your use of the Research Materials must comply with applicable laws and regulations (including Trade Control Laws) and adhere to the FAIR Acceptable Use Policy, which is hereby incorporated by reference into this Agreement. +2. User Support. Your Noncommercial Research Use of the Research Materials is done at your own discretion; Meta does not process any information nor provide any service in relation to such use. Meta is under no obligation to provide any support services for the Research Materials. Any support provided is “as is”, “with all faults”, and without warranty of any kind. + + +3. Disclaimer of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE RESEARCH MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE RESEARCH MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE RESEARCH MATERIALS AND ANY OUTPUT AND RESULTS. + +4. Limitation of Liability. IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT OR INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING. + +5. Intellectual Property. + + +a. Subject to Meta’s ownership of Research Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the Research Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications. + +b. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Research Materials, outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the Research Materials. + +6. Term and Termination. The term of this Agreement will commence upon your acceptance of this Agreement or access to the Research Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the Research Materials. Sections 3, 4 and 7 shall survive the termination of this Agreement. + +7. Governing Law and Jurisdiction. This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement. + + +8. Modifications and Amendments. Meta may modify this Agreement from time to time; provided that they are similar in spirit to the current version of the Agreement, but may differ in detail to address new problems or concerns. All such changes will be effective immediately. Your continued use of the Research Materials after any modification to this Agreement constitutes your agreement to such modification. Except as provided in this Agreement, no modification or addition to any provision of this Agreement will be binding unless it is in writing and signed by an authorized representative of both you and Meta. + + +FAIR Acceptable Use Policy + +The Fundamental AI Research (FAIR) team at Meta seeks to further understanding of new and existing research domains with the mission of advancing the state-of-the-art in artificial intelligence through open research for the benefit of all. + +As part of this mission, Meta makes certain research materials available for noncommercial research use. Meta is committed to promoting the safe and responsible use of such research materials. + +Prohibited Uses + +You agree you will not use, or allow others to use, Research Materials to: + + Violate the law or others’ rights, including to: +Engage in, promote, generate, contribute to, encourage, plan, incite, or further illegal or unlawful activity or content, such as: +Violence or terrorism +Exploitation or harm to children, including the solicitation, creation, acquisition, or dissemination of child exploitative content or failure to report Child Sexual Abuse Material +Human trafficking, exploitation, and sexual violence +The illegal distribution of information or materials to minors, including obscene materials, or failure to employ legally required age-gating in connection with such information or materials. +Sexual solicitation +Any other criminal activity + +Engage in, promote, incite, or facilitate the harassment, abuse, threatening, or bullying of individuals or groups of individuals + +Engage in, promote, incite, or facilitate discrimination or other unlawful or harmful conduct in the provision of employment, employment benefits, credit, housing, other economic benefits, or other essential goods and services + +Engage in the unauthorized or unlicensed practice of any profession including, but not limited to, financial, legal, medical/health, or related professional practices + +Collect, process, disclose, generate, or infer health, demographic, or other sensitive personal or private information about individuals without rights and consents required by applicable laws + +Engage in or facilitate any action or generate any content that infringes, misappropriates, or otherwise violates any third-party rights, including the outputs or results of any technology using FAIR research materials + +Create, generate, or facilitate the creation of malicious code, malware, computer viruses or do anything else that could disable, overburden, interfere with or impair the proper working, integrity, operation or appearance of a website or computer system + +2. Engage in, promote, incite, facilitate, or assist in the planning or development of activities that present a risk of death or bodily harm to individuals, including use of research artifacts related to the following: + +Military, warfare, nuclear industries or applications, espionage, use for materials or activities that are subject to the International Traffic Arms Regulations (ITAR) maintained by the United States Department of State + +Guns and illegal weapons (including weapon development) + +Illegal drugs and regulated/controlled substances + +Operation of critical infrastructure, transportation technologies, or heavy machinery + +Self-harm or harm to others, including suicide, cutting, and eating disorders + +Any content intended to incite or promote violence, abuse, or any infliction of bodily harm to an individual + +3. Intentionally deceive or mislead others, including use of FAIR Research Materials related to the following: + + Generating, promoting, or furthering fraud or the creation or promotion of disinformation + + Generating, promoting, or furthering defamatory content, including the creation of defamatory statements, images, or other content + +Generating, promoting, or further distributing spam + + Impersonating another individual without consent, authorization, or legal right + +Representing that outputs of FAIR research materials or outputs from technology using FAIR research materials are human-generated + +Generating or facilitating false online engagement, including fake reviews and other means of fake online engagement + +4. Fail to appropriately disclose to end users any known dangers of your Research Materials. + +Please report any violation of this Policy or other problems that could lead to a violation of this Policy by submitting a report here [https://docs.google.com/forms/d/e/1FAIpQLSeb11cryAopJ7LNrC4nxEUXrHY26hfkXQMf_uH-oFgA3WlYZQ/viewform]. \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/LICENSE_XRAY_DINO_MODEL b/torch_cache/facebookresearch_dinov2_main/LICENSE_XRAY_DINO_MODEL new file mode 100644 index 0000000000000000000000000000000000000000..1f2f03eab85b6054049adb198be4608a4d564f29 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/LICENSE_XRAY_DINO_MODEL @@ -0,0 +1,39 @@ +X-Ray DINO Research License [2025/12/18] + +This X-Ray DINO Research License (“Agreement”) contains the terms and conditions that govern your access and use of the Materials (as defined below). You may not use the Materials if you do not accept this Agreement. By clicking “I Accept” to accept, or accessing, using, or distributing any portion or element of the Materials you hereby agree to be bound by the terms of this Agreement. If you are agreeing to be bound by the Agreement on behalf of your employer or other entity, you represent and warrant to Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) and Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland) (“Meta”) that you have full legal authority to bind your employer or such entity to this Agreement. If you do not have requisite authority, you may not accept the Agreement or access the Materials on behalf of your employer or other entity. + +This Agreement is effective upon the earlier of the date that you first access the Materials or accept this Agreement (“Effective Date”), and is entered into by and between Meta, and you, or if you are entering into this Agreement on behalf of your employer or other entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules, or regulations to provide legal consent and, your employer or other entity and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf (“Licensee” or “You”). + +1. Definitions. +“Documentation” means the specifications, manuals and documentation accompanying this release distributed by Meta at [https://github.com/facebookresearch/dinov2/blob/main/README.md]. + +“Noncommercial Research Use” means noncommercial research use cases related to research, development, education, processing, or analysis and in each case, is not primarily intended for commercial advantage or monetary compensation to you or others. + +“Materials” means, collectively, Documentation and the models and software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code, demonstration materials and other elements of the foregoing distributed by Meta at [https://github.com/facebookresearch/dinov2/blob/main/README.md] and made available under this Agreement. + +“Trade Control Laws” means any applicable U.S. and non-U.S. export control and trade sanctions laws and regulations. + +2. License Rights and Redistribution. Subject to Your compliance with the terms and conditions of this Agreement, Meta hereby grants you the following: +Grant of Rights. You are hereby granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Materials solely for Noncommercial Research Uses. +Redistribution and Use. +Distribution of Materials, and any derivative works thereof, are subject to the terms of this Agreement. If you distribute or make the Materials, or any derivative works thereof, available to a third party, you may only do so under the terms of this Agreement. You shall also provide a copy of this Agreement to such third party. +If you submit for publication the results of research you perform on, using, or otherwise in connection with Materials, you must acknowledge the use of Materials in your publication. +You must retain in all copies of the Materials that you distribute and include the following attribution notice within a “Notice” text file distributed as a part of such copies: “Materials are licensed under the X-Ray DINO Research License, Copyright © Meta Platforms, Inc. All Rights Reserved.” +Your use of the Materials must comply with applicable laws and regulations (including Trade Control Laws). +You agree to report any violation of this X-Ray DINO Research License. +3. Restrictions. You will not, and will not permit, assist or cause any third party to: +use the Materials or any outputs or results of the Materials in connection with any commercial uses or for any uses other than Noncommercial Research Uses; +use the Materials or any outputs or results of the Materials for provisioning medical advice or in connection with any clinical purpose or medical procedures, including health preventative, mitigatory, diagnostic, treatment, or curative applications or as a substitute or adjunct to professional medical judgment as the Materials have not been reviewed or approved by the Food and Drug Administration, and are for non-clinical, Noncommerical Research Use only; +disguise your or their location through IP proxying or other methods; +use or download Materials if you or they are: (a) located in a comprehensively sanctioned jurisdiction, (b) currently listed on any U.S. or non-U.S. restricted parties list, or (c) will use Materials for any purpose prohibited by Trade Control Laws; or +directly or indirectly export, re-export, provide, or otherwise transfer Materials: (a) to any individual, entity, or country prohibited by Trade Control Laws; (b) to anyone on U.S. or non-U.S. government restricted parties lists; or (c) for any purpose prohibited by Trade Control Laws, including nuclear, chemical or biological weapons, or missile technology applications. +4. User Support. Your Noncommercial Research Use of the Materials is done at your own discretion; Meta does not process any information nor provide any service in relation to such use. Meta is under no obligation to provide any support services for the Materials. Any support provided is “as is”, “with all faults”, and without warranty of any kind. +5. Disclaimer of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE MATERIALS AND ANY OUTPUT AND RESULTS. +6. Limitation of Liability. IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT OR INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING. +7. Intellectual Property. +No trademark licenses are granted under this Agreement, and in connection with the Materials, neither Meta nor Licensee may use any name or mark owned by or associated with the other or any of its affiliates, except as required for reasonable and customary use in describing and redistributing the Materials. +Subject to Meta’s ownership of Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications. +If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Materials or outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses and rights granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the Materials. +8. Term and Termination. The term of this Agreement will commence upon your acceptance of this Agreement or access to the Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the Materials. Sections 3, 4, 5, 6, 7, 8 and 9 shall survive the termination of this Agreement. +9. Governing Law and Jurisdiction. This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement. +10. Modifications and Amendments. Meta may modify this Agreement from time to time by posting a revised version at [https://ai.meta.com/resources/models-and-libraries/raydino-license/]; provided that they are similar in spirit to the current version of the Agreement, but may differ in detail to address new problems or concerns. All such changes will be effective immediately. Your continued use of the Materials after any modification to this Agreement constitutes your agreement to such modification. Except as provided in this Agreement, no other modification or addition to any provision of this Agreement will be binding unless it is in writing and signed by an authorized representative of both you and Meta. diff --git a/torch_cache/facebookresearch_dinov2_main/MODEL_CARD.md b/torch_cache/facebookresearch_dinov2_main/MODEL_CARD.md new file mode 100644 index 0000000000000000000000000000000000000000..6e9212dc8134ca686fcceeed0564b174c6b7703a --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/MODEL_CARD.md @@ -0,0 +1,272 @@ +# Model Card for DINOv2-S/B/L/g + +These are Vision Transformer models trained following the method described in the papers: +"DINOv2: Learning Robust Visual Features without Supervision" +and +"Vision Transformers Need Registers". + +We provide 8 models: +- 1 ViT-g trained from scratch with 3 ViT-S/B/L models distilled from the ViT-g, without registers. +- 1 ViT-g trained from scratch with 3 ViT-S/B/L models distilled from the ViT-g, with registers. + +## Model Details +The model takes an image as input and returns a class token and patch tokens, and optionally 4 register tokens. + +The embedding dimension is: +- 384 for ViT-S. +- 768 for ViT-B. +- 1024 for ViT-L. +- 1536 for ViT-g. + +The models follow a Transformer architecture, with a patch size of 14. In the case of registers, we add 4 register tokens, learned during training, to the input sequence after the patch embedding. + +For a 224x224 image, this results in 1 class token + 256 patch tokens, and optionally 4 register tokens. + +The models can accept larger images provided the image shapes are multiples of the patch size (14). +If this condition is not verified, the model will crop to the closest smaller multiple of the patch size. + +### Model Description + +- **Developed by:** Meta AI +- **Model type:** Vision Transformer +- **License:** Apache License 2.0 + +- **Repository:** https://github.com/facebookresearch/dinov2 +- **Paper:** https://arxiv.org/abs/2304.07193 +- **Demo:** https://dinov2.metademolab.com/ + +## Uses + +The models are vision backbones providing multi-purpose features for downstream tasks. + +### Direct Use + +The models can be used without fine-tuning, with downstream classifiers as simple as linear layers, to obtain competitive results: +- on depth estimation, semantic segmentation, using linear layers. +- on image classification, using k-NN classifiers on the class token. +- on image classification, with logistic regression classifiers applied on the class token. +- on image classification, with a linear layer applied on the class token and the average of the patch tokens. +- on image retrieval using nearest neighbors. + +### Downstream Use + +It is technically possible to perform fine-tuning on the models, for small gains (we measured +2% on ImageNet-1k classification). +We recommend keeping this as a very last step and only when necessary, as the features already provide good performance out-of-the-box. + +## Bias, Risks, and Limitations + +Despite improvements thanks to the training method not using annotations, we still observe significant biases in our models toward rich households from Western countries. + +### Recommendations + +We expect fine-tuning will increase the biases in the features produced by the model as they will be tuned to the fine-tuning labels. + +## How to Get Started with the Model + +Use the code below to get started with the model. + +```python +import torch + +# DINOv2 +dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14') +dinov2_vitb14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14') +dinov2_vitl14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14') +dinov2_vitg14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14') + +# DINOv2 with registers +dinov2_vits14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg') +dinov2_vitb14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_reg') +dinov2_vitl14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg') +dinov2_vitg14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg') +``` + +## Training Details + +### Training Data + +- **Training data:** LVD-142M (see paper) +- **Training regime:** fp16 using PyTorch-FSDP mixed-precision. + +### Training Procedure + +- **Training objective:** + - DINO self-distillation loss with multi-crop + - iBOT masked-image modeling loss + - KoLeo regularization on [CLS] tokens +- **Architectures:** + - ViT-S (21M params): Patch size 14, embedding dimension 384, 6 heads, MLP FFN + - ViT-B (86M params): Patch size 14, embedding dimension 768, 12 heads, MLP FFN + - ViT-L (0.3B params): Patch size 14, embedding dimension 1024, 16 heads, MLP FFN + - ViT-g (1.1B params): Patch size 14, embedding dimension 1536, 24 heads, SwiGLU FFN +- **Distillation:** + - Distillation follows the standard DINOv2 pretraining procedure, except the teacher is a pretrained ViT-g, frozen. + +## Evaluation + +We refer users to the associated papers for the evaluation protocols. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ImageNet-1kNYU-Depth v2SUN-RGBDADE20kiNaturalist 2018Oxford-H
modelwith
registers		classif. (acc)classif. (acc)classif. V2 (acc)depth (RMSE)depth (RMSE)segm. (mAP)classif. (acc)retrieval (mAP)
k-NNlinearlinearlinear
4 layers		NYU-D transfermultiscalelinearnearest neighbor
ViT-S/14:x:79.0%81.1%70.8%0.4170.43147.269.5%43.2
ViT-S/14:white_check_mark:79.1%80.9%71.0%N/AN/AN/A67.6%39.5
ViT-B/14:x:82.1%84.5%74.9%0.3620.40051.376.3%49.5
ViT-B/14:white_check_mark:82.0%84.6%75.6%N/AN/AN/A73.8%51.0
ViT-L/14:x:83.5%86.3%77.6%0.3330.39653.179.8%54.0
ViT-L/14:white_check_mark:83.8%86.7%78.5%N/AN/AN/A80.9%55.7
ViT-g/14:x:83.5%86.5%78.4%0.2980.36253.081.6%52.3
ViT-g/14:white_check_mark:83.7%87.1%78.8%N/AN/AN/A81.5%58.2
+ +## Environmental Impact + +- **Hardware Type:** Nvidia A100 +- **Hours used:** 22,000 for ViT-g, 4,500 for ViT-S distillation, 5,300 for ViT-B distillation, 8,000 for ViT-L distillation +- **Cloud Provider:** Private infra +- **Compute Region:** USA +- **Carbon Emitted:** 7t CO2eq + +#### Hardware + +Nvidia A100 GPUs + +#### Software + +PyTorch 2.0, +xFormers 0.0.18 + +**BibTeX** + +``` +@misc{oquab2023dinov2, + title={DINOv2: Learning Robust Visual Features without Supervision}, + author={Oquab, Maxime and Darcet, Timothée and Moutakanni, Theo and Vo, Huy and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and Howes, Russell and Huang, Po-Yao and Xu, Hu and Sharma, Vasu and Li, Shang-Wen and Galuba, Wojciech and Rabbat, Mike and Assran, Mido and Ballas, Nicolas and Synnaeve, Gabriel and Misra, Ishan and Jegou, Herve and Mairal, Julien and Labatut, Patrick and Joulin, Armand and Bojanowski, Piotr}, + journal={arXiv:2304.07193}, + year={2023} +} +@misc{darcet2023vitneedreg, + title={Vision Transformers Need Registers}, + author={Darcet, Timothée and Oquab, Maxime and Mairal, Julien and Bojanowski, Piotr}, + journal={arXiv:2309.16588}, + year={2023} +} +``` diff --git a/torch_cache/facebookresearch_dinov2_main/README.md b/torch_cache/facebookresearch_dinov2_main/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a48471fc4544d77341debe3eaed7fbb98b28aec7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/README.md @@ -0,0 +1,757 @@ +:new: [2025-12-18] *Added support for loading XRay-DINO backbone following [Advancing human-centric AI for robust X-ray analysis through holistic self-supervised learning](https://arxiv.org/pdf/2405.01469), more details are [here](#pretrained-backbone-xray-dino)* + +:new: [2025-12-16] *Added Channel-Adaptive DINO code following [Scaling Channel-Adaptive Self-Supervised Learning](https://openreview.net/forum?id=pT8sgtRVAf), more details are [here](#dinov2-for-biology)* + +:new: [2025-12-16] *Added Cell-DINO code following [Cell-DINO: Self-Supervised Image-based Embeddings for Cell Fluorescent Microscopy](to appear in Plos One Computational Biology), more details are [here](#dinov2-for-biology)* + +[2025-08-14] *Please check out the more recent [DINOv3](https://github.com/facebookresearch/dinov3) effort continuing this line of work.* + +[2025-06-11] *Added dino.txt inference code, following [DINOv2 Meets Text: A Unified Framework for Image- and Pixel-Level Vision-Language Alignment](https://arxiv.org/abs/2412.16334).* + +[2023-10-26] *Added DINOv2 backbones with registers, following [Vision Transformers Need Registers](https://arxiv.org/abs/2309.16588).* + +# DINOv2: Learning Robust Visual Features without Supervision + +**[Meta AI Research, FAIR](https://ai.facebook.com/research/)** + +Maxime Oquab, +Timothée Darcet, +Théo Moutakanni, +Huy V. Vo, +Marc Szafraniec, +Vasil Khalidov, +Patrick Labatut, +Armand Joulin, +Piotr Bojanowski + +[[`Paper #1`](https://arxiv.org/abs/2304.07193)] [`Paper #2`](https://arxiv.org/abs/2309.16588)] [[`Blog`](https://ai.facebook.com/blog/dino-v2-computer-vision-self-supervised-learning/)] [[`Demo`](https://dinov2.metademolab.com)] [[`BibTeX`](#citing-dinov2)] + +PyTorch implementation and pretrained models for DINOv2. For details, see the papers: **[DINOv2: Learning Robust Visual Features without Supervision](https://arxiv.org/abs/2304.07193)** and **[Vision Transformers Need Registers](https://arxiv.org/abs/2309.16588)**. + +DINOv2 models produce high-performance visual features that can be directly employed with classifiers as simple as linear layers on a variety of computer vision tasks; these visual features are robust and perform well across domains without any requirement for fine-tuning. The models were pretrained on a dataset of 142 M images without using any labels or annotations. + +https://github.com/facebookresearch/dinov2/assets/60359573/f168823e-7922-415a-b429-578badf5c356 + +
+ Visualization of the three first principal components of the patch features of all frames, mapped to RGB values. +
+ +## Pretrained models + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
model# of
params		with
registers		ImageNet
k-NN		ImageNet
linear		download
ViT-S/14 distilled21 M:x:79.0%81.1%backbone only
ViT-S/14 distilled21 M:white_check_mark:79.1%80.9%backbone only
ViT-B/14 distilled86 M:x:82.1%84.5%backbone only
ViT-B/14 distilled86 M:white_check_mark:82.0%84.6%backbone only
ViT-L/14 distilled300 M:x:83.5%86.3%backbone only
ViT-L/14 distilled300 M:white_check_mark:83.8%86.7%backbone only
ViT-g/141,100 M:x:83.5%86.5%backbone only
ViT-g/141,100 M:white_check_mark:83.7%87.1%backbone only
+ +### Pretrained backbones (via PyTorch Hub) + +Please follow the instructions [here](https://pytorch.org/get-started/locally/) to install PyTorch (the only required dependency for loading the model). Installing PyTorch with CUDA support is strongly recommended. + +A corresponding [model card](MODEL_CARD.md) is included in the repository. + +```python +import torch + +# DINOv2 +dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14') +dinov2_vitb14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14') +dinov2_vitl14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14') +dinov2_vitg14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14') + +# DINOv2 with registers +dinov2_vits14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg') +dinov2_vitb14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_reg') +dinov2_vitl14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg') +dinov2_vitg14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg') +``` + +### Pretrained backbone: XRay-DINO + +Request for downloading the model is here: + +https://ai.meta.com/resources/models-and-libraries/raydino-downloads/ + + +After filling the form, you will get an email with a temporary link. You can either download it using `wget` and indicate the checkpoint path in your local filesystem, or you can directly use the URL from the email in the following code: + +```python +import torch + +REPO_DIR = + +xray_dino_vitl16 = torch.hub.load(REPO_DIR, 'xray_dino_vitl16', source='local', weights=) +``` + +**License** +Model weights are released under the FAIR Noncommercial Research License. See LICENSE_XRAY_DINO_MODEL for additional details. + + +### Pretrained heads - Image classification + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
backbonewith
registers		download
ImageNet
ViT-S/14 distilled:x: + linear head (1 layer, + 4 layers) +
ViT-S/14 distilled:white_check_mark: + linear head (1 layer, + 4 layers) +
ViT-B/14 distilled:x: + linear head (1 layer, + 4 layers) +
ViT-B/14 distilled:white_check_mark: + linear head (1 layer, + 4 layers) +
ViT-L/14 distilled:x: + linear head (1 layer, + 4 layers) +
ViT-L/14 distilled:white_check_mark: + linear head (1 layer, + 4 layers) +
ViT-g/14:x: + linear head (1 layer, + 4 layers) +
ViT-g/14:white_check_mark: + linear head (1 layer, + 4 layers) +
+ +The (full) classifier models can be loaded via PyTorch Hub: + +```python +import torch + +# DINOv2 +dinov2_vits14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_lc') +dinov2_vitb14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_lc') +dinov2_vitl14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_lc') +dinov2_vitg14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_lc') + +# DINOv2 with registers +dinov2_vits14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg_lc') +dinov2_vitb14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_reg_lc') +dinov2_vitl14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg_lc') +dinov2_vitg14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg_lc') +``` + +### Pretrained heads - Depth estimation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
backbonedownload head
NYUdKITTI
ViT-S/14 distilled + linear (1 layer, + 4 layers), + DPT + + linear (1 layer, + 4 layers), + DPT +
ViT-B/14 distilled + linear (1 layer, + 4 layers), + DPT + + linear (1 layer, + 4 layers), + DPT +
ViT-L/14 distilled + linear (1 layer, + 4 layers), + DPT + + linear (1 layer, + 4 layers), + DPT +
ViT-g/14 + linear (1 layer, + 4 layers), + DPT + + linear (1 layer, + 4 layers), + DPT +
+ +### Pretrained heads - Semantic segmentation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
backbonedownload modeldownload head
ADE20KADE20KVOC2012
ViT-S/14 distilled + linear, + multi-scale + + linear, + multi-scale +
ViT-B/14 distilled + linear, + multi-scale + + linear, + multi-scale +
ViT-L/14 distilled + linear, + multi-scale + + linear, + multi-scale +
ViT-g/14 + Mask2Former + + linear, + multi-scale + + linear, + multi-scale +
+ + +### Pretrained heads - Zero-shot tasks with dino.txt + + + + + + + + + + + + + + + + +
backbonewith
registers		download
ViT-L/14 distilled:white_check_mark: + vision head, + text model, + vocabulary, + vocabulary license +
+ +The (full) dino.txt model can be loaded via PyTorch Hub: + +```python +import torch + +# DINOv2 +dinov2_vitl14_reg4_dinotxt_tet1280d20h24l = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg4_dinotxt_tet1280d20h24l') +``` + + +## Installation + +The training and evaluation code requires PyTorch 2.0 and [xFormers](https://github.com/facebookresearch/xformers) 0.0.18 as well as a number of other 3rd party packages. Note that the code has only been tested with the specified versions and also expects a Linux environment. To setup all the required dependencies for training and evaluation, please follow the instructions below: + +*[conda](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)* **(Recommended)** - Clone the repository and then create and activate a `dinov2` conda environment using the provided environment definition: + +```shell +conda env create -f conda.yaml +conda activate dinov2 +``` + +*[pip](https://pip.pypa.io/en/stable/getting-started/)* - Clone the repository and then use the provided `requirements.txt` to install the dependencies: + +```shell +pip install -r requirements.txt +``` + +For dense tasks (depth estimation and semantic segmentation), there are additional dependencies (specific versions of `mmcv` and `mmsegmentation`) which are captured in the `extras` dependency specifications: + +*[conda](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)* **(Recommended)**: + +```shell +conda env create -f conda-extras.yaml +conda activate dinov2-extras +``` + +*[pip](https://pip.pypa.io/en/stable/getting-started/)*: + +```shell +pip install -r requirements.txt -r requirements-extras.txt +``` + +## Data preparation + +### ImageNet-1k + +The root directory of the dataset should hold the following contents: + +- `/test/ILSVRC2012_test_00000001.JPEG` +- `/test/[..]` +- `/test/ILSVRC2012_test_00100000.JPEG` +- `/train/n01440764/n01440764_10026.JPEG` +- `/train/[...]` +- `/train/n15075141/n15075141_9993.JPEG` +- `/val/n01440764/ILSVRC2012_val_00000293.JPEG` +- `/val/[...]` +- `/val/n15075141/ILSVRC2012_val_00049174.JPEG` +- `/labels.txt` + +The provided dataset implementation expects a few additional metadata files to be present under the extra directory: + +- `/class-ids-TRAIN.npy` +- `/class-ids-VAL.npy` +- `/class-names-TRAIN.npy` +- `/class-names-VAL.npy` +- `/entries-TEST.npy` +- `/entries-TRAIN.npy` +- `/entries-VAL.npy` + +These metadata files can be generated (once) with the following lines of Python code: + +```python +from dinov2.data.datasets import ImageNet + +for split in ImageNet.Split: + dataset = ImageNet(split=split, root="", extra="") + dataset.dump_extra() +``` + +Note that the root and extra directories do not have to be distinct directories. + +### ImageNet-22k + +Please adapt the [dataset class](dinov2/data/datasets/image_net_22k.py) to match your local setup. + +
+ +:warning: To execute the commands provided in the next sections for training and evaluation, the `dinov2` package should be included in the Python module search path, i.e. simply prefix the command to run with `PYTHONPATH=.`. + +## Training + +### Fast setup: training DINOv2 ViT-L/16 on ImageNet-1k + +Run DINOv2 training on 4 A100-80GB nodes (32 GPUs) in a SLURM cluster environment with submitit: + +```shell +python dinov2/run/train/train.py \ + --nodes 4 \ + --config-file dinov2/configs/train/vitl16_short.yaml \ + --output-dir \ + train.dataset_path=ImageNet:split=TRAIN:root=:extra= +``` + +Training time is approximately 1 day and the resulting checkpoint should reach 81.6% on k-NN eval and 82.9% on linear eval. + +The training code saves the weights of the teacher in the `eval` folder every 12500 iterations for evaluation. + +### Long setup: training DINOv2 ViT-L/14 on ImageNet-22k + +Run DINOv2 training on 12 A100-80GB nodes (96 GPUs) in a SLURM cluster environment with submitit: + +```shell +python dinov2/run/train/train.py \ + --nodes 12 \ + --config-file dinov2/configs/train/vitl14.yaml \ + --output-dir \ + train.dataset_path=ImageNet22k:root=:extra= +``` + +Training time is approximately 3.3 days and the resulting checkpoint should reach 82.0% on k-NN eval and 84.5% on linear eval. + +The training code saves the weights of the teacher in the `eval` folder every 12500 iterations for evaluation. + + +## Evaluation + +The training code regularly saves the teacher weights. In order to evaluate the model, run the following evaluation on a single node: + +### k-NN classification on ImageNet-1k + +```shell +python dinov2/run/eval/knn.py \ + --config-file /config.yaml \ + --pretrained-weights /eval/training_24999/teacher_checkpoint.pth \ + --output-dir /eval/training_24999/knn \ + --train-dataset ImageNet:split=TRAIN:root=:extra= \ + --val-dataset ImageNet:split=VAL:root=:extra= +``` + +### Logistic regression classification on ImageNet-1k + +```shell +python dinov2/run/eval/log_regression.py \ + --config-file /config.yaml \ + --pretrained-weights /eval/training_24999/teacher_checkpoint.pth \ + --output-dir /eval/training_24999/logreg \ + --train-dataset ImageNet:split=TRAIN:root=:extra= \ + --val-dataset ImageNet:split=VAL:root=:extra= +``` + +### Linear classification with data augmentation on ImageNet-1k + +```shell +python dinov2/run/eval/linear.py \ + --config-file /config.yaml \ + --pretrained-weights /eval/training_24999/teacher_checkpoint.pth \ + --output-dir /eval/training_24999/linear \ + --train-dataset ImageNet:split=TRAIN:root=:extra= \ + --val-dataset ImageNet:split=VAL:root=:extra= +``` + +We release the weights from evaluating the different models: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
modelwith
registers		ImageNet
top-1		linear evaluation
ViT-S/14 distilled:x:81.1%linear head weights
ViT-S/14 distilled:white_check_mark:80.8%linear head weights
ViT-B/14 distilled:x:84.5%linear head weights
ViT-B/14 distilled:white_check_mark:84.4%linear head weights
ViT-L/14 distilled:x:86.3%linear head weights
ViT-L/14 distilled:white_check_mark:86.5%linear head weights
ViT-g/14:x:86.5%linear head weights
ViT-g/14:white_check_mark:87.0%linear head weights
+ +The performance of the provided pretrained model weights can be evaluated as follows on ImageNet-1k: + +```shell +python dinov2/run/eval/linear.py \ + --config-file dinov2/configs/eval/vitg14_pretrain.yaml \ + --pretrained-weights https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_pretrain.pth \ + --train-dataset ImageNet:split=TRAIN:root=:extra= \ + --val-dataset ImageNet:split=VAL:root=:extra= +``` + +## Notebooks + +A few notebooks are provided to help the community leverage the models and code: + +
    +
  • Depth estimation - How to load and use the depth heads in combination with a matching backbone via mmcv
    • +
  • Semantic segmentation - How to load and use the segmentation heads in combination with a matching backbone via mmcv, and also how to load and use the Mask2Former-based segmentation model trained on ADE20K
    • +
+ +## License + +DINOv2 code and model weights are released under the Apache License 2.0. See [LICENSE](LICENSE) for additional details. + +## Contributing + +See [contributing](CONTRIBUTING.md) and the [code of conduct](CODE_OF_CONDUCT.md). + +## Citing DINOv2 + +If you find this repository useful, please consider giving a star :star: and citation :t-rex:: + +``` +@misc{oquab2023dinov2, + title={DINOv2: Learning Robust Visual Features without Supervision}, + author={Oquab, Maxime and Darcet, Timothée and Moutakanni, Theo and Vo, Huy V. and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and Howes, Russell and Huang, Po-Yao and Xu, Hu and Sharma, Vasu and Li, Shang-Wen and Galuba, Wojciech and Rabbat, Mike and Assran, Mido and Ballas, Nicolas and Synnaeve, Gabriel and Misra, Ishan and Jegou, Herve and Mairal, Julien and Labatut, Patrick and Joulin, Armand and Bojanowski, Piotr}, + journal={arXiv:2304.07193}, + year={2023} +} +``` + +``` +@misc{darcet2023vitneedreg, + title={Vision Transformers Need Registers}, + author={Darcet, Timothée and Oquab, Maxime and Mairal, Julien and Bojanowski, Piotr}, + journal={arXiv:2309.16588}, + year={2023} +} +``` + +``` +@misc{jose2024dinov2meetstextunified, + title={DINOv2 Meets Text: A Unified Framework for Image- and Pixel-Level Vision-Language Alignment}, + author={Cijo Jose and Théo Moutakanni and Dahyun Kang and Federico Baldassarre and Timothée Darcet and Hu Xu and Daniel Li and Marc Szafraniec and Michaël Ramamonjisoa and Maxime Oquab and Oriane Siméoni and Huy V. Vo and Patrick Labatut and Piotr Bojanowski}, + journal={arXiv:2412.16334}, + year={2024} +} +``` + + +# DINOv2 for Biology + +The contents of the source code contained in the cell_dino folders, including the code and model weights, are intended for research use only. It is not for use in medical procedures, including any diagnostics, treatment, or curative applications. Do not use this model for any clinical purpose or as a substitute for professional medical judgement. + + +## Scaling Channel-Adaptive Self-Supervised Learning (Channel-Adaptive DINO) + + [[`Paper `](https://openreview.net/forum?id=pT8sgtRVAf))] [[`BibTeX`](#citing-channeladaptivedino-and-dinov2)] + +Alice V. De Lorenci, Seungeun Yi, Théo Moutakanni, Piotr Bojanowski, Camille Couprie, Juan C. Caicedo, Wolfgang M. Pernice, + +with special thanks to Elouan Gardes for his contributions to the codebase. + + [README](https://github.com/facebookresearch/dinov2/blob/main/docs/README_CHANNEL_ADAPTIVE_DINO.md) + + + +## Cell-DINO: Self-Supervised Image-based Embeddings for Cell Fluorescent Microscopy (Cell-DINO) + +Théo Moutakanni, Camille Couprie, Seungeun Yi, Elouan Gardes, Piotr Bojanowski, Hugo Touvron, Michael Doron, Zitong S. Chen, Nikita Moshkov, Mathilde Caron, Armand Joulin, Wolfgang M. Pernice, Juan C. Caicedo + +to appear soon. + + [README](https://github.com/facebookresearch/dinov2/blob/main/docs/README_CELL_DINO.md) + + +## Pretrained models + +ℹ️ Please follow the link provided below to get access to all the model weights: once accepted, an e-mail will be sent with the complete list of URLs pointing to all the available model weights. These URLs can then be used to either: + +- download the model or adapter weights to a local filesystem and point `torch.hub.load()` to these local weights via the `pretrained_path` parameters, or +- directly invoke `torch.hub.load()` to download and load a backbone from its URL via also the `pretrained_url` parameter. + +⚠️ Please use wget instead of a web browser to download the weights. + +**Download link:** +https://ai.meta.com/resources/models-and-libraries/cell-dino-downloads/ + +```python +import torch + +REPO_DIR = + +# You can either download the URL link first, then load: +cell_dino_vits8 = torch.hub.load(REPO_DIR, 'cell_dino_cp_vits8', source='local', pretrained_path=) +# Or directly download the URL while using `torch.hub.load`: +cell_dino_vits8 = torch.hub.load(REPO_DIR, 'cell_dino_cp_vits8', source='local', pretrained_url=) + +# Similarily for other models: +cell_dino_vitl16_hpa_sc = torch.hub.load(REPO_DIR, 'cell_dino_hpa_vitl16', source='local', pretrained_path=) +cell_dino_vitl16_hpa_fov = torch.hub.load(REPO_DIR, 'cell_dino_hpa_vitl16', source='local', pretrained_path=) +channel_adaptive_dino_vitl16 = torch.hub.load(REPO_DIR, 'channel_adaptive_dino_vitl16', source='local', pretrained_path=) +cell_dino_vitl14 = torch.hub.load(REPO_DIR, 'cell_dino_hpa_vitl14', source='local', pretrained_path=) +``` + + + ## Licenses + + Code is released under the CC BY NC License. See [LICENSE_CELL_DINO_CODE](LICENSE_CELL_DINO_CODE) for additional details. + Model weights are released under the FAIR Noncommercial Research License. See [LICENSE_CELL_DINO_CODE_WEIGHTS](LICENSE_CELL_DINO_CODE_WEIGHTS) for additional details. diff --git a/torch_cache/facebookresearch_dinov2_main/__pycache__/hubconf.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/__pycache__/hubconf.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c95d6c549834222cf9a0fc55935a03fd3d18934 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/__pycache__/hubconf.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/conda-extras.yaml b/torch_cache/facebookresearch_dinov2_main/conda-extras.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0563878c0ca32c9e3cb9695b85e50ff3b91ce95f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/conda-extras.yaml @@ -0,0 +1,24 @@ +name: dinov2-extras +channels: + - defaults + - pytorch + - nvidia + - xformers + - conda-forge +dependencies: + - python=3.9 + - pytorch::pytorch=2.0.0 + - pytorch::pytorch-cuda=11.7.0 + - pytorch::torchvision=0.15.0 + - omegaconf + - torchmetrics=0.10.3 + - fvcore + - iopath + - xformers::xformers=0.0.18 + - pip + - pip: + - git+https://github.com/facebookincubator/submitit + - --extra-index-url https://pypi.nvidia.com + - cuml-cu11 + - mmcv-full==1.5.0 + - mmsegmentation==0.27.0 diff --git a/torch_cache/facebookresearch_dinov2_main/conda.yaml b/torch_cache/facebookresearch_dinov2_main/conda.yaml new file mode 100644 index 0000000000000000000000000000000000000000..abe596b48aad36b371d572ce052932cf4ad400b0 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/conda.yaml @@ -0,0 +1,22 @@ +name: dinov2 +channels: + - defaults + - pytorch + - nvidia + - xformers + - conda-forge +dependencies: + - python=3.9 + - pytorch::pytorch=2.0.0 + - pytorch::pytorch-cuda=11.7.0 + - pytorch::torchvision=0.15.0 + - omegaconf + - torchmetrics=0.10.3 + - fvcore + - iopath + - xformers::xformers=0.0.18 + - pip + - pip: + - git+https://github.com/facebookincubator/submitit + - --extra-index-url https://pypi.nvidia.com + - cuml-cu11 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4bd11e735b9c3a2ae2b1475ca163537e274fae76 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +__version__ = "0.0.1" diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/__pycache__/__init__.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0edabd83feac8d84930e7c6f774e10b8c8bd3fbc Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/__pycache__/__init__.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7bc8ad091d2b9d7c9a9d5cbb7b8a3e9d961532b7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/__init__.py @@ -0,0 +1,22 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import pathlib + +from omegaconf import OmegaConf + + +def load_config(config_name: str): + config_filename = config_name + ".yaml" + return OmegaConf.load(pathlib.Path(__file__).parent.resolve() / config_filename) + + +dinov2_default_config = load_config("ssl_default_config") + + +def load_and_merge_config(config_name: str): + default_config = OmegaConf.create(dinov2_default_config) + loaded_config = load_config(config_name) + return OmegaConf.merge(default_config, loaded_config) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/cell_dino/vitl16_channel_adaptive_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/cell_dino/vitl16_channel_adaptive_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bccb8660a42f918063bf7f763894096eccbdd8a5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/cell_dino/vitl16_channel_adaptive_pretrain.yaml @@ -0,0 +1,35 @@ +train: + batch_size_per_gpu: 32 + OFFICIAL_EPOCH_LENGTH: 450 + cell_augmentation: true + channel_adaptive: true +student: + arch: vit_large + patch_size: 16 + num_register_tokens: 0 + interpolate_antialias: false + interpolate_offset: 0.1 + drop_path_rate: 0.1 + in_chans: 1 + block_chunks: 4 + channel_adaptive: true +teacher: + momentum_teacher: 0.996 + warmup_teacher_temp_epochs: 20 + in_chans: 1 + channel_adaptive: true +crops: + global_crops_scale: + - 0.4 + - 1.0 + local_crops_number: 8 + local_crops_scale: + - 0.005 + - 0.4 + global_crops_size: 224 + local_crops_size: 96 +optim: + weight_decay_end: 0.2 + base_lr: 5.0e-4 + warmup_epochs: 20 + epochs: 400 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0bfbc23b35e6695cfa8e6bba27f37ebb963bee8f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml @@ -0,0 +1,14 @@ +student: + arch: vit_large + patch_size: 16 + num_register_tokens: 0 + interpolate_antialias: false + interpolate_offset: 0.1 + drop_path_rate: 0.1 + in_chans: 4 + block_chunks: 4 +teacher: + in_chans: 4 +crops: + global_crops_size: 224 + local_crops_size: 96 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitb14_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitb14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..43725df384813c3be3342488017f51e161e8ea9d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitb14_pretrain.yaml @@ -0,0 +1,6 @@ +student: + arch: vit_base + patch_size: 14 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitb14_reg4_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitb14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3a60a481261c70824427b28ce4cf62080dd84c6f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitb14_reg4_pretrain.yaml @@ -0,0 +1,9 @@ +student: + arch: vit_base + patch_size: 14 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitg14_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitg14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0b1066fcdaf5ae633b20e193505049ed9641c173 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitg14_pretrain.yaml @@ -0,0 +1,7 @@ +student: + arch: vit_giant2 + patch_size: 14 + ffn_layer: swiglufused +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitg14_reg4_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitg14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1b615c7cc0092da8ba57c4b5f42041b577f4f593 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitg14_reg4_pretrain.yaml @@ -0,0 +1,10 @@ +student: + arch: vit_giant2 + patch_size: 14 + ffn_layer: swiglufused + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitl14_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitl14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1df9fb1b902f727612fcf8abca532ca95fd2a4b0 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitl14_pretrain.yaml @@ -0,0 +1,6 @@ +student: + arch: vit_large + patch_size: 14 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitl14_reg4_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitl14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0181398907ce97fa3e28ff2f1f96977a2cd83519 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vitl14_reg4_pretrain.yaml @@ -0,0 +1,9 @@ +student: + arch: vit_large + patch_size: 14 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vits14_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vits14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..043d428922b6d1d9b33e7637dd97d9290f98ee66 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vits14_pretrain.yaml @@ -0,0 +1,6 @@ +student: + arch: vit_small + patch_size: 14 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vits14_reg4_pretrain.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vits14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..800d1ec52c346837424c3485966d6d6f53e3582c --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/eval/vits14_reg4_pretrain.yaml @@ -0,0 +1,9 @@ +student: + arch: vit_small + patch_size: 14 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/ssl_default_config.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/ssl_default_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ddbcc84d58279c37a6986b23c6b3a3384a94f1d2 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/ssl_default_config.yaml @@ -0,0 +1,123 @@ +MODEL: + WEIGHTS: '' +compute_precision: + grad_scaler: true + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp32 + buffer_dtype: fp32 + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp32 + buffer_dtype: fp32 +dino: + loss_weight: 1.0 + head_n_prototypes: 65536 + head_bottleneck_dim: 256 + head_nlayers: 3 + head_hidden_dim: 2048 + koleo_loss_weight: 0.1 +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.5 + separate_head: false + head_n_prototypes: 65536 + head_bottleneck_dim: 256 + head_nlayers: 3 + head_hidden_dim: 2048 +train: + batch_size_per_gpu: 64 + dataset_path: ImageNet:split=TRAIN + output_dir: . + saveckp_freq: 20 + seed: 0 + num_workers: 10 + OFFICIAL_EPOCH_LENGTH: 1250 + cache_dataset: true + centering: "centering" # or "sinkhorn_knopp" + cell_augmentation: false +student: + arch: vit_large + patch_size: 16 + drop_path_rate: 0.3 + layerscale: 1.0e-05 + drop_path_uniform: true + pretrained_weights: '' + ffn_layer: "mlp" + block_chunks: 0 + qkv_bias: true + proj_bias: true + ffn_bias: true + num_register_tokens: 0 + interpolate_antialias: false + interpolate_offset: 0.1 + in_chans: 3 + channel_adaptive: false +teacher: + momentum_teacher: 0.992 + final_momentum_teacher: 1 + warmup_teacher_temp: 0.04 + teacher_temp: 0.07 + warmup_teacher_temp_epochs: 30 + in_chans: 3 + channel_adaptive: false +optim: + epochs: 100 + weight_decay: 0.04 + weight_decay_end: 0.4 + base_lr: 0.004 # learning rate for a batch size of 1024 + lr: 0. # will be set after applying scaling rule + warmup_epochs: 10 + min_lr: 1.0e-06 + clip_grad: 3.0 + freeze_last_layer_epochs: 1 + scaling_rule: sqrt_wrt_1024 + patch_embed_lr_mult: 0.2 + layerwise_decay: 0.9 + adamw_beta1: 0.9 + adamw_beta2: 0.999 +crops: + global_crops_scale: + - 0.32 + - 1.0 + local_crops_number: 8 + local_crops_scale: + - 0.05 + - 0.32 + global_crops_size: 224 + local_crops_size: 96 +evaluation: + eval_period_iterations: 12500 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_boc_hpafov.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_boc_hpafov.yaml new file mode 100644 index 0000000000000000000000000000000000000000..751575e37b13641f7245107f6ac0f7734b547d56 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_boc_hpafov.yaml @@ -0,0 +1,31 @@ +train: + batch_size_per_gpu: 16 + OFFICIAL_EPOCH_LENGTH: 450 + cell_augmentation: true + channel_adaptive: true +student: + arch: vit_large + patch_size: 16 + in_chans: 1 + drop_path_rate: 0.1 + block_chunks: 4 +teacher: + momentum_teacher: 0.996 + warmup_teacher_temp_epochs: 20 + in_chans: 1 +crops: + global_crops_scale: + - 0.4 + - 1.0 + local_crops_number: 8 + local_crops_scale: + - 0.005 + - 0.4 + global_crops_size: 224 + local_crops_size: 96 +optim: + weight_decay_end: 0.2 + base_lr: 5.0e-4 + warmup_epochs: 20 + epochs: 400 + \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_hpafov.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_hpafov.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c920d6e8b59ddf868a2354b126c44b61387baac0 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_hpafov.yaml @@ -0,0 +1,32 @@ +train: + batch_size_per_gpu: 16 + OFFICIAL_EPOCH_LENGTH: 450 + cell_augmentation: true +student: + arch: vit_large + patch_size: 16 + in_chans: 4 + drop_path_rate: 0.1 + block_chunks: 4 +teacher: + momentum_teacher: 0.996 + warmup_teacher_temp_epochs: 20 + in_chans: 4 +optim: + weight_decay_end: 0.2 + base_lr: 5.0e-4 + warmup_epochs: 20 +crops: + global_crops_scale: + - 0.4 + - 1.0 + local_crops_number: 8 + local_crops_scale: + - 0.005 + - 0.4 + global_crops_size: 224 + local_crops_size: 96 +evaluation: + eval_period_iterations: 9000 + + \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_hpaone.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_hpaone.yaml new file mode 100644 index 0000000000000000000000000000000000000000..38306465aedfe5920cbf3fb10594e4a06da8e576 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/cell_dino/vitl16_hpaone.yaml @@ -0,0 +1,30 @@ +train: + batch_size_per_gpu: 16 + OFFICIAL_EPOCH_LENGTH: 1756 + cell_augmentation: true +student: + arch: vit_large + patch_size: 16 + in_chans: 4 + drop_path_rate: 0.1 + block_chunks: 4 +teacher: + momentum_teacher: 0.996 + warmup_teacher_temp_epochs: 20 + in_chans: 4 +optim: + weight_decay_end: 0.2 + base_lr: 5.0e-4 + warmup_epochs: 20 +crops: + global_crops_scale: + - 0.4 + - 1.0 + local_crops_number: 8 + local_crops_scale: + - 0.005 + - 0.4 + global_crops_size: 224 + local_crops_size: 96 +evaluation: + eval_period_iterations: 9000 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitg14.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitg14.yaml new file mode 100644 index 0000000000000000000000000000000000000000..09475150a1aa6c356bb9ed6c6933a6f226a2d032 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitg14.yaml @@ -0,0 +1,26 @@ +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 +ibot: + separate_head: true + head_n_prototypes: 131072 +train: + batch_size_per_gpu: 12 + dataset_path: ImageNet22k + centering: sinkhorn_knopp +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 500 + weight_decay_end: 0.2 + base_lr: 2.0e-04 # learning rate for a batch size of 1024 + warmup_epochs: 80 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitl14.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitl14.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0e23046c457e572545908817ef2cb4ba46dc5b9a --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitl14.yaml @@ -0,0 +1,26 @@ +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 +ibot: + separate_head: true + head_n_prototypes: 131072 +train: + batch_size_per_gpu: 32 + dataset_path: ImageNet22k + centering: sinkhorn_knopp +student: + arch: vit_large + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 500 + weight_decay_end: 0.2 + base_lr: 2.0e-04 # learning rate for a batch size of 1024 + warmup_epochs: 80 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 \ No newline at end of file diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitl16_short.yaml b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitl16_short.yaml new file mode 100644 index 0000000000000000000000000000000000000000..57a1ccc912602ea2bb10f4eb36899d82db49ef88 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/configs/train/vitl16_short.yaml @@ -0,0 +1,6 @@ +# this corresponds to the default config +train: + dataset_path: ImageNet:split=TRAIN + batch_size_per_gpu: 64 +student: + block_chunks: 4 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5b152baaf64f9bc9873f4f1ed8a9c15c00a1aec4 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .adapters import DatasetWithEnumeratedTargets +from .loaders import make_data_loader, make_dataset, SamplerType +from .collate import collate_data_and_cast +from .masking import MaskingGenerator +from .augmentations import DataAugmentationDINO +from .cell_dino.augmentations import CellAugmentationDINO +from .accumulators import NoOpAccumulator, ResultsAccumulator diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/accumulators.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/accumulators.py new file mode 100644 index 0000000000000000000000000000000000000000..75abf36f3bfcf7474fcc842800c944399e9719b9 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/accumulators.py @@ -0,0 +1,133 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import defaultdict +from typing import Dict, List, Optional, Any + +import torch +from torch import Tensor +from torch.nn import functional as F + +import torch.distributed as dist +from dinov2.distributed import get_global_size + + +def _simple_gather_all_tensors(result: torch.Tensor, group: Any, world_size: int) -> List[torch.Tensor]: + gathered_result = [torch.zeros_like(result) for _ in range(world_size)] + dist.all_gather(gathered_result, result, group) + return gathered_result + + +def gather_all_tensors(result: torch.Tensor, group: Optional[Any] = None) -> List[torch.Tensor]: + """ + Copied from https://github.com/Lightning-AI/torchmetrics/blob/master/src/torchmetrics/utilities/distributed.py + Gather all tensors from several ddp processes onto a list that is broadcasted to all processes. + + Works on tensors that have the same number of dimensions, but where each dimension may differ. In this case + tensors are padded, gathered and then trimmed to secure equal workload for all processes. + + Args: + result: the value to sync + group: the process group to gather results from. Defaults to all processes (world) + + Return: + list with size equal to the process group where element i corresponds to result tensor from process i + """ + # convert tensors to contiguous format + result = result.contiguous() + + world_size = get_global_size() + dist.barrier(group=group) + + # if the tensor is scalar, things are easy + if result.ndim == 0: + return _simple_gather_all_tensors(result, group, world_size) + + # 1. Gather sizes of all tensors + local_size = torch.tensor(result.shape, device=result.device) + local_sizes = [torch.zeros_like(local_size) for _ in range(world_size)] + dist.all_gather(local_sizes, local_size, group=group) + max_size = torch.stack(local_sizes).max(dim=0).values + all_sizes_equal = all(all(ls == max_size) for ls in local_sizes) + + # 2. If shapes are all the same, then do a simple gather: + if all_sizes_equal: + return _simple_gather_all_tensors(result, group, world_size) + + # 3. If not, we need to pad each local tensor to maximum size, gather and then truncate + pad_dims = [] + pad_by = (max_size - local_size).detach().cpu() + for val in reversed(pad_by): + pad_dims.append(0) + pad_dims.append(val.item()) + result_padded = F.pad(result, pad_dims) + gathered_result = [torch.zeros_like(result_padded) for _ in range(world_size)] + dist.all_gather(gathered_result, result_padded, group) + for idx, item_size in enumerate(local_sizes): + slice_param = [slice(dim_size) for dim_size in item_size] + gathered_result[idx] = gathered_result[idx][slice_param] + return gathered_result + + +def _cat_and_gather_tensor_list(tensor_list: List[Tensor]) -> Tensor: + local_cat = torch.cat(tensor_list) + return torch.cat(gather_all_tensors(local_cat)) + + +class Accumulator: + def __init__(self) -> None: + pass + + def update(self, preds: Tensor, target: Tensor, index: Tensor) -> None: + raise NotImplementedError + + def accumulate(self) -> Optional[Dict[str, Tensor]]: + raise NotImplementedError + + +class NoOpAccumulator(Accumulator): + def __init__(self) -> None: + pass + + def update(self, preds: Tensor, target: Tensor, index: Tensor) -> None: + pass + + def accumulate(self) -> None: + return None + + +class ResultsAccumulator(Accumulator): + """ + Accumulate predictions and targets across processes + """ + + def __init__(self) -> None: + self._local_values: Dict[str, List[Tensor]] = defaultdict(list) + self._gathered_values: Dict[str, Tensor] = {} + self._gathered = False + + def update(self, preds: Tensor, target: Tensor, index: Tensor) -> None: + assert len(preds) == len(target) == len(index) + assert not self._gathered, "Tensors have already been gathered in this helper" + self._local_values["preds"].append(preds) + self._local_values["target"].append(target) + self._local_values["index"].append(index) + self._gathered = False + + def _gather_tensors(self): + for k, tensor_list in self._local_values.items(): + self._gathered_values[k] = _cat_and_gather_tensor_list(tensor_list) + self._gathered = True + + def accumulate(self) -> Dict[str, Tensor]: + if not self._gathered: + self._gather_tensors() + preds, target, index = [self._gathered_values[k] for k in ["preds", "target", "index"]] + assert len(preds) == len(target) == len(index) and index.min() == 0 + preds_ordered = torch.zeros((index.max() + 1, *preds.shape[1:]), dtype=preds.dtype, device=preds.device) + preds_ordered[index] = preds + target_ordered = torch.zeros((index.max() + 1, *target.shape[1:]), dtype=target.dtype, device=target.device) + target_ordered[index] = target + return {"preds": preds_ordered, "target": target_ordered} diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/adapters.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/adapters.py new file mode 100644 index 0000000000000000000000000000000000000000..434dde73c54f0f17932967652c12253f886cc461 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/adapters.py @@ -0,0 +1,51 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Any, Tuple, Optional + +from torch.utils.data import Dataset + + +class DatasetWithEnumeratedTargets(Dataset): + """ + If pad_dataset is set, pads based on torch's DistributedSampler implementation, which + with drop_last=False pads the last batch to be a multiple of the world size. + https://github.com/pytorch/pytorch/blob/main/torch/utils/data/distributed.py#L91 + """ + + def __init__(self, dataset: Dataset, pad_dataset: bool = False, num_replicas: Optional[int] = None): + self._dataset = dataset + self._size = len(self._dataset) + self._padded_size = self._size + self._pad_dataset = pad_dataset + if self._pad_dataset: + assert num_replicas is not None, "num_replicas should be set if pad_dataset is True" + self._padded_size = num_replicas * ((len(dataset) + num_replicas - 1) // num_replicas) + + def get_image_relpath(self, index: int) -> str: + assert self._pad_dataset or index < self._size + return self._dataset.get_image_relpath(index % self._size) + + def get_image_data(self, index: int) -> bytes: + assert self._pad_dataset or index < self._size + return self._dataset.get_image_data(index % self._size) + + def get_target(self, index: int) -> Tuple[Any, int]: + target = self._dataset.get_target(index % self._size) + if index >= self._size: + assert self._pad_dataset + return (-1, target) + return (index, target) + + def __getitem__(self, index: int) -> Tuple[Any, Tuple[Any, int]]: + image, target = self._dataset[index % self._size] + if index >= self._size: + assert self._pad_dataset + return image, (-1, target) + target = index if target is None else target + return image, (index, target) + + def __len__(self) -> int: + return self._padded_size diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/augmentations.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/augmentations.py new file mode 100644 index 0000000000000000000000000000000000000000..80254c34fb376edbac41a6cce547ac8d27e1e23e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/augmentations.py @@ -0,0 +1,118 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging + +from torchvision import transforms + +from .transforms import ( + GaussianBlur, + make_normalize_transform, +) + + +logger = logging.getLogger("dinov2") + + +class DataAugmentationDINO(object): + def __init__( + self, + global_crops_scale, + local_crops_scale, + local_crops_number, + global_crops_size=224, + local_crops_size=96, + ): + self.global_crops_scale = global_crops_scale + self.local_crops_scale = local_crops_scale + self.local_crops_number = local_crops_number + self.global_crops_size = global_crops_size + self.local_crops_size = local_crops_size + + logger.info("###################################") + logger.info("Using data augmentation parameters:") + logger.info(f"global_crops_scale: {global_crops_scale}") + logger.info(f"local_crops_scale: {local_crops_scale}") + logger.info(f"local_crops_number: {local_crops_number}") + logger.info(f"global_crops_size: {global_crops_size}") + logger.info(f"local_crops_size: {local_crops_size}") + logger.info("###################################") + + # random resized crop and flip + self.geometric_augmentation_global = transforms.Compose( + [ + transforms.RandomResizedCrop( + global_crops_size, scale=global_crops_scale, interpolation=transforms.InterpolationMode.BICUBIC + ), + transforms.RandomHorizontalFlip(p=0.5), + ] + ) + + self.geometric_augmentation_local = transforms.Compose( + [ + transforms.RandomResizedCrop( + local_crops_size, scale=local_crops_scale, interpolation=transforms.InterpolationMode.BICUBIC + ), + transforms.RandomHorizontalFlip(p=0.5), + ] + ) + + # color distorsions / blurring + color_jittering = transforms.Compose( + [ + transforms.RandomApply( + [transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)], + p=0.8, + ), + transforms.RandomGrayscale(p=0.2), + ] + ) + + global_transfo1_extra = GaussianBlur(p=1.0) + + global_transfo2_extra = transforms.Compose( + [ + GaussianBlur(p=0.1), + transforms.RandomSolarize(threshold=128, p=0.2), + ] + ) + + local_transfo_extra = GaussianBlur(p=0.5) + + # normalization + self.normalize = transforms.Compose( + [ + transforms.ToTensor(), + make_normalize_transform(), + ] + ) + + self.global_transfo1 = transforms.Compose([color_jittering, global_transfo1_extra, self.normalize]) + self.global_transfo2 = transforms.Compose([color_jittering, global_transfo2_extra, self.normalize]) + self.local_transfo = transforms.Compose([color_jittering, local_transfo_extra, self.normalize]) + + def __call__(self, image): + output = {} + + # global crops: + im1_base = self.geometric_augmentation_global(image) + global_crop_1 = self.global_transfo1(im1_base) + + im2_base = self.geometric_augmentation_global(image) + global_crop_2 = self.global_transfo2(im2_base) + + output["global_crops"] = [global_crop_1, global_crop_2] + + # global crops for teacher: + output["global_crops_teacher"] = [global_crop_1, global_crop_2] + + # local crops: + local_crops = [ + self.local_transfo(self.geometric_augmentation_local(image)) for _ in range(self.local_crops_number) + ] + output["local_crops"] = local_crops + output["offsets"] = () + + return output diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/cell_dino/augmentations.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/cell_dino/augmentations.py new file mode 100644 index 0000000000000000000000000000000000000000..716c41ae35a728b3974f91cb3c2dffbc8173b325 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/cell_dino/augmentations.py @@ -0,0 +1,91 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import logging +import torchvision +from torchvision import transforms + +from .transforms import ( + RandomContrastProteinChannel, + RandomRemoveChannelExceptProtein, + RandomBrightness, + RandomContrast, + Div255, + SelfNormalizeNoDiv, +) + +logger = logging.getLogger("dinov2") + + +class CellAugmentationDINO(object): + def __init__( + self, + global_crops_scale, + local_crops_scale, + local_crops_number, + global_crops_size=224, + local_crops_size=96, + ): + self.global_crops_scale = global_crops_scale + self.local_crops_scale = local_crops_scale + self.local_crops_number = local_crops_number + self.global_crops_size = global_crops_size + self.local_crops_size = local_crops_size + + logger.info("###################################") + logger.info("Using data augmentation parameters:") + logger.info(f"global_crops_scale: {global_crops_scale}") + logger.info(f"local_crops_scale: {local_crops_scale}") + logger.info(f"local_crops_number: {local_crops_number}") + logger.info(f"global_crops_size: {global_crops_size}") + logger.info(f"local_crops_size: {local_crops_size}") + logger.info("###################################") + + additional_transforms_list = [ + torchvision.transforms.RandomHorizontalFlip(), + torchvision.transforms.RandomVerticalFlip(), + RandomBrightness(), + RandomContrast(), + SelfNormalizeNoDiv(), + ] + + first_transforms_list = [ + Div255(), + RandomRemoveChannelExceptProtein(), + RandomContrastProteinChannel(), + ] + + global_transforms_list = first_transforms_list.copy() + global_transforms_list.append( + torchvision.transforms.RandomResizedCrop(size=global_crops_size, scale=global_crops_scale) + ) + global_transforms_list = global_transforms_list + additional_transforms_list + + local_transforms_list = first_transforms_list + local_transforms_list.append( + torchvision.transforms.RandomResizedCrop(size=local_crops_size, scale=local_crops_scale) + ) + local_transforms_list = local_transforms_list + additional_transforms_list + + self.global_transform = transforms.Compose(global_transforms_list) + self.local_transform = transforms.Compose(local_transforms_list) + + def __call__(self, image): + output = {} + + global_crop1 = self.global_transform(image) + global_crop2 = self.global_transform(image) + + output["global_crops"] = [global_crop1, global_crop2] + + local_crops = [] + for _ in range(self.local_crops_number): + local_crops.append(self.local_transform(image)) + + output["local_crops"] = local_crops + output["global_crops_teacher"] = [global_crop1, global_crop2] + output["offsets"] = () + + return output diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/cell_dino/transforms.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/cell_dino/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..08363f5f9ef6c4418476669e0fe633d653a32aaf --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/cell_dino/transforms.py @@ -0,0 +1,169 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import torch +from torchvision import transforms +import numpy as np +from enum import Enum + + +class NormalizationType(Enum): + SELF_NORM_AUG_DECODER = "self_norm_aug_decoder" + SELF_NORM_CENTER_CROP = "self_norm_center_crop" + + +class Div255(torch.nn.Module): + def forward(self, x): + x = x / 255 + return x + + +class SelfNormalizeNoDiv(torch.nn.Module): + def forward(self, x): + m = x.mean((-2, -1), keepdim=True) + s = x.std((-2, -1), unbiased=False, keepdim=True) + x -= m + x /= s + 1e-7 + return x + + +class SelfNormalize(torch.nn.Module): + def forward(self, x): + x = x / 255 + m = x.mean((-2, -1), keepdim=True) + s = x.std((-2, -1), unbiased=False, keepdim=True) + x -= m + x /= s + 1e-7 + return x + + +class RandomContrastProteinChannel(torch.nn.Module): + """ + Random constrast rescaling of the protein channel only. + RescaleProtein function in Dino4cell codebase. + """ + + def __init__(self, p=0.2): + super().__init__() + self.p = p + + def forward(self, img): + if img.max() == 0: + return img + if len(img) == 1: + return img + if np.random.rand() <= self.p: + random_factor = (np.random.rand() * 2) / img.max() # scaling + img[1] = img[1] * random_factor + return img + else: + return img + + +class RandomRemoveChannelExceptProtein(torch.nn.Module): + """ + dropping a channel at random except the channel 1, corresponding to proteins in HPA datasets. + """ + + def __init__(self, p=0.2): + super().__init__() + self.p = p + + def forward(self, img): + img_size = np.array(img).shape + if img_size[0] < 4: + return img + if np.random.rand() <= self.p: + channel_to_blacken = np.random.choice(np.array([0, 2, 3])) + img[channel_to_blacken] = torch.zeros(1, *img.shape[1:]) + return img + else: + return img + + +class RandomRemoveChannel(torch.nn.Module): + """ + dropping a channel at random + """ + + def __init__(self, p=0.2): + super().__init__() + self.p = p + + def forward(self, img): + img_size = np.array(img).shape + num_channels = img_size[0] + if num_channels < 4: + return img + if np.random.rand() <= self.p: + channel_to_blacken = np.random.choice(np.array(list(range(num_channels)))) + img[channel_to_blacken] = torch.zeros(1, *img.shape[1:]) + return img + else: + return img + + +class RandomContrast(torch.nn.Module): + def __init__(self, p=0.2): + super().__init__() + self.p = p + + def forward(self, img): + if img.max() == 0: + return img + n_channels = img.shape[0] + for ind in range(n_channels): + factor = max(np.random.normal(1, self.p), 0.5) + img[ind] = transforms.functional.adjust_contrast(img[ind][None, ...], factor) + return img + + +class RandomBrightness(torch.nn.Module): + def __init__(self, p=0.2): + super().__init__() + self.p = p + + def forward(self, img): + if img.max() == 0: + return img + n_channels = img.shape[0] + for ind in range(n_channels): + factor = max(np.random.normal(1, self.p), 0.5) + img[ind] = transforms.functional.adjust_brightness(img[ind], factor) + return img + + +def make_classification_eval_cell_transform( + *, + resize_size: int = 0, + interpolation=transforms.InterpolationMode.BICUBIC, + crop_size: int = 384, + normalization_type: Enum = NormalizationType.SELF_NORM_CENTER_CROP, +) -> transforms.Compose: + + from .transforms import ( + Div255, + SelfNormalizeNoDiv, + ) + + transforms_list = [Div255()] + if resize_size > 0: + transforms_list.append(transforms.Resize(resize_size, interpolation=interpolation)) + + if normalization_type == NormalizationType.SELF_NORM_AUG_DECODER: + transforms_list.extend( + [ + transforms.RandomCrop(size=crop_size, pad_if_needed=True), + transforms.RandomHorizontalFlip(), + transforms.RandomVerticalFlip(), + ] + ) + elif normalization_type == NormalizationType.SELF_NORM_CENTER_CROP: + transforms_list.append(transforms.CenterCrop(size=crop_size)) + else: + raise ValueError("f{normalization_type}: unknown NormalizationType") + transforms_list.append(SelfNormalizeNoDiv()) + + return transforms.Compose(transforms_list) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/collate.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/collate.py new file mode 100644 index 0000000000000000000000000000000000000000..dbefab294ba43ac9d720434869ccaf2bdf1b93b1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/collate.py @@ -0,0 +1,49 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import random + + +def collate_data_and_cast(samples_list, mask_ratio_tuple, mask_probability, dtype, n_tokens=None, mask_generator=None): + # dtype = torch.half # TODO: Remove + + n_global_crops = len(samples_list[0][0]["global_crops"]) + n_local_crops = len(samples_list[0][0]["local_crops"]) + + collated_global_crops = torch.stack([s[0]["global_crops"][i] for i in range(n_global_crops) for s in samples_list]) + + collated_local_crops = torch.stack([s[0]["local_crops"][i] for i in range(n_local_crops) for s in samples_list]) + + B = len(collated_global_crops) + N = n_tokens + n_samples_masked = int(B * mask_probability) + probs = torch.linspace(*mask_ratio_tuple, n_samples_masked + 1) + upperbound = 0 + masks_list = [] + for i in range(0, n_samples_masked): + prob_min = probs[i] + prob_max = probs[i + 1] + masks_list.append(torch.BoolTensor(mask_generator(int(N * random.uniform(prob_min, prob_max))))) + upperbound += int(N * prob_max) + for i in range(n_samples_masked, B): + masks_list.append(torch.BoolTensor(mask_generator(0))) + + random.shuffle(masks_list) + + collated_masks = torch.stack(masks_list).flatten(1) + mask_indices_list = collated_masks.flatten().nonzero().flatten() + + masks_weight = (1 / collated_masks.sum(-1).clamp(min=1.0)).unsqueeze(-1).expand_as(collated_masks)[collated_masks] + + return { + "collated_global_crops": collated_global_crops.to(dtype), + "collated_local_crops": collated_local_crops.to(dtype), + "collated_masks": collated_masks, + "mask_indices_list": mask_indices_list, + "masks_weight": masks_weight, + "upperbound": upperbound, + "n_masked_patches": torch.full((1,), fill_value=mask_indices_list.shape[0], dtype=torch.long), + } diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..258dac0760cdb59f65b28e77f6e27d8e2cdb9dd9 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .image_net import ImageNet +from .image_net_22k import ImageNet22k +from .cell_dino.hpaone import HPAone +from .cell_dino.hpafov import HPAFoV +from .cell_dino.chammi_cp import CHAMMI_CP +from .cell_dino.chammi_hpa import CHAMMI_HPA +from .cell_dino.chammi_wtc import CHAMMI_WTC diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_cp.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_cp.py new file mode 100644 index 0000000000000000000000000000000000000000..78b5b498f42636acb2ff3ba564158669f25dc725 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_cp.py @@ -0,0 +1,112 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Any, Callable, Optional, Union + +import numpy as np + +from ..extended import ExtendedVisionDataset +from ..decoders import DecoderType + +logger = logging.getLogger("dinov2") + + +METADATA_FILE = "morphem70k_v2.csv" + +CLASS_LABELS = { + "BRD-A29260609": 0, + "BRD-K04185004": 1, + "BRD-K21680192": 2, + "DMSO": 3, + "BRD-K11129031": 4, # labels only seen in TASK_FOUR + "BRD-K62310379": 5, + "BRD-K77947974": 6, +} + + +class _Split(Enum): + TRAIN = "Train" + TASK_ONE = "Task_one" + TASK_TWO = "Task_two" + TASK_THREE = "Task_three" + TASK_FOUR = "Task_four" + + +def _load_file_names_and_targets( + root: str, + split: _Split, +): + image_paths = [] + labels = [] + with open(os.path.join(root, METADATA_FILE)) as metadata: + metadata_reader = csv.DictReader(metadata) + for row in metadata_reader: + row_dataset = row["file_path"].split("/")[0] + + if row["train_test_split"].upper() == split and row_dataset == "CP": + image_paths.append(row["file_path"]) + labels.append(CLASS_LABELS[row["label"]]) + + return image_paths, labels # to debug + + +class CHAMMI_CP(ExtendedVisionDataset): + """ + Implementation of the CP (Cell-Painting) subset of the CHAMMI benchmark dataset, + following the CHAMMI paper: https://arxiv.org/pdf/2310.19224 + Github code: https://github.com/chaudatascience/channel_adaptive_models + """ + + Split = Union[_Split] + + def __init__( + self, + *, + split: "CHAMMI_CP.Split", + root: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + image_decoder_type: DecoderType = DecoderType.XChannelsDecoder, + **kwargs: Any, + ) -> None: + super().__init__( + root, + transforms, + transform, + target_transform, + image_decoder_type=image_decoder_type, + **kwargs, + ) + self.split = split + self.root = root + self.num_additional_labels_loo_eval = 3 + self._image_paths, self._targets = _load_file_names_and_targets( + root, + split, + ) + + def get_image_relpath(self, index: int) -> str: + return self._image_paths[index] + + def get_image_data(self, index: int) -> bytes: + image_relpath = self.get_image_relpath(index) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + return image_data + + def get_target(self, index: int) -> Any: + return self._targets[index] + + def get_targets(self) -> np.ndarray: + return np.array(self._targets) + + def __len__(self) -> int: + return len(self._image_paths) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_hpa.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_hpa.py new file mode 100644 index 0000000000000000000000000000000000000000..8eb6619c99cc7d000ed743ac513358fcbb98ff4e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_hpa.py @@ -0,0 +1,111 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Any, Callable, Optional, Union + +import numpy as np + +from ..extended import ExtendedVisionDataset +from ..decoders import DecoderType + +logger = logging.getLogger("dinov2") + + +METADATA_FILE = "morphem70k_v2.csv" + +CLASS_LABELS = { + "golgi apparatus": 0, + "microtubules": 1, + "mitochondria": 2, + "nuclear speckles": 3, + "cytosol": 4, # labels only seen in TASK_THREE + "endoplasmic reticulum": 5, + "nucleoplasm": 6, +} + + +class _Split(Enum): + TRAIN = "Train" + TASK_ONE = "Task_one" + TASK_TWO = "Task_two" + TASK_THREE = "Task_three" + + +def _load_file_names_and_targets( + root: str, + split: _Split, +): + image_paths = [] + labels = [] + with open(os.path.join(root, METADATA_FILE)) as metadata: + metadata_reader = csv.DictReader(metadata) + for row in metadata_reader: + row_dataset = row["file_path"].split("/")[0] + if row["train_test_split"].upper() == split and row_dataset == "HPA": + image_paths.append(row["file_path"]) + labels.append(CLASS_LABELS[row["label"]]) + + return image_paths, labels + + +class CHAMMI_HPA(ExtendedVisionDataset): + """ + Implementation of the CP (Cell-Painting) subset of the CHAMMI benchmark dataset, + following the CHAMMI paper: https://arxiv.org/pdf/2310.19224 + Github code: https://github.com/chaudatascience/channel_adaptive_models + """ + + Split = Union[_Split] + + def __init__( + self, + *, + split: "CHAMMI_HPA.Split", + root: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + image_decoder_type: DecoderType = DecoderType.XChannelsDecoder, + **kwargs: Any, + ) -> None: + super().__init__( + root, + transforms, + transform, + target_transform, + image_decoder_type=image_decoder_type, + **kwargs, + ) + self.split = split + self.root = root + self.num_additional_labels_loo_eval = 3 + + self._image_paths, self._targets = _load_file_names_and_targets( + root, + split, + ) + + def get_image_relpath(self, index: int) -> str: + return self._image_paths[index] + + def get_image_data(self, index: int) -> bytes: + image_relpath = self.get_image_relpath(index) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + return image_data + + def get_target(self, index: int) -> Any: + return self._targets[index] + + def get_targets(self) -> np.ndarray: + return np.array(self._targets) + + def __len__(self) -> int: + return len(self._image_paths) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_wtc.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_wtc.py new file mode 100644 index 0000000000000000000000000000000000000000..6f05bb38d0817a7bb515c4bdbb3d2aa7820e726d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/chammi_wtc.py @@ -0,0 +1,108 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Any, Callable, Optional, Union + +import numpy as np + +from ..extended import ExtendedVisionDataset +from ..decoders import DecoderType + +logger = logging.getLogger("dinov2") + + +METADATA_FILE = "morphem70k_v2.csv" + +CLASS_LABELS = { + "M0": 0, + "M1M2": 1, + "M3": 2, + "M4M5": 3, + "M6M7_complete": 4, + "M6M7_single": 5, +} + + +class _Split(Enum): + TRAIN = "Train" + TASK_ONE = "Task_one" + TASK_TWO = "Task_two" + + +def _load_file_names_and_targets( + root: str, + split: _Split, +): + image_paths = [] + labels = [] + with open(os.path.join(root, METADATA_FILE)) as metadata: + metadata_reader = csv.DictReader(metadata) + for row in metadata_reader: + row_dataset = row["file_path"].split("/")[0] + if row["train_test_split"].upper() == split and row_dataset == "Allen": + image_paths.append(row["file_path"]) + labels.append(CLASS_LABELS[row["label"]]) + + return image_paths, labels + + +class CHAMMI_WTC(ExtendedVisionDataset): + """ + Implementation of the CP (Cell-Painting) subset of the CHAMMI benchmark dataset, + following the CHAMMI paper: https://arxiv.org/pdf/2310.19224 + Github code: https://github.com/chaudatascience/channel_adaptive_models + """ + + Split = Union[_Split] + + def __init__( + self, + *, + split: "CHAMMI_WTC.Split", + root: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + image_decoder_type: DecoderType = DecoderType.XChannelsTIFFDecoder, + **kwargs: Any, + ) -> None: + super().__init__( + root, + transforms, + transform, + target_transform, + image_decoder_type=image_decoder_type, + **kwargs, + ) + self.split = split + self.root = root + + self._image_paths, self._targets = _load_file_names_and_targets( + root, + split, + ) + + def get_image_relpath(self, index: int) -> str: + return self._image_paths[index] + + def get_image_data(self, index: int) -> bytes: + image_relpath = self.get_image_relpath(index) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + return image_data + + def get_target(self, index: int) -> Any: + return self._targets[index] + + def get_targets(self) -> np.ndarray: + return np.array(self._targets) + + def __len__(self) -> int: + return len(self._image_paths) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/hpafov.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/hpafov.py new file mode 100644 index 0000000000000000000000000000000000000000..51b1c539ee7f9bfa5df5f6479220f2abb31d37f4 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/hpafov.py @@ -0,0 +1,283 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Any, Callable, List, Optional, Tuple, Union, Dict + +import numpy as np + +from ..extended import ExtendedVisionDataset +from ..decoders import DecoderType + +logger = logging.getLogger("dinov2") + +CELL_TYPE = [ + "BJ", # 1 + "LHCN-M2", + "RH-30", + "SH-SY5Y", + "U-2 OS", # 5 + "ASC TERT1", + "HaCaT", + "A-431", + "U-251 MG", + "HEK 293", # 10 + "A549", + "RT4", + "HeLa", + "MCF7", + "PC-3", # 15 + "hTERT-RPE1", + "SK-MEL-30", + "EFO-21", + "AF22", + "HEL", # 20 + "Hep G2", + "HUVEC TERT2", + "THP-1", + "CACO-2", + "JURKAT", # 25 + "RPTEC TERT1", + "SuSa", + "REH", + "HDLM-2", + "K-562", # 30 + "hTCEpi", + "NB-4", + "HAP1", + "OE19", + "SiHa", # 35 +] + +PROTEIN_LOCALIZATION = [ # matches https://www.kaggle.com/c/human-protein-atlas-image-classification/data + "nucleoplasm", + "nuclear membrane", + "nucleoli", + "nucleoli fibrillar center", + "nuclear speckles", # 5 + "nuclear bodies", + "endoplasmic reticulum", + "golgi apparatus", + "peroxisomes", + "endosomes", # 10 + "lysosomes", + "intermediate filaments", + "actin filaments", + "focal adhesion sites", + "microtubules", # 15 + "microtubule ends", + "cytokinetic bridge", + "mitotic spindle", + "microtubule organizing center", + "centrosome", # 20 + "lipid droplets", + "plasma membrane", + "cell junctions", + "mitochondria", + "aggresome", # 25 + "cytosol", + "cytoplasmic bodies", + "rods & rings", +] + + +class _Split(Enum): + TRAIN = "train" + VAL = "val" + SSL = "ssl" + + +def get_csv_fpath(split): + """ + Path to data relative to root + """ + if split == _Split.TRAIN.value.upper() or split == _Split.TRAIN or split == "TRAIN": + return "whole_images_512_train.csv" + elif split == _Split.VAL.value.upper() or split == _Split.VAL or split == "VAL": + return "whole_images_512_test.csv" + + +class _WildCard(Enum): + NONE = "none" + SEPARATECHANNELS = "separate_channels" # each channel from each image is treated as an independent sample, overrides chosen channel configuration + + +class _Mode(Enum): + """ + Targets: + - ALL: tuple, (one hot encoding of multilabel protein localization, categorical encoding of cell type) + - PROTEIN_LOCALIZATION: one hot encoding of multilabel protein localization + - CELL_TYPE: categorical encoding of cell type + """ + + ALL = "all" + PROTEIN_LOCALIZATION = "protein_localization" + CELL_TYPE = "cell_type" + + @property + def nb_labels(self): + if self == _Mode.CELL_TYPE: + return len(CELL_TYPE) + elif self == _Mode.PROTEIN_LOCALIZATION: + return len(PROTEIN_LOCALIZATION) + else: + return None + + +def _list_images_from_csv(img_path, csv_path): + L = [] + with open(csv_path) as filename: + reader = csv.DictReader(filename) + for row in reader: + L.append(os.path.join(img_path, row["ID"] + ".png")) + return L + + +def _load_file_names_and_labels_ssl( + root: str, +) -> Tuple[List[str], List[Any]]: + + curr_img_path = os.path.join(root, "normalized_data") + csv_train_ssl = os.path.join(root, "whole_images_names.csv") + image_paths = _list_images_from_csv(curr_img_path, csv_train_ssl) + labels = [i for i in range(len(image_paths))] + return image_paths, labels + + +def _load_file_names_and_labels( + root: str, + split: _Split, + mode: _Mode, +) -> Tuple[List[str], List[Any], np.ndarray]: + + data_path = os.path.join(root, "512_whole_images") + csv_fpath = os.path.join(root, get_csv_fpath(split)) + + image_paths = [] + labels = [] + + with open(csv_fpath) as filename: + reader = csv.DictReader(filename) + for row in reader: + + add_sample = True + if mode != _Mode.PROTEIN_LOCALIZATION.value.upper(): + # categorical + if row["cell_type"] in CELL_TYPE: + cell_type = CELL_TYPE.index(row["cell_type"]) + else: + cell_type = np.nan + + if mode != _Mode.CELL_TYPE.value.upper(): + # one hot encoding + prot_loc = np.zeros(len(PROTEIN_LOCALIZATION), dtype=np.int_) + for k in range(len(PROTEIN_LOCALIZATION)): + if row[PROTEIN_LOCALIZATION[k]] == "True": + prot_loc[k] = 1 + if prot_loc.max() < 0.5: + add_sample = False + + if add_sample: + if mode == _Mode.PROTEIN_LOCALIZATION.value.upper(): + labels.append(prot_loc) + elif mode == _Mode.CELL_TYPE.value.upper(): + labels.append(cell_type) + else: + labels.append({"prot_loc": prot_loc, "cell_type": cell_type}) + + candidate_path = os.path.join(data_path, row["file"].split("/")[-1]) + if os.path.exists(candidate_path): + image_paths.append(candidate_path) + else: + candidate_path = os.path.join( + data_path, row["file"].split("/")[-1].split(".")[0] + ".tiff" + ) # _blue.png") # some images on the normalized_data folder have a _blue suffix on their names + if os.path.exists(candidate_path): + image_paths.append(candidate_path) + else: + raise FileNotFoundError(f"File {candidate_path} not found.") + + return image_paths, labels + + +class HPAFoV(ExtendedVisionDataset): + Split = Union[_Split] + Mode = Union[_Mode] + WildCard = Union[_WildCard] + + def __init__( + self, + *, + split: "HPAFoV.Split" = _Split.TRAIN, + mode: "HPAFoV.Mode" = _Mode.ALL, + wildcard: "HPAFoV.WildCard" = _WildCard.NONE, + root: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + image_decoder_type: DecoderType = DecoderType.ChannelSelectDecoder, + image_decoder_params: Dict[str, Any] = {}, + **kwargs: Any, + ) -> None: + super().__init__( + root, + transforms, + transform, + target_transform, + image_decoder_type=image_decoder_type, + image_decoder_params={ + "select_channel": True + if wildcard == _WildCard.SEPARATECHANNELS or wildcard == "SEPARATE_CHANNELS" + else False + }, + **kwargs, + ) + self.mode = mode + self.split = split + self.root = root + self.wildcard = wildcard + self.channel_adaptive = True + if split == _Split.SSL.value.upper() or split == _Split.SSL or split == "SSL": + self._image_paths, self._labels = _load_file_names_and_labels_ssl(root) + else: + self._image_paths, self._labels = _load_file_names_and_labels(root, self.split, self.mode) + + self._channels = np.repeat(np.array([[0, 1, 2, 3]]), len(self._image_paths), axis=0).tolist() + + if self.wildcard == _WildCard.SEPARATECHANNELS.value.upper(): + image_paths, labels, channels = self._image_paths, self._labels, self._channels + channels = np.array(channels) + # separate and stack the columns of the channels array + C = channels.shape[1] + channels = np.concatenate([channels[:, i] for i in range(C)]) + self._channels = np.expand_dims(channels, 1).tolist() + self.image_paths = image_paths * C + self.labels = labels * C + + def get_image_relpath(self, index: int) -> str: + return self._image_paths[index] + + def get_image_data(self, index: int) -> bytes: + image_relpath = self.get_image_relpath(index) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + if self.channel_adaptive: + channels = self._channels[index] + return image_data + bytes(channels) + (len(channels)).to_bytes(1, byteorder="big") + else: + return image_data + + def get_target(self, index: int) -> Any: + return self._labels[index] + + def get_targets(self) -> np.ndarray: + return np.array(self._labels) + + def __len__(self) -> int: + return len(self._image_paths) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/hpaone.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/hpaone.py new file mode 100644 index 0000000000000000000000000000000000000000..bb9f653ad7d3702c68c422c73e9c7e98d315e634 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/cell_dino/hpaone.py @@ -0,0 +1,223 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Any, Callable, List, Optional, Tuple, Union + +import numpy as np + +from ..extended import ExtendedVisionDataset +from ..decoders import DecoderType + +logger = logging.getLogger("dinov2") + +PROTEIN_LOCALIZATION = [ + "actin filaments,focal adhesion sites", + "aggresome", + "centrosome,centriolar satellite", + "cytosol", + "endoplasmic reticulum", + "golgi apparatus", + "intermediate filaments", + "microtubules", + "mitochondria", + "mitotic spindle", + "no staining", + "nuclear bodies", + "nuclear membrane", + "nuclear speckles", + "nucleoli", + "nucleoli fibrillar center", + "nucleoplasm", + "plasma membrane,cell junctions", + "vesicles,peroxisomes,endosomes,lysosomes,lipid droplets,cytoplasmic bodies", +] # 19 + + +CELL_TYPE = [ + "A-431", # 0 + "A549", + "AF22", + "ASC TERT1", + "BJ", + "CACO-2", + "EFO-21", + "HAP1", + "HDLM-2", + "HEK 293", # 9 + "HEL", + "HUVEC TERT2", + "HaCaT", + "HeLa", + "Hep G2", + "JURKAT", + "K-562", + "MCF7", + "PC-3", + "REH", + "RH-30", # 20 + "RPTEC TERT1", + "RT4", + "SH-SY5Y", + "SK-MEL-30", + "SiHa", + "U-2 OS", + "U-251 MG", + "hTCEpi", # 28 +] # 29 cell types + + +class _Split(Enum): + VAL = "val" + TRAIN = "train" + ALL = "all" # images without labels, for encoder training + + +class _Mode(Enum): + PROTEIN_LOCALIZATION = "protein_localization" + CELL_TYPE = "cell_type" + + @property + def num_labels(self): + if self == _Mode.CELL_TYPE.value.upper(): + return len(CELL_TYPE) + return len(PROTEIN_LOCALIZATION) + + +def _simple_parse_csv(img_rootdir, csv_filepath: str): + samples = [] + with open(csv_filepath) as filename: + template = csv.DictReader(filename) + samples = [(os.path.join(img_rootdir, row["img_path"]), 0) for row in template] + return samples + + +def _parse_csv(img_rootdir, csv_labels_path: str): + nb_protein_location = len(PROTEIN_LOCALIZATION) + nb_cell_type = len(CELL_TYPE) + samples = [] + with open(csv_labels_path) as filename: + reader = csv.DictReader(filename) + for row in reader: + protein_location = np.zeros(nb_protein_location, dtype=np.int_) + for k in range(nb_protein_location): + if row[PROTEIN_LOCALIZATION[k]] == "True": + protein_location[k] = 1 + + cell_type = 0 + for k in range(nb_cell_type): + if row[CELL_TYPE[k]] == "True": + cell_type = k + + samples.append( + ( + img_rootdir + "/" + row["file"].rsplit("/", 1)[1], + protein_location, + cell_type, + ) + ) + return samples + + +def _load_file_names_and_labels_ssl( + root: str, +) -> Tuple[List[str], List[Any]]: + curr_dir_train = os.path.join(root, "varied_size_masked_single_cells_HPA") + csv_all_path = os.path.join(root, "varied_size_masked_single_cells_pretrain_20240507.csv") + samples = _simple_parse_csv(curr_dir_train, csv_all_path) + image_paths, fake_labels = zip(*samples) + lab = list(fake_labels) + return image_paths, lab + + +def _load_file_names_and_labels_train_or_test( + root: str, + split: _Split, + mode: _Mode, +) -> Tuple[List[str], List[Any]]: + + if split == _Split.TRAIN.value.upper() or split == _Split.TRAIN: + csv_labels_path = os.path.join(root, "fixed_size_masked_single_cells_pretrain_20240507.csv") + elif split == _Split.VAL.value.upper() or split == _Split.VAL: + csv_labels_path = os.path.join(root, "fixed_size_masked_single_cells_evaluation_20240507.csv") + else: + print("wrong split name") + curr_dir_val = os.path.join(root, "fixed_size_masked_single_cells_HPA") + + samples = _parse_csv(curr_dir_val, csv_labels_path) + image_paths, protein_location, cell_type = zip(*samples) + if mode == _Mode.PROTEIN_LOCALIZATION.value.upper(): + lab = protein_location + elif mode == _Mode.CELL_TYPE.value.upper(): + lab = cell_type + else: + lab = protein_location, cell_type + image_paths = list(image_paths) + return image_paths, lab + + +class HPAone(ExtendedVisionDataset): + Split = Union[_Split] + Mode = Union[_Mode] + + def __init__( + self, + *, + split: "HPAone.Split" = _Split.ALL, + mode: "HPAone.Mode" = None, + root: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + image_decoder_type: DecoderType = DecoderType.XChannelsDecoder, + **kwargs: Any, + ) -> None: + super().__init__( + root, + transforms, + transform, + target_transform, + image_decoder_type=image_decoder_type, + **kwargs, + ) + self.mode = mode + self.split = split + self.root = root + + if ( + split in {_Split.TRAIN.value.upper(), _Split.VAL.value.upper()} + or split == _Split.TRAIN + or split == _Split.VAL + ): + ( + self._image_paths, + self._labels, + ) = _load_file_names_and_labels_train_or_test(root, split, mode) + elif split == _Split.ALL.value.upper() or split == _Split.ALL: + self._image_paths, self._labels = _load_file_names_and_labels_ssl(root) + else: + logger.info(f"unknown split: {split}, {_Split.ALL.value.upper()}") + + def get_image_relpath(self, index: int) -> str: + return self._image_paths[index] + + def get_image_data(self, index: int) -> bytes: + image_relpath = self.get_image_relpath(index) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + return image_data + + def get_target(self, index: int) -> Any: + return self._labels[index] + + def get_targets(self) -> np.ndarray: + return np.array(self._labels) + + def __len__(self) -> int: + return len(self._image_paths) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/decoders.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/decoders.py new file mode 100644 index 0000000000000000000000000000000000000000..80400f540f4025a6c70fe70d6218b5c4c8cd1532 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/decoders.py @@ -0,0 +1,94 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from io import BytesIO +from typing import Any, Type + +from PIL import Image +import numpy as np +import torch +from enum import Enum + +try: + import tifffile +except ImportError: + print("Could not import `tifffile`, TIFFImageDataDecoder will be disabled") + + +class Decoder: + def decode(self) -> Any: + raise NotImplementedError + + +class DecoderType(Enum): + ImageDataDecoder = "ImageDataDecoder" + XChannelsDecoder = "XChannelsDecoder" + XChannelsTIFFDecoder = "XChannelsTIFFDecoder" + ChannelSelectDecoder = "ChannelSelectDecoder" + + def get_class(self) -> Type[Decoder]: # noqa: C901 + if self == DecoderType.ImageDataDecoder: + return ImageDataDecoder + if self == DecoderType.XChannelsDecoder: + return XChannelsDecoder + if self == DecoderType.XChannelsTIFFDecoder: + return XChannelsTIFFDecoder + if self == DecoderType.ChannelSelectDecoder: + return ChannelSelectDecoder + + +class ImageDataDecoder(Decoder): + def __init__(self, image_data: bytes) -> None: + self._image_data = image_data + + def decode(self) -> Image: + f = BytesIO(self._image_data) + return Image.open(f).convert(mode="RGB") + + +class TargetDecoder(Decoder): + def __init__(self, target: Any): + self._target = target + + def decode(self) -> Any: + return self._target + + +class XChannelsDecoder(Decoder): + def __init__(self, image_data: bytes) -> None: + self._image_data = image_data + + def decode(self): + im = np.asarray(Image.open(BytesIO(self._image_data))) + if len(im.shape) == 2: + im = np.reshape(im, (im.shape[0], im.shape[0], -1), order="F") + return torch.Tensor(im).permute(2, 0, 1) + + +class XChannelsTIFFDecoder(Decoder): + def __init__(self, image_data: bytes, num_channels: int = 3) -> None: + self._image_data = image_data + self._num_channels = num_channels + + def decode(self): + numpy_array = tifffile.imread(BytesIO(self._image_data)) + numpy_array = np.reshape(numpy_array, (numpy_array.shape[0], -1, self._num_channels), order="F") + return torch.Tensor(numpy_array).permute(2, 0, 1) + + +class ChannelSelectDecoder(Decoder): + def __init__(self, image_data: bytes, select_channel: bool = False) -> None: + self.select_channel = select_channel + if select_channel: + self._image_data = image_data[:-1] + self._channel = image_data[-1] + else: + self._image_data = image_data + + def decode(self): + im = np.asarray(Image.open(BytesIO(self._image_data))) + if self.select_channel: + return torch.Tensor(im).permute(2, 0, 1)[[self._channel]] + return torch.Tensor(im).permute(2, 0, 1) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/extended.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/extended.py new file mode 100644 index 0000000000000000000000000000000000000000..95c49bc0ce7d62687a4c83ea8a93e7316646c8f6 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/extended.py @@ -0,0 +1,44 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Any, Tuple + +from torchvision.datasets import VisionDataset + +from .decoders import DecoderType, TargetDecoder + + +class ExtendedVisionDataset(VisionDataset): + def __init__(self, *args, **kwargs) -> None: + image_decoder_type = kwargs.pop("image_decoder_type", DecoderType.ImageDataDecoder) + self._decoder_params = {} + self._image_decoder_class = image_decoder_type.get_class() + if "image_decoder_params" in kwargs: + self._decoder_params = kwargs.pop("image_decoder_params") + + super().__init__(*args, **kwargs) # type: ignore + + def get_image_data(self, index: int) -> bytes: + raise NotImplementedError + + def get_target(self, index: int) -> Any: + raise NotImplementedError + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + try: + image_data = self.get_image_data(index) + image = self._image_decoder_class(image_data, **self._decoder_params).decode() + except Exception as e: + raise RuntimeError(f"can not read image for sample {index}") from e + target = self.get_target(index) + target = TargetDecoder(target).decode() + + if self.transforms is not None: + image, target = self.transforms(image, target) + + return image, target + + def __len__(self) -> int: + raise NotImplementedError diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/image_net.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/image_net.py new file mode 100644 index 0000000000000000000000000000000000000000..9b63cec0d1e0ea6cc346ffcae8a4d211d8956014 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/image_net.py @@ -0,0 +1,290 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Callable, List, Optional, Tuple, Union + +import numpy as np + +from .extended import ExtendedVisionDataset + + +logger = logging.getLogger("dinov2") +_Target = int + + +class _Split(Enum): + TRAIN = "train" + VAL = "val" + TEST = "test" # NOTE: torchvision does not support the test split + + @property + def length(self) -> int: + split_lengths = { + _Split.TRAIN: 1_281_167, + _Split.VAL: 50_000, + _Split.TEST: 100_000, + } + return split_lengths[self] + + def get_dirname(self, class_id: Optional[str] = None) -> str: + return self.value if class_id is None else os.path.join(self.value, class_id) + + def get_image_relpath(self, actual_index: int, class_id: Optional[str] = None) -> str: + dirname = self.get_dirname(class_id) + if self == _Split.TRAIN: + basename = f"{class_id}_{actual_index}" + else: # self in (_Split.VAL, _Split.TEST): + basename = f"ILSVRC2012_{self.value}_{actual_index:08d}" + return os.path.join(dirname, basename + ".JPEG") + + def parse_image_relpath(self, image_relpath: str) -> Tuple[str, int]: + assert self != _Split.TEST + dirname, filename = os.path.split(image_relpath) + class_id = os.path.split(dirname)[-1] + basename, _ = os.path.splitext(filename) + actual_index = int(basename.split("_")[-1]) + return class_id, actual_index + + +class ImageNet(ExtendedVisionDataset): + Target = Union[_Target] + Split = Union[_Split] + + def __init__( + self, + *, + split: "ImageNet.Split", + root: str, + extra: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + ) -> None: + super().__init__(root, transforms, transform, target_transform) + self._extra_root = extra + self._split = split + + self._entries = None + self._class_ids = None + self._class_names = None + + @property + def split(self) -> "ImageNet.Split": + return self._split + + def _get_extra_full_path(self, extra_path: str) -> str: + return os.path.join(self._extra_root, extra_path) + + def _load_extra(self, extra_path: str) -> np.ndarray: + extra_full_path = self._get_extra_full_path(extra_path) + return np.load(extra_full_path, mmap_mode="r") + + def _save_extra(self, extra_array: np.ndarray, extra_path: str) -> None: + extra_full_path = self._get_extra_full_path(extra_path) + os.makedirs(self._extra_root, exist_ok=True) + np.save(extra_full_path, extra_array) + + @property + def _entries_path(self) -> str: + return f"entries-{self._split.value.upper()}.npy" + + @property + def _class_ids_path(self) -> str: + return f"class-ids-{self._split.value.upper()}.npy" + + @property + def _class_names_path(self) -> str: + return f"class-names-{self._split.value.upper()}.npy" + + def _get_entries(self) -> np.ndarray: + if self._entries is None: + self._entries = self._load_extra(self._entries_path) + assert self._entries is not None + return self._entries + + def _get_class_ids(self) -> np.ndarray: + if self._split == _Split.TEST: + assert False, "Class IDs are not available in TEST split" + if self._class_ids is None: + self._class_ids = self._load_extra(self._class_ids_path) + assert self._class_ids is not None + return self._class_ids + + def _get_class_names(self) -> np.ndarray: + if self._split == _Split.TEST: + assert False, "Class names are not available in TEST split" + if self._class_names is None: + self._class_names = self._load_extra(self._class_names_path) + assert self._class_names is not None + return self._class_names + + def find_class_id(self, class_index: int) -> str: + class_ids = self._get_class_ids() + return str(class_ids[class_index]) + + def find_class_name(self, class_index: int) -> str: + class_names = self._get_class_names() + return str(class_names[class_index]) + + def get_image_data(self, index: int) -> bytes: + entries = self._get_entries() + actual_index = entries[index]["actual_index"] + + class_id = self.get_class_id(index) + + image_relpath = self.split.get_image_relpath(actual_index, class_id) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + return image_data + + def get_target(self, index: int) -> Optional[Target]: + entries = self._get_entries() + class_index = entries[index]["class_index"] + return None if self.split == _Split.TEST else int(class_index) + + def get_targets(self) -> Optional[np.ndarray]: + entries = self._get_entries() + return None if self.split == _Split.TEST else entries["class_index"] + + def get_class_id(self, index: int) -> Optional[str]: + entries = self._get_entries() + class_id = entries[index]["class_id"] + return None if self.split == _Split.TEST else str(class_id) + + def get_class_name(self, index: int) -> Optional[str]: + entries = self._get_entries() + class_name = entries[index]["class_name"] + return None if self.split == _Split.TEST else str(class_name) + + def __len__(self) -> int: + entries = self._get_entries() + assert len(entries) == self.split.length + return len(entries) + + def _load_labels(self, labels_path: str) -> List[Tuple[str, str]]: + labels_full_path = os.path.join(self.root, labels_path) + labels = [] + + try: + with open(labels_full_path, "r") as f: + reader = csv.reader(f) + for row in reader: + class_id, class_name = row + labels.append((class_id, class_name)) + except OSError as e: + raise RuntimeError(f'can not read labels file "{labels_full_path}"') from e + + return labels + + def _dump_entries(self) -> None: + split = self.split + if split == ImageNet.Split.TEST: + dataset = None + sample_count = split.length + max_class_id_length, max_class_name_length = 0, 0 + else: + labels_path = "labels.txt" + logger.info(f'loading labels from "{labels_path}"') + labels = self._load_labels(labels_path) + + # NOTE: Using torchvision ImageFolder for consistency + from torchvision.datasets import ImageFolder + + dataset_root = os.path.join(self.root, split.get_dirname()) + dataset = ImageFolder(dataset_root) + sample_count = len(dataset) + max_class_id_length, max_class_name_length = -1, -1 + for sample in dataset.samples: + _, class_index = sample + class_id, class_name = labels[class_index] + max_class_id_length = max(len(class_id), max_class_id_length) + max_class_name_length = max(len(class_name), max_class_name_length) + + dtype = np.dtype( + [ + ("actual_index", " old_percent: + logger.info(f"creating entries: {percent}%") + old_percent = percent + + actual_index = index + 1 + class_index = np.uint32(-1) + class_id, class_name = "", "" + entries_array[index] = (actual_index, class_index, class_id, class_name) + else: + class_names = {class_id: class_name for class_id, class_name in labels} + + assert dataset + old_percent = -1 + for index in range(sample_count): + percent = 100 * (index + 1) // sample_count + if percent > old_percent: + logger.info(f"creating entries: {percent}%") + old_percent = percent + + image_full_path, class_index = dataset.samples[index] + image_relpath = os.path.relpath(image_full_path, self.root) + class_id, actual_index = split.parse_image_relpath(image_relpath) + class_name = class_names[class_id] + entries_array[index] = (actual_index, class_index, class_id, class_name) + + logger.info(f'saving entries to "{self._entries_path}"') + self._save_extra(entries_array, self._entries_path) + + def _dump_class_ids_and_names(self) -> None: + split = self.split + if split == ImageNet.Split.TEST: + return + + entries_array = self._load_extra(self._entries_path) + + max_class_id_length, max_class_name_length, max_class_index = -1, -1, -1 + for entry in entries_array: + class_index, class_id, class_name = ( + entry["class_index"], + entry["class_id"], + entry["class_name"], + ) + max_class_index = max(int(class_index), max_class_index) + max_class_id_length = max(len(str(class_id)), max_class_id_length) + max_class_name_length = max(len(str(class_name)), max_class_name_length) + + class_count = max_class_index + 1 + class_ids_array = np.empty(class_count, dtype=f"U{max_class_id_length}") + class_names_array = np.empty(class_count, dtype=f"U{max_class_name_length}") + for entry in entries_array: + class_index, class_id, class_name = ( + entry["class_index"], + entry["class_id"], + entry["class_name"], + ) + class_ids_array[class_index] = class_id + class_names_array[class_index] = class_name + + logger.info(f'saving class IDs to "{self._class_ids_path}"') + self._save_extra(class_ids_array, self._class_ids_path) + + logger.info(f'saving class names to "{self._class_names_path}"') + self._save_extra(class_names_array, self._class_names_path) + + def dump_extra(self) -> None: + self._dump_entries() + self._dump_class_ids_and_names() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/image_net_22k.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/image_net_22k.py new file mode 100644 index 0000000000000000000000000000000000000000..828c1fcec520a1467eb2a9081580fbbf2e2e03c0 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/datasets/image_net_22k.py @@ -0,0 +1,302 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass +from enum import Enum +from functools import lru_cache +from gzip import GzipFile +from io import BytesIO +from mmap import ACCESS_READ, mmap +import os +from typing import Any, Callable, List, Optional, Set, Tuple +import warnings + +import numpy as np + +from .extended import ExtendedVisionDataset + + +_Labels = int + +_DEFAULT_MMAP_CACHE_SIZE = 16 # Warning: This can exhaust file descriptors + + +@dataclass +class _ClassEntry: + block_offset: int + maybe_filename: Optional[str] = None + + +@dataclass +class _Entry: + class_index: int # noqa: E701 + start_offset: int + end_offset: int + filename: str + + +class _Split(Enum): + TRAIN = "train" + VAL = "val" + + @property + def length(self) -> int: + return { + _Split.TRAIN: 11_797_647, + _Split.VAL: 561_050, + }[self] + + def entries_path(self): + return f"imagenet21kp_{self.value}.txt" + + +def _get_tarball_path(class_id: str) -> str: + return f"{class_id}.tar" + + +def _make_mmap_tarball(tarballs_root: str, mmap_cache_size: int): + @lru_cache(maxsize=mmap_cache_size) + def _mmap_tarball(class_id: str) -> mmap: + tarball_path = _get_tarball_path(class_id) + tarball_full_path = os.path.join(tarballs_root, tarball_path) + with open(tarball_full_path) as f: + return mmap(fileno=f.fileno(), length=0, access=ACCESS_READ) + + return _mmap_tarball + + +class ImageNet22k(ExtendedVisionDataset): + _GZIPPED_INDICES: Set[int] = { + 841_545, + 1_304_131, + 2_437_921, + 2_672_079, + 2_795_676, + 2_969_786, + 6_902_965, + 6_903_550, + 6_903_628, + 7_432_557, + 7_432_589, + 7_813_809, + 8_329_633, + 10_296_990, + 10_417_652, + 10_492_265, + 10_598_078, + 10_782_398, + 10_902_612, + 11_203_736, + 11_342_890, + 11_397_596, + 11_589_762, + 11_705_103, + 12_936_875, + 13_289_782, + } + Labels = _Labels + + def __init__( + self, + *, + root: str, + extra: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + mmap_cache_size: int = _DEFAULT_MMAP_CACHE_SIZE, + ) -> None: + super().__init__(root, transforms, transform, target_transform) + self._extra_root = extra + + entries_path = self._get_entries_path(root) + self._entries = self._load_extra(entries_path) + + class_ids_path = self._get_class_ids_path(root) + self._class_ids = self._load_extra(class_ids_path) + + self._gzipped_indices = ImageNet22k._GZIPPED_INDICES + self._mmap_tarball = _make_mmap_tarball(self._tarballs_root, mmap_cache_size) + + def _get_entries_path(self, root: Optional[str] = None) -> str: + return "entries.npy" + + def _get_class_ids_path(self, root: Optional[str] = None) -> str: + return "class-ids.npy" + + def _find_class_ids(self, path: str) -> List[str]: + class_ids = [] + + with os.scandir(path) as entries: + for entry in entries: + root, ext = os.path.splitext(entry.name) + if ext != ".tar": + continue + class_ids.append(root) + + return sorted(class_ids) + + def _load_entries_class_ids(self, root: Optional[str] = None) -> Tuple[List[_Entry], List[str]]: + root = self.get_root(root) + entries: List[_Entry] = [] + class_ids = self._find_class_ids(root) + + for class_index, class_id in enumerate(class_ids): + path = os.path.join(root, "blocks", f"{class_id}.log") + class_entries = [] + + try: + with open(path) as f: + for line in f: + line = line.rstrip() + block, filename = line.split(":") + block_offset = int(block[6:]) + filename = filename[1:] + + maybe_filename = None + if filename != "** Block of NULs **": + maybe_filename = filename + _, ext = os.path.splitext(filename) + # assert ext == ".JPEG" + + class_entry = _ClassEntry(block_offset, maybe_filename) + class_entries.append(class_entry) + except OSError as e: + raise RuntimeError(f'can not read blocks file "{path}"') from e + + assert class_entries[-1].maybe_filename is None + + for class_entry1, class_entry2 in zip(class_entries, class_entries[1:]): + assert class_entry1.block_offset <= class_entry2.block_offset + start_offset = 512 * class_entry1.block_offset + end_offset = 512 * class_entry2.block_offset + assert class_entry1.maybe_filename is not None + filename = class_entry1.maybe_filename + entry = _Entry(class_index, start_offset, end_offset, filename) + # Skip invalid image files (PIL throws UnidentifiedImageError) + if filename == "n06470073_47249.JPEG": + continue + entries.append(entry) + + return entries, class_ids + + def _load_extra(self, extra_path: str) -> np.ndarray: + extra_root = self._extra_root + extra_full_path = os.path.join(extra_root, extra_path) + return np.load(extra_full_path, mmap_mode="r") + + def _save_extra(self, extra_array: np.ndarray, extra_path: str) -> None: + extra_root = self._extra_root + extra_full_path = os.path.join(extra_root, extra_path) + os.makedirs(extra_root, exist_ok=True) + np.save(extra_full_path, extra_array) + + @property + def _tarballs_root(self) -> str: + return self.root + + def find_class_id(self, class_index: int) -> str: + return str(self._class_ids[class_index]) + + def get_image_data(self, index: int) -> bytes: + entry = self._entries[index] + class_id = entry["class_id"] + class_mmap = self._mmap_tarball(class_id) + + start_offset, end_offset = entry["start_offset"], entry["end_offset"] + try: + mapped_data = class_mmap[start_offset:end_offset] + data = mapped_data[512:] # Skip entry header block + + if len(data) >= 2 and tuple(data[:2]) == (0x1F, 0x8B): + assert index in self._gzipped_indices, f"unexpected gzip header for sample {index}" + with GzipFile(fileobj=BytesIO(data)) as g: + data = g.read() + except Exception as e: + raise RuntimeError(f"can not retrieve image data for sample {index} " f'from "{class_id}" tarball') from e + + return data + + def get_target(self, index: int) -> Any: + return int(self._entries[index]["class_index"]) + + def get_targets(self) -> np.ndarray: + return self._entries["class_index"] + + def get_class_id(self, index: int) -> str: + return str(self._entries[index]["class_id"]) + + def get_class_ids(self) -> np.ndarray: + return self._entries["class_id"] + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + return super().__getitem__(index) + + def __len__(self) -> int: + return len(self._entries) + + def _dump_entries(self, *args, **kwargs) -> None: + entries, class_ids = self._load_entries_class_ids(*args, **kwargs) + + max_class_id_length, max_filename_length, max_class_index = -1, -1, -1 + for entry in entries: + class_id = class_ids[entry.class_index] + max_class_index = max(entry.class_index, max_class_index) + max_class_id_length = max(len(class_id), max_class_id_length) + max_filename_length = max(len(entry.filename), max_filename_length) + + dtype = np.dtype( + [ + ("class_index", " None: + entries_path = self._get_entries_path(*args, **kwargs) + entries_array = self._load_extra(entries_path) + + max_class_id_length, max_class_index = -1, -1 + for entry in entries_array: + class_index, class_id = entry["class_index"], entry["class_id"] + max_class_index = max(int(class_index), max_class_index) + max_class_id_length = max(len(str(class_id)), max_class_id_length) + + class_ids_array = np.empty(max_class_index + 1, dtype=f"U{max_class_id_length}") + for entry in entries_array: + class_index, class_id = entry["class_index"], entry["class_id"] + class_ids_array[class_index] = class_id + class_ids_path = self._get_class_ids_path(*args, **kwargs) + self._save_extra(class_ids_array, class_ids_path) + + def _dump_extra(self, *args, **kwargs) -> None: + self._dump_entries(*args, *kwargs) + self._dump_class_ids(*args, *kwargs) + + def dump_extra(self, root: Optional[str] = None) -> None: + return self._dump_extra(root) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/loaders.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/loaders.py new file mode 100644 index 0000000000000000000000000000000000000000..6acc3834348cdfad48c55b6498519860988d292b --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/loaders.py @@ -0,0 +1,232 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +from enum import Enum +from typing import Any, Callable, List, Optional, TypeVar + +import torch +from torch.utils.data import Sampler + +from .datasets import ImageNet, ImageNet22k, HPAone, HPAFoV, CHAMMI_CP, CHAMMI_HPA, CHAMMI_WTC +from .samplers import EpochSampler, InfiniteSampler, ShardedInfiniteSampler + + +logger = logging.getLogger("dinov2") + + +class SamplerType(Enum): + DISTRIBUTED = 0 + EPOCH = 1 + INFINITE = 2 + SHARDED_INFINITE = 3 + SHARDED_INFINITE_NEW = 4 + + +def _make_bool_str(b: bool) -> str: + return "yes" if b else "no" + + +def _make_sample_transform(image_transform: Optional[Callable] = None, target_transform: Optional[Callable] = None): + def transform(sample): + image, target = sample + if image_transform is not None: + image = image_transform(image) + if target_transform is not None: + target = target_transform(target) + return image, target + + return transform + + +def _parse_dataset_str(dataset_str: str): + tokens = dataset_str.split(":") + + name = tokens[0] + kwargs = {} + + for token in tokens[1:]: + key, value = token.split("=") + assert key in ("root", "extra", "split", "mode", "wildcard") + kwargs[key] = value + + if name == "ImageNet": + class_ = ImageNet + if "split" in kwargs: + kwargs["split"] = ImageNet.Split[kwargs["split"]] + elif name == "ImageNet22k": + class_ = ImageNet22k + elif name == "HPAone": + class_ = HPAone + elif name == "HPAFoV": + class_ = HPAFoV + elif name == "CHAMMI_CP": + class_ = CHAMMI_CP + elif name == "CHAMMI_WTC": + class_ = CHAMMI_WTC + elif name == "CHAMMI_HPA": + class_ = CHAMMI_HPA + else: + raise ValueError(f'Unsupported dataset "{name}"') + + return class_, kwargs + + +def make_dataset( + *, + dataset_str: str, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, +): + """ + Creates a dataset with the specified parameters. + + Args: + dataset_str: A dataset string description (e.g. ImageNet:split=TRAIN). + transform: A transform to apply to images. + target_transform: A transform to apply to targets. + + Returns: + The created dataset. + """ + logger.info(f'using dataset: "{dataset_str}"') + + class_, kwargs = _parse_dataset_str(dataset_str) + dataset = class_(transform=transform, target_transform=target_transform, **kwargs) + + logger.info(f"# of dataset samples: {len(dataset):,d}") + + # Aggregated datasets do not expose (yet) these attributes, so add them. + if not hasattr(dataset, "transform"): + setattr(dataset, "transform", transform) + if not hasattr(dataset, "target_transform"): + setattr(dataset, "target_transform", target_transform) + + return dataset + + +def _make_sampler( + *, + dataset, + type: Optional[SamplerType] = None, + shuffle: bool = False, + seed: int = 0, + size: int = -1, + advance: int = 0, +) -> Optional[Sampler]: + sample_count = len(dataset) + + if type == SamplerType.INFINITE: + logger.info("sampler: infinite") + if size > 0: + raise ValueError("sampler size > 0 is invalid") + return InfiniteSampler( + sample_count=sample_count, + shuffle=shuffle, + seed=seed, + advance=advance, + ) + elif type in (SamplerType.SHARDED_INFINITE, SamplerType.SHARDED_INFINITE_NEW): + logger.info("sampler: sharded infinite") + if size > 0: + raise ValueError("sampler size > 0 is invalid") + # TODO: Remove support for old shuffling + use_new_shuffle_tensor_slice = type == SamplerType.SHARDED_INFINITE_NEW + return ShardedInfiniteSampler( + sample_count=sample_count, + shuffle=shuffle, + seed=seed, + advance=advance, + use_new_shuffle_tensor_slice=use_new_shuffle_tensor_slice, + ) + elif type == SamplerType.EPOCH: + logger.info("sampler: epoch") + if advance > 0: + raise NotImplementedError("sampler advance > 0 is not supported") + size = size if size > 0 else sample_count + logger.info(f"# of samples / epoch: {size:,d}") + return EpochSampler( + size=size, + sample_count=sample_count, + shuffle=shuffle, + seed=seed, + ) + elif type == SamplerType.DISTRIBUTED: + logger.info("sampler: distributed") + if size > 0: + raise ValueError("sampler size > 0 is invalid") + if advance > 0: + raise ValueError("sampler advance > 0 is invalid") + return torch.utils.data.DistributedSampler( + dataset=dataset, + shuffle=shuffle, + seed=seed, + drop_last=False, + ) + + logger.info("sampler: none") + return None + + +T = TypeVar("T") + + +def make_data_loader( + *, + dataset, + batch_size: int, + num_workers: int, + shuffle: bool = True, + seed: int = 0, + sampler_type: Optional[SamplerType] = SamplerType.INFINITE, + sampler_size: int = -1, + sampler_advance: int = 0, + drop_last: bool = True, + persistent_workers: bool = False, + collate_fn: Optional[Callable[[List[T]], Any]] = None, +): + """ + Creates a data loader with the specified parameters. + + Args: + dataset: A dataset (third party, LaViDa or WebDataset). + batch_size: The size of batches to generate. + num_workers: The number of workers to use. + shuffle: Whether to shuffle samples. + seed: The random seed to use. + sampler_type: Which sampler to use: EPOCH, INFINITE, SHARDED_INFINITE, SHARDED_INFINITE_NEW, DISTRIBUTED or None. + sampler_size: The number of images per epoch (when applicable) or -1 for the entire dataset. + sampler_advance: How many samples to skip (when applicable). + drop_last: Whether the last non-full batch of data should be dropped. + persistent_workers: maintain the workers Dataset instances alive after a dataset has been consumed once. + collate_fn: Function that performs batch collation + """ + + sampler = _make_sampler( + dataset=dataset, + type=sampler_type, + shuffle=shuffle, + seed=seed, + size=sampler_size, + advance=sampler_advance, + ) + + logger.info("using PyTorch data loader") + data_loader = torch.utils.data.DataLoader( + dataset, + sampler=sampler, + batch_size=batch_size, + num_workers=num_workers, + pin_memory=True, + drop_last=drop_last, + persistent_workers=persistent_workers, + collate_fn=collate_fn, + ) + + try: + logger.info(f"# of batches: {len(data_loader):,d}") + except TypeError: # data loader has no length + logger.info("infinite data loader") + return data_loader diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/masking.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/masking.py new file mode 100644 index 0000000000000000000000000000000000000000..0f7e58374013599f420175453b917295d1c62ec5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/masking.py @@ -0,0 +1,86 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import random +import math +import numpy as np + + +class MaskingGenerator: + def __init__( + self, + input_size, + num_masking_patches=None, + min_num_patches=4, + max_num_patches=None, + min_aspect=0.3, + max_aspect=None, + ): + if not isinstance(input_size, tuple): + input_size = (input_size,) * 2 + self.height, self.width = input_size + + self.num_patches = self.height * self.width + self.num_masking_patches = num_masking_patches + + self.min_num_patches = min_num_patches + self.max_num_patches = num_masking_patches if max_num_patches is None else max_num_patches + + max_aspect = max_aspect or 1 / min_aspect + self.log_aspect_ratio = (math.log(min_aspect), math.log(max_aspect)) + + def __repr__(self): + repr_str = "Generator(%d, %d -> [%d ~ %d], max = %d, %.3f ~ %.3f)" % ( + self.height, + self.width, + self.min_num_patches, + self.max_num_patches, + self.num_masking_patches, + self.log_aspect_ratio[0], + self.log_aspect_ratio[1], + ) + return repr_str + + def get_shape(self): + return self.height, self.width + + def _mask(self, mask, max_mask_patches): + delta = 0 + for _ in range(10): + target_area = random.uniform(self.min_num_patches, max_mask_patches) + aspect_ratio = math.exp(random.uniform(*self.log_aspect_ratio)) + h = int(round(math.sqrt(target_area * aspect_ratio))) + w = int(round(math.sqrt(target_area / aspect_ratio))) + if w < self.width and h < self.height: + top = random.randint(0, self.height - h) + left = random.randint(0, self.width - w) + + num_masked = mask[top : top + h, left : left + w].sum() + # Overlap + if 0 < h * w - num_masked <= max_mask_patches: + for i in range(top, top + h): + for j in range(left, left + w): + if mask[i, j] == 0: + mask[i, j] = 1 + delta += 1 + + if delta > 0: + break + return delta + + def __call__(self, num_masking_patches=0): + mask = np.zeros(shape=self.get_shape(), dtype=bool) + mask_count = 0 + while mask_count < num_masking_patches: + max_mask_patches = num_masking_patches - mask_count + max_mask_patches = min(max_mask_patches, self.max_num_patches) + + delta = self._mask(mask, max_mask_patches) + if delta == 0: + break + else: + mask_count += delta + + return mask diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/samplers.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/samplers.py new file mode 100644 index 0000000000000000000000000000000000000000..c4167ebb9b522c8e49b1351c1ee87e628c852a68 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/samplers.py @@ -0,0 +1,229 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import itertools +from typing import Any, Optional +import warnings + +import numpy as np +import torch +from torch.utils.data.sampler import Sampler + +import dinov2.distributed as distributed + + +class EpochSampler(Sampler): + def __init__( + self, + *, + size: int, + sample_count: int, + shuffle: bool = False, + seed: int = 0, + start: Optional[int] = None, + step: Optional[int] = None, + ): + self._size = size + self._sample_count = sample_count + self._shuffle = shuffle + self._seed = seed + self._start = distributed.get_global_rank() if start is None else start + self._step = distributed.get_global_size() if step is None else step + self._epoch = 0 + + def __iter__(self): + count = (self._size + self._sample_count - 1) // self._sample_count + tiled_indices = np.tile(np.arange(self._sample_count), count) + if self._shuffle: + seed = self._seed * self._epoch if self._seed != 0 else self._epoch + rng = np.random.default_rng(seed) + iterable = rng.choice(tiled_indices, self._size, replace=False) + else: + iterable = tiled_indices[: self._size] + + yield from itertools.islice(iterable, self._start, None, self._step) + + def __len__(self): + return (self._size - self._start + self._step - 1) // self._step + + def set_epoch(self, epoch): + self._epoch = epoch + + +def _get_numpy_dtype(size: int) -> Any: + return np.int32 if size <= 2**31 else np.int64 + + +def _get_torch_dtype(size: int) -> Any: + return torch.int32 if size <= 2**31 else torch.int64 + + +def _generate_randperm_indices(*, size: int, generator: torch.Generator): + """Generate the indices of a random permutation.""" + dtype = _get_torch_dtype(size) + # This is actually matching PyTorch's CPU implementation, see: https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/TensorFactories.cpp#L900-L921 + perm = torch.arange(size, dtype=dtype) + for i in range(size): + j = torch.randint(i, size, size=(1,), generator=generator).item() + + # Always swap even if no-op + value = perm[j].item() + perm[j] = perm[i].item() + perm[i] = value + yield value + + +class InfiniteSampler(Sampler): + def __init__( + self, + *, + sample_count: int, + shuffle: bool = False, + seed: int = 0, + start: Optional[int] = None, + step: Optional[int] = None, + advance: int = 0, + ): + self._sample_count = sample_count + self._seed = seed + self._shuffle = shuffle + self._start = distributed.get_global_rank() if start is None else start + self._step = distributed.get_global_size() if step is None else step + self._advance = advance + + def __iter__(self): + if self._shuffle: + iterator = self._shuffled_iterator() + else: + iterator = self._iterator() + + yield from itertools.islice(iterator, self._advance, None) + + def _iterator(self): + assert not self._shuffle + + while True: + iterable = range(self._sample_count) + yield from itertools.islice(iterable, self._start, None, self._step) + + def _shuffled_iterator(self): + assert self._shuffle + + # Instantiate a generator here (rather than in the ctor) to keep the class + # picklable (requirement of mp.spawn) + generator = torch.Generator().manual_seed(self._seed) + + while True: + iterable = _generate_randperm_indices(size=self._sample_count, generator=generator) + yield from itertools.islice(iterable, self._start, None, self._step) + + +# The following function is somewhat equivalent to _new_shuffle_tensor_slice below, +# but avoids a full in-place random permutation generation. +def _shuffle_tensor_slice( + *, tensor: torch.Tensor, start: int = 0, step: int = 1, generator: torch.Generator +) -> np.ndarray: + stop = len(tensor) + count = stop // step + drop_count = stop - step * count + if drop_count: + warnings.warn(f"# of dropped samples: {drop_count}") + + dtype = _get_numpy_dtype(stop) + result = np.empty(count, dtype=dtype) + + for i in range(count): + j = torch.randint(0, i + 1, size=(1,), generator=generator).item() if i > 0 else 0 + + result[i] = result[j] + result[j] = tensor[start + i * step].item() + + return result + + +def _new_shuffle_tensor_slice( + *, tensor: torch.Tensor, start: int = 0, step: int = 1, generator: torch.Generator +) -> np.ndarray: + stop = len(tensor) + count = stop // step + dtype = torch.int64 # Needed for using randperm result as indices + count = stop // step + drop_count = stop - step * count + if drop_count: + warnings.warn(f"# of dropped samples: {drop_count}") + indices = torch.randperm(count, dtype=dtype, generator=generator) + return tensor[start::step][indices].numpy() + + +def _make_seed(seed: int, start: int, iter_count: int) -> int: + # NOTE: Tried a few variants (including iter_count << 32), this one worked best. + return seed + start + (iter_count << 24) + + +class ShardedInfiniteSampler(Sampler): + def __init__( + self, + *, + sample_count: int, + shuffle: bool = False, + seed: int = 0, + start: Optional[int] = None, + step: Optional[int] = None, + advance: int = 0, + use_new_shuffle_tensor_slice: bool = False, + ): + self._sample_count = sample_count + self._seed = seed + self._shuffle = shuffle + self._start = distributed.get_global_rank() if start is None else start + self._step = distributed.get_global_size() if step is None else step + self._advance = advance + self._iter_count = 0 + self._shuffle_tensor_slice_fn = ( + _new_shuffle_tensor_slice if use_new_shuffle_tensor_slice else _shuffle_tensor_slice + ) + + def __iter__(self): + iter_count = self._advance // self._sample_count + if iter_count > 0: + self._advance -= iter_count * self._sample_count + self._iter_count += iter_count + + if self._shuffle: + iterator = self._shuffled_iterator() + else: + iterator = self._iterator() + + yield from itertools.islice(iterator, self._advance, None) + + def _iterator(self): + assert not self._shuffle + + while True: + iterable = range(self._sample_count) + yield from itertools.islice(iterable, self._start, None, self._step) + + def _shuffled_iterator(self): + assert self._shuffle + + # Instantiate a generator here (rather than in the ctor) to be keep the class + # picklable (requirement of mp.spawn) + generator = torch.Generator() + + # Always shuffle everything first + generator.manual_seed(self._seed) + dtype = _get_torch_dtype(self._sample_count) + perm = torch.randperm(self._sample_count, dtype=dtype, generator=generator) + + while True: + # Re-seed on each iteration to allow skipping whole permutations + seed = _make_seed(self._seed, self._start, self._iter_count) + generator.manual_seed(seed) + + iterable = self._shuffle_tensor_slice_fn( + tensor=perm, start=self._start, step=self._step, generator=generator + ) + yield from iterable + self._iter_count += 1 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/data/transforms.py b/torch_cache/facebookresearch_dinov2_main/dinov2/data/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..c79036f1b60542d380c55c27e9944ccf29b23fd7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/data/transforms.py @@ -0,0 +1,91 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Sequence + +import torch +from torchvision import transforms + + +class GaussianBlur(transforms.RandomApply): + """ + Apply Gaussian Blur to the PIL image. + """ + + def __init__(self, *, p: float = 0.5, radius_min: float = 0.1, radius_max: float = 2.0): + # NOTE: torchvision is applying 1 - probability to return the original image + keep_p = 1 - p + transform = transforms.GaussianBlur(kernel_size=9, sigma=(radius_min, radius_max)) + super().__init__(transforms=[transform], p=keep_p) + + +class MaybeToTensor(transforms.ToTensor): + """ + Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor, or keep as is if already a tensor. + """ + + def __call__(self, pic): + """ + Args: + pic (PIL Image, numpy.ndarray or torch.tensor): Image to be converted to tensor. + Returns: + Tensor: Converted image. + """ + if isinstance(pic, torch.Tensor): + return pic + return super().__call__(pic) + + +# Use timm's names +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + +def make_normalize_transform( + mean: Sequence[float] = IMAGENET_DEFAULT_MEAN, + std: Sequence[float] = IMAGENET_DEFAULT_STD, +) -> transforms.Normalize: + return transforms.Normalize(mean=mean, std=std) + + +# This roughly matches torchvision's preset for classification training: +# https://github.com/pytorch/vision/blob/main/references/classification/presets.py#L6-L44 +def make_classification_train_transform( + *, + crop_size: int = 224, + interpolation=transforms.InterpolationMode.BICUBIC, + hflip_prob: float = 0.5, + mean: Sequence[float] = IMAGENET_DEFAULT_MEAN, + std: Sequence[float] = IMAGENET_DEFAULT_STD, +): + transforms_list = [transforms.RandomResizedCrop(crop_size, interpolation=interpolation)] + if hflip_prob > 0.0: + transforms_list.append(transforms.RandomHorizontalFlip(hflip_prob)) + transforms_list.extend( + [ + MaybeToTensor(), + make_normalize_transform(mean=mean, std=std), + ] + ) + return transforms.Compose(transforms_list) + + +# This matches (roughly) torchvision's preset for classification evaluation: +# https://github.com/pytorch/vision/blob/main/references/classification/presets.py#L47-L69 +def make_classification_eval_transform( + *, + resize_size: int = 256, + interpolation=transforms.InterpolationMode.BICUBIC, + crop_size: int = 224, + mean: Sequence[float] = IMAGENET_DEFAULT_MEAN, + std: Sequence[float] = IMAGENET_DEFAULT_STD, +) -> transforms.Compose: + transforms_list = [ + transforms.Resize(resize_size, interpolation=interpolation), + transforms.CenterCrop(crop_size), + MaybeToTensor(), + make_normalize_transform(mean=mean, std=std), + ] + return transforms.Compose(transforms_list) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/distributed/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/distributed/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..804355b246f9d210082ea86895d3b415fd997d4d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/distributed/__init__.py @@ -0,0 +1,270 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import os +import random +import re +import socket +from typing import Dict, List + +import torch +import torch.distributed as dist + +_LOCAL_RANK = -1 +_LOCAL_WORLD_SIZE = -1 + + +def is_enabled() -> bool: + """ + Returns: + True if distributed training is enabled + """ + return dist.is_available() and dist.is_initialized() + + +def get_global_size() -> int: + """ + Returns: + The number of processes in the process group + """ + return dist.get_world_size() if is_enabled() else 1 + + +def get_global_rank() -> int: + """ + Returns: + The rank of the current process within the global process group. + """ + return dist.get_rank() if is_enabled() else 0 + + +def get_local_rank() -> int: + """ + Returns: + The rank of the current process within the local (per-machine) process group. + """ + if not is_enabled(): + return 0 + assert 0 <= _LOCAL_RANK < _LOCAL_WORLD_SIZE + return _LOCAL_RANK + + +def get_local_size() -> int: + """ + Returns: + The size of the per-machine process group, + i.e. the number of processes per machine. + """ + if not is_enabled(): + return 1 + assert 0 <= _LOCAL_RANK < _LOCAL_WORLD_SIZE + return _LOCAL_WORLD_SIZE + + +def is_main_process() -> bool: + """ + Returns: + True if the current process is the main one. + """ + return get_global_rank() == 0 + + +def _restrict_print_to_main_process() -> None: + """ + This function disables printing when not in the main process + """ + import builtins as __builtin__ + + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop("force", False) + if is_main_process() or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print + + +def _get_master_port(seed: int = 0) -> int: + MIN_MASTER_PORT, MAX_MASTER_PORT = (20_000, 60_000) + + master_port_str = os.environ.get("MASTER_PORT") + if master_port_str is None: + rng = random.Random(seed) + return rng.randint(MIN_MASTER_PORT, MAX_MASTER_PORT) + + return int(master_port_str) + + +def _get_available_port() -> int: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + # A "" host address means INADDR_ANY i.e. binding to all interfaces. + # Note this is not compatible with IPv6. + s.bind(("", 0)) + port = s.getsockname()[1] + return port + + +_TORCH_DISTRIBUTED_ENV_VARS = ( + "MASTER_ADDR", + "MASTER_PORT", + "RANK", + "WORLD_SIZE", + "LOCAL_RANK", + "LOCAL_WORLD_SIZE", +) + + +def _collect_env_vars() -> Dict[str, str]: + return {env_var: os.environ[env_var] for env_var in _TORCH_DISTRIBUTED_ENV_VARS if env_var in os.environ} + + +def _is_slurm_job_process() -> bool: + return "SLURM_JOB_ID" in os.environ + + +def _parse_slurm_node_list(s: str) -> List[str]: + nodes = [] + # Extract "hostname", "hostname[1-2,3,4-5]," substrings + p = re.compile(r"(([^\[]+)(?:\[([^\]]+)\])?),?") + for m in p.finditer(s): + prefix, suffixes = s[m.start(2) : m.end(2)], s[m.start(3) : m.end(3)] + for suffix in suffixes.split(","): + span = suffix.split("-") + if len(span) == 1: + nodes.append(prefix + suffix) + else: + width = len(span[0]) + start, end = int(span[0]), int(span[1]) + 1 + nodes.extend([prefix + f"{i:0{width}}" for i in range(start, end)]) + return nodes + + +def _check_env_variable(key: str, new_value: str): + # Only check for difference with preset environment variables + if key in os.environ and os.environ[key] != new_value: + raise RuntimeError(f"Cannot export environment variables as {key} is already set") + + +class _TorchDistributedEnvironment: + def __init__(self): + self.master_addr = "127.0.0.1" + self.master_port = 0 + self.rank = -1 + self.world_size = -1 + self.local_rank = -1 + self.local_world_size = -1 + + if _is_slurm_job_process(): + return self._set_from_slurm_env() + + env_vars = _collect_env_vars() + if not env_vars: + # Environment is not set + pass + elif len(env_vars) == len(_TORCH_DISTRIBUTED_ENV_VARS): + # Environment is fully set + return self._set_from_preset_env() + else: + # Environment is partially set + collected_env_vars = ", ".join(env_vars.keys()) + raise RuntimeError(f"Partially set environment: {collected_env_vars}") + + if torch.cuda.device_count() > 0: + return self._set_from_local() + + raise RuntimeError("Can't initialize PyTorch distributed environment") + + # Slurm job created with sbatch, submitit, etc... + def _set_from_slurm_env(self): + # logger.info("Initialization from Slurm environment") + job_id = int(os.environ["SLURM_JOB_ID"]) + node_count = int(os.environ["SLURM_JOB_NUM_NODES"]) + nodes = _parse_slurm_node_list(os.environ["SLURM_JOB_NODELIST"]) + assert len(nodes) == node_count + + self.master_addr = nodes[0] + self.master_port = _get_master_port(seed=job_id) + self.rank = int(os.environ["SLURM_PROCID"]) + self.world_size = int(os.environ["SLURM_NTASKS"]) + assert self.rank < self.world_size + self.local_rank = int(os.environ["SLURM_LOCALID"]) + self.local_world_size = self.world_size // node_count + assert self.local_rank < self.local_world_size + + # Single node job with preset environment (i.e. torchrun) + def _set_from_preset_env(self): + # logger.info("Initialization from preset environment") + self.master_addr = os.environ["MASTER_ADDR"] + self.master_port = os.environ["MASTER_PORT"] + self.rank = int(os.environ["RANK"]) + self.world_size = int(os.environ["WORLD_SIZE"]) + assert self.rank < self.world_size + self.local_rank = int(os.environ["LOCAL_RANK"]) + self.local_world_size = int(os.environ["LOCAL_WORLD_SIZE"]) + assert self.local_rank < self.local_world_size + + # Single node and GPU job (i.e. local script run) + def _set_from_local(self): + # logger.info("Initialization from local") + self.master_addr = "127.0.0.1" + self.master_port = _get_available_port() + self.rank = 0 + self.world_size = 1 + self.local_rank = 0 + self.local_world_size = 1 + + def export(self, *, overwrite: bool) -> "_TorchDistributedEnvironment": + # See the "Environment variable initialization" section from + # https://pytorch.org/docs/stable/distributed.html for the complete list of + # environment variables required for the env:// initialization method. + env_vars = { + "MASTER_ADDR": self.master_addr, + "MASTER_PORT": str(self.master_port), + "RANK": str(self.rank), + "WORLD_SIZE": str(self.world_size), + "LOCAL_RANK": str(self.local_rank), + "LOCAL_WORLD_SIZE": str(self.local_world_size), + } + if not overwrite: + for k, v in env_vars.items(): + _check_env_variable(k, v) + + os.environ.update(env_vars) + return self + + +def enable(*, set_cuda_current_device: bool = True, overwrite: bool = False, allow_nccl_timeout: bool = False): + """Enable distributed mode + + Args: + set_cuda_current_device: If True, call torch.cuda.set_device() to set the + current PyTorch CUDA device to the one matching the local rank. + overwrite: If True, overwrites already set variables. Else fails. + """ + + global _LOCAL_RANK, _LOCAL_WORLD_SIZE + if _LOCAL_RANK >= 0 or _LOCAL_WORLD_SIZE >= 0: + raise RuntimeError("Distributed mode has already been enabled") + torch_env = _TorchDistributedEnvironment() + torch_env.export(overwrite=overwrite) + + if set_cuda_current_device: + torch.cuda.set_device(torch_env.local_rank) + + if allow_nccl_timeout: + # This allows to use torch distributed timeout in a NCCL backend + key, value = "NCCL_ASYNC_ERROR_HANDLING", "1" + if not overwrite: + _check_env_variable(key, value) + os.environ[key] = value + + dist.init_process_group(backend="nccl") + dist.barrier() + + # Finalize setup + _LOCAL_RANK = torch_env.local_rank + _LOCAL_WORLD_SIZE = torch_env.local_world_size + _restrict_print_to_main_process() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/knn.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/knn.py new file mode 100644 index 0000000000000000000000000000000000000000..d5893acc6c36559ee2ca520d09ecfac4833d414f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/knn.py @@ -0,0 +1,479 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import argparse +from functools import partial +import json +import logging +import os +import sys +from typing import List, Optional, Any +import numpy as np + +import torch +import torch.backends.cudnn as cudnn +import pandas as pd +from sklearn.metrics import f1_score + +import dinov2.distributed as distributed +from dinov2.data import make_dataset, DatasetWithEnumeratedTargets, SamplerType, make_data_loader +from dinov2.data.cell_dino.transforms import NormalizationType, make_classification_eval_cell_transform +from dinov2.eval.metrics import build_metric, MetricType +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model + +from dinov2.data import ResultsAccumulator +from dinov2.eval.utils import ModelWithNormalize +from dinov2.eval.cell_dino.utils import ( + BagOfChannelsModelWithNormalize, + extract_features_cell_dino, + average_metrics, + create_train_dataset_dict, + get_num_classes, + extract_features_for_dataset_dict, + evaluate_with_accumulate, + KnnModule, +) +from dinov2.eval.knn import DictKeysModule +from torch.utils.data import Subset as SubsetEx +from torch.utils.data import ConcatDataset as ConcatDatasetEx + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--nb_knn", + nargs="+", + type=int, + help="Number of NN to use. 20 is usually working the best.", + ) + parser.add_argument( + "--temperature", + type=float, + help="Temperature used in the voting coefficient", + ) + parser.add_argument( + "--gather-on-cpu", + action="store_true", + help="Whether to gather the train features on cpu, slower" + "but useful to avoid OOM for large datasets (e.g. ImageNet22k).", + ) + parser.add_argument( + "--batch-size", + type=int, + help="Batch size.", + ) + parser.add_argument( + "--n-per-class-list", + nargs="+", + type=int, + help="Number to take per class", + ) + parser.add_argument( + "--n-tries", + type=int, + help="Number of tries", + ) + parser.add_argument( + "--leave-one-out-dataset", + type=str, + help="Path with indexes to use the leave one out strategy for CHAMMI_CP task 3 and CHAMMI_HPA task 4", + ) + parser.add_argument( + "--bag-of-channels", + action="store_true", + help='Whether to use the "bag of channels" channel adaptive strategy', + ) + parser.add_argument( + "--crop-size", + type=int, + help="crop size for train and eval", + ) + parser.add_argument( + "--resize-size", + type=int, + help="resize size for image just before crop. 0: no resize", + ) + parser.add_argument( + "--metric-type", + type=MetricType, + choices=list(MetricType), + help="Validation metric", + ) + parser.add_argument( + "--avgpool", + action="store_true", + help="Whether to use average pooling of path tokens in addition to CLS tokens", + ) + + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + nb_knn=[1], + temperature=0.07, + batch_size=256, + resize_size=0, + ) + return parser + + +class SequentialWithKwargs(torch.nn.Sequential): + def __init__(self, *args): + super().__init__(*args) + + def forward(self, input, **kwargs): + + input = self[0](input, **kwargs) + for module in self[1:]: + input = module(input) + return input + + +def create_train_test_dataset_dict_leave_one_out( + train_dataset, + test_dataset, +) -> dict[int, dict[int, Any]]: + """ + This function implements a train dataset dictionary with the leave-one-out (LOO) method. + Specifically, given a train dataset and test dataset, it creates a train dataset for each + test dataset point, which is a combination of train+test dataset except for this specific data point. + At the end, it contains len(test_dataset) key and value pairs. + + Format is {"nth-test-sample": dataset_without_test_sample} + """ + train_dataset_dict: dict[int, Any] = {} + test_size = len(test_dataset) + + for test_sample_index in range(test_size): + test_indices_bool = torch.ones(test_size, dtype=bool) + test_indices_bool[test_sample_index] = False + train_dataset_dict[test_sample_index] = ConcatDatasetEx( + [train_dataset, SubsetEx(test_dataset, test_indices_bool.nonzero().flatten())] + ) + + return train_dataset_dict + + +def eval_knn_with_leave_one_out( + model, leave_one_out_dataset, train_dataset, test_dataset, metric_type, nb_knn, temperature, batch_size, num_workers +): + num_classes = get_num_classes(test_dataset) + train_dataset_dict = create_train_dataset_dict(train_dataset) + test_dataset_dict = create_train_dataset_dict(test_dataset) + + logger.info("Extracting features for train set...") + train_data_dict = extract_features_for_dataset_dict( + model, train_dataset_dict, batch_size, num_workers, gather_on_cpu=True + ) + test_data_dict = extract_features_for_dataset_dict( + model, test_dataset_dict, batch_size, num_workers, gather_on_cpu=True + ) + + train_features = train_data_dict[0]["train_features"] + train_labels = train_data_dict[0]["train_labels"] + test_features = test_data_dict[0]["train_features"] + test_labels = test_data_dict[0]["train_labels"] + + metric_collection = build_metric(metric_type, num_classes=3) + + device = torch.cuda.current_device() + partial_knn_module = partial(KnnModule, T=temperature, device=device, num_classes=num_classes) + + logger.info("Reading the leave-one-out label metadata.") + + leave_one_out_indices = {} + metadata = pd.read_csv(leave_one_out_dataset) + if "HPA" in leave_one_out_dataset: + metadata = metadata[metadata["Task_three"]].reset_index() + leave_one_out_label_type = "cell_type" + else: + metadata = metadata[metadata["Task_four"]].reset_index() + leave_one_out_label_type = "Plate" + leave_one_out_labels = metadata[leave_one_out_label_type].unique() + + for leave_one_out_label in leave_one_out_labels: + leave_one_out_indices[leave_one_out_label] = torch.tensor( + metadata[metadata[leave_one_out_label_type] == leave_one_out_label].index.values + ) + + # ============ evaluation ... ============ + logger.info("Start the k-NN classification.") + + eval_metrics_dict = {} + postprocessors, metrics = {k: DictKeysModule([k]) for k in nb_knn}, { + k: metric_collection.clone().to(device) for k in nb_knn + } + for metric_key in metrics.keys(): + metrics[metric_key] = metrics[metric_key].to(device) + + accumulator_class = ResultsAccumulator + accumulators = {k: accumulator_class() for k in postprocessors.keys()} + all_preds = [] + all_target = [] + + for loo_label, loo_indices in leave_one_out_indices.items(): + logger.info(f"Evaluating on test sample {loo_label}") + loo_for_training_indices = torch.ones(test_features.shape[0], dtype=bool) + loo_for_training_indices[loo_indices] = False + train_features_sample = torch.cat([train_features, test_features[loo_for_training_indices]]) + train_labels_sample = torch.cat([train_labels, test_labels[loo_for_training_indices]]) + logger.info(f"Train shape {train_features_sample.shape}, Test shape {test_features[loo_indices].shape}") + logger.info( + f"Train values {train_labels_sample.unique(return_counts=True)}, Test shape {test_labels[loo_indices].unique(return_counts=True)}" + ) + knn_module = partial_knn_module( + train_features=train_features_sample, train_labels=train_labels_sample, nb_knn=nb_knn + ) + + output = knn_module(test_features[loo_indices].to(device)) + all_preds.append(output[1]) + all_target.append(test_labels[loo_indices]) + output[1] = output[1][:, 4:] + transformed_test_labels = test_labels[loo_indices] - 4 + for k, metric in metrics.items(): + metric_inputs = postprocessors[k](output, transformed_test_labels.to(device)) + metric.update(**metric_inputs) + accumulators[k].update( + preds=metric_inputs["preds"], target=metric_inputs["target"], index=loo_indices.to(device) + ) + + all_preds = torch.cat(all_preds).cpu().detach().numpy() + + all_preds = np.argmax(all_preds, axis=1) + all_target = torch.cat(all_target).cpu().detach().numpy() + + f1 = f1_score(all_target, all_preds, average="macro", labels=[4, 5, 6]) + logger.info(f"Real f1 score: {f1}") + eval_metrics = { + k: metric.compute() for k, metric in metrics.items() + } # next erased by the real f1 score computed above + + for k in nb_knn: + if k not in eval_metrics_dict: + eval_metrics_dict[k] = {} + eval_metrics_dict[k] = {metric: f1 * 100.0 for metric, v in eval_metrics[k].items()} + + if len(train_data_dict) > 1: + return {k: average_metrics(eval_metrics_dict[k]) for k in eval_metrics_dict.keys()} + + return {k: eval_metrics_dict[k] for k in eval_metrics_dict.keys()} + + +def eval_knn_with_model( + model, + output_dir, + train_dataset_str, + val_dataset_str, + nb_knn=(10, 20, 100, 200), + temperature=0.07, + autocast_dtype=torch.float, + metric_type=MetricType.MEAN_ACCURACY, + transform=None, + resize_size=256, + crop_size=224, + batch_size=256, + num_workers=5, + leave_one_out_dataset="", + bag_of_channels=False, + avgpool=False, +): + autocast_ctx = partial(torch.cuda.amp.autocast, enabled=True, dtype=autocast_dtype) + if bag_of_channels: + model = BagOfChannelsModelWithNormalize(model, autocast_ctx, avgpool) + else: + model = ModelWithNormalize(model) + if leave_one_out_dataset == "" or leave_one_out_dataset is None: + leave_one_out = False + else: + leave_one_out = True + + cudnn.benchmark = True + transform = make_classification_eval_cell_transform( + normalization_type=NormalizationType.SELF_NORM_CENTER_CROP, resize_size=resize_size, crop_size=crop_size + ) + + train_dataset = make_dataset(dataset_str=train_dataset_str, transform=transform) + results_dict = {} + test_dataset = make_dataset(dataset_str=val_dataset_str, transform=transform) + + with torch.cuda.amp.autocast(dtype=autocast_dtype): + if leave_one_out: + results_dict_knn = eval_knn_with_leave_one_out( + model=model, + leave_one_out_dataset=leave_one_out_dataset, + train_dataset=train_dataset, + test_dataset=test_dataset, + metric_type=metric_type, + nb_knn=nb_knn, + temperature=temperature, + batch_size=batch_size, + num_workers=num_workers, + ) + else: + results_dict_knn = eval_knn( + model=model, + train_dataset=train_dataset, + test_dataset=test_dataset, + metric_type=metric_type, + nb_knn=nb_knn, + temperature=temperature, + batch_size=batch_size, + num_workers=num_workers, + ) + + for knn_ in results_dict_knn.keys(): + top1 = results_dict_knn[knn_]["top-1"] + results_dict[f"{val_dataset_str}_{knn_} Top 1"] = top1 + results_string = f"{val_dataset_str} {knn_} NN classifier result: Top1: {top1:.2f}" + if "top-5" in results_dict_knn[knn_]: + top5 = results_dict_knn[knn_]["top-5"] + results_dict[f"{val_dataset_str}_{knn_} Top 5"] = top5 + results_string += f"Top5: {top5:.2f}" + logger.info(results_string) + + metrics_file_path = os.path.join(output_dir, "results_eval_knn.json") + with open(metrics_file_path, "a") as f: + for k, v in results_dict.items(): + f.write(json.dumps({k: v}) + "\n") + + if distributed.is_enabled(): + torch.distributed.barrier() + return results_dict + + +def eval_knn( + model, + train_dataset, + test_dataset, + metric_type, + nb_knn, + temperature, + batch_size, + num_workers, + few_shot_eval=False, + few_shot_k_or_percent=None, + few_shot_n_tries=1, +): + num_classes = get_num_classes(train_dataset) + train_dataset_dict = create_train_dataset_dict( + train_dataset, + few_shot_eval=few_shot_eval, + few_shot_k_or_percent=few_shot_k_or_percent, + few_shot_n_tries=few_shot_n_tries, + ) + + logger.info("Extracting features for train set...") + + train_data_dict: dict[int, dict[str, torch.Tensor]] = {} + for try_n, dataset in train_dataset_dict.items(): + features, labels = extract_features_cell_dino(model, dataset, batch_size, num_workers, gather_on_cpu=True) + train_data_dict[try_n] = {"train_features": features, "train_labels": labels} + + test_data_loader = make_data_loader( + dataset=DatasetWithEnumeratedTargets( + test_dataset, pad_dataset=True, num_replicas=distributed.get_global_size() + ), + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + persistent_workers=True, + collate_fn=None, + ) + metric_collection = build_metric(metric_type, num_classes=num_classes) + + device = torch.cuda.current_device() + partial_knn_module = partial( + KnnModule, + T=temperature, + device=device, + num_classes=num_classes, + ) + + # ============ evaluation ... ============ + logger.info("Start the k-NN classification.") + eval_metrics_dict = {} + + for try_ in train_data_dict.keys(): + train_features, train_labels = train_data_dict[try_]["train_features"], train_data_dict[try_]["train_labels"] + k_list = sorted(set([el if el < len(train_features) else len(train_features) for el in nb_knn])) + knn_module = partial_knn_module(train_features=train_features, train_labels=train_labels, nb_knn=k_list) + postprocessors, metrics = {k: DictKeysModule([k]) for k in k_list}, { + k: metric_collection.clone() for k in k_list + } + _, eval_metrics, _ = evaluate_with_accumulate( + SequentialWithKwargs(model, knn_module), + test_data_loader, + postprocessors, + metrics, + device, + accumulate_results=False, + ) + for k in k_list: + if k not in eval_metrics_dict: + eval_metrics_dict[k] = {} + eval_metrics_dict[k][try_] = {metric: v.item() * 100.0 for metric, v in eval_metrics[k].items()} + + if len(train_data_dict) > 1: + return {k: average_metrics(eval_metrics_dict[k]) for k in eval_metrics_dict.keys()} + + return {k: eval_metrics_dict[k][0] for k in eval_metrics_dict.keys()} + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + eval_knn_with_model( + model=model, + output_dir=args.output_dir, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + nb_knn=args.nb_knn, + temperature=args.temperature, + autocast_dtype=autocast_dtype, + transform=None, + metric_type=args.metric_type, + batch_size=args.batch_size, + num_workers=5, + leave_one_out_dataset=args.leave_one_out_dataset, + resize_size=args.resize_size, + crop_size=args.crop_size, + avgpool=args.avgpool, + bag_of_channels=args.bag_of_channels, + ) + return 0 + + +if __name__ == "__main__": + description = "k-NN evaluation on models trained with bag of channel strategy or cell dino" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/linear.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/linear.py new file mode 100644 index 0000000000000000000000000000000000000000..b5f52caefd6e89e994c13ed0569021b2e3c0ee75 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/linear.py @@ -0,0 +1,1048 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import argparse +from functools import partial +import json +import logging +import os +import sys +from typing import Any, Callable, Dict, Optional, Tuple, List +from enum import Enum +from dataclasses import dataclass + +from sklearn.metrics import f1_score +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from torch.utils.data import TensorDataset +from torch.nn.parallel import DistributedDataParallel + + +from dinov2.data import SamplerType, make_data_loader, make_dataset, DatasetWithEnumeratedTargets +from dinov2.data.cell_dino.transforms import NormalizationType, make_classification_eval_cell_transform +import dinov2.distributed as distributed +from dinov2.eval.metrics import MetricType, build_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.cell_dino.utils import ( + evaluate_with_accumulate, + LossType, + average_metrics, + create_train_dataset_dict, + get_num_classes, + extract_features_for_dataset_dict, +) +from dinov2.eval.utils import ModelWithIntermediateLayers +from dinov2.logging import MetricLogger +from dinov2.utils.checkpoint import build_periodic_checkpointer, resume_or_load + +logger = logging.getLogger("dinov2") + +""" +List of changes with respect to the standard linear evaluation script: + +bag of channel option : SCALE ADAPTIVE STRATEGY + +Adam optimizer instead of SGD +Scheduler : two options : onecycleLR or CosineAnnealingLR +the transforms/normalization are different, now calling make_classification_eval_cell_transform +add binary cross entropy loss option for protein localization +change the definition of the num_classes using get_num_classes +change of some default parameters (batch_size, epoch_length, epochs, lrs) +defined n_last_blocks option +avgpool option +leave one out strategy for CHAMMI evaluation +grid search for optimal weight decay +""" + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--test-datasets", + dest="test_dataset_strs", + type=str, + nargs="+", + help="Test datasets, none to reuse the validation dataset", + ) + parser.add_argument( + "--epochs", + type=int, + help="Number of training epochs", + ) + parser.add_argument( + "--batch-size", + type=int, + help="Batch Size (per GPU)", + ) + parser.add_argument( + "--num-workers", + type=int, + help="Number de Workers", + ) + parser.add_argument( + "--epoch-length", + type=int, + help="Length of an epoch in number of iterations", + ) + parser.add_argument( + "--save-checkpoint-frequency", + type=int, + help="Number of epochs between two named checkpoint saves.", + ) + parser.add_argument( + "--eval-period-iterations", + type=int, + help="Number of iterations between two evaluations.", + ) + parser.add_argument( + "--learning-rates", + nargs="+", + type=float, + help="Learning rates to grid search.", + ) + parser.add_argument( + "--weight_decays", + nargs="+", + type=float, + help="Weight decays to grid search.", + ) + parser.add_argument( + "--n-last-blocks", + type=int, + help="number of backbone last blocks used for the linear classifier", + ) + parser.add_argument( + "--no-resume", + action="store_true", + help="Whether to not resume from existing checkpoints", + ) + parser.add_argument( + "--val-metric-type", + type=MetricType, + choices=list(MetricType), + help="Validation metric", + ) + parser.add_argument( + "--test-metric-types", + type=MetricType, + choices=list(MetricType), + nargs="+", + help="Evaluation metric", + ) + parser.add_argument( + "--classifier-fpath", + type=str, + help="Path to a file containing pretrained linear classifiers", + ) + parser.add_argument( + "--val-class-mapping-fpath", + type=str, + help="Path to a file containing a mapping to adjust classifier outputs", + ) + parser.add_argument( + "--test-class-mapping-fpaths", + nargs="+", + type=str, + help="Path to a file containing a mapping to adjust classifier outputs", + ) + parser.add_argument( + "--loss-type", + type=LossType, + help="Cross Entropy or Binary Cross Entropy, default cross entropy loss", + ) + parser.add_argument( + "--bag-of-channels", + action="store_true", + help='Whether to use the "bag of channels" channel adaptive strategy', + ) + parser.add_argument( + "--leave-one-out-dataset", + type=str, + help="Path with indexes to use the leave one out strategy for CHAMMI_CP task 3 and CHAMMI_HPA task 4", + ) + parser.add_argument( + "--crop-size", + type=int, + help="crop size for train and eval", + ) + parser.add_argument( + "--resize-size", + type=int, + help="resize size for image just before crop. 0: no resize", + ) + parser.add_argument( + "--avgpool", + action="store_true", + help="Whether to use average pooling of path tokens in addition to CLS tokens", + ) + parser.add_argument( + "--scheduler", + type=SchedulerType, + help="Scheduler type", + ) + + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + test_dataset_strs=None, + epochs=30, + batch_size=64, + num_workers=8, + epoch_length=145, + save_checkpoint_frequency=1250, + eval_period_iterations=1250, + learning_rates=[1e-5, 2e-5, 5e-5, 1e-4, 2e-4, 5e-4, 1e-3, 2e-3, 5e-3, 1e-2, 2e-2, 5e-2, 1e-1, 2e-1, 5e-1, 1.0], + weight_decays=[0.0, 0.0001, 1.0e-05], + val_metric_type=MetricType.MEAN_ACCURACY, + test_metric_types=None, + classifier_fpath=None, + val_class_mapping_fpath=None, + test_class_mapping_fpaths=[None], + loss_type=LossType.CROSS_ENTROPY, + crop_size=384, + resize_size=0, + n_last_blocks=4, + avgpool=False, + scheduler=SchedulerType.COSINE_ANNEALING, + ) + return parser + + +def has_ddp_wrapper(m: nn.Module) -> bool: + return isinstance(m, DistributedDataParallel) + + +def remove_ddp_wrapper(m: nn.Module) -> nn.Module: + return m.module if has_ddp_wrapper(m) else m + + +def create_linear_input(x_tokens_list, use_n_blocks, use_avgpool, bag_of_channels): + intermediate_output = x_tokens_list[-use_n_blocks:] + output = torch.cat([class_token for _, class_token in intermediate_output], dim=-1) + if bag_of_channels: + if use_avgpool: + output = torch.cat( + ( + output, + torch.mean(intermediate_output[-1][0], dim=-2).reshape(intermediate_output[-1][0].shape[0], -1), + # average pooling of patch tokens: average over N, then concatenate channels if single-channel patch model + ), + dim=-1, + ) # concatenate average pooling of patch tokens to concatenated patch tokens + else: + if use_avgpool: + output = torch.cat( + ( + output, + torch.mean(intermediate_output[-1][0], dim=1), # patch tokens + ), + dim=-1, + ) + output = output.reshape(output.shape[0], -1) + return output.float() + + +class LinearClassifier(nn.Module): + """Linear layer to train on top of frozen features""" + + def __init__( + self, out_dim, use_n_blocks, use_avgpool, num_classes=1000, bag_of_channels=False, leave_one_out=False + ): + super().__init__() + self.out_dim = out_dim + self.use_n_blocks = use_n_blocks + self.use_avgpool = use_avgpool + self.num_classes = num_classes + self.bag_of_channels = bag_of_channels + self.leave_one_out = leave_one_out + self.linear = nn.Linear(out_dim, num_classes) + self.linear.weight.data.normal_(mean=0.0, std=0.01) + self.linear.bias.data.zero_() + + def forward(self, x_tokens_list): + if self.leave_one_out: + return self.linear(x_tokens_list) + output = create_linear_input(x_tokens_list, self.use_n_blocks, self.use_avgpool, self.bag_of_channels) + return self.linear(output) + + +class AllClassifiers(nn.Module): + def __init__(self, classifiers_dict): + super().__init__() + self.classifiers_dict = nn.ModuleDict() + self.classifiers_dict.update(classifiers_dict) + + def forward(self, inputs): + return {k: v.forward(inputs) for k, v in self.classifiers_dict.items()} + + def __len__(self): + return len(self.classifiers_dict) + + +class LinearPostprocessor(nn.Module): + def __init__(self, linear_classifier, class_mapping=None): + super().__init__() + self.linear_classifier = linear_classifier + self.register_buffer("class_mapping", None if class_mapping is None else torch.LongTensor(class_mapping)) + + def forward(self, samples, targets): + preds = self.linear_classifier(samples) + return { + "preds": preds[:, self.class_mapping] if self.class_mapping is not None else preds, + "target": targets, + } + + +def scale_lr(learning_rates, batch_size): + return learning_rates * (batch_size * distributed.get_global_size()) / 256.0 + + +def setup_linear_classifiers( + sample_output, + n_last_blocks_list, + learning_rates, + weight_decays, + batch_size, + num_classes=1000, + bag_of_channels=False, + leave_one_out=False, + avgpool=False, +): + linear_classifiers_dict = nn.ModuleDict() + avgpool_value = avgpool + optim_param_groups = [] + for n in n_last_blocks_list: + for avgpool in [avgpool_value]: + for _lr in learning_rates: + for wd in weight_decays: + lr = scale_lr(_lr, batch_size) + out_dim = create_linear_input( + sample_output, use_n_blocks=n, use_avgpool=avgpool, bag_of_channels=bag_of_channels + ).shape[1] + linear_classifier = LinearClassifier( + out_dim, + use_n_blocks=n, + use_avgpool=avgpool, + num_classes=num_classes, + bag_of_channels=bag_of_channels, + leave_one_out=leave_one_out, + ) + linear_classifier = linear_classifier.cuda() + linear_classifiers_dict[ + f"classifier_{n}_blocks_avgpool_{avgpool}_lr_{lr:.5f}_wd_{wd:.2E}".replace(".", "_") + ] = linear_classifier + optim_param_groups.append({"params": linear_classifier.parameters(), "lr": lr, "weight_decay": wd}) + + linear_classifiers = AllClassifiers(linear_classifiers_dict) + if distributed.is_enabled(): + linear_classifiers = nn.parallel.DistributedDataParallel(linear_classifiers) + + return linear_classifiers, optim_param_groups + + +def make_eval_data_loader( + *, + test_dataset_str_or_path_or_loo_dataset, + config, + batch_size, + num_workers, +): + if isinstance(test_dataset_str_or_path_or_loo_dataset, str): + logger.info(f"Loading dataset {test_dataset_str_or_path_or_loo_dataset}") + transform = make_classification_eval_cell_transform( + normalization_type=NormalizationType.SELF_NORM_CENTER_CROP, + resize_size=config["resize_size"], + crop_size=config["crop_size"], + ) + test_dataset = make_dataset(dataset_str=test_dataset_str_or_path_or_loo_dataset, transform=transform) + collate_fn = None + else: + logger.info("Making data loader for feature dataset (typical in leave one out evaluation)") + test_dataset = test_dataset_str_or_path_or_loo_dataset + collate_fn = None + class_mapping = None + if hasattr(test_dataset, "get_imagenet_class_mapping"): + class_mapping = test_dataset.get_imagenet_class_mapping() + + test_data_loader = make_data_loader( + dataset=DatasetWithEnumeratedTargets( + test_dataset, pad_dataset=True, num_replicas=distributed.get_global_size() + ), + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + persistent_workers=False, + collate_fn=collate_fn, + ) + return test_data_loader, class_mapping + + +@dataclass +class Evaluator: + batch_size: int + num_workers: int + dataset_str_or_path: str + config: Dict + metric_type: MetricType + metrics_file_path: str + training_num_classes: int + save_results_func: Optional[Callable] + val_dataset_loo: Optional[TensorDataset] = None + + def __post_init__(self): + self.main_metric_name = f"{self.dataset_str_or_path}_accuracy" + + if self.val_dataset_loo is not None: + self.dataset_str_or_path = self.val_dataset_loo + + self.data_loader, self.class_mapping = make_eval_data_loader( + test_dataset_str_or_path_or_loo_dataset=self.dataset_str_or_path, + batch_size=self.batch_size, + num_workers=self.num_workers, + config=self.config, + ) + + @torch.no_grad() + def _evaluate_linear_classifiers( + self, + *, + feature_model, + linear_classifiers, + iteration, + prefixstring="", + best_classifier_on_val=None, + accumulate_results=False, + test_mode=False, + ) -> Tuple[Dict[str, Any], Optional[Dict[str, torch.Tensor]]]: + logger.info("running validation !") + + num_classes = len(self.class_mapping) if self.class_mapping is not None else self.training_num_classes + metric = build_metric(self.metric_type, num_classes=num_classes) + postprocessors = { + k: LinearPostprocessor(v, self.class_mapping) for k, v in linear_classifiers.classifiers_dict.items() + } + metrics = {k: metric.clone() for k in linear_classifiers.classifiers_dict} + + _, results_dict_temp, accumulated_results = evaluate_with_accumulate( + feature_model, + self.data_loader, + postprocessors, + metrics, + torch.cuda.current_device(), + accumulate_results=accumulate_results, + leave_one_out=self.config["leave_one_out"], + test_mode=test_mode, + ) + + logger.info("") + results_dict = {} + max_accuracy = 0 + best_classifier = "" + for _, (classifier_string, metric) in enumerate(results_dict_temp.items()): + logger.info(f"{prefixstring} -- Classifier: {classifier_string} * {metric}") + if ( + best_classifier_on_val is None and metric["top-1"].item() > max_accuracy + ) or classifier_string == best_classifier_on_val: + max_accuracy = metric["top-1"].item() + best_classifier = classifier_string + + results_dict["best_classifier"] = {"name": best_classifier, "accuracy": max_accuracy} + + logger.info(f"best classifier: {results_dict['best_classifier']}") + + accumulated_best_results = None + if test_mode: + accumulated_best_results = accumulated_results + elif accumulated_results is not None: + accumulated_best_results = accumulated_results[best_classifier] + + if distributed.is_main_process(): + with open(self.metrics_file_path, "a") as f: + f.write(f"iter: {iteration}\n") + for k, v in results_dict.items(): + f.write(json.dumps({k: v}) + "\n") + f.write("\n") + + return results_dict, accumulated_best_results + + def evaluate_and_maybe_save( + self, + feature_model, + linear_classifiers, + iteration: int, + best_classifier_on_val: Optional[Any] = None, + save_filename_suffix: str = "", + prefixstring: str = "", + test_mode: bool = False, + ): + logger.info(f"Testing on {self.dataset_str_or_path}") + save_results = self.save_results_func is not None + full_results_dict, accumulated_best_results = self._evaluate_linear_classifiers( + feature_model=feature_model, + linear_classifiers=remove_ddp_wrapper(linear_classifiers), + iteration=iteration, + prefixstring=prefixstring, + best_classifier_on_val=best_classifier_on_val, + accumulate_results=save_results, + test_mode=test_mode, + ) + if self.save_results_func is not None: + self.save_results_func( + filename_suffix=f"{self.dataset_str_or_path}{save_filename_suffix}", **accumulated_best_results + ) + + results_dict = { + self.main_metric_name: 100.0 * full_results_dict["best_classifier"]["accuracy"], + "best_classifier": full_results_dict["best_classifier"]["name"], + } + return results_dict, accumulated_best_results + + +def make_evaluators( + config: Dict, + val_metric_type: MetricType, + val_dataset: str, + metric_type: MetricType, + metrics_file_path: str, + training_num_classes: int, + save_results_func: Optional[Callable], + val_dataset_loo: Optional[TensorDataset] = None, +): + test_metric_types = config["test_metric_types"] + test_dataset_strs = config["test_datasets"] + if test_dataset_strs is None: + test_dataset_strs = (config["val_dataset"],) + if test_metric_types is None: + test_metric_types = (val_metric_type,) + else: + assert len(test_metric_types) == len(config["test_datasets"]) + + val_evaluator, *test_evaluators = [ + Evaluator( + dataset_str_or_path=dataset_str_or_path, + batch_size=config["batch_size"], + num_workers=config["num_workers"], + config=config, + metric_type=metric_type, + metrics_file_path=metrics_file_path, + training_num_classes=training_num_classes, + save_results_func=save_results_func, + val_dataset_loo=val_dataset_loo, + ) + for dataset_str_or_path, metric_type in zip( + (val_dataset,) + tuple(test_dataset_strs), + (val_metric_type,) + tuple(test_metric_types), + ) + ] + return val_evaluator, test_evaluators + + +class SchedulerType(Enum): + COSINE_ANNEALING = "cosine_annealing" + ONE_CYCLE = "one_cycle" + + def get_scheduler(self, optimizer, optim_param_groups, epoch_length, epochs, max_iter): + if self == SchedulerType.ONE_CYCLE: + lr_list = [optim_param_groups[i]["lr"] for i in range(len(optim_param_groups))] + scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, max_lr=lr_list, steps_per_epoch=epoch_length, epochs=epochs + ) + else: + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, max_iter, eta_min=0) + print("CosineAnnealingLR scheduler") + return scheduler + + +def setup_linear_training( + *, + config: Dict, + sample_output: torch.Tensor, + training_num_classes: int, + checkpoint_output_dir: str, +): + linear_classifiers, optim_param_groups = setup_linear_classifiers( + sample_output, + config["n_last_blocks_list"], + config["learning_rates"], + config["weight_decays"], + config["batch_size"], + training_num_classes, + config["bag_of_channels"], + config["leave_one_out"], + config["avgpool"], + ) + max_iter = config["epochs"] * config["epoch_length"] + optimizer = torch.optim.AdamW(optim_param_groups, weight_decay=0) + + scheduler = config["scheduler"].get_scheduler( + optimizer=optimizer, + optim_param_groups=optim_param_groups, + epoch_length=config["epoch_length"], + epochs=config["epochs"], + max_iter=max_iter, + ) + checkpoint_period = config["save_checkpoint_iterations"] or config["epoch_length"] + periodic_checkpointer = build_periodic_checkpointer( + linear_classifiers, + checkpoint_output_dir, + optimizer=optimizer, + scheduler=scheduler, + period=checkpoint_period, + max_iter=max_iter, + max_to_keep=None, + ) + checkpoint = resume_or_load(periodic_checkpointer, config["classifier_fpath"] or "", resume=config["resume"]) + + start_iter = checkpoint.get("iteration", -1) + 1 + best_accuracy = checkpoint.get("best_accuracy", -1) + + if config["loss_type"] == LossType.BINARY_CROSS_ENTROPY: + criterion = nn.BCEWithLogitsLoss() + else: + criterion = nn.CrossEntropyLoss() + + return ( + linear_classifiers, + start_iter, + max_iter, + criterion, + optimizer, + scheduler, + periodic_checkpointer, + best_accuracy, + ) + + +def train_linear_classifiers( + *, + feature_model, + train_dataset, + train_config: Dict, + training_num_classes: int, + val_evaluator: Evaluator, + checkpoint_output_dir: str, + sample_output: Optional[torch.Tensor] = None, +): + + if train_config["leave_one_out"]: + assert sample_output is not None, "sample_output should be passed as argument when using leave_one_out." + else: + sample_output = feature_model(train_dataset[0][0].unsqueeze(0).cuda()) + + ( + linear_classifiers, + start_iter, + max_iter, + criterion, + optimizer, + scheduler, + periodic_checkpointer, + best_accuracy, + ) = setup_linear_training( + config=train_config, + sample_output=sample_output, + training_num_classes=training_num_classes, + checkpoint_output_dir=checkpoint_output_dir, + ) + + sampler_type = SamplerType.INFINITE + train_data_loader = make_data_loader( + dataset=train_dataset, + batch_size=train_config["batch_size"], + num_workers=train_config["num_workers"], + shuffle=True, + seed=0, + sampler_type=sampler_type, + sampler_advance=start_iter, + drop_last=True, + persistent_workers=True, + ) + eval_period = train_config["eval_period_iterations"] or train_config["epoch_length"] + iteration = start_iter + logger.info("Starting training from iteration {}".format(start_iter)) + metric_logger = MetricLogger(delimiter=" ") + header = "Training" + + for data, labels in metric_logger.log_every( + train_data_loader, + 10, + header, + max_iter, + start_iter, + ): + data = data.cuda(non_blocking=True) + labels = labels.cuda(non_blocking=True) + + if not train_config["leave_one_out"]: + in_classifier = feature_model(data) + else: + in_classifier = data + + outputs = linear_classifiers(in_classifier) + + if len(labels.shape) > 1: + labels = labels.float() + losses = {f"loss_{k}": criterion(v, labels) for k, v in outputs.items()} + loss = sum(losses.values()) + + optimizer.zero_grad() + loss.backward() + + optimizer.step() + scheduler.step() + + if iteration % 10 == 0: + torch.cuda.synchronize() + metric_logger.update(loss=loss.item()) + metric_logger.update(lr=optimizer.param_groups[0]["lr"]) + + periodic_checkpointer.step(iteration=iteration, best_accuracy=best_accuracy) + + if eval_period > 0 and (iteration + 1) % eval_period == 0 and iteration != max_iter - 1: + val_results_dict, _ = val_evaluator.evaluate_and_maybe_save( + feature_model=feature_model, + linear_classifiers=linear_classifiers, + prefixstring=f"ITER: {iteration}", + iteration=iteration, + ) + val_accuracy = val_results_dict[val_evaluator.main_metric_name] + if val_accuracy >= best_accuracy: + best_accuracy = val_accuracy + periodic_checkpointer.save_best(iteration=iteration, best_accuracy=best_accuracy) + torch.distributed.barrier() + + iteration = iteration + 1 + + return feature_model, linear_classifiers, iteration, periodic_checkpointer + + +def eval_linear_with_model( + model, + output_dir, + train_dataset_str, + val_dataset_str, + batch_size, + epochs, + epoch_length, + num_workers, + save_checkpoint_frequency, + eval_period_iterations, + learning_rates, + weight_decays, + autocast_dtype, + test_dataset_strs=None, + resume=True, + classifier_fpath=None, + val_metric_type=MetricType.MEAN_ACCURACY, + test_metric_types=None, + loss_type=LossType.CROSS_ENTROPY, + bag_of_channels=False, + leave_one_out_dataset="", + resize_size=0, + crop_size=384, + n_last_blocks=4, + avgpool=False, + scheduler=SchedulerType.COSINE_ANNEALING, +): + + if leave_one_out_dataset == "" or leave_one_out_dataset is None: + leave_one_out = False + else: + logger.info("Reading the leave-one-out label metadata.") + + leave_one_out_indices = {} + metadata = pd.read_csv(leave_one_out_dataset) + if "HPA" in leave_one_out_dataset: + metadata = metadata[metadata["Task_three"]].reset_index() + leave_one_out_label_type = "cell_type" + else: + metadata = metadata[metadata["Task_four"]].reset_index() + leave_one_out_label_type = "Plate" + leave_one_out_labels = metadata[leave_one_out_label_type].unique() + + for leave_one_out_label in leave_one_out_labels: + leave_one_out_indices[leave_one_out_label] = np.array( + metadata[metadata[leave_one_out_label_type] == leave_one_out_label].index.values + ) + + leave_one_out = True + + train_transform = make_classification_eval_cell_transform( + normalization_type=NormalizationType.SELF_NORM_AUG_DECODER, crop_size=crop_size, resize_size=resize_size + ) + print("train_transform", train_transform) + train_dataset = make_dataset( + dataset_str=train_dataset_str, + transform=train_transform, + ) + + training_num_classes = get_num_classes(train_dataset) + if leave_one_out: + training_num_classes += train_dataset.num_additional_labels_loo_eval + train_dataset_dict = create_train_dataset_dict(train_dataset) + n_last_blocks_list = [n_last_blocks] + n_last_blocks = max(n_last_blocks_list) + dataset_use_cache = True + autocast_ctx = partial(torch.cuda.amp.autocast, enabled=True, dtype=autocast_dtype) + feature_model = ModelWithIntermediateLayers(model, n_last_blocks, autocast_ctx) + + if bag_of_channels: + sample = train_dataset[0][0].unsqueeze(0) + sample_output = feature_model(sample.cuda()) + + if leave_one_out: + loo_dict = {} + train_data_dict = extract_features_for_dataset_dict( + feature_model, + train_dataset_dict, + batch_size, + num_workers, + gather_on_cpu=True, + avgpool=avgpool, + ) + val_dataset = make_dataset( + dataset_str=val_dataset_str, + transform=make_classification_eval_cell_transform( + normalization_type=NormalizationType.SELF_NORM_CENTER_CROP, crop_size=crop_size, resize_size=resize_size + ), + ) + val_dataset_dict = create_train_dataset_dict(val_dataset) + val_data_dict = extract_features_for_dataset_dict( + feature_model, + val_dataset_dict, + batch_size, + num_workers, + gather_on_cpu=True, + avgpool=avgpool, + ) + + train_features = train_data_dict[0]["train_features"] + train_labels = train_data_dict[0]["train_labels"] + val_features = val_data_dict[0]["train_features"] + val_labels = val_data_dict[0]["train_labels"] + + for loo_label, loo_indices in leave_one_out_indices.items(): + loo_for_training_indices = torch.ones(val_features.shape[0], dtype=bool) + loo_for_training_indices[loo_indices] = False + loo_for_val_indices = torch.zeros(val_features.shape[0], dtype=bool) + loo_for_val_indices[loo_indices] = True + + loo_dict[loo_label] = { + "train_features": torch.cat([train_features, val_features[loo_for_training_indices]]), + "train_labels": torch.cat([train_labels, val_labels[loo_for_training_indices]]), + "val_features": val_features[loo_indices], + "val_labels": val_labels[loo_indices], + } + save_results_func = None + # if config.save_results: + # save_results_func = partial(default_save_results_func, output_dir=output_dir) + + metrics_file_path = os.path.join(output_dir, "results_eval_linear.json") + periodic_checkpointers: list = [] + + train_config = { + "learning_rates": learning_rates, + "weight_decays": weight_decays, + "batch_size": batch_size, + "num_workers": num_workers, + "dataset_use_cache": dataset_use_cache, + "eval_period_iterations": eval_period_iterations, + "epoch_length": epoch_length, + "leave_one_out": leave_one_out, + "bag_of_channels": bag_of_channels, + "n_last_blocks_list": n_last_blocks_list, + "epochs": epochs, + "loss_type": loss_type, + "resume": resume, + "save_checkpoint_iterations": save_checkpoint_frequency, + "classifier_fpath": classifier_fpath, + "avgpool": avgpool, + "scheduler": scheduler, + } + config = { + "test_metric_types": test_metric_types, + "test_datasets": test_dataset_strs, + "val_metric_types": val_metric_type, + "val_dataset": val_dataset_str, + "batch_size": batch_size, + "num_workers": num_workers, + "leave_one_out": leave_one_out, + "crop_size": crop_size, + "resize_size": resize_size, + } + if not leave_one_out: + val_evaluator, test_evaluators = make_evaluators( + config=config, + val_metric_type=val_metric_type, + val_dataset=val_dataset_str, + metric_type=test_metric_types, + metrics_file_path=metrics_file_path, + training_num_classes=training_num_classes, + save_results_func=save_results_func, + ) + results_dict = {} + + for _try in train_dataset_dict.keys(): + if len(train_dataset_dict) > 1: + checkpoint_output_dir = os.path.join(output_dir, f"checkpoints_{_try}") + save_filename_suffix = f"_{_try}" + else: + checkpoint_output_dir, save_filename_suffix = output_dir, "" + os.makedirs(checkpoint_output_dir, exist_ok=True) + + feature_model, linear_classifiers, iteration, periodic_checkpointer = train_linear_classifiers( + train_config=train_config, + feature_model=feature_model, + train_dataset=train_dataset_dict[_try], + training_num_classes=training_num_classes, + val_evaluator=val_evaluator, + checkpoint_output_dir=checkpoint_output_dir, + ) + periodic_checkpointers.append(periodic_checkpointer) + results_dict[_try], _ = val_evaluator.evaluate_and_maybe_save( + feature_model=feature_model, + linear_classifiers=linear_classifiers, + iteration=iteration, + save_filename_suffix=save_filename_suffix, + ) + for test_evaluator in test_evaluators: + eval_results_dict, _ = test_evaluator.evaluate_and_maybe_save( + feature_model=feature_model, + linear_classifiers=linear_classifiers, + iteration=iteration, + best_classifier_on_val=results_dict[_try]["best_classifier"], + save_filename_suffix=save_filename_suffix, + ) + results_dict[_try] = {**eval_results_dict, **results_dict[_try]} + if len(train_dataset_dict) > 1: + results_dict = average_metrics(results_dict, ignore_keys=["best_classifier"]) + else: + results_dict = {**results_dict[_try]} + else: # if leave one out is True + test_results_dict = {} + for loo_label in loo_dict.keys(): + + checkpoint_output_dir, save_filename_suffix = os.path.join(output_dir, f"checkpoints_{loo_label}"), "" + os.makedirs(checkpoint_output_dir, exist_ok=True) + + train_dataset_loo = TensorDataset( + loo_dict[loo_label]["train_features"], loo_dict[loo_label]["train_labels"] + ) + + logger.info(f"Creating leave_one_out evaluators. loo_label: {loo_label}") + val_dataset_loo = TensorDataset(loo_dict[loo_label]["val_features"], loo_dict[loo_label]["val_labels"]) + val_evaluators_loo, _ = make_evaluators( + config=config, + val_metric_type=val_metric_type, + val_dataset="loo", + metric_type=test_metric_types, + metrics_file_path=metrics_file_path, + training_num_classes=training_num_classes, + save_results_func=save_results_func, + val_dataset_loo=val_dataset_loo, + ) + feature_model, linear_classifiers, iteration, periodic_checkpointer = train_linear_classifiers( + feature_model=feature_model, + train_dataset=train_dataset_loo, + train_config=train_config, + training_num_classes=training_num_classes, + val_evaluator=val_evaluators_loo, + checkpoint_output_dir=checkpoint_output_dir, + sample_output=sample_output, + ) + periodic_checkpointers.append(periodic_checkpointer) + _, test_results_dict[loo_label] = val_evaluators_loo.evaluate_and_maybe_save( + feature_model=feature_model, + linear_classifiers=linear_classifiers, + iteration=iteration, + save_filename_suffix=save_filename_suffix, + test_mode=True, + ) + classifier_names = test_results_dict[loo_label].keys() + results_dict = {k: [[], []] for k in classifier_names} + for ll in test_results_dict.keys(): + for k in classifier_names: + results_dict[k][0].append(test_results_dict[ll][k][0]) + results_dict[k][1].append(test_results_dict[ll][k][1]) + for k in classifier_names: + results_dict[k] = [ + np.argmax(torch.cat(results_dict[k][0]).cpu().detach().numpy(), axis=1), + torch.cat(results_dict[k][1]).cpu().detach().numpy(), + ] + results_dict[k] = f1_score(results_dict[k][1], results_dict[k][0], average="macro", labels=[4, 5, 6]) + logger.info( + f"Best performance is for {max(results_dict, key=results_dict.get)}, with F1-Score of {results_dict[max(results_dict, key=results_dict.get)]}" + ) + + logger.info("Test Results Dict " + str(results_dict)) + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + eval_linear_with_model( + model=model, + output_dir=args.output_dir, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + test_dataset_strs=args.test_dataset_strs, + batch_size=args.batch_size, + epochs=args.epochs, + epoch_length=args.epoch_length, + num_workers=args.num_workers, + save_checkpoint_frequency=args.save_checkpoint_frequency, + eval_period_iterations=args.eval_period_iterations, + learning_rates=args.learning_rates, + weight_decays=args.weight_decays, + autocast_dtype=autocast_dtype, + resume=not args.no_resume, + classifier_fpath=args.classifier_fpath, + val_metric_type=args.val_metric_type, + test_metric_types=args.test_metric_types, + loss_type=args.loss_type, + bag_of_channels=args.bag_of_channels, + leave_one_out_dataset=args.leave_one_out_dataset, + crop_size=args.crop_size, + resize_size=args.resize_size, + n_last_blocks=args.n_last_blocks, + avgpool=args.avgpool, + scheduler=args.scheduler, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 linear_cell_dino evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/utils.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ad2ef5395c3d6772588f8f0d2b205796bd54352d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/cell_dino/utils.py @@ -0,0 +1,542 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import logging +from typing import Callable, Dict, Optional, Any, List + +import torch +from torch import nn +from torchmetrics import MetricCollection + +from dinov2.data import DatasetWithEnumeratedTargets, SamplerType, make_data_loader +from dinov2.data import NoOpAccumulator, ResultsAccumulator +import dinov2.distributed as distributed +from dinov2.logging import MetricLogger +from enum import Enum +from torch.utils.data import Subset +from torchvision.datasets.vision import StandardTransform +import numpy as np +from torch.nn.functional import one_hot, softmax + +logger = logging.getLogger("dinov2") + + +class LossType(Enum): + CROSS_ENTROPY = "cross_entropy" + BINARY_CROSS_ENTROPY = "binary_cross_entropy" + + +class BagOfChannelsModelWithNormalize(nn.Module): + def __init__(self, model, autocast_ctx, avgpool, n_last_blocks=1): + super().__init__() + self.model = model + self.autocast_ctx = autocast_ctx + self.n_last_blocks = n_last_blocks + self.avgpool = avgpool + + def forward(self, samples): + with self.autocast_ctx(): + features = self.model.get_intermediate_layers(samples, self.n_last_blocks, return_class_token=True) + output = create_linear_input(features, self.avgpool, use_n_blocks=self.n_last_blocks) + return nn.functional.normalize(output, dim=1, p=2) + + +@torch.inference_mode() +def evaluate_with_accumulate( + model: nn.Module, + data_loader, + postprocessors: Dict[str, nn.Module], + metrics: Dict[str, MetricCollection], + device: torch.device, + criterion: Optional[nn.Module] = None, + test_mode: bool = False, + accumulate_results: bool = False, + leave_one_out: bool = False, +): + model.eval() + + if test_mode: + output_tensor = {k: [] for k in postprocessors.keys()} + target_tensor = {k: [] for k in postprocessors.keys()} + + if criterion is not None: + criterion.eval() + + accumulator_class = ResultsAccumulator if accumulate_results else NoOpAccumulator + accumulators = {k: accumulator_class() for k in postprocessors.keys()} + + for metric in metrics.values(): + metric = metric.to(device) + + metric_logger = MetricLogger(delimiter=" ") + header = "Test:" + + for samples, targets, *_ in metric_logger.log_every(data_loader, 10, header): + if isinstance(targets, list): + index = targets[0] + targets = targets[1] + samples, targets, index = samples[index >= 0], targets[index >= 0], index[index >= 0] + if len(index) == 0: + continue + + outputs = samples.to(device) if leave_one_out else model(samples.to(device)) + targets = targets.to(device) + + if criterion is not None: + loss = criterion(outputs, targets) + metric_logger.update(loss=loss.item()) + + for k, metric in metrics.items(): + metric_inputs = postprocessors[k](outputs, targets) + metric.update(**metric_inputs) + if test_mode: + output_tensor[k].append(metric_inputs["preds"]) + target_tensor[k].append(metric_inputs["target"]) + accumulators[k].update(preds=metric_inputs["preds"], target=metric_inputs["target"], index=index) + + metric_logger.synchronize_between_processes() + logger.info(f"Averaged stats: {metric_logger}") + + stats = {k: metric.compute() for k, metric in metrics.items()} + metric_logger_stats = {k: meter.global_avg for k, meter in metric_logger.meters.items()} + + # accumulator.accumulate() returns None for the NoOpAccumulator + accumulated_results = {k: accumulator.accumulate() for k, accumulator in accumulators.items()} + if test_mode: + for k in postprocessors.keys(): + output_tensor[k] = torch.cat(output_tensor[k]) + target_tensor[k] = torch.cat(target_tensor[k]) + accumulated_results = {k: [output_tensor[k], target_tensor[k]] for k in postprocessors.keys()} + + if accumulate_results: + return metric_logger_stats, stats + return metric_logger_stats, stats, accumulated_results + + +def all_gather_and_flatten(tensor_rank): + tensor_all_ranks = torch.empty( + distributed.get_global_size(), + *tensor_rank.shape, + dtype=tensor_rank.dtype, + device=tensor_rank.device, + ) + tensor_list = list(tensor_all_ranks.unbind(0)) + torch.distributed.all_gather(tensor_list, tensor_rank.contiguous()) + return tensor_all_ranks.flatten(end_dim=1) + + +def extract_features_cell_dino( + model, dataset, batch_size, num_workers, gather_on_cpu=False, shuffle=False, avgpool=False +): + dataset_with_enumerated_targets = DatasetWithEnumeratedTargets(dataset) + sample_count = len(dataset_with_enumerated_targets) + data_loader = make_data_loader( + dataset=dataset_with_enumerated_targets, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=shuffle, + ) + return extract_features_with_dataloader_cell_dino(model, data_loader, sample_count, gather_on_cpu, avgpool=avgpool) + + +@torch.inference_mode() +def extract_features_with_dataloader_cell_dino(model, data_loader, sample_count, gather_on_cpu=False, avgpool=False): + gather_device = torch.device("cpu") if gather_on_cpu else torch.device("cuda") + metric_logger = MetricLogger(delimiter=" ") + features, all_labels = None, None + for samples, (index, labels_rank) in metric_logger.log_every(data_loader, 10): + samples = samples.cuda(non_blocking=True) + labels_rank = labels_rank.cuda(non_blocking=True) + index = index.cuda(non_blocking=True) + feat = model(samples) + if isinstance(samples, list) or isinstance(feat, tuple): + features_rank = create_linear_input(feat, avgpool=avgpool) + else: + features_rank = feat + + # init storage feature matrix + if features is None: + features = torch.zeros(sample_count, features_rank.shape[-1], device=gather_device) + labels_shape = list(labels_rank.shape) + labels_shape[0] = sample_count + all_labels = torch.full(labels_shape, fill_value=-1, device=gather_device) + logger.info(f"Storing features into tensor of shape {features.shape}") + + # share indexes, features and labels between processes + index_all = all_gather_and_flatten(index).to(gather_device) + features_all_ranks = all_gather_and_flatten(features_rank).to(gather_device) + labels_all_ranks = all_gather_and_flatten(labels_rank).to(gather_device) + + # update storage feature matrix + if len(index_all) > 0: + features.index_copy_(0, index_all, features_all_ranks) + all_labels.index_copy_(0, index_all, labels_all_ranks) + + logger.info(f"Features shape: {tuple(features.shape)}") + logger.info(f"Labels shape: {tuple(all_labels.shape)}") + + assert torch.all(all_labels > -1) + + return features, all_labels + + +def create_linear_input(x_tokens_list, avgpool=False, use_n_blocks=1): + intermediate_output = x_tokens_list[-use_n_blocks:] + output = torch.cat( + [class_token for _, class_token in intermediate_output], dim=-1 + ) # concatenate class tokens of the last n blocks + if avgpool: + output = torch.cat( + ( + output, + torch.mean(intermediate_output[-1][0], dim=-2).reshape( + intermediate_output[-1][0].shape[0], -1 + ), # average pooling of patch tokens: average over N, then concatenate channels if single-channel patch model + ), + dim=-1, + ) # concatenate average pooling of patch tokens to concatenated patch tokens + output = output.reshape(output.shape[0], -1) + + return output.float() + + +def get_target_transform(dataset) -> Optional[Callable]: + if hasattr(dataset, "transforms"): + if isinstance(dataset.transforms, StandardTransform): + return dataset.transforms.target_transform + raise ValueError("Dataset has a non-standard .transforms property") + if hasattr(dataset, "target_transform"): + return dataset.target_transform + return None + + +def get_labels(dataset) -> torch.Tensor: + """ + Get the labels of a classification dataset, as a Tensor, using the `get_targets` method + if it is present or loading the labels one by one with `get_target`, if it exists. + If the dataset has a target transform, iterate over the whole dataset to get the + transformed labels for each element, then stack them as a torch tensor. + """ + logger.info("Getting dataset labels ...") + if hasattr(dataset, "get_targets") or hasattr(dataset, "get_target"): + if hasattr(dataset, "get_targets"): # Returns a np.array + labels = dataset.get_targets() + elif hasattr(dataset, "get_target"): + labels = [dataset.get_target(i) for i in range(len(dataset))] + target_transform = get_target_transform(dataset) + if target_transform is not None: + labels = [target_transform(label) for label in labels] + else: + # Target transform is applied in this case + labels = [dataset[i][1] for i in range(len(dataset))] + return torch.stack([torch.tensor(label, dtype=int) for label in labels]) + + +def get_num_classes(dataset) -> int: + """ + Get the labels of a dataset and compute the number of classes + """ + labels = get_labels(dataset) + if len(labels.shape) > 1: + return int(labels.shape[1]) + return int(labels.max() + 1) + + +def average_metrics(eval_metrics_dict: dict[Any, dict[str, torch.Tensor]], ignore_keys: List[str] = []): + """ + Function that computes the average and the std on a metrics dict. + A linear evaluation dictionary contains "best_classifier", + so this specific key is removed for computing aggregated metrics. + """ + output_metrics_dict = {} + metrics = [metric for metric in eval_metrics_dict[0].keys() if metric not in ignore_keys] + for metric in metrics: + stats_tensor = torch.tensor([stat[metric] for stat in eval_metrics_dict.values()]) + output_metrics_dict[metric + "_mean"] = stats_tensor.mean().item() + output_metrics_dict[metric + "_std"] = torch.std(stats_tensor).item() + + return output_metrics_dict + + +def create_class_indices_mapping(labels: torch.Tensor) -> dict[int, torch.Tensor]: + """ + Efficiently creates a mapping between the labels and tensors containing + the indices of all the dataset elements that share this label. + In the case of multiple labels, it is not guaranteed that there + will be exactly the specified percentage of labels. + """ + if len(labels.shape) > 1: # labels are a one-hot encoding + assert len(labels.shape) == 2 + sorted_labels, indices = torch.nonzero(labels.T, as_tuple=True) + else: + sorted_labels, indices = torch.sort(labels, stable=True) + unique_labels, counts = torch.unique_consecutive(sorted_labels, return_counts=True) + mapping = dict(zip(unique_labels.tolist(), torch.split(indices, counts.tolist()))) + return mapping + + +def _shuffle_dataset(dataset: torch.Tensor, seed: int = 0): + """ + Shuffling a dataset by subsetting it with a random permutation of its indices + """ + random_generator = torch.Generator() + random_generator.manual_seed(seed) + random_indices = torch.randperm(len(dataset), generator=random_generator) + return Subset(dataset, random_indices) + + +def _subset_dataset_per_class( + class_indices_mapping: dict[int, torch.Tensor], + n_or_percent_per_class: float, + dataset_size: int, + seed: int = 0, + is_percent: bool = False, +) -> torch.Tensor: + """ + Helper function to select a percentage of a dataset, equally distributed across classes, + or to take the same number of elements from each class of the dataset. + Returns a boolean mask tensor being True at indices of selected elements + """ + + random_generator = torch.Generator() + random_generator.manual_seed(seed) + + final_indices_bool = torch.zeros(dataset_size, dtype=bool) + for class_indices in class_indices_mapping.values(): + # Select at least one element + n_for_class = max(int(len(class_indices) * n_or_percent_per_class), 1) if is_percent else n_or_percent_per_class + assert isinstance(n_for_class, int) + filtered_index = torch.randperm(len(class_indices), generator=random_generator)[:n_for_class] + final_indices_bool[class_indices[filtered_index]] = True + return final_indices_bool + + +def _multilabel_rebalance_subset( + class_indices_mapping: dict[int, torch.Tensor], + n_or_percent_per_class: float, + labels: torch.Tensor, + indices_bool: torch.Tensor, + dataset_size: int, + seed: int = 0, +) -> torch.Tensor: + """ + Helper function to refine a subset of a multi-label dataset (indices_bool) + to better match a target percentage of labels. + Returns a boolean mask tensor being True at indices of selected elements. + """ + + # Compute the number of selected labels in indices_bool + num_total_labels = labels.sum() + num_wanted_labels = int(num_total_labels * n_or_percent_per_class) + num_selected_labels = (labels[indices_bool] > 0).sum() + logger.info(f" {num_selected_labels} labels instead of {num_wanted_labels}") + + # Compute a new percentage and new set selecting less images, therefore less labels, to match approximatelly the exact percentage of labels selected + n_or_percent_per_class = n_or_percent_per_class / (num_selected_labels / num_wanted_labels) + final_indices_bool = _subset_dataset_per_class( + class_indices_mapping, n_or_percent_per_class, dataset_size, seed, True + ) + + # Compute the number of labels finally used + num_selected_labels = (labels[final_indices_bool] > 0).sum() + logger.info(f" {num_selected_labels} labels instead of {num_wanted_labels}") + + return final_indices_bool + + +def split_train_val_datasets(train_dataset, split_percentage: float = 0.1, shuffle_train: bool = True): + """ + Splitting a percent of the train dataset to choose hyperparameters, taking the same percentage for each class. + If `shuffle` is False, taking the first elements of each class as the validaton set. + """ + assert 0 < split_percentage < 1 + logger.info(f"Selecting {int(split_percentage * 100)}% of the train dataset as the validation set") + if shuffle_train: + logger.info("Shuffling train dataset before splitting in train and validation sets") + train_dataset = _shuffle_dataset(train_dataset) + train_labels = get_labels(train_dataset) + class_indices_mapping = create_class_indices_mapping(train_labels) + val_mask = torch.zeros(len(train_labels), dtype=bool) + for class_indices in class_indices_mapping.values(): + # If there is only one element, it goes in the train set + n_for_val = max(1, int(split_percentage * len(class_indices))) if len(class_indices) > 1 else 0 + val_mask[class_indices[:n_for_val]] = True + + val_dataset = Subset(train_dataset, val_mask.nonzero().flatten()) + train_dataset = Subset(train_dataset, (~val_mask).nonzero().flatten()) + return train_dataset, val_dataset + + +def create_train_dataset_dict( + train_dataset, + few_shot_eval: bool = False, + few_shot_k_or_percent=None, + few_shot_n_tries: int = 1, +) -> dict[int, dict[int, Any]]: + """ + Randomly split a dataset for few-shot evaluation, with `few_shot_k_or_percent` being + n elements or x% of a class. Produces a dict, which keys are number of random "tries" + and values are the dataset subset for this "try". + + Format is {"nth-try": dataset} + """ + if few_shot_eval is False: + assert few_shot_k_or_percent is None + assert few_shot_n_tries == 1 + return {0: train_dataset} + + assert few_shot_k_or_percent is not None + train_labels = get_labels(train_dataset) + class_indices_mapping = create_class_indices_mapping(train_labels) + train_dataset_dict: dict[int, Any] = {} + is_percent = few_shot_k_or_percent < 1 + if not is_percent: + few_shot_k_or_percent = int(few_shot_k_or_percent) + + for t in range(few_shot_n_tries): + t_subset_bool = _subset_dataset_per_class( + class_indices_mapping=class_indices_mapping, + n_or_percent_per_class=few_shot_k_or_percent, + dataset_size=len(train_labels), + is_percent=is_percent, + seed=t, + ) + if len(train_labels.shape) > 1 and is_percent: + t_subset_bool = _multilabel_rebalance_subset( + class_indices_mapping=class_indices_mapping, + n_or_percent_per_class=few_shot_k_or_percent, + dataset_size=len(train_labels), + labels=train_labels, + indices_bool=t_subset_bool, + seed=t, + ) + train_dataset_dict[t] = Subset(train_dataset, t_subset_bool.nonzero().flatten()) + return train_dataset_dict + + +def extract_features_for_dataset_dict( + model, + dataset_dict: dict[int, dict[int, Any]], + batch_size: int, + num_workers: int, + gather_on_cpu=False, + avgpool=False, +) -> dict[int, dict[str, torch.Tensor]]: + """ + Extract features for each subset of dataset in the context of few-shot evaluations + """ + few_shot_data_dict: dict[int, dict[str, torch.Tensor]] = {} + for try_n, dataset in dataset_dict.items(): + features, labels = extract_features_cell_dino( + model, dataset, batch_size, num_workers, gather_on_cpu=gather_on_cpu, avgpool=avgpool + ) + few_shot_data_dict[try_n] = {"train_features": features, "train_labels": labels} + return few_shot_data_dict + + +def pad_multilabel_and_collate(batch, pad_value=-1): + """ + This method pads and collates a batch of (image, (index, target)) tuples, coming from + DatasetWithEnumeratedTargets, with targets that are list of potentially varying sizes. + The targets are padded to the length of the longest target list in the batch. + """ + maxlen = max(len(targets) for _, (_, targets) in batch) + padded_batch = [ + (image, (index, np.pad(targets, (0, maxlen - len(targets)), constant_values=pad_value))) + for image, (index, targets) in batch + ] + return torch.utils.data.default_collate(padded_batch) + + +class KnnModule(torch.nn.Module): + """ + Gets knn of test features from all processes on a chunk of the train features + + Each rank gets a chunk of the train features as well as a chunk of the test features. + In `compute_neighbors`, for each rank one after the other, its chunk of test features + is sent to all devices, partial knns are computed with each chunk of train features + then collated back on the original device. + """ + + def __init__(self, train_features, train_labels, nb_knn, T, device, num_classes=1000): + super().__init__() + + self.global_rank = distributed.get_global_rank() + self.global_size = distributed.get_global_size() + + self.device = device + self.train_features_rank_T = train_features.chunk(self.global_size)[self.global_rank].T.to(self.device) + # Labels can either be integers, or in a one-hot format + self.candidates = train_labels.chunk(self.global_size)[self.global_rank].unsqueeze(0).to(self.device) + self.nb_knn = nb_knn + self.max_k = max(self.nb_knn) + self.T = T + self.num_classes = num_classes + + def _get_knn_sims_and_labels(self, similarity, train_labels): + topk_sims, indices = similarity.topk(self.max_k, largest=True, sorted=True) + if len(train_labels.shape) == 3: # If the labels are in one_hot format + indices = indices.unsqueeze(2).expand(-1, -1, self.num_classes) # Orignally [bs, max_k] + neighbors_labels = torch.gather(train_labels, 1, indices) + return topk_sims, neighbors_labels + + def _similarity_for_rank(self, features_rank, source_rank): + # Send the features from `source_rank` to all ranks + broadcast_shape = torch.tensor(features_rank.shape).to(self.device) + torch.distributed.broadcast(broadcast_shape, source_rank) + + broadcasted = features_rank + if self.global_rank != source_rank: + broadcasted = torch.zeros(*broadcast_shape, dtype=features_rank.dtype, device=self.device) + torch.distributed.broadcast(broadcasted, source_rank) + + # Compute the neighbors for `source_rank` among `train_features_rank_T` + similarity_rank = torch.mm(broadcasted, self.train_features_rank_T) + candidate_labels = self.candidates.expand(len(similarity_rank), *self.candidates.shape[1:]) + return self._get_knn_sims_and_labels(similarity_rank, candidate_labels) + + def _gather_all_knn_for_rank(self, topk_sims, neighbors_labels, target_rank): + # Gather all neighbors for `target_rank` + topk_sims_rank = retrieved_rank = None + if self.global_rank == target_rank: + topk_sims_rank = [torch.zeros_like(topk_sims) for _ in range(self.global_size)] + retrieved_rank = [torch.zeros_like(neighbors_labels) for _ in range(self.global_size)] + + torch.distributed.gather(topk_sims, topk_sims_rank, dst=target_rank) + torch.distributed.gather(neighbors_labels, retrieved_rank, dst=target_rank) + + if self.global_rank == target_rank: + # Perform a second top-k on the k * global_size retrieved neighbors + topk_sims_rank = torch.cat(topk_sims_rank, dim=1) + retrieved_rank = torch.cat(retrieved_rank, dim=1) + results = self._get_knn_sims_and_labels(topk_sims_rank, retrieved_rank) + return results + return None + + def compute_neighbors(self, features_rank): + for rank in range(self.global_size): + topk_sims, neighbors_labels = self._similarity_for_rank(features_rank, rank) + results = self._gather_all_knn_for_rank(topk_sims, neighbors_labels, rank) + if results is not None: + topk_sims_rank, neighbors_labels_rank = results + return topk_sims_rank, neighbors_labels_rank + + def forward(self, features_rank): + """ + Compute the results on all values of `self.nb_knn` neighbors from the full `self.max_k` + """ + assert all(k <= self.max_k for k in self.nb_knn) + + topk_sims, neighbors_labels = self.compute_neighbors(features_rank) + batch_size = neighbors_labels.shape[0] + topk_sims_transform = softmax(topk_sims / self.T, 1) + voting_coefficient = topk_sims_transform.view(batch_size, -1, 1) + if len(neighbors_labels.shape) == 2: # If the labels are not yet one hot + neighbors_labels = one_hot(neighbors_labels, num_classes=self.num_classes) + matmul = torch.mul(neighbors_labels, voting_coefficient) + probas_for_k = {k: torch.sum(matmul[:, :k, :], 1) for k in self.nb_knn} + return probas_for_k diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6715f9db507bdfda0d7b6e831369256d0c2cec1f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .backbones import * # noqa: F403 +from .builder import BACKBONES, DEPTHER, HEADS, LOSSES, build_backbone, build_depther, build_head, build_loss +from .decode_heads import * # noqa: F403 +from .depther import * # noqa: F403 +from .losses import * # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/backbones/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/backbones/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1fa5f656694c330041eb5afd991f8b0f15f5f61c --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/backbones/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .vision_transformer import DinoVisionTransformer diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/backbones/vision_transformer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/backbones/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..caed6fdd8e4d10cec6dca69481754d5f8efb38f2 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/backbones/vision_transformer.py @@ -0,0 +1,16 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.runner import BaseModule + +from ..builder import BACKBONES + + +@BACKBONES.register_module() +class DinoVisionTransformer(BaseModule): + """Vision Transformer.""" + + def __init__(self, *args, **kwargs): + super().__init__() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/builder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..24cc144b4c854a62af1ce46366e56c77ba5367d7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/builder.py @@ -0,0 +1,49 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +from mmcv.cnn import MODELS as MMCV_MODELS +from mmcv.cnn.bricks.registry import ATTENTION as MMCV_ATTENTION +from mmcv.utils import Registry + +MODELS = Registry("models", parent=MMCV_MODELS) +ATTENTION = Registry("attention", parent=MMCV_ATTENTION) + + +BACKBONES = MODELS +NECKS = MODELS +HEADS = MODELS +LOSSES = MODELS +DEPTHER = MODELS + + +def build_backbone(cfg): + """Build backbone.""" + return BACKBONES.build(cfg) + + +def build_neck(cfg): + """Build neck.""" + return NECKS.build(cfg) + + +def build_head(cfg): + """Build head.""" + return HEADS.build(cfg) + + +def build_loss(cfg): + """Build loss.""" + return LOSSES.build(cfg) + + +def build_depther(cfg, train_cfg=None, test_cfg=None): + """Build depther.""" + if train_cfg is not None or test_cfg is not None: + warnings.warn("train_cfg and test_cfg is deprecated, " "please specify them in model", UserWarning) + assert cfg.get("train_cfg") is None or train_cfg is None, "train_cfg specified in both outer field and model field " + assert cfg.get("test_cfg") is None or test_cfg is None, "test_cfg specified in both outer field and model field " + return DEPTHER.build(cfg, default_args=dict(train_cfg=train_cfg, test_cfg=test_cfg)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c224b24e3c71dd572c35a750a3da6c41ed4baed7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dpt_head import DPTHead +from .linear_head import BNHead diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/decode_head.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/decode_head.py new file mode 100644 index 0000000000000000000000000000000000000000..80a9da84a1969aa6d43e48ca3fcba50643afdcd8 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/decode_head.py @@ -0,0 +1,225 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import copy +from abc import ABCMeta, abstractmethod + +import mmcv +import numpy as np +import torch +import torch.nn as nn +from mmcv.runner import BaseModule, auto_fp16, force_fp32 + +from ...ops import resize +from ..builder import build_loss + + +class DepthBaseDecodeHead(BaseModule, metaclass=ABCMeta): + """Base class for BaseDecodeHead. + + Args: + in_channels (List): Input channels. + channels (int): Channels after modules, before conv_depth. + conv_cfg (dict|None): Config of conv layers. Default: None. + act_cfg (dict): Config of activation layers. + Default: dict(type='ReLU') + loss_decode (dict): Config of decode loss. + Default: dict(type='SigLoss'). + sampler (dict|None): The config of depth map sampler. + Default: None. + align_corners (bool): align_corners argument of F.interpolate. + Default: False. + min_depth (int): Min depth in dataset setting. + Default: 1e-3. + max_depth (int): Max depth in dataset setting. + Default: None. + norm_cfg (dict|None): Config of norm layers. + Default: None. + classify (bool): Whether predict depth in a cls.-reg. manner. + Default: False. + n_bins (int): The number of bins used in cls. step. + Default: 256. + bins_strategy (str): The discrete strategy used in cls. step. + Default: 'UD'. + norm_strategy (str): The norm strategy on cls. probability + distribution. Default: 'linear' + scale_up (str): Whether predict depth in a scale-up manner. + Default: False. + """ + + def __init__( + self, + in_channels, + channels=96, + conv_cfg=None, + act_cfg=dict(type="ReLU"), + loss_decode=dict(type="SigLoss", valid_mask=True, loss_weight=10), + sampler=None, + align_corners=False, + min_depth=1e-3, + max_depth=None, + norm_cfg=None, + classify=False, + n_bins=256, + bins_strategy="UD", + norm_strategy="linear", + scale_up=False, + ): + super(DepthBaseDecodeHead, self).__init__() + + self.in_channels = in_channels + self.channels = channels + self.conv_cfg = conv_cfg + self.act_cfg = act_cfg + if isinstance(loss_decode, dict): + self.loss_decode = build_loss(loss_decode) + elif isinstance(loss_decode, (list, tuple)): + self.loss_decode = nn.ModuleList() + for loss in loss_decode: + self.loss_decode.append(build_loss(loss)) + self.align_corners = align_corners + self.min_depth = min_depth + self.max_depth = max_depth + self.norm_cfg = norm_cfg + self.classify = classify + self.n_bins = n_bins + self.scale_up = scale_up + + if self.classify: + assert bins_strategy in ["UD", "SID"], "Support bins_strategy: UD, SID" + assert norm_strategy in ["linear", "softmax", "sigmoid"], "Support norm_strategy: linear, softmax, sigmoid" + + self.bins_strategy = bins_strategy + self.norm_strategy = norm_strategy + self.softmax = nn.Softmax(dim=1) + self.conv_depth = nn.Conv2d(channels, n_bins, kernel_size=3, padding=1, stride=1) + else: + self.conv_depth = nn.Conv2d(channels, 1, kernel_size=3, padding=1, stride=1) + + self.fp16_enabled = False + self.relu = nn.ReLU() + self.sigmoid = nn.Sigmoid() + + def extra_repr(self): + """Extra repr.""" + s = f"align_corners={self.align_corners}" + return s + + @auto_fp16() + @abstractmethod + def forward(self, inputs, img_metas): + """Placeholder of forward function.""" + pass + + def forward_train(self, img, inputs, img_metas, depth_gt, train_cfg): + """Forward function for training. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): GT depth + train_cfg (dict): The training config. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + depth_pred = self.forward(inputs, img_metas) + losses = self.losses(depth_pred, depth_gt) + + log_imgs = self.log_images(img[0], depth_pred[0], depth_gt[0], img_metas[0]) + losses.update(**log_imgs) + + return losses + + def forward_test(self, inputs, img_metas, test_cfg): + """Forward function for testing. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + test_cfg (dict): The testing config. + + Returns: + Tensor: Output depth map. + """ + return self.forward(inputs, img_metas) + + def depth_pred(self, feat): + """Prediction each pixel.""" + if self.classify: + logit = self.conv_depth(feat) + + if self.bins_strategy == "UD": + bins = torch.linspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + elif self.bins_strategy == "SID": + bins = torch.logspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + + # following Adabins, default linear + if self.norm_strategy == "linear": + logit = torch.relu(logit) + eps = 0.1 + logit = logit + eps + logit = logit / logit.sum(dim=1, keepdim=True) + elif self.norm_strategy == "softmax": + logit = torch.softmax(logit, dim=1) + elif self.norm_strategy == "sigmoid": + logit = torch.sigmoid(logit) + logit = logit / logit.sum(dim=1, keepdim=True) + + output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(dim=1) + + else: + if self.scale_up: + output = self.sigmoid(self.conv_depth(feat)) * self.max_depth + else: + output = self.relu(self.conv_depth(feat)) + self.min_depth + return output + + @force_fp32(apply_to=("depth_pred",)) + def losses(self, depth_pred, depth_gt): + """Compute depth loss.""" + loss = dict() + depth_pred = resize( + input=depth_pred, size=depth_gt.shape[2:], mode="bilinear", align_corners=self.align_corners, warning=False + ) + if not isinstance(self.loss_decode, nn.ModuleList): + losses_decode = [self.loss_decode] + else: + losses_decode = self.loss_decode + for loss_decode in losses_decode: + if loss_decode.loss_name not in loss: + loss[loss_decode.loss_name] = loss_decode(depth_pred, depth_gt) + else: + loss[loss_decode.loss_name] += loss_decode(depth_pred, depth_gt) + return loss + + def log_images(self, img_path, depth_pred, depth_gt, img_meta): + show_img = copy.deepcopy(img_path.detach().cpu().permute(1, 2, 0)) + show_img = show_img.numpy().astype(np.float32) + show_img = mmcv.imdenormalize( + show_img, + img_meta["img_norm_cfg"]["mean"], + img_meta["img_norm_cfg"]["std"], + img_meta["img_norm_cfg"]["to_rgb"], + ) + show_img = np.clip(show_img, 0, 255) + show_img = show_img.astype(np.uint8) + show_img = show_img[:, :, ::-1] + show_img = show_img.transpose(0, 2, 1) + show_img = show_img.transpose(1, 0, 2) + + depth_pred = depth_pred / torch.max(depth_pred) + depth_gt = depth_gt / torch.max(depth_gt) + + depth_pred_color = copy.deepcopy(depth_pred.detach().cpu()) + depth_gt_color = copy.deepcopy(depth_gt.detach().cpu()) + + return {"img_rgb": show_img, "img_depth_pred": depth_pred_color, "img_depth_gt": depth_gt_color} diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/dpt_head.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/dpt_head.py new file mode 100644 index 0000000000000000000000000000000000000000..f44ca2bf15e2c5c95a0528d06e4e4f890621d117 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/dpt_head.py @@ -0,0 +1,270 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +from mmcv.cnn import ConvModule, Linear, build_activation_layer +from mmcv.runner import BaseModule + +from ...ops import resize +from ..builder import HEADS +from .decode_head import DepthBaseDecodeHead + + +class Interpolate(nn.Module): + def __init__(self, scale_factor, mode, align_corners=False): + super(Interpolate, self).__init__() + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners) + return x + + +class HeadDepth(nn.Module): + def __init__(self, features): + super(HeadDepth, self).__init__() + self.head = nn.Sequential( + nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + ) + + def forward(self, x): + x = self.head(x) + return x + + +class ReassembleBlocks(BaseModule): + """ViTPostProcessBlock, process cls_token in ViT backbone output and + rearrange the feature vector to feature map. + Args: + in_channels (int): ViT feature channels. Default: 768. + out_channels (List): output channels of each stage. + Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + init_cfg (dict, optional): Initialization config dict. Default: None. + """ + + def __init__( + self, in_channels=768, out_channels=[96, 192, 384, 768], readout_type="ignore", patch_size=16, init_cfg=None + ): + super(ReassembleBlocks, self).__init__(init_cfg) + + assert readout_type in ["ignore", "add", "project"] + self.readout_type = readout_type + self.patch_size = patch_size + + self.projects = nn.ModuleList( + [ + ConvModule( + in_channels=in_channels, + out_channels=out_channel, + kernel_size=1, + act_cfg=None, + ) + for out_channel in out_channels + ] + ) + + self.resize_layers = nn.ModuleList( + [ + nn.ConvTranspose2d( + in_channels=out_channels[0], out_channels=out_channels[0], kernel_size=4, stride=4, padding=0 + ), + nn.ConvTranspose2d( + in_channels=out_channels[1], out_channels=out_channels[1], kernel_size=2, stride=2, padding=0 + ), + nn.Identity(), + nn.Conv2d( + in_channels=out_channels[3], out_channels=out_channels[3], kernel_size=3, stride=2, padding=1 + ), + ] + ) + if self.readout_type == "project": + self.readout_projects = nn.ModuleList() + for _ in range(len(self.projects)): + self.readout_projects.append( + nn.Sequential(Linear(2 * in_channels, in_channels), build_activation_layer(dict(type="GELU"))) + ) + + def forward(self, inputs): + assert isinstance(inputs, list) + out = [] + for i, x in enumerate(inputs): + assert len(x) == 2 + x, cls_token = x[0], x[1] + feature_shape = x.shape + if self.readout_type == "project": + x = x.flatten(2).permute((0, 2, 1)) + readout = cls_token.unsqueeze(1).expand_as(x) + x = self.readout_projects[i](torch.cat((x, readout), -1)) + x = x.permute(0, 2, 1).reshape(feature_shape) + elif self.readout_type == "add": + x = x.flatten(2) + cls_token.unsqueeze(-1) + x = x.reshape(feature_shape) + else: + pass + x = self.projects[i](x) + x = self.resize_layers[i](x) + out.append(x) + return out + + +class PreActResidualConvUnit(BaseModule): + """ResidualConvUnit, pre-activate residual unit. + Args: + in_channels (int): number of channels in the input feature map. + act_cfg (dict): dictionary to construct and config activation layer. + norm_cfg (dict): dictionary to construct and config norm layer. + stride (int): stride of the first block. Default: 1 + dilation (int): dilation rate for convs layers. Default: 1. + init_cfg (dict, optional): Initialization config dict. Default: None. + """ + + def __init__(self, in_channels, act_cfg, norm_cfg, stride=1, dilation=1, init_cfg=None): + super(PreActResidualConvUnit, self).__init__(init_cfg) + + self.conv1 = ConvModule( + in_channels, + in_channels, + 3, + stride=stride, + padding=dilation, + dilation=dilation, + norm_cfg=norm_cfg, + act_cfg=act_cfg, + bias=False, + order=("act", "conv", "norm"), + ) + + self.conv2 = ConvModule( + in_channels, + in_channels, + 3, + padding=1, + norm_cfg=norm_cfg, + act_cfg=act_cfg, + bias=False, + order=("act", "conv", "norm"), + ) + + def forward(self, inputs): + inputs_ = inputs.clone() + x = self.conv1(inputs) + x = self.conv2(x) + return x + inputs_ + + +class FeatureFusionBlock(BaseModule): + """FeatureFusionBlock, merge feature map from different stages. + Args: + in_channels (int): Input channels. + act_cfg (dict): The activation config for ResidualConvUnit. + norm_cfg (dict): Config dict for normalization layer. + expand (bool): Whether expand the channels in post process block. + Default: False. + align_corners (bool): align_corner setting for bilinear upsample. + Default: True. + init_cfg (dict, optional): Initialization config dict. Default: None. + """ + + def __init__(self, in_channels, act_cfg, norm_cfg, expand=False, align_corners=True, init_cfg=None): + super(FeatureFusionBlock, self).__init__(init_cfg) + + self.in_channels = in_channels + self.expand = expand + self.align_corners = align_corners + + self.out_channels = in_channels + if self.expand: + self.out_channels = in_channels // 2 + + self.project = ConvModule(self.in_channels, self.out_channels, kernel_size=1, act_cfg=None, bias=True) + + self.res_conv_unit1 = PreActResidualConvUnit(in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg) + self.res_conv_unit2 = PreActResidualConvUnit(in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg) + + def forward(self, *inputs): + x = inputs[0] + if len(inputs) == 2: + if x.shape != inputs[1].shape: + res = resize(inputs[1], size=(x.shape[2], x.shape[3]), mode="bilinear", align_corners=False) + else: + res = inputs[1] + x = x + self.res_conv_unit1(res) + x = self.res_conv_unit2(x) + x = resize(x, scale_factor=2, mode="bilinear", align_corners=self.align_corners) + x = self.project(x) + return x + + +@HEADS.register_module() +class DPTHead(DepthBaseDecodeHead): + """Vision Transformers for Dense Prediction. + This head is implemented of `DPT `_. + Args: + embed_dims (int): The embed dimension of the ViT backbone. + Default: 768. + post_process_channels (List): Out channels of post process conv + layers. Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + expand_channels (bool): Whether expand the channels in post process + block. Default: False. + """ + + def __init__( + self, + embed_dims=768, + post_process_channels=[96, 192, 384, 768], + readout_type="ignore", + patch_size=16, + expand_channels=False, + **kwargs + ): + super(DPTHead, self).__init__(**kwargs) + + self.in_channels = self.in_channels + self.expand_channels = expand_channels + self.reassemble_blocks = ReassembleBlocks(embed_dims, post_process_channels, readout_type, patch_size) + + self.post_process_channels = [ + channel * math.pow(2, i) if expand_channels else channel for i, channel in enumerate(post_process_channels) + ] + self.convs = nn.ModuleList() + for channel in self.post_process_channels: + self.convs.append(ConvModule(channel, self.channels, kernel_size=3, padding=1, act_cfg=None, bias=False)) + self.fusion_blocks = nn.ModuleList() + for _ in range(len(self.convs)): + self.fusion_blocks.append(FeatureFusionBlock(self.channels, self.act_cfg, self.norm_cfg)) + self.fusion_blocks[0].res_conv_unit1 = None + self.project = ConvModule(self.channels, self.channels, kernel_size=3, padding=1, norm_cfg=self.norm_cfg) + self.num_fusion_blocks = len(self.fusion_blocks) + self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers) + self.num_post_process_channels = len(self.post_process_channels) + assert self.num_fusion_blocks == self.num_reassemble_blocks + assert self.num_reassemble_blocks == self.num_post_process_channels + self.conv_depth = HeadDepth(self.channels) + + def forward(self, inputs, img_metas): + assert len(inputs) == self.num_reassemble_blocks + x = [inp for inp in inputs] + x = self.reassemble_blocks(x) + x = [self.convs[i](feature) for i, feature in enumerate(x)] + out = self.fusion_blocks[0](x[-1]) + for i in range(1, len(self.fusion_blocks)): + out = self.fusion_blocks[i](out, x[-(i + 1)]) + out = self.project(out) + out = self.depth_pred(out) + return out diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/linear_head.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/linear_head.py new file mode 100644 index 0000000000000000000000000000000000000000..fba0c8edc6e5d12cfb0e20541e884e241d51efc8 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/decode_heads/linear_head.py @@ -0,0 +1,89 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from ...ops import resize +from ..builder import HEADS +from .decode_head import DepthBaseDecodeHead + + +@HEADS.register_module() +class BNHead(DepthBaseDecodeHead): + """Just a batchnorm.""" + + def __init__(self, input_transform="resize_concat", in_index=(0, 1, 2, 3), upsample=1, **kwargs): + super().__init__(**kwargs) + self.input_transform = input_transform + self.in_index = in_index + self.upsample = upsample + # self.bn = nn.SyncBatchNorm(self.in_channels) + if self.classify: + self.conv_depth = nn.Conv2d(self.channels, self.n_bins, kernel_size=1, padding=0, stride=1) + else: + self.conv_depth = nn.Conv2d(self.channels, 1, kernel_size=1, padding=0, stride=1) + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + Tensor: The transformed inputs + """ + + if "concat" in self.input_transform: + inputs = [inputs[i] for i in self.in_index] + if "resize" in self.input_transform: + inputs = [ + resize( + input=x, + size=[s * self.upsample for s in inputs[0].shape[2:]], + mode="bilinear", + align_corners=self.align_corners, + ) + for x in inputs + ] + inputs = torch.cat(inputs, dim=1) + elif self.input_transform == "multiple_select": + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def _forward_feature(self, inputs, img_metas=None, **kwargs): + """Forward function for feature maps before classifying each pixel with + ``self.cls_seg`` fc. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + feats (Tensor): A tensor of shape (batch_size, self.channels, + H, W) which is feature map for last layer of decoder head. + """ + # accept lists (for cls token) + inputs = list(inputs) + for i, x in enumerate(inputs): + if len(x) == 2: + x, cls_token = x[0], x[1] + if len(x.shape) == 2: + x = x[:, :, None, None] + cls_token = cls_token[:, :, None, None].expand_as(x) + inputs[i] = torch.cat((x, cls_token), 1) + else: + x = x[0] + if len(x.shape) == 2: + x = x[:, :, None, None] + inputs[i] = x + x = self._transform_inputs(inputs) + # feats = self.bn(x) + return x + + def forward(self, inputs, img_metas=None, **kwargs): + """Forward function.""" + output = self._forward_feature(inputs, img_metas=img_metas, **kwargs) + output = self.depth_pred(output) + + return output diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0fe6fade0fa9682a62210cbc26a265bdbc3594a2 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .base import BaseDepther +from .encoder_decoder import DepthEncoderDecoder diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/base.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/base.py new file mode 100644 index 0000000000000000000000000000000000000000..bb1ade57cb6aea34def4b332145de27a45e3f54d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/base.py @@ -0,0 +1,194 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from abc import ABCMeta, abstractmethod +from collections import OrderedDict + +import torch +import torch.distributed as dist +from mmcv.runner import BaseModule, auto_fp16 + + +class BaseDepther(BaseModule, metaclass=ABCMeta): + """Base class for depther.""" + + def __init__(self, init_cfg=None): + super(BaseDepther, self).__init__(init_cfg) + self.fp16_enabled = False + + @property + def with_neck(self): + """bool: whether the depther has neck""" + return hasattr(self, "neck") and self.neck is not None + + @property + def with_auxiliary_head(self): + """bool: whether the depther has auxiliary head""" + return hasattr(self, "auxiliary_head") and self.auxiliary_head is not None + + @property + def with_decode_head(self): + """bool: whether the depther has decode head""" + return hasattr(self, "decode_head") and self.decode_head is not None + + @abstractmethod + def extract_feat(self, imgs): + """Placeholder for extract features from images.""" + pass + + @abstractmethod + def encode_decode(self, img, img_metas): + """Placeholder for encode images with backbone and decode into a + semantic depth map of the same size as input.""" + pass + + @abstractmethod + def forward_train(self, imgs, img_metas, **kwargs): + """Placeholder for Forward function for training.""" + pass + + @abstractmethod + def simple_test(self, img, img_meta, **kwargs): + """Placeholder for single image test.""" + pass + + @abstractmethod + def aug_test(self, imgs, img_metas, **kwargs): + """Placeholder for augmentation test.""" + pass + + def forward_test(self, imgs, img_metas, **kwargs): + """ + Args: + imgs (List[Tensor]): the outer list indicates test-time + augmentations and inner Tensor should have a shape NxCxHxW, + which contains all images in the batch. + img_metas (List[List[dict]]): the outer list indicates test-time + augs (multiscale, flip, etc.) and the inner list indicates + images in a batch. + """ + for var, name in [(imgs, "imgs"), (img_metas, "img_metas")]: + if not isinstance(var, list): + raise TypeError(f"{name} must be a list, but got " f"{type(var)}") + num_augs = len(imgs) + if num_augs != len(img_metas): + raise ValueError(f"num of augmentations ({len(imgs)}) != " f"num of image meta ({len(img_metas)})") + # all images in the same aug batch all of the same ori_shape and pad + # shape + for img_meta in img_metas: + ori_shapes = [_["ori_shape"] for _ in img_meta] + assert all(shape == ori_shapes[0] for shape in ori_shapes) + img_shapes = [_["img_shape"] for _ in img_meta] + assert all(shape == img_shapes[0] for shape in img_shapes) + pad_shapes = [_["pad_shape"] for _ in img_meta] + assert all(shape == pad_shapes[0] for shape in pad_shapes) + + if num_augs == 1: + return self.simple_test(imgs[0], img_metas[0], **kwargs) + else: + return self.aug_test(imgs, img_metas, **kwargs) + + @auto_fp16(apply_to=("img",)) + def forward(self, img, img_metas, return_loss=True, **kwargs): + """Calls either :func:`forward_train` or :func:`forward_test` depending + on whether ``return_loss`` is ``True``. + + Note this setting will change the expected inputs. When + ``return_loss=True``, img and img_meta are single-nested (i.e. Tensor + and List[dict]), and when ``resturn_loss=False``, img and img_meta + should be double nested (i.e. List[Tensor], List[List[dict]]), with + the outer list indicating test time augmentations. + """ + if return_loss: + return self.forward_train(img, img_metas, **kwargs) + else: + return self.forward_test(img, img_metas, **kwargs) + + def train_step(self, data_batch, optimizer, **kwargs): + """The iteration step during training. + + This method defines an iteration step during training, except for the + back propagation and optimizer updating, which are done in an optimizer + hook. Note that in some complicated cases or models, the whole process + including back propagation and optimizer updating is also defined in + this method, such as GAN. + + Args: + data (dict): The output of dataloader. + optimizer (:obj:`torch.optim.Optimizer` | dict): The optimizer of + runner is passed to ``train_step()``. This argument is unused + and reserved. + + Returns: + dict: It should contain at least 3 keys: ``loss``, ``log_vars``, + ``num_samples``. + ``loss`` is a tensor for back propagation, which can be a + weighted sum of multiple losses. + ``log_vars`` contains all the variables to be sent to the + logger. + ``num_samples`` indicates the batch size (when the model is + DDP, it means the batch size on each GPU), which is used for + averaging the logs. + """ + losses = self(**data_batch) + + # split losses and images + real_losses = {} + log_imgs = {} + for k, v in losses.items(): + if "img" in k: + log_imgs[k] = v + else: + real_losses[k] = v + + loss, log_vars = self._parse_losses(real_losses) + + outputs = dict(loss=loss, log_vars=log_vars, num_samples=len(data_batch["img_metas"]), log_imgs=log_imgs) + + return outputs + + def val_step(self, data_batch, **kwargs): + """The iteration step during validation. + + This method shares the same signature as :func:`train_step`, but used + during val epochs. Note that the evaluation after training epochs is + not implemented with this method, but an evaluation hook. + """ + output = self(**data_batch, **kwargs) + return output + + @staticmethod + def _parse_losses(losses): + """Parse the raw outputs (losses) of the network. + + Args: + losses (dict): Raw output of the network, which usually contain + losses and other necessary information. + + Returns: + tuple[Tensor, dict]: (loss, log_vars), loss is the loss tensor + which may be a weighted sum of all losses, log_vars contains + all the variables to be sent to the logger. + """ + 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) + else: + raise TypeError(f"{loss_name} is not a tensor or list of tensors") + + loss = sum(_value for _key, _value in log_vars.items() if "loss" in _key) + + log_vars["loss"] = loss + 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() + + return loss, log_vars diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/encoder_decoder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/encoder_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..4b5c2790f2046d3a7760936e70b503440ac00102 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/depther/encoder_decoder.py @@ -0,0 +1,236 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F + +from ...models import builder +from ...models.builder import DEPTHER +from ...ops import resize +from .base import BaseDepther + + +def add_prefix(inputs, prefix): + """Add prefix for dict. + + Args: + inputs (dict): The input dict with str keys. + prefix (str): The prefix to add. + + Returns: + + dict: The dict with keys updated with ``prefix``. + """ + + outputs = dict() + for name, value in inputs.items(): + outputs[f"{prefix}.{name}"] = value + + return outputs + + +@DEPTHER.register_module() +class DepthEncoderDecoder(BaseDepther): + """Encoder Decoder depther. + + EncoderDecoder typically consists of backbone, (neck) and decode_head. + """ + + def __init__(self, backbone, decode_head, neck=None, train_cfg=None, test_cfg=None, pretrained=None, init_cfg=None): + super(DepthEncoderDecoder, self).__init__(init_cfg) + if pretrained is not None: + assert backbone.get("pretrained") is None, "both backbone and depther set pretrained weight" + backbone.pretrained = pretrained + self.backbone = builder.build_backbone(backbone) + self._init_decode_head(decode_head) + + if neck is not None: + self.neck = builder.build_neck(neck) + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + assert self.with_decode_head + + def _init_decode_head(self, decode_head): + """Initialize ``decode_head``""" + self.decode_head = builder.build_head(decode_head) + self.align_corners = self.decode_head.align_corners + + def extract_feat(self, img): + """Extract features from images.""" + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def encode_decode(self, img, img_metas, rescale=True, size=None): + """Encode images with backbone and decode into a depth estimation + map of the same size as input.""" + x = self.extract_feat(img) + out = self._decode_head_forward_test(x, img_metas) + # crop the pred depth to the certain range. + out = torch.clamp(out, min=self.decode_head.min_depth, max=self.decode_head.max_depth) + if rescale: + if size is None: + if img_metas is not None: + size = img_metas[0]["ori_shape"][:2] + else: + size = img.shape[2:] + out = resize(input=out, size=size, mode="bilinear", align_corners=self.align_corners) + return out + + def _decode_head_forward_train(self, img, x, img_metas, depth_gt, **kwargs): + """Run forward function and calculate loss for decode head in + training.""" + losses = dict() + loss_decode = self.decode_head.forward_train(img, x, img_metas, depth_gt, self.train_cfg, **kwargs) + losses.update(add_prefix(loss_decode, "decode")) + return losses + + def _decode_head_forward_test(self, x, img_metas): + """Run forward function and calculate loss for decode head in + inference.""" + depth_pred = self.decode_head.forward_test(x, img_metas, self.test_cfg) + return depth_pred + + def forward_dummy(self, img): + """Dummy forward function.""" + depth = self.encode_decode(img, None) + + return depth + + def forward_train(self, img, img_metas, depth_gt, **kwargs): + """Forward function for training. + + Args: + img (Tensor): Input images. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): Depth gt + used if the architecture supports depth estimation task. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + + x = self.extract_feat(img) + + losses = dict() + + # the last of x saves the info from neck + loss_decode = self._decode_head_forward_train(img, x, img_metas, depth_gt, **kwargs) + + losses.update(loss_decode) + + return losses + + def whole_inference(self, img, img_meta, rescale, size=None): + """Inference with full image.""" + depth_pred = self.encode_decode(img, img_meta, rescale, size=size) + + return depth_pred + + def slide_inference(self, img, img_meta, rescale): + """Inference by sliding-window with overlap. + + If h_crop > h_img or w_crop > w_img, the small patch will be used to + decode without padding. + """ + + h_stride, w_stride = self.test_cfg.stride + h_crop, w_crop = self.test_cfg.crop_size + batch_size, _, h_img, w_img = img.size() + h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1 + w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1 + preds = img.new_zeros((batch_size, 1, h_img, w_img)) + count_mat = img.new_zeros((batch_size, 1, h_img, w_img)) + for h_idx in range(h_grids): + for w_idx in range(w_grids): + y1 = h_idx * h_stride + x1 = w_idx * w_stride + y2 = min(y1 + h_crop, h_img) + x2 = min(x1 + w_crop, w_img) + y1 = max(y2 - h_crop, 0) + x1 = max(x2 - w_crop, 0) + crop_img = img[:, :, y1:y2, x1:x2] + depth_pred = self.encode_decode(crop_img, img_meta, rescale) + preds += F.pad(depth_pred, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2))) + + count_mat[:, :, y1:y2, x1:x2] += 1 + assert (count_mat == 0).sum() == 0 + if torch.onnx.is_in_onnx_export(): + # cast count_mat to constant while exporting to ONNX + count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device) + preds = preds / count_mat + return preds + + def inference(self, img, img_meta, rescale, size=None): + """Inference with slide/whole style. + + Args: + img (Tensor): The input image of shape (N, 3, H, W). + img_meta (dict): Image info dict where each dict has: 'img_shape', + 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + rescale (bool): Whether rescale back to original shape. + + Returns: + Tensor: The output depth map. + """ + + assert self.test_cfg.mode in ["slide", "whole"] + ori_shape = img_meta[0]["ori_shape"] + assert all(_["ori_shape"] == ori_shape for _ in img_meta) + if self.test_cfg.mode == "slide": + depth_pred = self.slide_inference(img, img_meta, rescale) + else: + depth_pred = self.whole_inference(img, img_meta, rescale, size=size) + output = depth_pred + flip = img_meta[0]["flip"] + if flip: + flip_direction = img_meta[0]["flip_direction"] + assert flip_direction in ["horizontal", "vertical"] + if flip_direction == "horizontal": + output = output.flip(dims=(3,)) + elif flip_direction == "vertical": + output = output.flip(dims=(2,)) + + return output + + def simple_test(self, img, img_meta, rescale=True): + """Simple test with single image.""" + depth_pred = self.inference(img, img_meta, rescale) + if torch.onnx.is_in_onnx_export(): + # our inference backend only support 4D output + depth_pred = depth_pred.unsqueeze(0) + return depth_pred + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred + + def aug_test(self, imgs, img_metas, rescale=True): + """Test with augmentations. + + Only rescale=True is supported. + """ + # aug_test rescale all imgs back to ori_shape for now + assert rescale + # to save memory, we get augmented depth logit inplace + depth_pred = self.inference(imgs[0], img_metas[0], rescale) + for i in range(1, len(imgs)): + cur_depth_pred = self.inference(imgs[i], img_metas[i], rescale, size=depth_pred.shape[-2:]) + depth_pred += cur_depth_pred + depth_pred /= len(imgs) + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..96d54b514d2af8ef435888de85c44b4f1c6b8bad --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .gradientloss import GradientLoss +from .sigloss import SigLoss diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/gradientloss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/gradientloss.py new file mode 100644 index 0000000000000000000000000000000000000000..d761b5e5841e546b9f07c4bf1f19360e152f5b99 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/gradientloss.py @@ -0,0 +1,69 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from ...models.builder import LOSSES + + +@LOSSES.register_module() +class GradientLoss(nn.Module): + """GradientLoss. + + Adapted from https://www.cs.cornell.edu/projects/megadepth/ + + Args: + valid_mask (bool): Whether filter invalid gt (gt > 0). Default: True. + loss_weight (float): Weight of the loss. Default: 1.0. + max_depth (int): When filtering invalid gt, set a max threshold. Default: None. + """ + + def __init__(self, valid_mask=True, loss_weight=1.0, max_depth=None, loss_name="loss_grad"): + super(GradientLoss, self).__init__() + self.valid_mask = valid_mask + self.loss_weight = loss_weight + self.max_depth = max_depth + self.loss_name = loss_name + + self.eps = 0.001 # avoid grad explode + + def gradientloss(self, input, target): + input_downscaled = [input] + [input[:: 2 * i, :: 2 * i] for i in range(1, 4)] + target_downscaled = [target] + [target[:: 2 * i, :: 2 * i] for i in range(1, 4)] + + gradient_loss = 0 + for input, target in zip(input_downscaled, target_downscaled): + if self.valid_mask: + mask = target > 0 + if self.max_depth is not None: + mask = torch.logical_and(target > 0, target <= self.max_depth) + N = torch.sum(mask) + else: + mask = torch.ones_like(target) + N = input.numel() + input_log = torch.log(input + self.eps) + target_log = torch.log(target + self.eps) + log_d_diff = input_log - target_log + + log_d_diff = torch.mul(log_d_diff, mask) + + v_gradient = torch.abs(log_d_diff[0:-2, :] - log_d_diff[2:, :]) + v_mask = torch.mul(mask[0:-2, :], mask[2:, :]) + v_gradient = torch.mul(v_gradient, v_mask) + + h_gradient = torch.abs(log_d_diff[:, 0:-2] - log_d_diff[:, 2:]) + h_mask = torch.mul(mask[:, 0:-2], mask[:, 2:]) + h_gradient = torch.mul(h_gradient, h_mask) + + gradient_loss += (torch.sum(h_gradient) + torch.sum(v_gradient)) / N + + return gradient_loss + + def forward(self, depth_pred, depth_gt): + """Forward function.""" + + gradient_loss = self.loss_weight * self.gradientloss(depth_pred, depth_gt) + return gradient_loss diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/sigloss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/sigloss.py new file mode 100644 index 0000000000000000000000000000000000000000..57bd33cc938509967e007a3f11bc089b29226df1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/models/losses/sigloss.py @@ -0,0 +1,65 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from ...models.builder import LOSSES + + +@LOSSES.register_module() +class SigLoss(nn.Module): + """SigLoss. + + This follows `AdaBins `_. + + Args: + valid_mask (bool): Whether filter invalid gt (gt > 0). Default: True. + loss_weight (float): Weight of the loss. Default: 1.0. + max_depth (int): When filtering invalid gt, set a max threshold. Default: None. + warm_up (bool): A simple warm up stage to help convergence. Default: False. + warm_iter (int): The number of warm up stage. Default: 100. + """ + + def __init__( + self, valid_mask=True, loss_weight=1.0, max_depth=None, warm_up=False, warm_iter=100, loss_name="sigloss" + ): + super(SigLoss, self).__init__() + self.valid_mask = valid_mask + self.loss_weight = loss_weight + self.max_depth = max_depth + self.loss_name = loss_name + + self.eps = 0.001 # avoid grad explode + + # HACK: a hack implementation for warmup sigloss + self.warm_up = warm_up + self.warm_iter = warm_iter + self.warm_up_counter = 0 + + def sigloss(self, input, target): + if self.valid_mask: + valid_mask = target > 0 + if self.max_depth is not None: + valid_mask = torch.logical_and(target > 0, target <= self.max_depth) + input = input[valid_mask] + target = target[valid_mask] + + if self.warm_up: + if self.warm_up_counter < self.warm_iter: + g = torch.log(input + self.eps) - torch.log(target + self.eps) + g = 0.15 * torch.pow(torch.mean(g), 2) + self.warm_up_counter += 1 + return torch.sqrt(g) + + g = torch.log(input + self.eps) - torch.log(target + self.eps) + Dg = torch.var(g) + 0.15 * torch.pow(torch.mean(g), 2) + return torch.sqrt(Dg) + + def forward(self, depth_pred, depth_gt): + """Forward function.""" + + loss_depth = self.loss_weight * self.sigloss(depth_pred, depth_gt) + return loss_depth diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/ops/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/ops/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..395729b397696a7e4b5b0947db72adba2ed090ed --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/ops/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .wrappers import resize diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/ops/wrappers.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/ops/wrappers.py new file mode 100644 index 0000000000000000000000000000000000000000..0abb2a7040f487371b2f89875ef5fa180a87f4ae --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/depth/ops/wrappers.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +import torch.nn.functional as F + + +def resize(input, size=None, scale_factor=None, mode="nearest", align_corners=None, warning=False): + if warning: + if size is not None and align_corners: + input_h, input_w = tuple(int(x) for x in input.shape[2:]) + output_h, output_w = tuple(int(x) for x in size) + if output_h > input_h or output_w > output_h: + if ( + (output_h > 1 and output_w > 1 and input_h > 1 and input_w > 1) + and (output_h - 1) % (input_h - 1) + and (output_w - 1) % (input_w - 1) + ): + warnings.warn( + f"When align_corners={align_corners}, " + "the output would more aligned if " + f"input size {(input_h, input_w)} is `x+1` and " + f"out size {(output_h, output_w)} is `nx+1`" + ) + return F.interpolate(input, size, scale_factor, mode, align_corners) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/knn.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/knn.py new file mode 100644 index 0000000000000000000000000000000000000000..59db32727866b4f3611523ba34ce86d5428a94a5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/knn.py @@ -0,0 +1,404 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +from functools import partial +import json +import logging +import os +import sys +from typing import List, Optional + +import torch +from torch.nn.functional import one_hot, softmax + +import dinov2.distributed as distributed +from dinov2.data import SamplerType, make_data_loader, make_dataset +from dinov2.data.transforms import make_classification_eval_transform +from dinov2.eval.metrics import AccuracyAveraging, build_topk_accuracy_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.utils import ModelWithNormalize, evaluate, extract_features + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--nb_knn", + nargs="+", + type=int, + help="Number of NN to use. 20 is usually working the best.", + ) + parser.add_argument( + "--temperature", + type=float, + help="Temperature used in the voting coefficient", + ) + parser.add_argument( + "--gather-on-cpu", + action="store_true", + help="Whether to gather the train features on cpu, slower" + "but useful to avoid OOM for large datasets (e.g. ImageNet22k).", + ) + parser.add_argument( + "--batch-size", + type=int, + help="Batch size.", + ) + parser.add_argument( + "--n-per-class-list", + nargs="+", + type=int, + help="Number to take per class", + ) + parser.add_argument( + "--n-tries", + type=int, + help="Number of tries", + ) + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + nb_knn=[10, 20, 100, 200], + temperature=0.07, + batch_size=256, + n_per_class_list=[-1], + n_tries=1, + ) + return parser + + +class KnnModule(torch.nn.Module): + """ + Gets knn of test features from all processes on a chunk of the train features + + Each rank gets a chunk of the train features as well as a chunk of the test features. + In `compute_neighbors`, for each rank one after the other, its chunk of test features + is sent to all devices, partial knns are computed with each chunk of train features + then collated back on the original device. + """ + + def __init__(self, train_features, train_labels, nb_knn, T, device, num_classes=1000): + super().__init__() + + self.global_rank = distributed.get_global_rank() + self.global_size = distributed.get_global_size() + + self.device = device + self.train_features_rank_T = train_features.chunk(self.global_size)[self.global_rank].T.to(self.device) + self.candidates = train_labels.chunk(self.global_size)[self.global_rank].view(1, -1).to(self.device) + + self.nb_knn = nb_knn + self.max_k = max(self.nb_knn) + self.T = T + self.num_classes = num_classes + + def _get_knn_sims_and_labels(self, similarity, train_labels): + topk_sims, indices = similarity.topk(self.max_k, largest=True, sorted=True) + neighbors_labels = torch.gather(train_labels, 1, indices) + return topk_sims, neighbors_labels + + def _similarity_for_rank(self, features_rank, source_rank): + # Send the features from `source_rank` to all ranks + broadcast_shape = torch.tensor(features_rank.shape).to(self.device) + torch.distributed.broadcast(broadcast_shape, source_rank) + + broadcasted = features_rank + if self.global_rank != source_rank: + broadcasted = torch.zeros(*broadcast_shape, dtype=features_rank.dtype, device=self.device) + torch.distributed.broadcast(broadcasted, source_rank) + + # Compute the neighbors for `source_rank` among `train_features_rank_T` + similarity_rank = torch.mm(broadcasted, self.train_features_rank_T) + candidate_labels = self.candidates.expand(len(similarity_rank), -1) + return self._get_knn_sims_and_labels(similarity_rank, candidate_labels) + + def _gather_all_knn_for_rank(self, topk_sims, neighbors_labels, target_rank): + # Gather all neighbors for `target_rank` + topk_sims_rank = retrieved_rank = None + if self.global_rank == target_rank: + topk_sims_rank = [torch.zeros_like(topk_sims) for _ in range(self.global_size)] + retrieved_rank = [torch.zeros_like(neighbors_labels) for _ in range(self.global_size)] + + torch.distributed.gather(topk_sims, topk_sims_rank, dst=target_rank) + torch.distributed.gather(neighbors_labels, retrieved_rank, dst=target_rank) + + if self.global_rank == target_rank: + # Perform a second top-k on the k * global_size retrieved neighbors + topk_sims_rank = torch.cat(topk_sims_rank, dim=1) + retrieved_rank = torch.cat(retrieved_rank, dim=1) + results = self._get_knn_sims_and_labels(topk_sims_rank, retrieved_rank) + return results + return None + + def compute_neighbors(self, features_rank): + for rank in range(self.global_size): + topk_sims, neighbors_labels = self._similarity_for_rank(features_rank, rank) + results = self._gather_all_knn_for_rank(topk_sims, neighbors_labels, rank) + if results is not None: + topk_sims_rank, neighbors_labels_rank = results + return topk_sims_rank, neighbors_labels_rank + + def forward(self, features_rank): + """ + Compute the results on all values of `self.nb_knn` neighbors from the full `self.max_k` + """ + assert all(k <= self.max_k for k in self.nb_knn) + + topk_sims, neighbors_labels = self.compute_neighbors(features_rank) + batch_size = neighbors_labels.shape[0] + topk_sims_transform = softmax(topk_sims / self.T, 1) + matmul = torch.mul( + one_hot(neighbors_labels, num_classes=self.num_classes), + topk_sims_transform.view(batch_size, -1, 1), + ) + probas_for_k = {k: torch.sum(matmul[:, :k, :], 1) for k in self.nb_knn} + return probas_for_k + + +class DictKeysModule(torch.nn.Module): + def __init__(self, keys): + super().__init__() + self.keys = keys + + def forward(self, features_dict, targets): + for k in self.keys: + features_dict = features_dict[k] + return {"preds": features_dict, "target": targets} + + +def create_module_dict(*, module, n_per_class_list, n_tries, nb_knn, train_features, train_labels): + modules = {} + mapping = create_class_indices_mapping(train_labels) + for npc in n_per_class_list: + if npc < 0: # Only one try needed when using the full data + full_module = module( + train_features=train_features, + train_labels=train_labels, + nb_knn=nb_knn, + ) + modules["full"] = ModuleDictWithForward({"1": full_module}) + continue + all_tries = {} + for t in range(n_tries): + final_indices = filter_train(mapping, npc, seed=t) + k_list = list(set(nb_knn + [npc])) + k_list = sorted([el for el in k_list if el <= npc]) + all_tries[str(t)] = module( + train_features=train_features[final_indices], + train_labels=train_labels[final_indices], + nb_knn=k_list, + ) + modules[f"{npc} per class"] = ModuleDictWithForward(all_tries) + + return ModuleDictWithForward(modules) + + +def filter_train(mapping, n_per_class, seed): + torch.manual_seed(seed) + final_indices = [] + for k in mapping.keys(): + index = torch.randperm(len(mapping[k]))[:n_per_class] + final_indices.append(mapping[k][index]) + return torch.cat(final_indices).squeeze() + + +def create_class_indices_mapping(labels): + unique_labels, inverse = torch.unique(labels, return_inverse=True) + mapping = {unique_labels[i]: (inverse == i).nonzero() for i in range(len(unique_labels))} + return mapping + + +class ModuleDictWithForward(torch.nn.ModuleDict): + def forward(self, *args, **kwargs): + return {k: module(*args, **kwargs) for k, module in self._modules.items()} + + +def eval_knn( + model, + train_dataset, + val_dataset, + accuracy_averaging, + nb_knn, + temperature, + batch_size, + num_workers, + gather_on_cpu, + n_per_class_list=[-1], + n_tries=1, +): + model = ModelWithNormalize(model) + + logger.info("Extracting features for train set...") + train_features, train_labels = extract_features( + model, train_dataset, batch_size, num_workers, gather_on_cpu=gather_on_cpu + ) + logger.info(f"Train features created, shape {train_features.shape}.") + + val_dataloader = make_data_loader( + dataset=val_dataset, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + persistent_workers=True, + ) + num_classes = train_labels.max() + 1 + metric_collection = build_topk_accuracy_metric(accuracy_averaging, num_classes=num_classes) + + device = torch.cuda.current_device() + partial_module = partial(KnnModule, T=temperature, device=device, num_classes=num_classes) + knn_module_dict = create_module_dict( + module=partial_module, + n_per_class_list=n_per_class_list, + n_tries=n_tries, + nb_knn=nb_knn, + train_features=train_features, + train_labels=train_labels, + ) + postprocessors, metrics = {}, {} + for n_per_class, knn_module in knn_module_dict.items(): + for t, knn_try in knn_module.items(): + postprocessors = { + **postprocessors, + **{(n_per_class, t, k): DictKeysModule([n_per_class, t, k]) for k in knn_try.nb_knn}, + } + metrics = {**metrics, **{(n_per_class, t, k): metric_collection.clone() for k in knn_try.nb_knn}} + model_with_knn = torch.nn.Sequential(model, knn_module_dict) + + # ============ evaluation ... ============ + logger.info("Start the k-NN classification.") + _, results_dict = evaluate(model_with_knn, val_dataloader, postprocessors, metrics, device) + + # Averaging the results over the n tries for each value of n_per_class + for n_per_class, knn_module in knn_module_dict.items(): + first_try = list(knn_module.keys())[0] + k_list = knn_module[first_try].nb_knn + for k in k_list: + keys = results_dict[(n_per_class, first_try, k)].keys() # keys are e.g. `top-1` and `top-5` + results_dict[(n_per_class, k)] = { + key: torch.mean(torch.stack([results_dict[(n_per_class, t, k)][key] for t in knn_module.keys()])) + for key in keys + } + for t in knn_module.keys(): + del results_dict[(n_per_class, t, k)] + + return results_dict + + +def eval_knn_with_model( + model, + output_dir, + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + nb_knn=(10, 20, 100, 200), + temperature=0.07, + autocast_dtype=torch.float, + accuracy_averaging=AccuracyAveraging.MEAN_ACCURACY, + transform=None, + gather_on_cpu=False, + batch_size=256, + num_workers=5, + n_per_class_list=[-1], + n_tries=1, +): + transform = transform or make_classification_eval_transform() + + train_dataset = make_dataset( + dataset_str=train_dataset_str, + transform=transform, + ) + val_dataset = make_dataset( + dataset_str=val_dataset_str, + transform=transform, + ) + + with torch.cuda.amp.autocast(dtype=autocast_dtype): + results_dict_knn = eval_knn( + model=model, + train_dataset=train_dataset, + val_dataset=val_dataset, + accuracy_averaging=accuracy_averaging, + nb_knn=nb_knn, + temperature=temperature, + batch_size=batch_size, + num_workers=num_workers, + gather_on_cpu=gather_on_cpu, + n_per_class_list=n_per_class_list, + n_tries=n_tries, + ) + + results_dict = {} + if distributed.is_main_process(): + for knn_ in results_dict_knn.keys(): + top1 = results_dict_knn[knn_]["top-1"].item() * 100.0 + top5 = results_dict_knn[knn_]["top-5"].item() * 100.0 + results_dict[f"{knn_} Top 1"] = top1 + results_dict[f"{knn_} Top 5"] = top5 + logger.info(f"{knn_} classifier result: Top1: {top1:.2f} Top5: {top5:.2f}") + + metrics_file_path = os.path.join(output_dir, "results_eval_knn.json") + with open(metrics_file_path, "a") as f: + for k, v in results_dict.items(): + f.write(json.dumps({k: v}) + "\n") + + if distributed.is_enabled(): + torch.distributed.barrier() + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + eval_knn_with_model( + model=model, + output_dir=args.output_dir, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + nb_knn=args.nb_knn, + temperature=args.temperature, + autocast_dtype=autocast_dtype, + accuracy_averaging=AccuracyAveraging.MEAN_ACCURACY, + transform=None, + gather_on_cpu=args.gather_on_cpu, + batch_size=args.batch_size, + num_workers=5, + n_per_class_list=args.n_per_class_list, + n_tries=args.n_tries, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 k-NN evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/linear.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/linear.py new file mode 100644 index 0000000000000000000000000000000000000000..c8f3c3ae67b7e33d036f6a0053ca419516d94b27 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/linear.py @@ -0,0 +1,625 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +from functools import partial +import json +import logging +import os +import sys +from typing import List, Optional + +import numpy as np +import torch +import torch.nn as nn +from torch.nn.parallel import DistributedDataParallel +from fvcore.common.checkpoint import Checkpointer, PeriodicCheckpointer + +from dinov2.data import SamplerType, make_data_loader, make_dataset +from dinov2.data.transforms import make_classification_eval_transform, make_classification_train_transform +import dinov2.distributed as distributed +from dinov2.eval.metrics import MetricType, build_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.utils import ModelWithIntermediateLayers, evaluate +from dinov2.logging import MetricLogger + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--test-datasets", + dest="test_dataset_strs", + type=str, + nargs="+", + help="Test datasets, none to reuse the validation dataset", + ) + parser.add_argument( + "--epochs", + type=int, + help="Number of training epochs", + ) + parser.add_argument( + "--batch-size", + type=int, + help="Batch Size (per GPU)", + ) + parser.add_argument( + "--num-workers", + type=int, + help="Number de Workers", + ) + parser.add_argument( + "--epoch-length", + type=int, + help="Length of an epoch in number of iterations", + ) + parser.add_argument( + "--save-checkpoint-frequency", + type=int, + help="Number of epochs between two named checkpoint saves.", + ) + parser.add_argument( + "--eval-period-iterations", + type=int, + help="Number of iterations between two evaluations.", + ) + parser.add_argument( + "--learning-rates", + nargs="+", + type=float, + help="Learning rates to grid search.", + ) + parser.add_argument( + "--no-resume", + action="store_true", + help="Whether to not resume from existing checkpoints", + ) + parser.add_argument( + "--val-metric-type", + type=MetricType, + choices=list(MetricType), + help="Validation metric", + ) + parser.add_argument( + "--test-metric-types", + type=MetricType, + choices=list(MetricType), + nargs="+", + help="Evaluation metric", + ) + parser.add_argument( + "--classifier-fpath", + type=str, + help="Path to a file containing pretrained linear classifiers", + ) + parser.add_argument( + "--val-class-mapping-fpath", + type=str, + help="Path to a file containing a mapping to adjust classifier outputs", + ) + parser.add_argument( + "--test-class-mapping-fpaths", + nargs="+", + type=str, + help="Path to a file containing a mapping to adjust classifier outputs", + ) + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + test_dataset_strs=None, + epochs=10, + batch_size=128, + num_workers=8, + epoch_length=1250, + save_checkpoint_frequency=20, + eval_period_iterations=1250, + learning_rates=[1e-5, 2e-5, 5e-5, 1e-4, 2e-4, 5e-4, 1e-3, 2e-3, 5e-3, 1e-2, 2e-2, 5e-2, 0.1], + val_metric_type=MetricType.MEAN_ACCURACY, + test_metric_types=None, + classifier_fpath=None, + val_class_mapping_fpath=None, + test_class_mapping_fpaths=[None], + ) + return parser + + +def has_ddp_wrapper(m: nn.Module) -> bool: + return isinstance(m, DistributedDataParallel) + + +def remove_ddp_wrapper(m: nn.Module) -> nn.Module: + return m.module if has_ddp_wrapper(m) else m + + +def _pad_and_collate(batch): + maxlen = max(len(targets) for image, targets in batch) + padded_batch = [ + (image, np.pad(targets, (0, maxlen - len(targets)), constant_values=-1)) for image, targets in batch + ] + return torch.utils.data.default_collate(padded_batch) + + +def create_linear_input(x_tokens_list, use_n_blocks, use_avgpool): + intermediate_output = x_tokens_list[-use_n_blocks:] + output = torch.cat([class_token for _, class_token in intermediate_output], dim=-1) + if use_avgpool: + output = torch.cat( + ( + output, + torch.mean(intermediate_output[-1][0], dim=1), # patch tokens + ), + dim=-1, + ) + output = output.reshape(output.shape[0], -1) + return output.float() + + +class LinearClassifier(nn.Module): + """Linear layer to train on top of frozen features""" + + def __init__(self, out_dim, use_n_blocks, use_avgpool, num_classes=1000): + super().__init__() + self.out_dim = out_dim + self.use_n_blocks = use_n_blocks + self.use_avgpool = use_avgpool + self.num_classes = num_classes + self.linear = nn.Linear(out_dim, num_classes) + self.linear.weight.data.normal_(mean=0.0, std=0.01) + self.linear.bias.data.zero_() + + def forward(self, x_tokens_list): + output = create_linear_input(x_tokens_list, self.use_n_blocks, self.use_avgpool) + return self.linear(output) + + +class AllClassifiers(nn.Module): + def __init__(self, classifiers_dict): + super().__init__() + self.classifiers_dict = nn.ModuleDict() + self.classifiers_dict.update(classifiers_dict) + + def forward(self, inputs): + return {k: v.forward(inputs) for k, v in self.classifiers_dict.items()} + + def __len__(self): + return len(self.classifiers_dict) + + +class LinearPostprocessor(nn.Module): + def __init__(self, linear_classifier, class_mapping=None): + super().__init__() + self.linear_classifier = linear_classifier + self.register_buffer("class_mapping", None if class_mapping is None else torch.LongTensor(class_mapping)) + + def forward(self, samples, targets): + preds = self.linear_classifier(samples) + return { + "preds": preds[:, self.class_mapping] if self.class_mapping is not None else preds, + "target": targets, + } + + +def scale_lr(learning_rates, batch_size): + return learning_rates * (batch_size * distributed.get_global_size()) / 256.0 + + +def setup_linear_classifiers(sample_output, n_last_blocks_list, learning_rates, batch_size, num_classes=1000): + linear_classifiers_dict = nn.ModuleDict() + optim_param_groups = [] + for n in n_last_blocks_list: + for avgpool in [False, True]: + for _lr in learning_rates: + lr = scale_lr(_lr, batch_size) + out_dim = create_linear_input(sample_output, use_n_blocks=n, use_avgpool=avgpool).shape[1] + linear_classifier = LinearClassifier( + out_dim, use_n_blocks=n, use_avgpool=avgpool, num_classes=num_classes + ) + linear_classifier = linear_classifier.cuda() + linear_classifiers_dict[ + f"classifier_{n}_blocks_avgpool_{avgpool}_lr_{lr:.5f}".replace(".", "_") + ] = linear_classifier + optim_param_groups.append({"params": linear_classifier.parameters(), "lr": lr}) + + linear_classifiers = AllClassifiers(linear_classifiers_dict) + if distributed.is_enabled(): + linear_classifiers = nn.parallel.DistributedDataParallel(linear_classifiers) + + return linear_classifiers, optim_param_groups + + +@torch.no_grad() +def evaluate_linear_classifiers( + feature_model, + linear_classifiers, + data_loader, + metric_type, + metrics_file_path, + training_num_classes, + iteration, + prefixstring="", + class_mapping=None, + best_classifier_on_val=None, +): + logger.info("running validation !") + + num_classes = len(class_mapping) if class_mapping is not None else training_num_classes + metric = build_metric(metric_type, num_classes=num_classes) + postprocessors = {k: LinearPostprocessor(v, class_mapping) for k, v in linear_classifiers.classifiers_dict.items()} + metrics = {k: metric.clone() for k in linear_classifiers.classifiers_dict} + + _, results_dict_temp = evaluate( + feature_model, + data_loader, + postprocessors, + metrics, + torch.cuda.current_device(), + ) + + logger.info("") + results_dict = {} + max_accuracy = 0 + best_classifier = "" + for i, (classifier_string, metric) in enumerate(results_dict_temp.items()): + logger.info(f"{prefixstring} -- Classifier: {classifier_string} * {metric}") + if ( + best_classifier_on_val is None and metric["top-1"].item() > max_accuracy + ) or classifier_string == best_classifier_on_val: + max_accuracy = metric["top-1"].item() + best_classifier = classifier_string + + results_dict["best_classifier"] = {"name": best_classifier, "accuracy": max_accuracy} + + logger.info(f"best classifier: {results_dict['best_classifier']}") + + if distributed.is_main_process(): + with open(metrics_file_path, "a") as f: + f.write(f"iter: {iteration}\n") + for k, v in results_dict.items(): + f.write(json.dumps({k: v}) + "\n") + f.write("\n") + + return results_dict + + +def eval_linear( + *, + feature_model, + linear_classifiers, + train_data_loader, + val_data_loader, + metrics_file_path, + optimizer, + scheduler, + output_dir, + max_iter, + checkpoint_period, # In number of iter, creates a new file every period + running_checkpoint_period, # Period to update main checkpoint file + eval_period, + metric_type, + training_num_classes, + resume=True, + classifier_fpath=None, + val_class_mapping=None, +): + checkpointer = Checkpointer(linear_classifiers, output_dir, optimizer=optimizer, scheduler=scheduler) + start_iter = checkpointer.resume_or_load(classifier_fpath or "", resume=resume).get("iteration", -1) + 1 + + periodic_checkpointer = PeriodicCheckpointer(checkpointer, checkpoint_period, max_iter=max_iter) + iteration = start_iter + logger.info("Starting training from iteration {}".format(start_iter)) + metric_logger = MetricLogger(delimiter=" ") + header = "Training" + + for data, labels in metric_logger.log_every( + train_data_loader, + 10, + header, + max_iter, + start_iter, + ): + data = data.cuda(non_blocking=True) + labels = labels.cuda(non_blocking=True) + + features = feature_model(data) + outputs = linear_classifiers(features) + + losses = {f"loss_{k}": nn.CrossEntropyLoss()(v, labels) for k, v in outputs.items()} + loss = sum(losses.values()) + + # compute the gradients + optimizer.zero_grad() + loss.backward() + + # step + optimizer.step() + scheduler.step() + + # log + if iteration % 10 == 0: + torch.cuda.synchronize() + metric_logger.update(loss=loss.item()) + metric_logger.update(lr=optimizer.param_groups[0]["lr"]) + print("lr", optimizer.param_groups[0]["lr"]) + + if iteration - start_iter > 5: + if iteration % running_checkpoint_period == 0: + torch.cuda.synchronize() + if distributed.is_main_process(): + logger.info("Checkpointing running_checkpoint") + periodic_checkpointer.save("running_checkpoint_linear_eval", iteration=iteration) + torch.cuda.synchronize() + periodic_checkpointer.step(iteration) + + if eval_period > 0 and (iteration + 1) % eval_period == 0 and iteration != max_iter - 1: + _ = evaluate_linear_classifiers( + feature_model=feature_model, + linear_classifiers=remove_ddp_wrapper(linear_classifiers), + data_loader=val_data_loader, + metrics_file_path=metrics_file_path, + prefixstring=f"ITER: {iteration}", + metric_type=metric_type, + training_num_classes=training_num_classes, + iteration=iteration, + class_mapping=val_class_mapping, + ) + torch.cuda.synchronize() + + iteration = iteration + 1 + + val_results_dict = evaluate_linear_classifiers( + feature_model=feature_model, + linear_classifiers=remove_ddp_wrapper(linear_classifiers), + data_loader=val_data_loader, + metrics_file_path=metrics_file_path, + metric_type=metric_type, + training_num_classes=training_num_classes, + iteration=iteration, + class_mapping=val_class_mapping, + ) + return val_results_dict, feature_model, linear_classifiers, iteration + + +def make_eval_data_loader(test_dataset_str, batch_size, num_workers, metric_type): + test_dataset = make_dataset( + dataset_str=test_dataset_str, + transform=make_classification_eval_transform(), + ) + test_data_loader = make_data_loader( + dataset=test_dataset, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + persistent_workers=False, + collate_fn=_pad_and_collate if metric_type == MetricType.IMAGENET_REAL_ACCURACY else None, + ) + return test_data_loader + + +def test_on_datasets( + feature_model, + linear_classifiers, + test_dataset_strs, + batch_size, + num_workers, + test_metric_types, + metrics_file_path, + training_num_classes, + iteration, + best_classifier_on_val, + prefixstring="", + test_class_mappings=[None], +): + results_dict = {} + for test_dataset_str, class_mapping, metric_type in zip(test_dataset_strs, test_class_mappings, test_metric_types): + logger.info(f"Testing on {test_dataset_str}") + test_data_loader = make_eval_data_loader(test_dataset_str, batch_size, num_workers, metric_type) + dataset_results_dict = evaluate_linear_classifiers( + feature_model, + remove_ddp_wrapper(linear_classifiers), + test_data_loader, + metric_type, + metrics_file_path, + training_num_classes, + iteration, + prefixstring="", + class_mapping=class_mapping, + best_classifier_on_val=best_classifier_on_val, + ) + results_dict[f"{test_dataset_str}_accuracy"] = 100.0 * dataset_results_dict["best_classifier"]["accuracy"] + return results_dict + + +def run_eval_linear( + model, + output_dir, + train_dataset_str, + val_dataset_str, + batch_size, + epochs, + epoch_length, + num_workers, + save_checkpoint_frequency, + eval_period_iterations, + learning_rates, + autocast_dtype, + test_dataset_strs=None, + resume=True, + classifier_fpath=None, + val_class_mapping_fpath=None, + test_class_mapping_fpaths=[None], + val_metric_type=MetricType.MEAN_ACCURACY, + test_metric_types=None, +): + seed = 0 + + if test_dataset_strs is None: + test_dataset_strs = [val_dataset_str] + if test_metric_types is None: + test_metric_types = [val_metric_type] * len(test_dataset_strs) + else: + assert len(test_metric_types) == len(test_dataset_strs) + assert len(test_dataset_strs) == len(test_class_mapping_fpaths) + + train_transform = make_classification_train_transform() + train_dataset = make_dataset( + dataset_str=train_dataset_str, + transform=train_transform, + ) + training_num_classes = len(torch.unique(torch.Tensor(train_dataset.get_targets().astype(int)))) + sampler_type = SamplerType.SHARDED_INFINITE + # sampler_type = SamplerType.INFINITE + + n_last_blocks_list = [1, 4] + n_last_blocks = max(n_last_blocks_list) + autocast_ctx = partial(torch.cuda.amp.autocast, enabled=True, dtype=autocast_dtype) + feature_model = ModelWithIntermediateLayers(model, n_last_blocks, autocast_ctx) + sample_output = feature_model(train_dataset[0][0].unsqueeze(0).cuda()) + + linear_classifiers, optim_param_groups = setup_linear_classifiers( + sample_output, + n_last_blocks_list, + learning_rates, + batch_size, + training_num_classes, + ) + + optimizer = torch.optim.SGD(optim_param_groups, momentum=0.9, weight_decay=0) + max_iter = epochs * epoch_length + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, max_iter, eta_min=0) + checkpointer = Checkpointer(linear_classifiers, output_dir, optimizer=optimizer, scheduler=scheduler) + start_iter = checkpointer.resume_or_load(classifier_fpath or "", resume=resume).get("iteration", -1) + 1 + train_data_loader = make_data_loader( + dataset=train_dataset, + batch_size=batch_size, + num_workers=num_workers, + shuffle=True, + seed=seed, + sampler_type=sampler_type, + sampler_advance=start_iter, + drop_last=True, + persistent_workers=True, + ) + val_data_loader = make_eval_data_loader(val_dataset_str, batch_size, num_workers, val_metric_type) + + checkpoint_period = save_checkpoint_frequency * epoch_length + + if val_class_mapping_fpath is not None: + logger.info(f"Using class mapping from {val_class_mapping_fpath}") + val_class_mapping = np.load(val_class_mapping_fpath) + else: + val_class_mapping = None + + test_class_mappings = [] + for class_mapping_fpath in test_class_mapping_fpaths: + if class_mapping_fpath is not None and class_mapping_fpath != "None": + logger.info(f"Using class mapping from {class_mapping_fpath}") + class_mapping = np.load(class_mapping_fpath) + else: + class_mapping = None + test_class_mappings.append(class_mapping) + + metrics_file_path = os.path.join(output_dir, "results_eval_linear.json") + val_results_dict, feature_model, linear_classifiers, iteration = eval_linear( + feature_model=feature_model, + linear_classifiers=linear_classifiers, + train_data_loader=train_data_loader, + val_data_loader=val_data_loader, + metrics_file_path=metrics_file_path, + optimizer=optimizer, + scheduler=scheduler, + output_dir=output_dir, + max_iter=max_iter, + checkpoint_period=checkpoint_period, + running_checkpoint_period=epoch_length, + eval_period=eval_period_iterations, + metric_type=val_metric_type, + training_num_classes=training_num_classes, + resume=resume, + val_class_mapping=val_class_mapping, + classifier_fpath=classifier_fpath, + ) + results_dict = {} + if len(test_dataset_strs) > 1 or test_dataset_strs[0] != val_dataset_str: + results_dict = test_on_datasets( + feature_model, + linear_classifiers, + test_dataset_strs, + batch_size, + 0, # num_workers, + test_metric_types, + metrics_file_path, + training_num_classes, + iteration, + val_results_dict["best_classifier"]["name"], + prefixstring="", + test_class_mappings=test_class_mappings, + ) + results_dict["best_classifier"] = val_results_dict["best_classifier"]["name"] + results_dict[f"{val_dataset_str}_accuracy"] = 100.0 * val_results_dict["best_classifier"]["accuracy"] + logger.info("Test Results Dict " + str(results_dict)) + + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + run_eval_linear( + model=model, + output_dir=args.output_dir, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + test_dataset_strs=args.test_dataset_strs, + batch_size=args.batch_size, + epochs=args.epochs, + epoch_length=args.epoch_length, + num_workers=args.num_workers, + save_checkpoint_frequency=args.save_checkpoint_frequency, + eval_period_iterations=args.eval_period_iterations, + learning_rates=args.learning_rates, + autocast_dtype=autocast_dtype, + resume=not args.no_resume, + classifier_fpath=args.classifier_fpath, + val_metric_type=args.val_metric_type, + test_metric_types=args.test_metric_types, + val_class_mapping_fpath=args.val_class_mapping_fpath, + test_class_mapping_fpaths=args.test_class_mapping_fpaths, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 linear evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/log_regression.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/log_regression.py new file mode 100644 index 0000000000000000000000000000000000000000..459716f3c775d46e221b31f014c65a937f27b488 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/log_regression.py @@ -0,0 +1,444 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +import gc +import logging +import sys +import time +from typing import List, Optional + +from cuml.linear_model import LogisticRegression +import torch +import torch.backends.cudnn as cudnn +import torch.distributed +from torch import nn +from torch.utils.data import TensorDataset +from torchmetrics import MetricTracker + +from dinov2.data import make_dataset +from dinov2.data.transforms import make_classification_eval_transform +from dinov2.distributed import get_global_rank, get_global_size +from dinov2.eval.metrics import MetricType, build_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.utils import evaluate, extract_features +from dinov2.utils.dtype import as_torch_dtype + + +logger = logging.getLogger("dinov2") + +DEFAULT_MAX_ITER = 1_000 +C_POWER_RANGE = torch.linspace(-6, 5, 45) +_CPU_DEVICE = torch.device("cpu") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--finetune-dataset-str", + dest="finetune_dataset_str", + type=str, + help="Fine-tuning dataset", + ) + parser.add_argument( + "--finetune-on-val", + action="store_true", + help="If there is no finetune dataset, whether to choose the " + "hyperparameters on the val set instead of 10%% of the train dataset", + ) + parser.add_argument( + "--metric-type", + type=MetricType, + choices=list(MetricType), + help="Metric type", + ) + parser.add_argument( + "--train-features-device", + type=str, + help="Device to gather train features (cpu, cuda, cuda:0, etc.), default: %(default)s", + ) + parser.add_argument( + "--train-dtype", + type=str, + help="Data type to convert the train features to (default: %(default)s)", + ) + parser.add_argument( + "--max-train-iters", + type=int, + help="Maximum number of train iterations (default: %(default)s)", + ) + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + finetune_dataset_str=None, + metric_type=MetricType.MEAN_ACCURACY, + train_features_device="cpu", + train_dtype="float64", + max_train_iters=DEFAULT_MAX_ITER, + finetune_on_val=False, + ) + return parser + + +class LogRegModule(nn.Module): + def __init__( + self, + C, + max_iter=DEFAULT_MAX_ITER, + dtype=torch.float64, + device=_CPU_DEVICE, + ): + super().__init__() + self.dtype = dtype + self.device = device + self.estimator = LogisticRegression( + penalty="l2", + C=C, + max_iter=max_iter, + output_type="numpy", + tol=1e-12, + linesearch_max_iter=50, + ) + + def forward(self, samples, targets): + samples_device = samples.device + samples = samples.to(dtype=self.dtype, device=self.device) + if self.device == _CPU_DEVICE: + samples = samples.numpy() + probas = self.estimator.predict_proba(samples) + return {"preds": torch.from_numpy(probas).to(samples_device), "target": targets} + + def fit(self, train_features, train_labels): + train_features = train_features.to(dtype=self.dtype, device=self.device) + train_labels = train_labels.to(dtype=self.dtype, device=self.device) + if self.device == _CPU_DEVICE: + # both cuML and sklearn only work with numpy arrays on CPU + train_features = train_features.numpy() + train_labels = train_labels.numpy() + self.estimator.fit(train_features, train_labels) + + +def evaluate_model(*, logreg_model, logreg_metric, test_data_loader, device): + postprocessors = {"metrics": logreg_model} + metrics = {"metrics": logreg_metric} + return evaluate(nn.Identity(), test_data_loader, postprocessors, metrics, device) + + +def train_for_C(*, C, max_iter, train_features, train_labels, dtype=torch.float64, device=_CPU_DEVICE): + logreg_model = LogRegModule(C, max_iter=max_iter, dtype=dtype, device=device) + logreg_model.fit(train_features, train_labels) + return logreg_model + + +def train_and_evaluate( + *, + C, + max_iter, + train_features, + train_labels, + logreg_metric, + test_data_loader, + train_dtype=torch.float64, + train_features_device, + eval_device, +): + logreg_model = train_for_C( + C=C, + max_iter=max_iter, + train_features=train_features, + train_labels=train_labels, + dtype=train_dtype, + device=train_features_device, + ) + return evaluate_model( + logreg_model=logreg_model, + logreg_metric=logreg_metric, + test_data_loader=test_data_loader, + device=eval_device, + ) + + +def sweep_C_values( + *, + train_features, + train_labels, + test_data_loader, + metric_type, + num_classes, + train_dtype=torch.float64, + train_features_device=_CPU_DEVICE, + max_train_iters=DEFAULT_MAX_ITER, +): + if metric_type == MetricType.PER_CLASS_ACCURACY: + # If we want to output per-class accuracy, we select the hyperparameters with mean per class + metric_type = MetricType.MEAN_PER_CLASS_ACCURACY + logreg_metric = build_metric(metric_type, num_classes=num_classes) + metric_tracker = MetricTracker(logreg_metric, maximize=True) + ALL_C = 10**C_POWER_RANGE + logreg_models = {} + + train_features = train_features.to(dtype=train_dtype, device=train_features_device) + train_labels = train_labels.to(device=train_features_device) + + for i in range(get_global_rank(), len(ALL_C), get_global_size()): + C = ALL_C[i].item() + logger.info( + f"Training for C = {C:.5f}, dtype={train_dtype}, " + f"features: {train_features.shape}, {train_features.dtype}, " + f"labels: {train_labels.shape}, {train_labels.dtype}" + ) + logreg_models[C] = train_for_C( + C=C, + max_iter=max_train_iters, + train_features=train_features, + train_labels=train_labels, + dtype=train_dtype, + device=train_features_device, + ) + + gather_list = [None for _ in range(get_global_size())] + torch.distributed.all_gather_object(gather_list, logreg_models) + + logreg_models_gathered = {} + for logreg_dict in gather_list: + logreg_models_gathered.update(logreg_dict) + + for i in range(len(ALL_C)): + metric_tracker.increment() + C = ALL_C[i].item() + evals = evaluate_model( + logreg_model=logreg_models_gathered[C], + logreg_metric=metric_tracker, + test_data_loader=test_data_loader, + device=torch.cuda.current_device(), + ) + logger.info(f"Trained for C = {C:.5f}, accuracies = {evals}") + + best_stats, which_epoch = metric_tracker.best_metric(return_step=True) + best_stats_100 = {k: 100.0 * v for k, v in best_stats.items()} + if which_epoch["top-1"] == i: + best_C = C + logger.info(f"Sweep best {best_stats_100}, best C = {best_C:.6f}") + + return best_stats, best_C + + +def eval_log_regression( + *, + model, + train_dataset, + val_dataset, + finetune_dataset, + metric_type, + batch_size, + num_workers, + finetune_on_val=False, + train_dtype=torch.float64, + train_features_device=_CPU_DEVICE, + max_train_iters=DEFAULT_MAX_ITER, +): + """ + Implements the "standard" process for log regression evaluation: + The value of C is chosen by training on train_dataset and evaluating on + finetune_dataset. Then, the final model is trained on a concatenation of + train_dataset and finetune_dataset, and is evaluated on val_dataset. + If there is no finetune_dataset, the value of C is the one that yields + the best results on a random 10% subset of the train dataset + """ + + start = time.time() + + train_features, train_labels = extract_features( + model, train_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE) + ) + val_features, val_labels = extract_features( + model, val_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE) + ) + val_data_loader = torch.utils.data.DataLoader( + TensorDataset(val_features, val_labels), + batch_size=batch_size, + drop_last=False, + num_workers=0, + persistent_workers=False, + ) + + if finetune_dataset is None and finetune_on_val: + logger.info("Choosing hyperparameters on the val dataset") + finetune_features, finetune_labels = val_features, val_labels + elif finetune_dataset is None and not finetune_on_val: + logger.info("Choosing hyperparameters on 10% of the train dataset") + torch.manual_seed(0) + indices = torch.randperm(len(train_features), device=train_features.device) + finetune_index = indices[: len(train_features) // 10] + train_index = indices[len(train_features) // 10 :] + finetune_features, finetune_labels = train_features[finetune_index], train_labels[finetune_index] + train_features, train_labels = train_features[train_index], train_labels[train_index] + else: + logger.info("Choosing hyperparameters on the finetune dataset") + finetune_features, finetune_labels = extract_features( + model, finetune_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE) + ) + # release the model - free GPU memory + del model + gc.collect() + torch.cuda.empty_cache() + finetune_data_loader = torch.utils.data.DataLoader( + TensorDataset(finetune_features, finetune_labels), + batch_size=batch_size, + drop_last=False, + ) + + if len(train_labels.shape) > 1: + num_classes = train_labels.shape[1] + else: + num_classes = train_labels.max() + 1 + + logger.info("Using cuML for logistic regression") + + best_stats, best_C = sweep_C_values( + train_features=train_features, + train_labels=train_labels, + test_data_loader=finetune_data_loader, + metric_type=metric_type, + num_classes=num_classes, + train_dtype=train_dtype, + train_features_device=train_features_device, + max_train_iters=max_train_iters, + ) + + if not finetune_on_val: + logger.info("Best parameter found, concatenating features") + train_features = torch.cat((train_features, finetune_features)) + train_labels = torch.cat((train_labels, finetune_labels)) + + logger.info("Training final model") + logreg_metric = build_metric(metric_type, num_classes=num_classes) + evals = train_and_evaluate( + C=best_C, + max_iter=max_train_iters, + train_features=train_features, + train_labels=train_labels, + logreg_metric=logreg_metric.clone(), + test_data_loader=val_data_loader, + eval_device=torch.cuda.current_device(), + train_dtype=train_dtype, + train_features_device=train_features_device, + ) + + best_stats = evals[1]["metrics"] + + best_stats["best_C"] = best_C + + logger.info(f"Log regression evaluation done in {int(time.time() - start)}s") + return best_stats + + +def eval_log_regression_with_model( + model, + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + finetune_dataset_str=None, + autocast_dtype=torch.float, + finetune_on_val=False, + metric_type=MetricType.MEAN_ACCURACY, + train_dtype=torch.float64, + train_features_device=_CPU_DEVICE, + max_train_iters=DEFAULT_MAX_ITER, +): + cudnn.benchmark = True + + transform = make_classification_eval_transform(resize_size=224) + target_transform = None + + train_dataset = make_dataset(dataset_str=train_dataset_str, transform=transform, target_transform=target_transform) + val_dataset = make_dataset(dataset_str=val_dataset_str, transform=transform, target_transform=target_transform) + if finetune_dataset_str is not None: + finetune_dataset = make_dataset( + dataset_str=finetune_dataset_str, transform=transform, target_transform=target_transform + ) + else: + finetune_dataset = None + + with torch.cuda.amp.autocast(dtype=autocast_dtype): + results_dict_logreg = eval_log_regression( + model=model, + train_dataset=train_dataset, + val_dataset=val_dataset, + finetune_dataset=finetune_dataset, + metric_type=metric_type, + batch_size=256, + num_workers=0, # 5, + finetune_on_val=finetune_on_val, + train_dtype=train_dtype, + train_features_device=train_features_device, + max_train_iters=max_train_iters, + ) + + results_dict = { + "top-1": results_dict_logreg["top-1"].cpu().numpy() * 100.0, + "top-5": results_dict_logreg.get("top-5", torch.tensor(0.0)).cpu().numpy() * 100.0, + "best_C": results_dict_logreg["best_C"], + } + logger.info( + "\n".join( + [ + "Training of the supervised logistic regression on frozen features completed.\n" + "Top-1 test accuracy: {acc:.1f}".format(acc=results_dict["top-1"]), + "Top-5 test accuracy: {acc:.1f}".format(acc=results_dict["top-5"]), + "obtained for C = {c:.6f}".format(c=results_dict["best_C"]), + ] + ) + ) + + torch.distributed.barrier() + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + eval_log_regression_with_model( + model=model, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + finetune_dataset_str=args.finetune_dataset_str, + autocast_dtype=autocast_dtype, + finetune_on_val=args.finetune_on_val, + metric_type=args.metric_type, + train_dtype=as_torch_dtype(args.train_dtype), + train_features_device=torch.device(args.train_features_device), + max_train_iters=args.max_train_iters, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 logistic regression evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/metrics.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..1f3ccd57582b44c361205ecabb96c57fda4dfbf5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/metrics.py @@ -0,0 +1,119 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +import logging +from typing import Any, Dict, Optional + +import torch +from torch import Tensor +from torchmetrics import Metric, MetricCollection +from torchmetrics.classification import MulticlassAccuracy, MulticlassF1Score, MultilabelF1Score +from torchmetrics.utilities.data import dim_zero_cat, select_topk + + +logger = logging.getLogger("dinov2") + + +class MetricType(Enum): + MEAN_ACCURACY = "mean_accuracy" + MEAN_PER_CLASS_ACCURACY = "mean_per_class_accuracy" + PER_CLASS_ACCURACY = "per_class_accuracy" + IMAGENET_REAL_ACCURACY = "imagenet_real_accuracy" + MEAN_PER_CLASS_MULTICLASS_F1 = "mean_per_class_multiclass_f1" + MEAN_PER_CLASS_MULTILABEL_F1 = "mean_per_class_multilabel_f1" + + @property + def accuracy_averaging(self): + return getattr(AccuracyAveraging, self.name, None) + + def __str__(self): + return self.value + + +class AccuracyAveraging(Enum): + MEAN_ACCURACY = "micro" + MEAN_PER_CLASS_ACCURACY = "macro" + PER_CLASS_ACCURACY = "none" + + def __str__(self): + return self.value + + +def build_metric(metric_type: MetricType, *, num_classes: int, ks: Optional[tuple] = None): + if metric_type.accuracy_averaging is not None: + return build_topk_accuracy_metric( + average_type=metric_type.accuracy_averaging, + num_classes=num_classes, + ks=(1, 5) if ks is None else ks, + ) + elif metric_type == MetricType.IMAGENET_REAL_ACCURACY: + return build_topk_imagenet_real_accuracy_metric( + num_classes=num_classes, + ks=(1, 5) if ks is None else ks, + ) + elif metric_type == MetricType.MEAN_PER_CLASS_MULTILABEL_F1: + return MetricCollection({"top-1": MultilabelF1Score(num_labels=int(num_classes), average="macro")}) + elif metric_type == MetricType.MEAN_PER_CLASS_MULTICLASS_F1: + return MetricCollection({"top-1": MulticlassF1Score(num_classes=int(num_classes), average="macro")}) + + raise ValueError(f"Unknown metric type {metric_type}") + + +def build_topk_accuracy_metric(average_type: AccuracyAveraging, num_classes: int, ks: tuple = (1, 5)): + metrics: Dict[str, Metric] = { + f"top-{k}": MulticlassAccuracy(top_k=k, num_classes=int(num_classes), average=average_type.value) for k in ks + } + return MetricCollection(metrics) + + +def build_topk_imagenet_real_accuracy_metric(num_classes: int, ks: tuple = (1, 5)): + metrics: Dict[str, Metric] = {f"top-{k}": ImageNetReaLAccuracy(top_k=k, num_classes=int(num_classes)) for k in ks} + return MetricCollection(metrics) + + +class ImageNetReaLAccuracy(Metric): + is_differentiable: bool = False + higher_is_better: Optional[bool] = None + full_state_update: bool = False + + def __init__( + self, + num_classes: int, + top_k: int = 1, + **kwargs: Any, + ) -> None: + super().__init__(**kwargs) + self.num_classes = num_classes + self.top_k = top_k + self.add_state("tp", [], dist_reduce_fx="cat") + + def update(self, preds: Tensor, target: Tensor) -> None: # type: ignore + # preds [B, D] + # target [B, A] + # preds_oh [B, D] with 0 and 1 + # select top K highest probabilities, use one hot representation + preds_oh = select_topk(preds, self.top_k) + # target_oh [B, D + 1] with 0 and 1 + target_oh = torch.zeros((preds_oh.shape[0], preds_oh.shape[1] + 1), device=target.device, dtype=torch.int32) + target = target.long() + # for undefined targets (-1) use a fake value `num_classes` + target[target == -1] = self.num_classes + # fill targets, use one hot representation + target_oh.scatter_(1, target, 1) + # target_oh [B, D] (remove the fake target at index `num_classes`) + target_oh = target_oh[:, :-1] + # tp [B] with 0 and 1 + tp = (preds_oh * target_oh == 1).sum(dim=1) + # at least one match between prediction and target + tp.clip_(max=1) + # ignore instances where no targets are defined + mask = target_oh.sum(dim=1) > 0 + tp = tp[mask] + self.tp.append(tp) # type: ignore + + def compute(self) -> Tensor: + tp = dim_zero_cat(self.tp) # type: ignore + return tp.float().mean() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/hooks/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/hooks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ff54ac7a8f0585bc96efcafb8df1cbdf40d46e79 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/hooks/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .optimizer import DistOptimizerHook diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/hooks/optimizer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/hooks/optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..88eebd0fefa5051a121e60ba6a26560aa2f0d309 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/hooks/optimizer.py @@ -0,0 +1,40 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +try: + import apex +except ImportError: + print("apex is not installed") + +from mmcv.runner import OptimizerHook, HOOKS + + +@HOOKS.register_module() +class DistOptimizerHook(OptimizerHook): + """Optimizer hook for distributed training.""" + + def __init__(self, update_interval=1, grad_clip=None, coalesce=True, bucket_size_mb=-1, use_fp16=False): + self.grad_clip = grad_clip + self.coalesce = coalesce + self.bucket_size_mb = bucket_size_mb + self.update_interval = update_interval + self.use_fp16 = use_fp16 + + def before_run(self, runner): + runner.optimizer.zero_grad() + + def after_train_iter(self, runner): + runner.outputs["loss"] /= self.update_interval + if self.use_fp16: + # runner.outputs['loss'].backward() + with apex.amp.scale_loss(runner.outputs["loss"], runner.optimizer) as scaled_loss: + scaled_loss.backward() + else: + runner.outputs["loss"].backward() + if self.every_n_iters(runner, self.update_interval): + if self.grad_clip is not None: + self.clip_grads(runner.model.parameters()) + runner.optimizer.step() + runner.optimizer.zero_grad() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d104079b7d11715c2ab1406880ed5eb0e4072fdc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .backbones import * # noqa: F403 +from .decode_heads import * # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/backbones/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/backbones/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1fa5f656694c330041eb5afd991f8b0f15f5f61c --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/backbones/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .vision_transformer import DinoVisionTransformer diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/backbones/vision_transformer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/backbones/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..5ead53353b2e3fc6966547b1e7f028a15de68873 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/backbones/vision_transformer.py @@ -0,0 +1,19 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.runner import BaseModule +from mmseg.models.builder import BACKBONES + + +@BACKBONES.register_module() +class DinoVisionTransformer(BaseModule): + """Vision Transformer.""" + + def __init__( + self, + *args, + **kwargs, + ): + super().__init__() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/decode_heads/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/decode_heads/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8c34d2e6c0c920eb460afdc6b1409303cb8d6e7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/decode_heads/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .linear_head import BNHead diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/decode_heads/linear_head.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/decode_heads/linear_head.py new file mode 100644 index 0000000000000000000000000000000000000000..be48111767785a1c653ac322599dd047d86d1fc2 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/models/decode_heads/linear_head.py @@ -0,0 +1,90 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from mmseg.models.builder import HEADS +from mmseg.models.decode_heads.decode_head import BaseDecodeHead +from mmseg.ops import resize + + +@HEADS.register_module() +class BNHead(BaseDecodeHead): + """Just a batchnorm.""" + + def __init__(self, resize_factors=None, **kwargs): + super().__init__(**kwargs) + assert self.in_channels == self.channels + self.bn = nn.SyncBatchNorm(self.in_channels) + self.resize_factors = resize_factors + + def _forward_feature(self, inputs): + """Forward function for feature maps before classifying each pixel with + ``self.cls_seg`` fc. + + Args: + inputs (list[Tensor]): List of multi-level img features. + + Returns: + feats (Tensor): A tensor of shape (batch_size, self.channels, + H, W) which is feature map for last layer of decoder head. + """ + # print("inputs", [i.shape for i in inputs]) + x = self._transform_inputs(inputs) + # print("x", x.shape) + feats = self.bn(x) + # print("feats", feats.shape) + return feats + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + Tensor: The transformed inputs + """ + + if self.input_transform == "resize_concat": + # accept lists (for cls token) + input_list = [] + for x in inputs: + if isinstance(x, list): + input_list.extend(x) + else: + input_list.append(x) + inputs = input_list + # an image descriptor can be a local descriptor with resolution 1x1 + for i, x in enumerate(inputs): + if len(x.shape) == 2: + inputs[i] = x[:, :, None, None] + # select indices + inputs = [inputs[i] for i in self.in_index] + # Resizing shenanigans + # print("before", *(x.shape for x in inputs)) + if self.resize_factors is not None: + assert len(self.resize_factors) == len(inputs), (len(self.resize_factors), len(inputs)) + inputs = [ + resize(input=x, scale_factor=f, mode="bilinear" if f >= 1 else "area") + for x, f in zip(inputs, self.resize_factors) + ] + # print("after", *(x.shape for x in inputs)) + upsampled_inputs = [ + resize(input=x, size=inputs[0].shape[2:], mode="bilinear", align_corners=self.align_corners) + for x in inputs + ] + inputs = torch.cat(upsampled_inputs, dim=1) + elif self.input_transform == "multiple_select": + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def forward(self, inputs): + """Forward function.""" + output = self._forward_feature(inputs) + output = self.cls_seg(output) + return output diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/utils/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/utils/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/utils/colormaps.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/utils/colormaps.py new file mode 100644 index 0000000000000000000000000000000000000000..2355e5f15b15d385e99d4c258d23ba7fc402a944 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation/utils/colormaps.py @@ -0,0 +1,362 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +ADE20K_COLORMAP = [ + (0, 0, 0), + (120, 120, 120), + (180, 120, 120), + (6, 230, 230), + (80, 50, 50), + (4, 200, 3), + (120, 120, 80), + (140, 140, 140), + (204, 5, 255), + (230, 230, 230), + (4, 250, 7), + (224, 5, 255), + (235, 255, 7), + (150, 5, 61), + (120, 120, 70), + (8, 255, 51), + (255, 6, 82), + (143, 255, 140), + (204, 255, 4), + (255, 51, 7), + (204, 70, 3), + (0, 102, 200), + (61, 230, 250), + (255, 6, 51), + (11, 102, 255), + (255, 7, 71), + (255, 9, 224), + (9, 7, 230), + (220, 220, 220), + (255, 9, 92), + (112, 9, 255), + (8, 255, 214), + (7, 255, 224), + (255, 184, 6), + (10, 255, 71), + (255, 41, 10), + (7, 255, 255), + (224, 255, 8), + (102, 8, 255), + (255, 61, 6), + (255, 194, 7), + (255, 122, 8), + (0, 255, 20), + (255, 8, 41), + (255, 5, 153), + (6, 51, 255), + (235, 12, 255), + (160, 150, 20), + (0, 163, 255), + (140, 140, 140), + (250, 10, 15), + (20, 255, 0), + (31, 255, 0), + (255, 31, 0), + (255, 224, 0), + (153, 255, 0), + (0, 0, 255), + (255, 71, 0), + (0, 235, 255), + (0, 173, 255), + (31, 0, 255), + (11, 200, 200), + (255, 82, 0), + (0, 255, 245), + (0, 61, 255), + (0, 255, 112), + (0, 255, 133), + (255, 0, 0), + (255, 163, 0), + (255, 102, 0), + (194, 255, 0), + (0, 143, 255), + (51, 255, 0), + (0, 82, 255), + (0, 255, 41), + (0, 255, 173), + (10, 0, 255), + (173, 255, 0), + (0, 255, 153), + (255, 92, 0), + (255, 0, 255), + (255, 0, 245), + (255, 0, 102), + (255, 173, 0), + (255, 0, 20), + (255, 184, 184), + (0, 31, 255), + (0, 255, 61), + (0, 71, 255), + (255, 0, 204), + (0, 255, 194), + (0, 255, 82), + (0, 10, 255), + (0, 112, 255), + (51, 0, 255), + (0, 194, 255), + (0, 122, 255), + (0, 255, 163), + (255, 153, 0), + (0, 255, 10), + (255, 112, 0), + (143, 255, 0), + (82, 0, 255), + (163, 255, 0), + (255, 235, 0), + (8, 184, 170), + (133, 0, 255), + (0, 255, 92), + (184, 0, 255), + (255, 0, 31), + (0, 184, 255), + (0, 214, 255), + (255, 0, 112), + (92, 255, 0), + (0, 224, 255), + (112, 224, 255), + (70, 184, 160), + (163, 0, 255), + (153, 0, 255), + (71, 255, 0), + (255, 0, 163), + (255, 204, 0), + (255, 0, 143), + (0, 255, 235), + (133, 255, 0), + (255, 0, 235), + (245, 0, 255), + (255, 0, 122), + (255, 245, 0), + (10, 190, 212), + (214, 255, 0), + (0, 204, 255), + (20, 0, 255), + (255, 255, 0), + (0, 153, 255), + (0, 41, 255), + (0, 255, 204), + (41, 0, 255), + (41, 255, 0), + (173, 0, 255), + (0, 245, 255), + (71, 0, 255), + (122, 0, 255), + (0, 255, 184), + (0, 92, 255), + (184, 255, 0), + (0, 133, 255), + (255, 214, 0), + (25, 194, 194), + (102, 255, 0), + (92, 0, 255), +] + +ADE20K_CLASS_NAMES = [ + "", + "wall", + "building;edifice", + "sky", + "floor;flooring", + "tree", + "ceiling", + "road;route", + "bed", + "windowpane;window", + "grass", + "cabinet", + "sidewalk;pavement", + "person;individual;someone;somebody;mortal;soul", + "earth;ground", + "door;double;door", + "table", + "mountain;mount", + "plant;flora;plant;life", + "curtain;drape;drapery;mantle;pall", + "chair", + "car;auto;automobile;machine;motorcar", + "water", + "painting;picture", + "sofa;couch;lounge", + "shelf", + "house", + "sea", + "mirror", + "rug;carpet;carpeting", + "field", + "armchair", + "seat", + "fence;fencing", + "desk", + "rock;stone", + "wardrobe;closet;press", + "lamp", + "bathtub;bathing;tub;bath;tub", + "railing;rail", + "cushion", + "base;pedestal;stand", + "box", + "column;pillar", + "signboard;sign", + "chest;of;drawers;chest;bureau;dresser", + "counter", + "sand", + "sink", + "skyscraper", + "fireplace;hearth;open;fireplace", + "refrigerator;icebox", + "grandstand;covered;stand", + "path", + "stairs;steps", + "runway", + "case;display;case;showcase;vitrine", + "pool;table;billiard;table;snooker;table", + "pillow", + "screen;door;screen", + "stairway;staircase", + "river", + "bridge;span", + "bookcase", + "blind;screen", + "coffee;table;cocktail;table", + "toilet;can;commode;crapper;pot;potty;stool;throne", + "flower", + "book", + "hill", + "bench", + "countertop", + "stove;kitchen;stove;range;kitchen;range;cooking;stove", + "palm;palm;tree", + "kitchen;island", + "computer;computing;machine;computing;device;data;processor;electronic;computer;information;processing;system", + "swivel;chair", + "boat", + "bar", + "arcade;machine", + "hovel;hut;hutch;shack;shanty", + "bus;autobus;coach;charabanc;double-decker;jitney;motorbus;motorcoach;omnibus;passenger;vehicle", + "towel", + "light;light;source", + "truck;motortruck", + "tower", + "chandelier;pendant;pendent", + "awning;sunshade;sunblind", + "streetlight;street;lamp", + "booth;cubicle;stall;kiosk", + "television;television;receiver;television;set;tv;tv;set;idiot;box;boob;tube;telly;goggle;box", + "airplane;aeroplane;plane", + "dirt;track", + "apparel;wearing;apparel;dress;clothes", + "pole", + "land;ground;soil", + "bannister;banister;balustrade;balusters;handrail", + "escalator;moving;staircase;moving;stairway", + "ottoman;pouf;pouffe;puff;hassock", + "bottle", + "buffet;counter;sideboard", + "poster;posting;placard;notice;bill;card", + "stage", + "van", + "ship", + "fountain", + "conveyer;belt;conveyor;belt;conveyer;conveyor;transporter", + "canopy", + "washer;automatic;washer;washing;machine", + "plaything;toy", + "swimming;pool;swimming;bath;natatorium", + "stool", + "barrel;cask", + "basket;handbasket", + "waterfall;falls", + "tent;collapsible;shelter", + "bag", + "minibike;motorbike", + "cradle", + "oven", + "ball", + "food;solid;food", + "step;stair", + "tank;storage;tank", + "trade;name;brand;name;brand;marque", + "microwave;microwave;oven", + "pot;flowerpot", + "animal;animate;being;beast;brute;creature;fauna", + "bicycle;bike;wheel;cycle", + "lake", + "dishwasher;dish;washer;dishwashing;machine", + "screen;silver;screen;projection;screen", + "blanket;cover", + "sculpture", + "hood;exhaust;hood", + "sconce", + "vase", + "traffic;light;traffic;signal;stoplight", + "tray", + "ashcan;trash;can;garbage;can;wastebin;ash;bin;ash-bin;ashbin;dustbin;trash;barrel;trash;bin", + "fan", + "pier;wharf;wharfage;dock", + "crt;screen", + "plate", + "monitor;monitoring;device", + "bulletin;board;notice;board", + "shower", + "radiator", + "glass;drinking;glass", + "clock", + "flag", +] + + +VOC2012_COLORMAP = [ + (0, 0, 0), + (128, 0, 0), + (0, 128, 0), + (128, 128, 0), + (0, 0, 128), + (128, 0, 128), + (0, 128, 128), + (128, 128, 128), + (64, 0, 0), + (192, 0, 0), + (64, 128, 0), + (192, 128, 0), + (64, 0, 128), + (192, 0, 128), + (64, 128, 128), + (192, 128, 128), + (0, 64, 0), + (128, 64, 0), + (0, 192, 0), + (128, 192, 0), + (0, 64, 128), +] + + +VOC2012_CLASS_NAMES = [ + "", + "aeroplane", + "bicycle", + "bird", + "boat", + "bottle", + "bus", + "car", + "cat", + "chair", + "cow", + "diningtable", + "dog", + "horse", + "motorbike", + "person", + "pottedplant", + "sheep", + "sofa", + "train", + "tvmonitor", +] diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..05bdeb7696c970eba7534380a1645fc016412953 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .core import * # noqa: F403 +from .models import * # noqa: F403 +from .ops import * # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4a09f8636d96236225738ac9da59ddf3328f46e7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmseg.core.evaluation import * # noqa: F403 +from mmseg.core.seg import * # noqa: F403 + +from .anchor import * # noqa: F403 +from .box import * # noqa: F403 +from .utils import * # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fd8403182d5afe5175ea1d3e47a607c89a3fadf5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .point_generator import MlvlPointGenerator # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/builder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..109cdf920e5e98bceea8b60ffaff0bca4d008fef --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/builder.py @@ -0,0 +1,21 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +from mmcv.utils import Registry, build_from_cfg + +PRIOR_GENERATORS = Registry("Generator for anchors and points") + +ANCHOR_GENERATORS = PRIOR_GENERATORS + + +def build_prior_generator(cfg, default_args=None): + return build_from_cfg(cfg, PRIOR_GENERATORS, default_args) + + +def build_anchor_generator(cfg, default_args=None): + warnings.warn("``build_anchor_generator`` would be deprecated soon, please use " "``build_prior_generator`` ") + return build_prior_generator(cfg, default_args=default_args) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..e64a8f6c3276ababce943fe63075f2ac8eb7a7ac --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py @@ -0,0 +1,205 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from torch.nn.modules.utils import _pair + +from .builder import PRIOR_GENERATORS + + +@PRIOR_GENERATORS.register_module() +class MlvlPointGenerator: + """Standard points generator for multi-level (Mlvl) feature maps in 2D + points-based detectors. + + Args: + strides (list[int] | list[tuple[int, int]]): Strides of anchors + in multiple feature levels in order (w, h). + offset (float): The offset of points, the value is normalized with + corresponding stride. Defaults to 0.5. + """ + + def __init__(self, strides, offset=0.5): + self.strides = [_pair(stride) for stride in strides] + self.offset = offset + + @property + def num_levels(self): + """int: number of feature levels that the generator will be applied""" + return len(self.strides) + + @property + def num_base_priors(self): + """list[int]: The number of priors (points) at a point + on the feature grid""" + return [1 for _ in range(len(self.strides))] + + def _meshgrid(self, x, y, row_major=True): + yy, xx = torch.meshgrid(y, x) + if row_major: + # warning .flatten() would cause error in ONNX exporting + # have to use reshape here + return xx.reshape(-1), yy.reshape(-1) + + else: + return yy.reshape(-1), xx.reshape(-1) + + def grid_priors(self, featmap_sizes, dtype=torch.float32, device="cuda", with_stride=False): + """Generate grid points of multiple feature levels. + + Args: + featmap_sizes (list[tuple]): List of feature map sizes in + multiple feature levels, each size arrange as + as (h, w). + dtype (:obj:`dtype`): Dtype of priors. Default: torch.float32. + device (str): The device where the anchors will be put on. + with_stride (bool): Whether to concatenate the stride to + the last dimension of points. + + Return: + list[torch.Tensor]: Points of multiple feature levels. + The sizes of each tensor should be (N, 2) when with stride is + ``False``, where N = width * height, width and height + are the sizes of the corresponding feature level, + and the last dimension 2 represent (coord_x, coord_y), + otherwise the shape should be (N, 4), + and the last dimension 4 represent + (coord_x, coord_y, stride_w, stride_h). + """ + + assert self.num_levels == len(featmap_sizes) + multi_level_priors = [] + for i in range(self.num_levels): + priors = self.single_level_grid_priors( + featmap_sizes[i], level_idx=i, dtype=dtype, device=device, with_stride=with_stride + ) + multi_level_priors.append(priors) + return multi_level_priors + + def single_level_grid_priors(self, featmap_size, level_idx, dtype=torch.float32, device="cuda", with_stride=False): + """Generate grid Points of a single level. + + Note: + This function is usually called by method ``self.grid_priors``. + + Args: + featmap_size (tuple[int]): Size of the feature maps, arrange as + (h, w). + level_idx (int): The index of corresponding feature map level. + dtype (:obj:`dtype`): Dtype of priors. Default: torch.float32. + device (str, optional): The device the tensor will be put on. + Defaults to 'cuda'. + with_stride (bool): Concatenate the stride to the last dimension + of points. + + Return: + Tensor: Points of single feature levels. + The shape of tensor should be (N, 2) when with stride is + ``False``, where N = width * height, width and height + are the sizes of the corresponding feature level, + and the last dimension 2 represent (coord_x, coord_y), + otherwise the shape should be (N, 4), + and the last dimension 4 represent + (coord_x, coord_y, stride_w, stride_h). + """ + feat_h, feat_w = featmap_size + stride_w, stride_h = self.strides[level_idx] + shift_x = (torch.arange(0, feat_w, device=device) + self.offset) * stride_w + # keep featmap_size as Tensor instead of int, so that we + # can convert to ONNX correctly + shift_x = shift_x.to(dtype) + + shift_y = (torch.arange(0, feat_h, device=device) + self.offset) * stride_h + # keep featmap_size as Tensor instead of int, so that we + # can convert to ONNX correctly + shift_y = shift_y.to(dtype) + shift_xx, shift_yy = self._meshgrid(shift_x, shift_y) + if not with_stride: + shifts = torch.stack([shift_xx, shift_yy], dim=-1) + else: + # use `shape[0]` instead of `len(shift_xx)` for ONNX export + stride_w = shift_xx.new_full((shift_xx.shape[0],), stride_w).to(dtype) + stride_h = shift_xx.new_full((shift_yy.shape[0],), stride_h).to(dtype) + shifts = torch.stack([shift_xx, shift_yy, stride_w, stride_h], dim=-1) + all_points = shifts.to(device) + return all_points + + def valid_flags(self, featmap_sizes, pad_shape, device="cuda"): + """Generate valid flags of points of multiple feature levels. + + Args: + featmap_sizes (list(tuple)): List of feature map sizes in + multiple feature levels, each size arrange as + as (h, w). + pad_shape (tuple(int)): The padded shape of the image, + arrange as (h, w). + device (str): The device where the anchors will be put on. + + Return: + list(torch.Tensor): Valid flags of points of multiple levels. + """ + assert self.num_levels == len(featmap_sizes) + multi_level_flags = [] + for i in range(self.num_levels): + point_stride = self.strides[i] + feat_h, feat_w = featmap_sizes[i] + h, w = pad_shape[:2] + valid_feat_h = min(int(np.ceil(h / point_stride[1])), feat_h) + valid_feat_w = min(int(np.ceil(w / point_stride[0])), feat_w) + flags = self.single_level_valid_flags((feat_h, feat_w), (valid_feat_h, valid_feat_w), device=device) + multi_level_flags.append(flags) + return multi_level_flags + + def single_level_valid_flags(self, featmap_size, valid_size, device="cuda"): + """Generate the valid flags of points of a single feature map. + + Args: + featmap_size (tuple[int]): The size of feature maps, arrange as + as (h, w). + valid_size (tuple[int]): The valid size of the feature maps. + The size arrange as as (h, w). + device (str, optional): The device where the flags will be put on. + Defaults to 'cuda'. + + Returns: + torch.Tensor: The valid flags of each points in a single level \ + feature map. + """ + feat_h, feat_w = featmap_size + valid_h, valid_w = valid_size + assert valid_h <= feat_h and valid_w <= feat_w + valid_x = torch.zeros(feat_w, dtype=torch.bool, device=device) + valid_y = torch.zeros(feat_h, dtype=torch.bool, device=device) + valid_x[:valid_w] = 1 + valid_y[:valid_h] = 1 + valid_xx, valid_yy = self._meshgrid(valid_x, valid_y) + valid = valid_xx & valid_yy + return valid + + def sparse_priors(self, prior_idxs, featmap_size, level_idx, dtype=torch.float32, device="cuda"): + """Generate sparse points according to the ``prior_idxs``. + + Args: + prior_idxs (Tensor): The index of corresponding anchors + in the feature map. + featmap_size (tuple[int]): feature map size arrange as (w, h). + level_idx (int): The level index of corresponding feature + map. + dtype (obj:`torch.dtype`): Date type of points. Defaults to + ``torch.float32``. + device (obj:`torch.device`): The device where the points is + located. + Returns: + Tensor: Anchor with shape (N, 2), N should be equal to + the length of ``prior_idxs``. And last dimension + 2 represent (coord_x, coord_y). + """ + height, width = featmap_size + x = (prior_idxs % width + self.offset) * self.strides[level_idx][0] + y = ((prior_idxs // width) % height + self.offset) * self.strides[level_idx][1] + prioris = torch.stack([x, y], 1).to(dtype) + prioris = prioris.to(device) + return prioris diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0f734a816e4da0abb610881273b522ac3a330a1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .builder import * # noqa: F403 +from .samplers import MaskPseudoSampler # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/builder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..26dd1e1f7b30aa330119feaf6cc81a8f84299e5a --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/builder.py @@ -0,0 +1,19 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.utils import Registry, build_from_cfg + +BBOX_SAMPLERS = Registry("bbox_sampler") +BBOX_CODERS = Registry("bbox_coder") + + +def build_sampler(cfg, **default_args): + """Builder of box sampler.""" + return build_from_cfg(cfg, BBOX_SAMPLERS, default_args) + + +def build_bbox_coder(cfg, **default_args): + """Builder of box coder.""" + return build_from_cfg(cfg, BBOX_CODERS, default_args) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d7e98371adf26a9bdf1c903fae3484f699162576 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .mask_pseudo_sampler import MaskPseudoSampler # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..bc6942af70916c0235cf8cdd27ff09b7a290c2b9 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py @@ -0,0 +1,92 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from abc import ABCMeta, abstractmethod + +import torch + +from .sampling_result import SamplingResult + + +class BaseSampler(metaclass=ABCMeta): + """Base class of samplers.""" + + def __init__(self, num, pos_fraction, neg_pos_ub=-1, add_gt_as_proposals=True, **kwargs): + self.num = num + self.pos_fraction = pos_fraction + self.neg_pos_ub = neg_pos_ub + self.add_gt_as_proposals = add_gt_as_proposals + self.pos_sampler = self + self.neg_sampler = self + + @abstractmethod + def _sample_pos(self, assign_result, num_expected, **kwargs): + """Sample positive samples.""" + pass + + @abstractmethod + def _sample_neg(self, assign_result, num_expected, **kwargs): + """Sample negative samples.""" + pass + + def sample(self, assign_result, bboxes, gt_bboxes, gt_labels=None, **kwargs): + """Sample positive and negative bboxes. + + This is a simple implementation of bbox sampling given candidates, + assigning results and ground truth bboxes. + + Args: + assign_result (:obj:`AssignResult`): Bbox assigning results. + bboxes (Tensor): Boxes to be sampled from. + gt_bboxes (Tensor): Ground truth bboxes. + gt_labels (Tensor, optional): Class labels of ground truth bboxes. + + Returns: + :obj:`SamplingResult`: Sampling result. + + Example: + >>> from mmdet.core.bbox import RandomSampler + >>> from mmdet.core.bbox import AssignResult + >>> from mmdet.core.bbox.demodata import ensure_rng, random_boxes + >>> rng = ensure_rng(None) + >>> assign_result = AssignResult.random(rng=rng) + >>> bboxes = random_boxes(assign_result.num_preds, rng=rng) + >>> gt_bboxes = random_boxes(assign_result.num_gts, rng=rng) + >>> gt_labels = None + >>> self = RandomSampler(num=32, pos_fraction=0.5, neg_pos_ub=-1, + >>> add_gt_as_proposals=False) + >>> self = self.sample(assign_result, bboxes, gt_bboxes, gt_labels) + """ + if len(bboxes.shape) < 2: + bboxes = bboxes[None, :] + + bboxes = bboxes[:, :4] + + gt_flags = bboxes.new_zeros((bboxes.shape[0],), dtype=torch.uint8) + if self.add_gt_as_proposals and len(gt_bboxes) > 0: + if gt_labels is None: + raise ValueError("gt_labels must be given when add_gt_as_proposals is True") + bboxes = torch.cat([gt_bboxes, bboxes], dim=0) + assign_result.add_gt_(gt_labels) + gt_ones = bboxes.new_ones(gt_bboxes.shape[0], dtype=torch.uint8) + gt_flags = torch.cat([gt_ones, gt_flags]) + + num_expected_pos = int(self.num * self.pos_fraction) + pos_inds = self.pos_sampler._sample_pos(assign_result, num_expected_pos, bboxes=bboxes, **kwargs) + # We found that sampled indices have duplicated items occasionally. + # (may be a bug of PyTorch) + pos_inds = pos_inds.unique() + num_sampled_pos = pos_inds.numel() + num_expected_neg = self.num - num_sampled_pos + if self.neg_pos_ub >= 0: + _pos = max(1, num_sampled_pos) + neg_upper_bound = int(self.neg_pos_ub * _pos) + if num_expected_neg > neg_upper_bound: + num_expected_neg = neg_upper_bound + neg_inds = self.neg_sampler._sample_neg(assign_result, num_expected_neg, bboxes=bboxes, **kwargs) + neg_inds = neg_inds.unique() + + sampling_result = SamplingResult(pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags) + return sampling_result diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..6fe27c43bc483a7971a2a94802735d7994a93cfc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py @@ -0,0 +1,45 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py + +import torch + +from ..builder import BBOX_SAMPLERS +from .base_sampler import BaseSampler +from .mask_sampling_result import MaskSamplingResult + + +@BBOX_SAMPLERS.register_module() +class MaskPseudoSampler(BaseSampler): + """A pseudo sampler that does not do sampling actually.""" + + def __init__(self, **kwargs): + pass + + def _sample_pos(self, **kwargs): + """Sample positive samples.""" + raise NotImplementedError + + def _sample_neg(self, **kwargs): + """Sample negative samples.""" + raise NotImplementedError + + def sample(self, assign_result, masks, gt_masks, **kwargs): + """Directly returns the positive and negative indices of samples. + + Args: + assign_result (:obj:`AssignResult`): Assigned results + masks (torch.Tensor): Bounding boxes + gt_masks (torch.Tensor): Ground truth boxes + Returns: + :obj:`SamplingResult`: sampler results + """ + pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique() + neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique() + gt_flags = masks.new_zeros(masks.shape[0], dtype=torch.uint8) + sampling_result = MaskSamplingResult(pos_inds, neg_inds, masks, gt_masks, assign_result, gt_flags) + return sampling_result diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py new file mode 100644 index 0000000000000000000000000000000000000000..b07660767c4b02ff9a6eb0e1494ec0f72a70943b --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py @@ -0,0 +1,63 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py + +import torch + +from .sampling_result import SamplingResult + + +class MaskSamplingResult(SamplingResult): + """Mask sampling result.""" + + def __init__(self, pos_inds, neg_inds, masks, gt_masks, assign_result, gt_flags): + self.pos_inds = pos_inds + self.neg_inds = neg_inds + self.pos_masks = masks[pos_inds] + self.neg_masks = masks[neg_inds] + self.pos_is_gt = gt_flags[pos_inds] + + self.num_gts = gt_masks.shape[0] + self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1 + + if gt_masks.numel() == 0: + # hack for index error case + assert self.pos_assigned_gt_inds.numel() == 0 + self.pos_gt_masks = torch.empty_like(gt_masks) + else: + self.pos_gt_masks = gt_masks[self.pos_assigned_gt_inds, :] + + if assign_result.labels is not None: + self.pos_gt_labels = assign_result.labels[pos_inds] + else: + self.pos_gt_labels = None + + @property + def masks(self): + """torch.Tensor: concatenated positive and negative boxes""" + return torch.cat([self.pos_masks, self.neg_masks]) + + def __nice__(self): + data = self.info.copy() + data["pos_masks"] = data.pop("pos_masks").shape + data["neg_masks"] = data.pop("neg_masks").shape + parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())] + body = " " + ",\n ".join(parts) + return "{\n" + body + "\n}" + + @property + def info(self): + """Returns a dictionary of info about the object.""" + return { + "pos_inds": self.pos_inds, + "neg_inds": self.neg_inds, + "pos_masks": self.pos_masks, + "neg_masks": self.neg_masks, + "pos_is_gt": self.pos_is_gt, + "num_gts": self.num_gts, + "pos_assigned_gt_inds": self.pos_assigned_gt_inds, + } diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py new file mode 100644 index 0000000000000000000000000000000000000000..f1bddd50fe439f78bae06d26b30c9843f3a6b0a5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py @@ -0,0 +1,152 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch + + +class SamplingResult: + """Bbox sampling result. + + Example: + >>> # xdoctest: +IGNORE_WANT + >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA + >>> self = SamplingResult.random(rng=10) + >>> print(f'self = {self}') + self = + """ + + def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags): + self.pos_inds = pos_inds + self.neg_inds = neg_inds + self.pos_bboxes = bboxes[pos_inds] + self.neg_bboxes = bboxes[neg_inds] + self.pos_is_gt = gt_flags[pos_inds] + + self.num_gts = gt_bboxes.shape[0] + self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1 + + if gt_bboxes.numel() == 0: + # hack for index error case + assert self.pos_assigned_gt_inds.numel() == 0 + self.pos_gt_bboxes = torch.empty_like(gt_bboxes).view(-1, 4) + else: + if len(gt_bboxes.shape) < 2: + gt_bboxes = gt_bboxes.view(-1, 4) + + self.pos_gt_bboxes = gt_bboxes[self.pos_assigned_gt_inds.long(), :] + + if assign_result.labels is not None: + self.pos_gt_labels = assign_result.labels[pos_inds] + else: + self.pos_gt_labels = None + + @property + def bboxes(self): + """torch.Tensor: concatenated positive and negative boxes""" + return torch.cat([self.pos_bboxes, self.neg_bboxes]) + + def to(self, device): + """Change the device of the data inplace. + + Example: + >>> self = SamplingResult.random() + >>> print(f'self = {self.to(None)}') + >>> # xdoctest: +REQUIRES(--gpu) + >>> print(f'self = {self.to(0)}') + """ + _dict = self.__dict__ + for key, value in _dict.items(): + if isinstance(value, torch.Tensor): + _dict[key] = value.to(device) + return self + + def __nice__(self): + data = self.info.copy() + data["pos_bboxes"] = data.pop("pos_bboxes").shape + data["neg_bboxes"] = data.pop("neg_bboxes").shape + parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())] + body = " " + ",\n ".join(parts) + return "{\n" + body + "\n}" + + @property + def info(self): + """Returns a dictionary of info about the object.""" + return { + "pos_inds": self.pos_inds, + "neg_inds": self.neg_inds, + "pos_bboxes": self.pos_bboxes, + "neg_bboxes": self.neg_bboxes, + "pos_is_gt": self.pos_is_gt, + "num_gts": self.num_gts, + "pos_assigned_gt_inds": self.pos_assigned_gt_inds, + } + + @classmethod + def random(cls, rng=None, **kwargs): + """ + Args: + rng (None | int | numpy.random.RandomState): seed or state. + kwargs (keyword arguments): + - num_preds: number of predicted boxes + - num_gts: number of true boxes + - p_ignore (float): probability of a predicted box assigned to \ + an ignored truth. + - p_assigned (float): probability of a predicted box not being \ + assigned. + - p_use_label (float | bool): with labels or not. + + Returns: + :obj:`SamplingResult`: Randomly generated sampling result. + + Example: + >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA + >>> self = SamplingResult.random() + >>> print(self.__dict__) + """ + from mmdet.core.bbox import demodata + from mmdet.core.bbox.assigners.assign_result import AssignResult + from mmdet.core.bbox.samplers.random_sampler import RandomSampler + + rng = demodata.ensure_rng(rng) + + # make probabalistic? + num = 32 + pos_fraction = 0.5 + neg_pos_ub = -1 + + assign_result = AssignResult.random(rng=rng, **kwargs) + + # Note we could just compute an assignment + bboxes = demodata.random_boxes(assign_result.num_preds, rng=rng) + gt_bboxes = demodata.random_boxes(assign_result.num_gts, rng=rng) + + if rng.rand() > 0.2: + # sometimes algorithms squeeze their data, be robust to that + gt_bboxes = gt_bboxes.squeeze() + bboxes = bboxes.squeeze() + + if assign_result.labels is None: + gt_labels = None + else: + gt_labels = None + + if gt_labels is None: + add_gt_as_proposals = False + else: + add_gt_as_proposals = True # make probabalistic? + + sampler = RandomSampler( + num, pos_fraction, neg_pos_ub=neg_pos_ub, add_gt_as_proposals=add_gt_as_proposals, rng=rng + ) + self = sampler.sample(assign_result, bboxes, gt_bboxes, gt_labels) + return self diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..55c58e3548b907a7d505a2765f803d1177e87a1f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dist_utils import reduce_mean +from .misc import add_prefix, multi_apply diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8de07e4f4f4e41248c217d26d251ddaa81eb30ba --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py @@ -0,0 +1,15 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch.distributed as dist + + +def reduce_mean(tensor): + """ "Obtain the mean of tensor on different GPUs.""" + if not (dist.is_available() and dist.is_initialized()): + return tensor + tensor = tensor.clone() + dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM) + return tensor diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/misc.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..e51773cbcbbc48534f58f36b9758dedf5575c914 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/core/utils/misc.py @@ -0,0 +1,47 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial + + +def multi_apply(func, *args, **kwargs): + """Apply function to a list of arguments. + + Note: + This function applies the ``func`` to multiple inputs and + map the multiple outputs of the ``func`` into different + list. Each list contains the same type of outputs corresponding + to different inputs. + + Args: + func (Function): A function that will be applied to a list of + arguments + + Returns: + tuple(list): A tuple containing multiple list, each list contains \ + a kind of returned results by the function + """ + pfunc = partial(func, **kwargs) if kwargs else func + map_results = map(pfunc, *args) + return tuple(map(list, zip(*map_results))) + + +def add_prefix(inputs, prefix): + """Add prefix for dict. + + Args: + inputs (dict): The input dict with str keys. + prefix (str): The prefix to add. + + Returns: + + dict: The dict with keys updated with ``prefix``. + """ + + outputs = dict() + for name, value in inputs.items(): + outputs[f"{prefix}.{name}"] = value + + return outputs diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3ad9685ec787fa918de1c5df7f5de1ed2d12e433 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .backbones import * # noqa: F403 +from .builder import MASK_ASSIGNERS, MATCH_COST, TRANSFORMER, build_assigner, build_match_cost +from .decode_heads import * # noqa: F403 +from .losses import * # noqa: F403 +from .plugins import * # noqa: F403 +from .segmentors import * # noqa: F403 diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3c2df880b352f74ab41ea08649f19db2c8625f48 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .vit_adapter import ViTAdapter diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..05544f6ac5cb0742fcb83742e5a98293cd949965 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py @@ -0,0 +1,442 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial + +import torch +import torch.nn as nn +import torch.utils.checkpoint as cp + +from ...ops.modules import MSDeformAttn +from .drop_path import DropPath + + +def get_reference_points(spatial_shapes, device): + reference_points_list = [] + for lvl, (H_, W_) in enumerate(spatial_shapes): + ref_y, ref_x = torch.meshgrid( + torch.linspace(0.5, H_ - 0.5, H_, dtype=torch.float32, device=device), + torch.linspace(0.5, W_ - 0.5, W_, dtype=torch.float32, device=device), + ) + ref_y = ref_y.reshape(-1)[None] / H_ + ref_x = ref_x.reshape(-1)[None] / W_ + ref = torch.stack((ref_x, ref_y), -1) + reference_points_list.append(ref) + reference_points = torch.cat(reference_points_list, 1) + reference_points = reference_points[:, :, None] + return reference_points + + +def deform_inputs(x, patch_size): + bs, c, h, w = x.shape + spatial_shapes = torch.as_tensor( + [(h // 8, w // 8), (h // 16, w // 16), (h // 32, w // 32)], dtype=torch.long, device=x.device + ) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + reference_points = get_reference_points([(h // patch_size, w // patch_size)], x.device) + deform_inputs1 = [reference_points, spatial_shapes, level_start_index] + + spatial_shapes = torch.as_tensor([(h // patch_size, w // patch_size)], dtype=torch.long, device=x.device) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + reference_points = get_reference_points([(h // 8, w // 8), (h // 16, w // 16), (h // 32, w // 32)], x.device) + deform_inputs2 = [reference_points, spatial_shapes, level_start_index] + + return deform_inputs1, deform_inputs2 + + +class ConvFFN(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.0): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.dwconv = DWConv(hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x, H, W): + x = self.fc1(x) + x = self.dwconv(x, H, W) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class DWConv(nn.Module): + def __init__(self, dim=768): + super().__init__() + self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim) + + def forward(self, x, H, W): + B, N, C = x.shape + n = N // 21 + x1 = x[:, 0 : 16 * n, :].transpose(1, 2).view(B, C, H * 2, W * 2).contiguous() + x2 = x[:, 16 * n : 20 * n, :].transpose(1, 2).view(B, C, H, W).contiguous() + x3 = x[:, 20 * n :, :].transpose(1, 2).view(B, C, H // 2, W // 2).contiguous() + x1 = self.dwconv(x1).flatten(2).transpose(1, 2) + x2 = self.dwconv(x2).flatten(2).transpose(1, 2) + x3 = self.dwconv(x3).flatten(2).transpose(1, 2) + x = torch.cat([x1, x2, x3], dim=1) + return x + + +class Extractor(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + n_levels=1, + deform_ratio=1.0, + with_cffn=True, + cffn_ratio=0.25, + drop=0.0, + drop_path=0.0, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + with_cp=False, + ): + super().__init__() + self.query_norm = norm_layer(dim) + self.feat_norm = norm_layer(dim) + self.attn = MSDeformAttn( + d_model=dim, n_levels=n_levels, n_heads=num_heads, n_points=n_points, ratio=deform_ratio + ) + self.with_cffn = with_cffn + self.with_cp = with_cp + if with_cffn: + self.ffn = ConvFFN(in_features=dim, hidden_features=int(dim * cffn_ratio), drop=drop) + self.ffn_norm = norm_layer(dim) + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + def forward(self, query, reference_points, feat, spatial_shapes, level_start_index, H, W): + def _inner_forward(query, feat): + + attn = self.attn( + self.query_norm(query), reference_points, self.feat_norm(feat), spatial_shapes, level_start_index, None + ) + query = query + attn + + if self.with_cffn: + query = query + self.drop_path(self.ffn(self.ffn_norm(query), H, W)) + return query + + if self.with_cp and query.requires_grad: + query = cp.checkpoint(_inner_forward, query, feat) + else: + query = _inner_forward(query, feat) + + return query + + +class Injector(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + n_levels=1, + deform_ratio=1.0, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + init_values=0.0, + with_cp=False, + ): + super().__init__() + self.with_cp = with_cp + self.query_norm = norm_layer(dim) + self.feat_norm = norm_layer(dim) + self.attn = MSDeformAttn( + d_model=dim, n_levels=n_levels, n_heads=num_heads, n_points=n_points, ratio=deform_ratio + ) + self.gamma = nn.Parameter(init_values * torch.ones((dim)), requires_grad=True) + + def forward(self, query, reference_points, feat, spatial_shapes, level_start_index): + def _inner_forward(query, feat): + + attn = self.attn( + self.query_norm(query), reference_points, self.feat_norm(feat), spatial_shapes, level_start_index, None + ) + return query + self.gamma * attn + + if self.with_cp and query.requires_grad: + query = cp.checkpoint(_inner_forward, query, feat) + else: + query = _inner_forward(query, feat) + + return query + + +class InteractionBlock(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + drop=0.0, + drop_path=0.0, + with_cffn=True, + cffn_ratio=0.25, + init_values=0.0, + deform_ratio=1.0, + extra_extractor=False, + with_cp=False, + ): + super().__init__() + + self.injector = Injector( + dim=dim, + n_levels=3, + num_heads=num_heads, + init_values=init_values, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cp=with_cp, + ) + self.extractor = Extractor( + dim=dim, + n_levels=1, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + if extra_extractor: + self.extra_extractors = nn.Sequential( + *[ + Extractor( + dim=dim, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + deform_ratio=deform_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + for _ in range(2) + ] + ) + else: + self.extra_extractors = None + + def forward(self, x, c, blocks, deform_inputs1, deform_inputs2, H_c, W_c, H_toks, W_toks): + x = self.injector( + query=x, + reference_points=deform_inputs1[0], + feat=c, + spatial_shapes=deform_inputs1[1], + level_start_index=deform_inputs1[2], + ) + for idx, blk in enumerate(blocks): + x = blk(x, H_toks, W_toks) + c = self.extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + if self.extra_extractors is not None: + for extractor in self.extra_extractors: + c = extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + return x, c + + +class InteractionBlockWithCls(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + drop=0.0, + drop_path=0.0, + with_cffn=True, + cffn_ratio=0.25, + init_values=0.0, + deform_ratio=1.0, + extra_extractor=False, + with_cp=False, + ): + super().__init__() + + self.injector = Injector( + dim=dim, + n_levels=3, + num_heads=num_heads, + init_values=init_values, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cp=with_cp, + ) + self.extractor = Extractor( + dim=dim, + n_levels=1, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + if extra_extractor: + self.extra_extractors = nn.Sequential( + *[ + Extractor( + dim=dim, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + deform_ratio=deform_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + for _ in range(2) + ] + ) + else: + self.extra_extractors = None + + def forward(self, x, c, cls, blocks, deform_inputs1, deform_inputs2, H_c, W_c, H_toks, W_toks): + x = self.injector( + query=x, + reference_points=deform_inputs1[0], + feat=c, + spatial_shapes=deform_inputs1[1], + level_start_index=deform_inputs1[2], + ) + x = torch.cat((cls, x), dim=1) + for idx, blk in enumerate(blocks): + x = blk(x, H_toks, W_toks) + cls, x = ( + x[ + :, + :1, + ], + x[ + :, + 1:, + ], + ) + c = self.extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + if self.extra_extractors is not None: + for extractor in self.extra_extractors: + c = extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + return x, c, cls + + +class SpatialPriorModule(nn.Module): + def __init__(self, inplanes=64, embed_dim=384, with_cp=False): + super().__init__() + self.with_cp = with_cp + + self.stem = nn.Sequential( + *[ + nn.Conv2d(3, inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(inplanes), + nn.ReLU(inplace=True), + nn.Conv2d(inplanes, inplanes, kernel_size=3, stride=1, padding=1, bias=False), + nn.SyncBatchNorm(inplanes), + nn.ReLU(inplace=True), + nn.Conv2d(inplanes, inplanes, kernel_size=3, stride=1, padding=1, bias=False), + nn.SyncBatchNorm(inplanes), + nn.ReLU(inplace=True), + nn.MaxPool2d(kernel_size=3, stride=2, padding=1), + ] + ) + self.conv2 = nn.Sequential( + *[ + nn.Conv2d(inplanes, 2 * inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(2 * inplanes), + nn.ReLU(inplace=True), + ] + ) + self.conv3 = nn.Sequential( + *[ + nn.Conv2d(2 * inplanes, 4 * inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(4 * inplanes), + nn.ReLU(inplace=True), + ] + ) + self.conv4 = nn.Sequential( + *[ + nn.Conv2d(4 * inplanes, 4 * inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(4 * inplanes), + nn.ReLU(inplace=True), + ] + ) + self.fc1 = nn.Conv2d(inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + self.fc2 = nn.Conv2d(2 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + self.fc3 = nn.Conv2d(4 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + self.fc4 = nn.Conv2d(4 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + + def forward(self, x): + def _inner_forward(x): + c1 = self.stem(x) + c2 = self.conv2(c1) + c3 = self.conv3(c2) + c4 = self.conv4(c3) + c1 = self.fc1(c1) + c2 = self.fc2(c2) + c3 = self.fc3(c3) + c4 = self.fc4(c4) + + bs, dim, _, _ = c1.shape + # c1 = c1.view(bs, dim, -1).transpose(1, 2) # 4s + c2 = c2.view(bs, dim, -1).transpose(1, 2) # 8s + c3 = c3.view(bs, dim, -1).transpose(1, 2) # 16s + c4 = c4.view(bs, dim, -1).transpose(1, 2) # 32s + + return c1, c2, c3, c4 + + if self.with_cp and x.requires_grad: + outs = cp.checkpoint(_inner_forward, x) + else: + outs = _inner_forward(x) + return outs diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py new file mode 100644 index 0000000000000000000000000000000000000000..e5290ebc837144c4d84e06bff0e2274f84902b56 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py @@ -0,0 +1,32 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py + +from torch import nn + + +def drop_path(x, drop_prob: float = 0.0, training: bool = False): + if drop_prob == 0.0 or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0: + random_tensor.div_(keep_prob) + return x * random_tensor + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).""" + + def __init__(self, drop_prob: float = 0.0): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/vit.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/vit.py new file mode 100644 index 0000000000000000000000000000000000000000..8235ead9dcb163efd614c462bbfc5fe130f13c5d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/vit.py @@ -0,0 +1,552 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +"""Vision Transformer (ViT) in PyTorch. + +A PyTorch implement of Vision Transformers as described in: + +'An Image Is Worth 16 x 16 Words: Transformers for Image Recognition at Scale' + - https://arxiv.org/abs/2010.11929 + +`How to train your ViT? Data, Augmentation, and Regularization in Vision Transformers` + - https://arxiv.org/abs/2106.10270 + +The official jax code is released and available at https://github.com/google-research/vision_transformer + +DeiT model defs and weights from https://github.com/facebookresearch/deit, +paper `DeiT: Data-efficient Image Transformers` - https://arxiv.org/abs/2012.12877 + +Acknowledgments: +* The paper authors for releasing code and weights, thanks! +* I fixed my class token impl based on Phil Wang's https://github.com/lucidrains/vit-pytorch ... check it out +for some einops/einsum fun +* Simple transformer style inspired by Andrej Karpathy's https://github.com/karpathy/minGPT +* Bert reference code checks against Huggingface Transformers and Tensorflow Bert + +Hacked together by / Copyright 2021 Ross Wightman +""" +import logging +import math +from functools import partial +from itertools import repeat +from typing import Callable, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as cp +from mmcv.runner import BaseModule, load_checkpoint +from mmseg.ops import resize +from mmseg.utils import get_root_logger +from torch import Tensor + +from .drop_path import DropPath + + +def to_2tuple(x): + return tuple(repeat(x, 2)) + + +class Mlp(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = nn.GELU, + drop: float = 0.0, + bias: bool = True, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features, bias=bias) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features, bias=bias) + self.drop = nn.Dropout(drop) + + def forward(self, x: Tensor) -> Tensor: + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class SwiGLUFFN(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = None, + drop: float = 0.0, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + swiglu_hidden_features = int(2 * hidden_features / 3) + align_as = 8 + swiglu_hidden_features = (swiglu_hidden_features + align_as - 1) // align_as * align_as + self.w1 = nn.Linear(in_features, swiglu_hidden_features) + self.w2 = nn.Linear(in_features, swiglu_hidden_features) + self.w3 = nn.Linear(swiglu_hidden_features, out_features) + + def forward(self, x: Tensor) -> Tensor: + x1 = self.w1(x) + x2 = self.w2(x) + hidden = F.silu(x1) * x2 + return self.w3(hidden) + + +class PatchEmbed(nn.Module): + """2D Image to Patch Embedding.""" + + def __init__( + self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, norm_layer=None, flatten=True, bias=True + ): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + self.img_size = img_size + self.patch_size = patch_size + self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) + self.num_patches = self.grid_size[0] * self.grid_size[1] + self.flatten = flatten + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias) + self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity() + + def forward(self, x): + x = self.proj(x) + _, _, H, W = x.shape + if self.flatten: + x = x.flatten(2).transpose(1, 2) # BCHW -> BNC + x = self.norm(x) + return x, H, W + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x, H, W): + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) + q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) + + attn = (q @ k.transpose(-2, -1)) * self.scale + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, C) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +class MemEffAttention(nn.Module): + def __init__( + self, + dim: int, + num_heads: int = 8, + qkv_bias: bool = False, + attn_drop: float = 0.0, + proj_drop: float = 0.0, + ) -> None: + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x: Tensor, H, W) -> Tensor: + from xformers.ops import memory_efficient_attention, unbind + + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads) + + q, k, v = unbind(qkv, 2) + + x = memory_efficient_attention(q, k, v) + x = x.reshape([B, N, C]) + + x = self.proj(x) + x = self.proj_drop(x) + return x + + +def window_partition(x, window_size): + """ + Args: + x: (B, H, W, C) + window_size (int): window size + Returns: + windows: (num_windows*B, window_size, window_size, C) + """ + B, H, W, C = x.shape + x = x.view(B, H // window_size, window_size, W // window_size, window_size, C) + windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C) + return windows + + +def window_reverse(windows, window_size, H, W): + """ + Args: + windows: (num_windows*B, window_size, window_size, C) + window_size (int): Window size + H (int): Height of image + W (int): Width of image + Returns: + x: (B, H, W, C) + """ + B = int(windows.shape[0] / (H * W / window_size / window_size)) + x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1) + x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1) + return x + + +class WindowedAttention(nn.Module): + def __init__( + self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0, window_size=14, pad_mode="constant" + ): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + self.window_size = window_size + self.pad_mode = pad_mode + + def forward(self, x, H, W): + B, N, C = x.shape + N_ = self.window_size * self.window_size + H_ = math.ceil(H / self.window_size) * self.window_size + W_ = math.ceil(W / self.window_size) * self.window_size + + qkv = self.qkv(x) # [B, N, C] + qkv = qkv.transpose(1, 2).reshape(B, C * 3, H, W) # [B, C, H, W] + qkv = F.pad(qkv, [0, W_ - W, 0, H_ - H], mode=self.pad_mode) + + qkv = F.unfold( + qkv, kernel_size=(self.window_size, self.window_size), stride=(self.window_size, self.window_size) + ) + B, C_kw_kw, L = qkv.shape # L - the num of windows + qkv = qkv.reshape(B, C * 3, N_, L).permute(0, 3, 2, 1) # [B, L, N_, C] + qkv = qkv.reshape(B, L, N_, 3, self.num_heads, C // self.num_heads).permute(3, 0, 1, 4, 2, 5) + q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) + + # q,k,v [B, L, num_head, N_, C/num_head] + attn = (q @ k.transpose(-2, -1)) * self.scale # [B, L, num_head, N_, N_] + # if self.mask: + # attn = attn * mask + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) # [B, L, num_head, N_, N_] + # attn @ v = [B, L, num_head, N_, C/num_head] + x = (attn @ v).permute(0, 2, 4, 3, 1).reshape(B, C_kw_kw // 3, L) + + x = F.fold( + x, + output_size=(H_, W_), + kernel_size=(self.window_size, self.window_size), + stride=(self.window_size, self.window_size), + ) # [B, C, H_, W_] + x = x[:, :, :H, :W].reshape(B, C, N).transpose(-1, -2) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +# class WindowedAttention(nn.Module): +# def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0., window_size=14, pad_mode="constant"): +# super().__init__() +# self.num_heads = num_heads +# head_dim = dim // num_heads +# self.scale = head_dim ** -0.5 +# +# self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) +# self.attn_drop = nn.Dropout(attn_drop) +# self.proj = nn.Linear(dim, dim) +# self.proj_drop = nn.Dropout(proj_drop) +# self.window_size = window_size +# self.pad_mode = pad_mode +# +# def forward(self, x, H, W): +# B, N, C = x.shape +# +# N_ = self.window_size * self.window_size +# H_ = math.ceil(H / self.window_size) * self.window_size +# W_ = math.ceil(W / self.window_size) * self.window_size +# x = x.view(B, H, W, C) +# x = F.pad(x, [0, 0, 0, W_ - W, 0, H_- H], mode=self.pad_mode) +# +# x = window_partition(x, window_size=self.window_size)# nW*B, window_size, window_size, C +# x = x.view(-1, N_, C) +# +# qkv = self.qkv(x).view(-1, N_, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) +# q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) +# attn = (q @ k.transpose(-2, -1)) * self.scale # [B, L, num_head, N_, N_] +# attn = attn.softmax(dim=-1) +# attn = self.attn_drop(attn) # [B, L, num_head, N_, N_] +# x = (attn @ v).transpose(1, 2).reshape(-1, self.window_size, self.window_size, C) +# +# x = window_reverse(x, self.window_size, H_, W_) +# x = x[:, :H, :W, :].reshape(B, N, C).contiguous() +# x = self.proj(x) +# x = self.proj_drop(x) +# return x + + +class Block(nn.Module): + def __init__( + self, + dim, + num_heads, + mlp_ratio=4.0, + qkv_bias=False, + drop=0.0, + attn_drop=0.0, + drop_path=0.0, + act_layer=nn.GELU, + norm_layer=nn.LayerNorm, + windowed=False, + window_size=14, + pad_mode="constant", + layer_scale=False, + with_cp=False, + ffn_layer=Mlp, + memeff=False, + ): + super().__init__() + self.with_cp = with_cp + self.norm1 = norm_layer(dim) + if windowed: + self.attn = WindowedAttention( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + attn_drop=attn_drop, + proj_drop=drop, + window_size=window_size, + pad_mode=pad_mode, + ) + elif memeff: + self.attn = MemEffAttention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop + ) + else: + self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop) + # 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.0 else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = ffn_layer(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + self.layer_scale = layer_scale + if layer_scale: + self.gamma1 = nn.Parameter(torch.ones((dim)), requires_grad=True) + self.gamma2 = nn.Parameter(torch.ones((dim)), requires_grad=True) + + def forward(self, x, H, W): + def _inner_forward(x): + if self.layer_scale: + x = x + self.drop_path(self.gamma1 * self.attn(self.norm1(x), H, W)) + x = x + self.drop_path(self.gamma2 * self.mlp(self.norm2(x))) + else: + x = x + self.drop_path(self.attn(self.norm1(x), H, W)) + x = x + self.drop_path(self.mlp(self.norm2(x))) + return x + + if self.with_cp and x.requires_grad: + x = cp.checkpoint(_inner_forward, x) + else: + x = _inner_forward(x) + + return x + + +class TIMMVisionTransformer(BaseModule): + """Vision Transformer. + + A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale` + - https://arxiv.org/abs/2010.11929 + + Includes distillation token & head support for `DeiT: Data-efficient Image Transformers` + - https://arxiv.org/abs/2012.12877 + """ + + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + num_classes=1000, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=True, + drop_rate=0.0, + attn_drop_rate=0.0, + drop_path_rate=0.0, + layer_scale=True, + embed_layer=PatchEmbed, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + act_layer=nn.GELU, + window_attn=False, + window_size=14, + pretrained=None, + with_cp=False, + pre_norm=False, + ffn_type="mlp", + memeff=False, + ): + """ + Args: + img_size (int, tuple): input image size + patch_size (int, tuple): patch size + in_chans (int): number of input channels + num_classes (int): number of classes for classification head + embed_dim (int): embedding dimension + depth (int): depth of transformer + num_heads (int): number of attention heads + mlp_ratio (int): ratio of mlp hidden dim to embedding dim + qkv_bias (bool): enable bias for qkv if True + drop_rate (float): dropout rate + attn_drop_rate (float): attention dropout rate + drop_path_rate (float): stochastic depth rate + embed_layer (nn.Module): patch embedding layer + norm_layer: (nn.Module): normalization layer + pretrained: (str): pretrained path + """ + super().__init__() + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.num_tokens = 1 + norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6) + act_layer = act_layer or nn.GELU + self.norm_layer = norm_layer + self.act_layer = act_layer + self.pretrain_size = img_size + self.drop_path_rate = drop_path_rate + self.drop_rate = drop_rate + self.patch_size = patch_size + + window_attn = [window_attn] * depth if not isinstance(window_attn, list) else window_attn + window_size = [window_size] * depth if not isinstance(window_size, list) else window_size + logging.info("window attention:", window_attn) + logging.info("window size:", window_size) + logging.info("layer scale:", layer_scale) + + self.patch_embed = embed_layer( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, bias=not pre_norm + ) + num_patches = self.patch_embed.num_patches + + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim)) + self.pos_drop = nn.Dropout(p=drop_rate) + + ffn_types = {"mlp": Mlp, "swiglu": SwiGLUFFN} + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + self.blocks = nn.Sequential( + *[ + Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + drop=drop_rate, + attn_drop=attn_drop_rate, + drop_path=dpr[i], + norm_layer=norm_layer, + act_layer=act_layer, + windowed=window_attn[i], + window_size=window_size[i], + layer_scale=layer_scale, + with_cp=with_cp, + ffn_layer=ffn_types[ffn_type], + memeff=memeff, + ) + for i in range(depth) + ] + ) + + # self.norm = norm_layer(embed_dim) + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + # For CLIP + if pre_norm: + norm_pre = norm_layer(embed_dim) + self.norm_pre = norm_pre + else: + self.norm_pre = nn.Identity() + self.init_weights(pretrained) + + def init_weights(self, pretrained=None): + if isinstance(pretrained, str): + logger = get_root_logger() + load_checkpoint(self, pretrained, map_location="cpu", strict=False, logger=logger) + + def forward_features(self, x): + x, H, W = self.patch_embed(x) + cls_token = self.cls_token.expand(x.shape[0], -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_token, x), dim=1) + x = self.pos_drop(x + self.pos_embed) + + # For CLIP + x = self.norm_pre(x) + + for blk in self.blocks: + x = blk(x, H, W) + x = self.norm(x) + return x + + def forward(self, x): + x = self.forward_features(x) + return x + + @staticmethod + def resize_pos_embed(pos_embed, input_shpae, pos_shape, mode): + """Resize pos_embed weights. + + Resize pos_embed using bicubic interpolate method. + Args: + pos_embed (torch.Tensor): Position embedding weights. + input_shpae (tuple): Tuple for (downsampled input image height, + downsampled input image width). + pos_shape (tuple): The resolution of downsampled origin training + image. + mode (str): Algorithm used for upsampling: + ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` | + ``'trilinear'``. Default: ``'nearest'`` + Return: + torch.Tensor: The resized pos_embed of shape [B, L_new, C] + """ + assert pos_embed.ndim == 3, "shape of pos_embed must be [B, L, C]" + pos_h, pos_w = pos_shape + # keep dim for easy deployment + cls_token_weight = pos_embed[:, 0:1] + pos_embed_weight = pos_embed[:, (-1 * pos_h * pos_w) :] + pos_embed_weight = pos_embed_weight.reshape(1, pos_h, pos_w, pos_embed.shape[2]).permute(0, 3, 1, 2) + pos_embed_weight = resize(pos_embed_weight, size=input_shpae, align_corners=False, mode=mode) + pos_embed_weight = torch.flatten(pos_embed_weight, 2).transpose(1, 2) + pos_embed = torch.cat((cls_token_weight, pos_embed_weight), dim=1) + return pos_embed diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..8b7fbc63ce2b888ac27c43c4e64ca052d80d382f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py @@ -0,0 +1,217 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmseg.models.builder import BACKBONES +from torch.nn.init import normal_ + +from ...ops.modules import MSDeformAttn +from .adapter_modules import InteractionBlock, InteractionBlockWithCls, SpatialPriorModule, deform_inputs +from .vit import TIMMVisionTransformer + + +@BACKBONES.register_module() +class ViTAdapter(TIMMVisionTransformer): + def __init__( + self, + pretrain_size=224, + num_heads=12, + conv_inplane=64, + n_points=4, + deform_num_heads=6, + init_values=0.0, + interaction_indexes=None, + with_cffn=True, + cffn_ratio=0.25, + deform_ratio=1.0, + add_vit_feature=True, + pretrained=None, + use_extra_extractor=True, + freeze_vit=False, + use_cls=True, + with_cp=False, + *args, + **kwargs + ): + + super().__init__(num_heads=num_heads, pretrained=pretrained, with_cp=with_cp, *args, **kwargs) + if freeze_vit: + for param in self.parameters(): + param.requires_grad = False + + # self.num_classes = 80 + self.use_cls = use_cls + if not self.use_cls: + self.cls_token = None + self.num_block = len(self.blocks) + self.pretrain_size = (pretrain_size, pretrain_size) + self.interaction_indexes = interaction_indexes + self.add_vit_feature = add_vit_feature + embed_dim = self.embed_dim + + block_fn = InteractionBlockWithCls if use_cls else InteractionBlock + + self.level_embed = nn.Parameter(torch.zeros(3, embed_dim)) + self.spm = SpatialPriorModule(inplanes=conv_inplane, embed_dim=embed_dim, with_cp=False) + self.interactions = nn.Sequential( + *[ + block_fn( + dim=embed_dim, + num_heads=deform_num_heads, + n_points=n_points, + init_values=init_values, + drop_path=self.drop_path_rate, + norm_layer=self.norm_layer, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + deform_ratio=deform_ratio, + extra_extractor=((True if i == len(interaction_indexes) - 1 else False) and use_extra_extractor), + with_cp=with_cp, + ) + for i in range(len(interaction_indexes)) + ] + ) + self.up = nn.ConvTranspose2d(embed_dim, embed_dim, 2, 2) + self.norm1 = nn.SyncBatchNorm(embed_dim) + self.norm2 = nn.SyncBatchNorm(embed_dim) + self.norm3 = nn.SyncBatchNorm(embed_dim) + self.norm4 = nn.SyncBatchNorm(embed_dim) + + self.up.apply(self._init_weights) + self.spm.apply(self._init_weights) + self.interactions.apply(self._init_weights) + self.apply(self._init_deform_weights) + normal_(self.level_embed) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + torch.nn.init.trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm) or isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d): + 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 _get_pos_embed(self, pos_embed, H, W): + pos_embed = pos_embed.reshape( + 1, self.pretrain_size[0] // self.patch_size, self.pretrain_size[1] // self.patch_size, -1 + ).permute(0, 3, 1, 2) + pos_embed = ( + F.interpolate(pos_embed, size=(H, W), mode="bicubic", align_corners=False) + .reshape(1, -1, H * W) + .permute(0, 2, 1) + ) + return pos_embed + + def _init_deform_weights(self, m): + if isinstance(m, MSDeformAttn): + m._reset_parameters() + + def _add_level_embed(self, c2, c3, c4): + c2 = c2 + self.level_embed[0] + c3 = c3 + self.level_embed[1] + c4 = c4 + self.level_embed[2] + return c2, c3, c4 + + def forward(self, x): + deform_inputs1, deform_inputs2 = deform_inputs(x, self.patch_size) + + # SPM forward + c1, c2, c3, c4 = self.spm(x) + c2, c3, c4 = self._add_level_embed(c2, c3, c4) + c = torch.cat([c2, c3, c4], dim=1) + + # Patch Embedding forward + H_c, W_c = x.shape[2] // 16, x.shape[3] // 16 + x, H_toks, W_toks = self.patch_embed(x) + # print("H_toks, W_toks =", H_toks, W_toks) + bs, n, dim = x.shape + pos_embed = self._get_pos_embed(self.pos_embed[:, 1:], H_toks, W_toks) + if self.use_cls: + cls_token = self.cls_token.expand(x.shape[0], -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_token, x), dim=1) + pos_embed = torch.cat((self.pos_embed[:, :1], pos_embed), dim=1) + x = self.pos_drop(x + pos_embed) + # For CLIP + x = self.norm_pre(x) + + # Interaction + if self.use_cls: + cls, x = ( + x[ + :, + :1, + ], + x[ + :, + 1:, + ], + ) + outs = list() + for i, layer in enumerate(self.interactions): + indexes = self.interaction_indexes[i] + if self.use_cls: + x, c, cls = layer( + x, + c, + cls, + self.blocks[indexes[0] : indexes[-1] + 1], + deform_inputs1, + deform_inputs2, + H_c, + W_c, + H_toks, + W_toks, + ) + else: + x, c = layer( + x, + c, + self.blocks[indexes[0] : indexes[-1] + 1], + deform_inputs1, + deform_inputs2, + H_c, + W_c, + H_toks, + W_toks, + ) + outs.append(x.transpose(1, 2).view(bs, dim, H_toks, W_toks).contiguous()) + + # Split & Reshape + c2 = c[:, 0 : c2.size(1), :] + c3 = c[:, c2.size(1) : c2.size(1) + c3.size(1), :] + c4 = c[:, c2.size(1) + c3.size(1) :, :] + + c2 = c2.transpose(1, 2).view(bs, dim, H_c * 2, W_c * 2).contiguous() + c3 = c3.transpose(1, 2).view(bs, dim, H_c, W_c).contiguous() + c4 = c4.transpose(1, 2).view(bs, dim, H_c // 2, W_c // 2).contiguous() + c1 = self.up(c2) + c1 + + if self.add_vit_feature: + x1, x2, x3, x4 = outs + + x1 = F.interpolate(x1, size=(4 * H_c, 4 * W_c), mode="bilinear", align_corners=False) + x2 = F.interpolate(x2, size=(2 * H_c, 2 * W_c), mode="bilinear", align_corners=False) + x3 = F.interpolate(x3, size=(1 * H_c, 1 * W_c), mode="bilinear", align_corners=False) + x4 = F.interpolate(x4, size=(H_c // 2, W_c // 2), mode="bilinear", align_corners=False) + # print(c1.shape, c2.shape, c3.shape, c4.shape, x1.shape, x2.shape, x3.shape, x4.shape, H_c, H_toks) + c1, c2, c3, c4 = c1 + x1, c2 + x2, c3 + x3, c4 + x4 + + # Final Norm + f1 = self.norm1(c1) + f2 = self.norm2(c2) + f3 = self.norm3(c3) + f4 = self.norm4(c4) + return [f1, f2, f3, f4] diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/builder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..97f21db36059d5394ab44b654a9b22b5773b0b1a --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/builder.py @@ -0,0 +1,25 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.utils import Registry + +TRANSFORMER = Registry("Transformer") +MASK_ASSIGNERS = Registry("mask_assigner") +MATCH_COST = Registry("match_cost") + + +def build_match_cost(cfg): + """Build Match Cost.""" + return MATCH_COST.build(cfg) + + +def build_assigner(cfg): + """Build Assigner.""" + return MASK_ASSIGNERS.build(cfg) + + +def build_transformer(cfg): + """Build Transformer.""" + return TRANSFORMER.build(cfg) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..598a3341a6cfa7d038e90df9997986a1a71c4b60 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .mask2former_head import Mask2FormerHead diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py new file mode 100644 index 0000000000000000000000000000000000000000..c0b1a914b36a16b79a98ef5d7ffaed31b1fb6632 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py @@ -0,0 +1,544 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import copy + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import Conv2d, build_plugin_layer, caffe2_xavier_init +from mmcv.cnn.bricks.transformer import build_positional_encoding, build_transformer_layer_sequence +from mmcv.ops import point_sample +from mmcv.runner import ModuleList, force_fp32 +from mmseg.models.builder import HEADS, build_loss +from mmseg.models.decode_heads.decode_head import BaseDecodeHead + +from ...core import build_sampler, multi_apply, reduce_mean +from ..builder import build_assigner +from ..utils import get_uncertain_point_coords_with_randomness + + +@HEADS.register_module() +class Mask2FormerHead(BaseDecodeHead): + """Implements the Mask2Former head. + + See `Masked-attention Mask Transformer for Universal Image + Segmentation `_ for details. + + Args: + in_channels (list[int]): Number of channels in the input feature map. + feat_channels (int): Number of channels for features. + out_channels (int): Number of channels for output. + num_things_classes (int): Number of things. + num_stuff_classes (int): Number of stuff. + num_queries (int): Number of query in Transformer decoder. + pixel_decoder (:obj:`mmcv.ConfigDict` | dict): Config for pixel + decoder. Defaults to None. + enforce_decoder_input_project (bool, optional): Whether to add + a layer to change the embed_dim of tranformer encoder in + pixel decoder to the embed_dim of transformer decoder. + Defaults to False. + transformer_decoder (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder. Defaults to None. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder position encoding. Defaults to None. + loss_cls (:obj:`mmcv.ConfigDict` | dict): Config of the classification + loss. Defaults to None. + loss_mask (:obj:`mmcv.ConfigDict` | dict): Config of the mask loss. + Defaults to None. + loss_dice (:obj:`mmcv.ConfigDict` | dict): Config of the dice loss. + Defaults to None. + train_cfg (:obj:`mmcv.ConfigDict` | dict): Training config of + Mask2Former head. + test_cfg (:obj:`mmcv.ConfigDict` | dict): Testing config of + Mask2Former head. + init_cfg (dict or list[dict], optional): Initialization config dict. + Defaults to None. + """ + + def __init__( + self, + in_channels, + feat_channels, + out_channels, + num_things_classes=80, + num_stuff_classes=53, + num_queries=100, + num_transformer_feat_level=3, + pixel_decoder=None, + enforce_decoder_input_project=False, + transformer_decoder=None, + positional_encoding=None, + loss_cls=None, + loss_mask=None, + loss_dice=None, + train_cfg=None, + test_cfg=None, + init_cfg=None, + **kwargs, + ): + super(Mask2FormerHead, self).__init__( + in_channels=in_channels, + channels=feat_channels, + num_classes=(num_things_classes + num_stuff_classes), + init_cfg=init_cfg, + input_transform="multiple_select", + **kwargs, + ) + self.num_things_classes = num_things_classes + self.num_stuff_classes = num_stuff_classes + self.num_classes = self.num_things_classes + self.num_stuff_classes + self.num_queries = num_queries + self.num_transformer_feat_level = num_transformer_feat_level + self.num_heads = transformer_decoder.transformerlayers.attn_cfgs.num_heads + self.num_transformer_decoder_layers = transformer_decoder.num_layers + assert pixel_decoder.encoder.transformerlayers.attn_cfgs.num_levels == num_transformer_feat_level + pixel_decoder_ = copy.deepcopy(pixel_decoder) + pixel_decoder_.update(in_channels=in_channels, feat_channels=feat_channels, out_channels=out_channels) + self.pixel_decoder = build_plugin_layer(pixel_decoder_)[1] + self.transformer_decoder = build_transformer_layer_sequence(transformer_decoder) + self.decoder_embed_dims = self.transformer_decoder.embed_dims + + self.decoder_input_projs = ModuleList() + # from low resolution to high resolution + for _ in range(num_transformer_feat_level): + if self.decoder_embed_dims != feat_channels or enforce_decoder_input_project: + self.decoder_input_projs.append(Conv2d(feat_channels, self.decoder_embed_dims, kernel_size=1)) + else: + self.decoder_input_projs.append(nn.Identity()) + self.decoder_positional_encoding = build_positional_encoding(positional_encoding) + self.query_embed = nn.Embedding(self.num_queries, feat_channels) + self.query_feat = nn.Embedding(self.num_queries, feat_channels) + # from low resolution to high resolution + self.level_embed = nn.Embedding(self.num_transformer_feat_level, feat_channels) + + self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1) + self.mask_embed = nn.Sequential( + nn.Linear(feat_channels, feat_channels), + nn.ReLU(inplace=True), + nn.Linear(feat_channels, feat_channels), + nn.ReLU(inplace=True), + nn.Linear(feat_channels, out_channels), + ) + self.conv_seg = None # fix a bug here (conv_seg is not used) + + self.test_cfg = test_cfg + self.train_cfg = train_cfg + if train_cfg: + self.assigner = build_assigner(self.train_cfg.assigner) + self.sampler = build_sampler(self.train_cfg.sampler, context=self) + self.num_points = self.train_cfg.get("num_points", 12544) + self.oversample_ratio = self.train_cfg.get("oversample_ratio", 3.0) + self.importance_sample_ratio = self.train_cfg.get("importance_sample_ratio", 0.75) + + self.class_weight = loss_cls.class_weight + self.loss_cls = build_loss(loss_cls) + self.loss_mask = build_loss(loss_mask) + self.loss_dice = build_loss(loss_dice) + + def init_weights(self): + for m in self.decoder_input_projs: + if isinstance(m, Conv2d): + caffe2_xavier_init(m, bias=0) + + self.pixel_decoder.init_weights() + + for p in self.transformer_decoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + def get_targets(self, cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas): + """Compute classification and mask targets for all images for a decoder + layer. + + Args: + cls_scores_list (list[Tensor]): Mask score logits from a single + decoder layer for all images. Each with shape [num_queries, + cls_out_channels]. + mask_preds_list (list[Tensor]): Mask logits from a single decoder + layer for all images. Each with shape [num_queries, h, w]. + gt_labels_list (list[Tensor]): Ground truth class indices for all + images. Each with shape (n, ), n is the sum of number of stuff + type and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[list[Tensor]]: a tuple containing the following targets. + + - labels_list (list[Tensor]): Labels of all images. + Each with shape [num_queries, ]. + - label_weights_list (list[Tensor]): Label weights of all + images.Each with shape [num_queries, ]. + - mask_targets_list (list[Tensor]): Mask targets of all images. + Each with shape [num_queries, h, w]. + - mask_weights_list (list[Tensor]): Mask weights of all images. + Each with shape [num_queries, ]. + - num_total_pos (int): Number of positive samples in all + images. + - num_total_neg (int): Number of negative samples in all + images. + """ + ( + labels_list, + label_weights_list, + mask_targets_list, + mask_weights_list, + pos_inds_list, + neg_inds_list, + ) = multi_apply( + self._get_target_single, cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas + ) + + num_total_pos = sum((inds.numel() for inds in pos_inds_list)) + num_total_neg = sum((inds.numel() for inds in neg_inds_list)) + return (labels_list, label_weights_list, mask_targets_list, mask_weights_list, num_total_pos, num_total_neg) + + def _get_target_single(self, cls_score, mask_pred, gt_labels, gt_masks, img_metas): + """Compute classification and mask targets for one image. + + Args: + cls_score (Tensor): Mask score logits from a single decoder layer + for one image. Shape (num_queries, cls_out_channels). + mask_pred (Tensor): Mask logits for a single decoder layer for one + image. Shape (num_queries, h, w). + gt_labels (Tensor): Ground truth class indices for one image with + shape (num_gts, ). + gt_masks (Tensor): Ground truth mask for each image, each with + shape (num_gts, h, w). + img_metas (dict): Image informtation. + + Returns: + tuple[Tensor]: A tuple containing the following for one image. + + - labels (Tensor): Labels of each image. \ + shape (num_queries, ). + - label_weights (Tensor): Label weights of each image. \ + shape (num_queries, ). + - mask_targets (Tensor): Mask targets of each image. \ + shape (num_queries, h, w). + - mask_weights (Tensor): Mask weights of each image. \ + shape (num_queries, ). + - pos_inds (Tensor): Sampled positive indices for each \ + image. + - neg_inds (Tensor): Sampled negative indices for each \ + image. + """ + # sample points + num_queries = cls_score.shape[0] + num_gts = gt_labels.shape[0] + + point_coords = torch.rand((1, self.num_points, 2), device=cls_score.device) + # shape (num_queries, num_points) + mask_points_pred = point_sample(mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1, 1)).squeeze(1) + # shape (num_gts, num_points) + gt_points_masks = point_sample(gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1, 1)).squeeze(1) + + # assign and sample + assign_result = self.assigner.assign(cls_score, mask_points_pred, gt_labels, gt_points_masks, img_metas) + sampling_result = self.sampler.sample(assign_result, mask_pred, gt_masks) + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + + # label target + labels = gt_labels.new_full((self.num_queries,), self.num_classes, dtype=torch.long) + labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds] + label_weights = gt_labels.new_ones((self.num_queries,)) + + # mask target + mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds] + mask_weights = mask_pred.new_zeros((self.num_queries,)) + mask_weights[pos_inds] = 1.0 + + return (labels, label_weights, mask_targets, mask_weights, pos_inds, neg_inds) + + def loss_single(self, cls_scores, mask_preds, gt_labels_list, gt_masks_list, img_metas): + """Loss function for outputs from a single decoder layer. + + Args: + cls_scores (Tensor): Mask score logits from a single decoder layer + for all images. Shape (batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + mask_preds (Tensor): Mask logits for a pixel decoder for all + images. Shape (batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image, each with shape (num_gts, ). + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (num_gts, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[Tensor]: Loss components for outputs from a single \ + decoder layer. + """ + num_imgs = cls_scores.size(0) + cls_scores_list = [cls_scores[i] for i in range(num_imgs)] + mask_preds_list = [mask_preds[i] for i in range(num_imgs)] + ( + labels_list, + label_weights_list, + mask_targets_list, + mask_weights_list, + num_total_pos, + num_total_neg, + ) = self.get_targets(cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas) + # shape (batch_size, num_queries) + labels = torch.stack(labels_list, dim=0) + # shape (batch_size, num_queries) + label_weights = torch.stack(label_weights_list, dim=0) + # shape (num_total_gts, h, w) + mask_targets = torch.cat(mask_targets_list, dim=0) + # shape (batch_size, num_queries) + mask_weights = torch.stack(mask_weights_list, dim=0) + + # classfication loss + # shape (batch_size * num_queries, ) + cls_scores = cls_scores.flatten(0, 1) + labels = labels.flatten(0, 1) + label_weights = label_weights.flatten(0, 1) + + class_weight = cls_scores.new_tensor(self.class_weight) + loss_cls = self.loss_cls(cls_scores, labels, label_weights, avg_factor=class_weight[labels].sum()) + + num_total_masks = reduce_mean(cls_scores.new_tensor([num_total_pos])) + num_total_masks = max(num_total_masks, 1) + + # extract positive ones + # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w) + mask_preds = mask_preds[mask_weights > 0] + + if mask_targets.shape[0] == 0: + # zero match + loss_dice = mask_preds.sum() + loss_mask = mask_preds.sum() + return loss_cls, loss_mask, loss_dice + + with torch.no_grad(): + points_coords = get_uncertain_point_coords_with_randomness( + mask_preds.unsqueeze(1), None, self.num_points, self.oversample_ratio, self.importance_sample_ratio + ) + # shape (num_total_gts, h, w) -> (num_total_gts, num_points) + mask_point_targets = point_sample(mask_targets.unsqueeze(1).float(), points_coords).squeeze(1) + # shape (num_queries, h, w) -> (num_queries, num_points) + mask_point_preds = point_sample(mask_preds.unsqueeze(1), points_coords).squeeze(1) + + # dice loss + loss_dice = self.loss_dice(mask_point_preds, mask_point_targets, avg_factor=num_total_masks) + + # mask loss + # shape (num_queries, num_points) -> (num_queries * num_points, ) + mask_point_preds = mask_point_preds.reshape(-1, 1) + # shape (num_total_gts, num_points) -> (num_total_gts * num_points, ) + mask_point_targets = mask_point_targets.reshape(-1) + loss_mask = self.loss_mask(mask_point_preds, mask_point_targets, avg_factor=num_total_masks * self.num_points) + + return loss_cls, loss_mask, loss_dice + + @force_fp32(apply_to=("all_cls_scores", "all_mask_preds")) + def loss(self, all_cls_scores, all_mask_preds, gt_labels_list, gt_masks_list, img_metas): + """Loss function. + + Args: + all_cls_scores (Tensor): Classification scores for all decoder + layers with shape [num_decoder, batch_size, num_queries, + cls_out_channels]. + all_mask_preds (Tensor): Mask scores for all decoder layers with + shape [num_decoder, batch_size, num_queries, h, w]. + gt_labels_list (list[Tensor]): Ground truth class indices for each + image with shape (n, ). n is the sum of number of stuff type + and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image with + shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + dict[str, Tensor]: A dictionary of loss components. + """ + num_dec_layers = len(all_cls_scores) + all_gt_labels_list = [gt_labels_list for _ in range(num_dec_layers)] + all_gt_masks_list = [gt_masks_list for _ in range(num_dec_layers)] + img_metas_list = [img_metas for _ in range(num_dec_layers)] + losses_cls, losses_mask, losses_dice = multi_apply( + self.loss_single, all_cls_scores, all_mask_preds, all_gt_labels_list, all_gt_masks_list, img_metas_list + ) + + loss_dict = dict() + # loss from the last decoder layer + loss_dict["loss_cls"] = losses_cls[-1] + loss_dict["loss_mask"] = losses_mask[-1] + loss_dict["loss_dice"] = losses_dice[-1] + # loss from other decoder layers + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip(losses_cls[:-1], losses_mask[:-1], losses_dice[:-1]): + loss_dict[f"d{num_dec_layer}.loss_cls"] = loss_cls_i + loss_dict[f"d{num_dec_layer}.loss_mask"] = loss_mask_i + loss_dict[f"d{num_dec_layer}.loss_dice"] = loss_dice_i + num_dec_layer += 1 + return loss_dict + + def forward_head(self, decoder_out, mask_feature, attn_mask_target_size): + """Forward for head part which is called after every decoder layer. + + Args: + decoder_out (Tensor): in shape (num_queries, batch_size, c). + mask_feature (Tensor): in shape (batch_size, c, h, w). + attn_mask_target_size (tuple[int, int]): target attention + mask size. + + Returns: + tuple: A tuple contain three elements. + + - cls_pred (Tensor): Classification scores in shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred (Tensor): Mask scores in shape \ + (batch_size, num_queries,h, w). + - attn_mask (Tensor): Attention mask in shape \ + (batch_size * num_heads, num_queries, h, w). + """ + decoder_out = self.transformer_decoder.post_norm(decoder_out) + decoder_out = decoder_out.transpose(0, 1) + # shape (num_queries, batch_size, c) + cls_pred = self.cls_embed(decoder_out) + # shape (num_queries, batch_size, c) + mask_embed = self.mask_embed(decoder_out) + # shape (num_queries, batch_size, h, w) + mask_pred = torch.einsum("bqc,bchw->bqhw", mask_embed, mask_feature) + attn_mask = F.interpolate(mask_pred, attn_mask_target_size, mode="bilinear", align_corners=False) + # shape (num_queries, batch_size, h, w) -> + # (batch_size * num_head, num_queries, h, w) + attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat((1, self.num_heads, 1, 1)).flatten(0, 1) + attn_mask = attn_mask.sigmoid() < 0.5 + attn_mask = attn_mask.detach() + + return cls_pred, mask_pred, attn_mask + + def forward(self, feats, img_metas): + """Forward function. + + Args: + feats (list[Tensor]): Multi scale Features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two elements. + + - cls_pred_list (list[Tensor)]: Classification logits \ + for each decoder layer. Each is a 3D-tensor with shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred_list (list[Tensor]): Mask logits for each \ + decoder layer. Each with shape (batch_size, num_queries, \ + h, w). + """ + batch_size = len(img_metas) + mask_features, multi_scale_memorys = self.pixel_decoder(feats) + # multi_scale_memorys (from low resolution to high resolution) + decoder_inputs = [] + decoder_positional_encodings = [] + for i in range(self.num_transformer_feat_level): + decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i]) + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + decoder_input = decoder_input.flatten(2).permute(2, 0, 1) + level_embed = self.level_embed.weight[i].view(1, 1, -1) + decoder_input = decoder_input + level_embed + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + mask = decoder_input.new_zeros((batch_size,) + multi_scale_memorys[i].shape[-2:], dtype=torch.bool) + decoder_positional_encoding = self.decoder_positional_encoding(mask) + decoder_positional_encoding = decoder_positional_encoding.flatten(2).permute(2, 0, 1) + decoder_inputs.append(decoder_input) + decoder_positional_encodings.append(decoder_positional_encoding) + # shape (num_queries, c) -> (num_queries, batch_size, c) + query_feat = self.query_feat.weight.unsqueeze(1).repeat((1, batch_size, 1)) + query_embed = self.query_embed.weight.unsqueeze(1).repeat((1, batch_size, 1)) + + cls_pred_list = [] + mask_pred_list = [] + cls_pred, mask_pred, attn_mask = self.forward_head(query_feat, mask_features, multi_scale_memorys[0].shape[-2:]) + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + for i in range(self.num_transformer_decoder_layers): + level_idx = i % self.num_transformer_feat_level + # if a mask is all True(all background), then set it all False. + attn_mask[torch.where(attn_mask.sum(-1) == attn_mask.shape[-1])] = False + + # cross_attn + self_attn + layer = self.transformer_decoder.layers[i] + attn_masks = [attn_mask, None] + query_feat = layer( + query=query_feat, + key=decoder_inputs[level_idx], + value=decoder_inputs[level_idx], + query_pos=query_embed, + key_pos=decoder_positional_encodings[level_idx], + attn_masks=attn_masks, + query_key_padding_mask=None, + # here we do not apply masking on padded region + key_padding_mask=None, + ) + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[(i + 1) % self.num_transformer_feat_level].shape[-2:] + ) + + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + return cls_pred_list, mask_pred_list + + def forward_train(self, x, img_metas, gt_semantic_seg, gt_labels, gt_masks): + """Forward function for training mode. + + Args: + x (list[Tensor]): Multi-level features from the upstream network, + each is a 4D-tensor. + img_metas (list[Dict]): List of image information. + gt_semantic_seg (list[tensor]):Each element is the ground truth + of semantic segmentation with the shape (N, H, W). + train_cfg (dict): The training config, which not been used in + maskformer. + gt_labels (list[Tensor]): Each element is ground truth labels of + each box, shape (num_gts,). + gt_masks (list[BitmapMasks]): Each element is masks of instances + of a image, shape (num_gts, h, w). + + Returns: + losses (dict[str, Tensor]): a dictionary of loss components + """ + + # forward + all_cls_scores, all_mask_preds = self(x, img_metas) + + # loss + losses = self.loss(all_cls_scores, all_mask_preds, gt_labels, gt_masks, img_metas) + + return losses + + def forward_test(self, inputs, img_metas, test_cfg): + """Test segment without test-time aumengtation. + + Only the output of last decoder layers was used. + + Args: + inputs (list[Tensor]): Multi-level features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + test_cfg (dict): Testing config. + + Returns: + seg_mask (Tensor): Predicted semantic segmentation logits. + """ + all_cls_scores, all_mask_preds = self(inputs, img_metas) + cls_score, mask_pred = all_cls_scores[-1], all_mask_preds[-1] + ori_h, ori_w, _ = img_metas[0]["ori_shape"] + + # semantic inference + cls_score = F.softmax(cls_score, dim=-1)[..., :-1] + mask_pred = mask_pred.sigmoid() + seg_mask = torch.einsum("bqc,bqhw->bchw", cls_score, mask_pred) + return seg_mask diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d4cc4bf9f1a07a6c569727b044d2f9ee30944adc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .cross_entropy_loss import CrossEntropyLoss, binary_cross_entropy, cross_entropy, mask_cross_entropy +from .dice_loss import DiceLoss +from .match_costs import ClassificationCost, CrossEntropyLossCost, DiceCost diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..6cd4a0572837f2e92483d8cc48143cf2c1528c91 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py @@ -0,0 +1,279 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmseg.models.builder import LOSSES +from mmseg.models.losses.utils import get_class_weight, weight_reduce_loss + + +def cross_entropy( + pred, + label, + weight=None, + class_weight=None, + reduction="mean", + avg_factor=None, + ignore_index=-100, + avg_non_ignore=False, +): + """cross_entropy. The wrapper function for :func:`F.cross_entropy` + + Args: + pred (torch.Tensor): The prediction with shape (N, 1). + label (torch.Tensor): The learning label of the prediction. + weight (torch.Tensor, optional): Sample-wise loss weight. + Default: None. + class_weight (list[float], optional): The weight for each class. + Default: None. + reduction (str, optional): The method used to reduce the loss. + Options are 'none', 'mean' and 'sum'. Default: 'mean'. + avg_factor (int, optional): Average factor that is used to average + the loss. Default: None. + ignore_index (int): Specifies a target value that is ignored and + does not contribute to the input gradients. When + ``avg_non_ignore `` is ``True``, and the ``reduction`` is + ``''mean''``, the loss is averaged over non-ignored targets. + Defaults: -100. + avg_non_ignore (bool): The flag decides to whether the loss is + only averaged over non-ignored targets. Default: False. + `New in version 0.23.0.` + """ + + # class_weight is a manual rescaling weight given to each class. + # If given, has to be a Tensor of size C element-wise losses + loss = F.cross_entropy(pred, label, weight=class_weight, reduction="none", ignore_index=ignore_index) + + # apply weights and do the reduction + # average loss over non-ignored elements + # pytorch's official cross_entropy average loss over non-ignored elements + # refer to https://github.com/pytorch/pytorch/blob/56b43f4fec1f76953f15a627694d4bba34588969/torch/nn/functional.py#L2660 # noqa + if (avg_factor is None) and avg_non_ignore and reduction == "mean": + avg_factor = label.numel() - (label == ignore_index).sum().item() + if weight is not None: + weight = weight.float() + loss = weight_reduce_loss(loss, weight=weight, reduction=reduction, avg_factor=avg_factor) + + return loss + + +def _expand_onehot_labels(labels, label_weights, target_shape, ignore_index): + """Expand onehot labels to match the size of prediction.""" + bin_labels = labels.new_zeros(target_shape) + valid_mask = (labels >= 0) & (labels != ignore_index) + inds = torch.nonzero(valid_mask, as_tuple=True) + + if inds[0].numel() > 0: + if labels.dim() == 3: + bin_labels[inds[0], labels[valid_mask], inds[1], inds[2]] = 1 + else: + bin_labels[inds[0], labels[valid_mask]] = 1 + + valid_mask = valid_mask.unsqueeze(1).expand(target_shape).float() + + if label_weights is None: + bin_label_weights = valid_mask + else: + bin_label_weights = label_weights.unsqueeze(1).expand(target_shape) + bin_label_weights = bin_label_weights * valid_mask + + return bin_labels, bin_label_weights, valid_mask + + +def binary_cross_entropy( + pred, + label, + weight=None, + reduction="mean", + avg_factor=None, + class_weight=None, + ignore_index=-100, + avg_non_ignore=False, + **kwargs, +): + """Calculate the binary CrossEntropy loss. + + Args: + pred (torch.Tensor): The prediction with shape (N, 1). + label (torch.Tensor): The learning label of the prediction. + Note: In bce loss, label < 0 is invalid. + weight (torch.Tensor, optional): Sample-wise loss weight. + reduction (str, optional): The method used to reduce the loss. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + class_weight (list[float], optional): The weight for each class. + ignore_index (int): The label index to be ignored. Default: -100. + avg_non_ignore (bool): The flag decides to whether the loss is + only averaged over non-ignored targets. Default: False. + `New in version 0.23.0.` + + Returns: + torch.Tensor: The calculated loss + """ + if pred.size(1) == 1: + # For binary class segmentation, the shape of pred is + # [N, 1, H, W] and that of label is [N, H, W]. + assert label.max() <= 1, "For pred with shape [N, 1, H, W], its label must have at " "most 2 classes" + pred = pred.squeeze() + if pred.dim() != label.dim(): + assert (pred.dim() == 2 and label.dim() == 1) or (pred.dim() == 4 and label.dim() == 3), ( + "Only pred shape [N, C], label shape [N] or pred shape [N, C, " "H, W], label shape [N, H, W] are supported" + ) + # `weight` returned from `_expand_onehot_labels` + # has been treated for valid (non-ignore) pixels + label, weight, valid_mask = _expand_onehot_labels(label, weight, pred.shape, ignore_index) + else: + # should mask out the ignored elements + valid_mask = ((label >= 0) & (label != ignore_index)).float() + if weight is not None: + weight = weight * valid_mask + else: + weight = valid_mask + # average loss over non-ignored and valid elements + if reduction == "mean" and avg_factor is None and avg_non_ignore: + avg_factor = valid_mask.sum().item() + + loss = F.binary_cross_entropy_with_logits(pred, label.float(), pos_weight=class_weight, reduction="none") + # do the reduction for the weighted loss + loss = weight_reduce_loss(loss, weight, reduction=reduction, avg_factor=avg_factor) + + return loss + + +def mask_cross_entropy( + pred, target, label, reduction="mean", avg_factor=None, class_weight=None, ignore_index=None, **kwargs +): + """Calculate the CrossEntropy loss for masks. + + Args: + pred (torch.Tensor): The prediction with shape (N, C), C is the number + of classes. + target (torch.Tensor): The learning label of the prediction. + label (torch.Tensor): ``label`` indicates the class label of the mask' + corresponding object. This will be used to select the mask in the + of the class which the object belongs to when the mask prediction + if not class-agnostic. + reduction (str, optional): The method used to reduce the loss. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + class_weight (list[float], optional): The weight for each class. + ignore_index (None): Placeholder, to be consistent with other loss. + Default: None. + + Returns: + torch.Tensor: The calculated loss + """ + assert ignore_index is None, "BCE loss does not support ignore_index" + assert reduction == "mean" and avg_factor is None + num_rois = pred.size()[0] + inds = torch.arange(0, num_rois, dtype=torch.long, device=pred.device) + pred_slice = pred[inds, label].squeeze(1) + return F.binary_cross_entropy_with_logits(pred_slice, target, weight=class_weight, reduction="mean")[None] + + +@LOSSES.register_module(force=True) +class CrossEntropyLoss(nn.Module): + """CrossEntropyLoss. + + Args: + use_sigmoid (bool, optional): Whether the prediction uses sigmoid + of softmax. Defaults to False. + use_mask (bool, optional): Whether to use mask cross entropy loss. + Defaults to False. + reduction (str, optional): . Defaults to 'mean'. + Options are "none", "mean" and "sum". + class_weight (list[float] | str, optional): Weight of each class. If in + str format, read them from a file. Defaults to None. + loss_weight (float, optional): Weight of the loss. Defaults to 1.0. + loss_name (str, optional): Name of the loss item. If you want this loss + item to be included into the backward graph, `loss_` must be the + prefix of the name. Defaults to 'loss_ce'. + avg_non_ignore (bool): The flag decides to whether the loss is + only averaged over non-ignored targets. Default: False. + `New in version 0.23.0.` + """ + + def __init__( + self, + use_sigmoid=False, + use_mask=False, + reduction="mean", + class_weight=None, + loss_weight=1.0, + loss_name="loss_ce", + avg_non_ignore=False, + ): + super(CrossEntropyLoss, self).__init__() + assert (use_sigmoid is False) or (use_mask is False) + self.use_sigmoid = use_sigmoid + self.use_mask = use_mask + self.reduction = reduction + self.loss_weight = loss_weight + self.class_weight = get_class_weight(class_weight) + self.avg_non_ignore = avg_non_ignore + if not self.avg_non_ignore and self.reduction == "mean": + warnings.warn( + "Default ``avg_non_ignore`` is False, if you would like to " + "ignore the certain label and average loss over non-ignore " + "labels, which is the same with PyTorch official " + "cross_entropy, set ``avg_non_ignore=True``." + ) + + if self.use_sigmoid: + self.cls_criterion = binary_cross_entropy + elif self.use_mask: + self.cls_criterion = mask_cross_entropy + else: + self.cls_criterion = cross_entropy + self._loss_name = loss_name + + def extra_repr(self): + """Extra repr.""" + s = f"avg_non_ignore={self.avg_non_ignore}" + return s + + def forward( + self, cls_score, label, weight=None, avg_factor=None, reduction_override=None, ignore_index=-100, **kwargs + ): + """Forward function.""" + assert reduction_override in (None, "none", "mean", "sum") + reduction = reduction_override if reduction_override else self.reduction + if self.class_weight is not None: + class_weight = cls_score.new_tensor(self.class_weight) + else: + class_weight = None + # Note: for BCE loss, label < 0 is invalid. + loss_cls = self.loss_weight * self.cls_criterion( + cls_score, + label, + weight, + class_weight=class_weight, + reduction=reduction, + avg_factor=avg_factor, + avg_non_ignore=self.avg_non_ignore, + ignore_index=ignore_index, + **kwargs, + ) + return loss_cls + + @property + def loss_name(self): + """Loss Name. + + This function must be implemented and will return the name of this + loss function. This name will be used to combine different loss items + by simple sum operation. In addition, if you want this loss item to be + included into the backward graph, `loss_` must be the prefix of the + name. + + Returns: + str: The name of this loss item. + """ + return self._loss_name diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..2742f9f718f809b4288cf42b6737f1f8b4aa99b7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py @@ -0,0 +1,153 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +from mmseg.models.builder import LOSSES +from mmseg.models.losses.utils import weight_reduce_loss + + +def dice_loss(pred, target, weight=None, eps=1e-3, reduction="mean", avg_factor=None): + """Calculate dice loss, which is proposed in + `V-Net: Fully Convolutional Neural Networks for Volumetric + Medical Image Segmentation `_. + + Args: + pred (torch.Tensor): The prediction, has a shape (n, *) + target (torch.Tensor): The learning label of the prediction, + shape (n, *), same shape of pred. + weight (torch.Tensor, optional): The weight of loss for each + prediction, has a shape (n,). Defaults to None. + eps (float): Avoid dividing by zero. Default: 1e-3. + reduction (str, optional): The method used to reduce the loss into + a scalar. Defaults to 'mean'. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + """ + + input = pred.flatten(1) + target = target.flatten(1).float() + + a = torch.sum(input * target, 1) + b = torch.sum(input * input, 1) + eps + c = torch.sum(target * target, 1) + eps + d = (2 * a) / (b + c) + loss = 1 - d + if weight is not None: + assert weight.ndim == loss.ndim + assert len(weight) == len(pred) + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + +def naive_dice_loss(pred, target, weight=None, eps=1e-3, reduction="mean", avg_factor=None): + """Calculate naive dice loss, the coefficient in the denominator is the + first power instead of the second power. + + Args: + pred (torch.Tensor): The prediction, has a shape (n, *) + target (torch.Tensor): The learning label of the prediction, + shape (n, *), same shape of pred. + weight (torch.Tensor, optional): The weight of loss for each + prediction, has a shape (n,). Defaults to None. + eps (float): Avoid dividing by zero. Default: 1e-3. + reduction (str, optional): The method used to reduce the loss into + a scalar. Defaults to 'mean'. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + """ + input = pred.flatten(1) + target = target.flatten(1).float() + + a = torch.sum(input * target, 1) + b = torch.sum(input, 1) + c = torch.sum(target, 1) + d = (2 * a + eps) / (b + c + eps) + loss = 1 - d + if weight is not None: + assert weight.ndim == loss.ndim + assert len(weight) == len(pred) + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + +@LOSSES.register_module(force=True) +class DiceLoss(nn.Module): + def __init__(self, use_sigmoid=True, activate=True, reduction="mean", naive_dice=False, loss_weight=1.0, eps=1e-3): + """Dice Loss, there are two forms of dice loss is supported: + + - the one proposed in `V-Net: Fully Convolutional Neural + Networks for Volumetric Medical Image Segmentation + `_. + - the dice loss in which the power of the number in the + denominator is the first power instead of the second + power. + + Args: + use_sigmoid (bool, optional): Whether to the prediction is + used for sigmoid or softmax. Defaults to True. + activate (bool): Whether to activate the predictions inside, + this will disable the inside sigmoid operation. + Defaults to True. + reduction (str, optional): The method used + to reduce the loss. Options are "none", + "mean" and "sum". Defaults to 'mean'. + naive_dice (bool, optional): If false, use the dice + loss defined in the V-Net paper, otherwise, use the + naive dice loss in which the power of the number in the + denominator is the first power instead of the second + power.Defaults to False. + loss_weight (float, optional): Weight of loss. Defaults to 1.0. + eps (float): Avoid dividing by zero. Defaults to 1e-3. + """ + + super(DiceLoss, self).__init__() + self.use_sigmoid = use_sigmoid + self.reduction = reduction + self.naive_dice = naive_dice + self.loss_weight = loss_weight + self.eps = eps + self.activate = activate + + def forward(self, pred, target, weight=None, reduction_override=None, avg_factor=None): + """Forward function. + + Args: + pred (torch.Tensor): The prediction, has a shape (n, *). + target (torch.Tensor): The label of the prediction, + shape (n, *), same shape of pred. + weight (torch.Tensor, optional): The weight of loss for each + prediction, has a shape (n,). Defaults to None. + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + reduction_override (str, optional): The reduction method used to + override the original reduction method of the loss. + Options are "none", "mean" and "sum". + + Returns: + torch.Tensor: The calculated loss + """ + + assert reduction_override in (None, "none", "mean", "sum") + reduction = reduction_override if reduction_override else self.reduction + + if self.activate: + if self.use_sigmoid: + pred = pred.sigmoid() + else: + raise NotImplementedError + + if self.naive_dice: + loss = self.loss_weight * naive_dice_loss( + pred, target, weight, eps=self.eps, reduction=reduction, avg_factor=avg_factor + ) + else: + loss = self.loss_weight * dice_loss( + pred, target, weight, eps=self.eps, reduction=reduction, avg_factor=avg_factor + ) + + return loss diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/match_costs.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/match_costs.py new file mode 100644 index 0000000000000000000000000000000000000000..5da32bf6be247ca2d15a374a8ca4f02be12fac47 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/losses/match_costs.py @@ -0,0 +1,153 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F + +from ..builder import MATCH_COST + + +@MATCH_COST.register_module() +class ClassificationCost: + """ClsSoftmaxCost.Borrow from + mmdet.core.bbox.match_costs.match_cost.ClassificationCost. + + Args: + weight (int | float, optional): loss_weight + + Examples: + >>> import torch + >>> self = ClassificationCost() + >>> cls_pred = torch.rand(4, 3) + >>> gt_labels = torch.tensor([0, 1, 2]) + >>> factor = torch.tensor([10, 8, 10, 8]) + >>> self(cls_pred, gt_labels) + tensor([[-0.3430, -0.3525, -0.3045], + [-0.3077, -0.2931, -0.3992], + [-0.3664, -0.3455, -0.2881], + [-0.3343, -0.2701, -0.3956]]) + """ + + def __init__(self, weight=1.0): + self.weight = weight + + def __call__(self, cls_pred, gt_labels): + """ + Args: + cls_pred (Tensor): Predicted classification logits, shape + [num_query, num_class]. + gt_labels (Tensor): Label of `gt_bboxes`, shape (num_gt,). + + Returns: + torch.Tensor: cls_cost value with weight + """ + # Following the official DETR repo, contrary to the loss that + # NLL is used, we approximate it in 1 - cls_score[gt_label]. + # The 1 is a constant that doesn't change the matching, + # so it can be omitted. + cls_score = cls_pred.softmax(-1) + cls_cost = -cls_score[:, gt_labels] + return cls_cost * self.weight + + +@MATCH_COST.register_module() +class DiceCost: + """Cost of mask assignments based on dice losses. + + Args: + weight (int | float, optional): loss_weight. Defaults to 1. + pred_act (bool, optional): Whether to apply sigmoid to mask_pred. + Defaults to False. + eps (float, optional): default 1e-12. + """ + + def __init__(self, weight=1.0, pred_act=False, eps=1e-3): + self.weight = weight + self.pred_act = pred_act + self.eps = eps + + def binary_mask_dice_loss(self, mask_preds, gt_masks): + """ + Args: + mask_preds (Tensor): Mask prediction in shape (N1, H, W). + gt_masks (Tensor): Ground truth in shape (N2, H, W) + store 0 or 1, 0 for negative class and 1 for + positive class. + + Returns: + Tensor: Dice cost matrix in shape (N1, N2). + """ + mask_preds = mask_preds.reshape((mask_preds.shape[0], -1)) + gt_masks = gt_masks.reshape((gt_masks.shape[0], -1)).float() + numerator = 2 * torch.einsum("nc,mc->nm", mask_preds, gt_masks) + denominator = mask_preds.sum(-1)[:, None] + gt_masks.sum(-1)[None, :] + loss = 1 - (numerator + self.eps) / (denominator + self.eps) + return loss + + def __call__(self, mask_preds, gt_masks): + """ + Args: + mask_preds (Tensor): Mask prediction logits in shape (N1, H, W). + gt_masks (Tensor): Ground truth in shape (N2, H, W). + + Returns: + Tensor: Dice cost matrix in shape (N1, N2). + """ + if self.pred_act: + mask_preds = mask_preds.sigmoid() + dice_cost = self.binary_mask_dice_loss(mask_preds, gt_masks) + return dice_cost * self.weight + + +@MATCH_COST.register_module() +class CrossEntropyLossCost: + """CrossEntropyLossCost. + + Args: + weight (int | float, optional): loss weight. Defaults to 1. + use_sigmoid (bool, optional): Whether the prediction uses sigmoid + of softmax. Defaults to True. + """ + + def __init__(self, weight=1.0, use_sigmoid=True): + assert use_sigmoid, "use_sigmoid = False is not supported yet." + self.weight = weight + self.use_sigmoid = use_sigmoid + + def _binary_cross_entropy(self, cls_pred, gt_labels): + """ + Args: + cls_pred (Tensor): The prediction with shape (num_query, 1, *) or + (num_query, *). + gt_labels (Tensor): The learning label of prediction with + shape (num_gt, *). + Returns: + Tensor: Cross entropy cost matrix in shape (num_query, num_gt). + """ + cls_pred = cls_pred.flatten(1).float() + gt_labels = gt_labels.flatten(1).float() + n = cls_pred.shape[1] + pos = F.binary_cross_entropy_with_logits(cls_pred, torch.ones_like(cls_pred), reduction="none") + neg = F.binary_cross_entropy_with_logits(cls_pred, torch.zeros_like(cls_pred), reduction="none") + cls_cost = torch.einsum("nc,mc->nm", pos, gt_labels) + torch.einsum("nc,mc->nm", neg, 1 - gt_labels) + cls_cost = cls_cost / n + + return cls_cost + + def __call__(self, cls_pred, gt_labels): + """ + Args: + cls_pred (Tensor): Predicted classification logits. + gt_labels (Tensor): Labels. + Returns: + Tensor: Cross entropy cost matrix with weight in + shape (num_query, num_gt). + """ + if self.use_sigmoid: + cls_cost = self._binary_cross_entropy(cls_pred, gt_labels) + else: + raise NotImplementedError + + return cls_cost * self.weight diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/plugins/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/plugins/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0d5cbe22233c9a1c3157f467cbf682b8e15b42f --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/plugins/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .msdeformattn_pixel_decoder import MSDeformAttnPixelDecoder diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..736958aca447848c91c588e481ed4a2d072098fe --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py @@ -0,0 +1,242 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import PLUGIN_LAYERS, Conv2d, ConvModule, caffe2_xavier_init, normal_init, xavier_init +from mmcv.cnn.bricks.transformer import build_positional_encoding, build_transformer_layer_sequence +from mmcv.runner import BaseModule, ModuleList + +from ...core.anchor import MlvlPointGenerator +from ..utils.transformer import MultiScaleDeformableAttention + + +@PLUGIN_LAYERS.register_module() +class MSDeformAttnPixelDecoder(BaseModule): + """Pixel decoder with multi-scale deformable attention. + + Args: + in_channels (list[int] | tuple[int]): Number of channels in the + input feature maps. + strides (list[int] | tuple[int]): Output strides of feature from + backbone. + feat_channels (int): Number of channels for feature. + out_channels (int): Number of channels for output. + num_outs (int): Number of output scales. + norm_cfg (:obj:`mmcv.ConfigDict` | dict): Config for normalization. + Defaults to dict(type='GN', num_groups=32). + act_cfg (:obj:`mmcv.ConfigDict` | dict): Config for activation. + Defaults to dict(type='ReLU'). + encoder (:obj:`mmcv.ConfigDict` | dict): Config for transformer + encoder. Defaults to `DetrTransformerEncoder`. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer encoder position encoding. Defaults to + dict(type='SinePositionalEncoding', num_feats=128, + normalize=True). + init_cfg (:obj:`mmcv.ConfigDict` | dict): Initialization config dict. + """ + + def __init__( + self, + in_channels=[256, 512, 1024, 2048], + strides=[4, 8, 16, 32], + feat_channels=256, + out_channels=256, + num_outs=3, + norm_cfg=dict(type="GN", num_groups=32), + act_cfg=dict(type="ReLU"), + encoder=dict( + type="DetrTransformerEncoder", + num_layers=6, + transformerlayers=dict( + type="BaseTransformerLayer", + attn_cfgs=dict( + type="MultiScaleDeformableAttention", + embed_dims=256, + num_heads=8, + num_levels=3, + num_points=4, + im2col_step=64, + dropout=0.0, + batch_first=False, + norm_cfg=None, + init_cfg=None, + ), + feedforward_channels=1024, + ffn_dropout=0.0, + operation_order=("self_attn", "norm", "ffn", "norm"), + ), + init_cfg=None, + ), + positional_encoding=dict(type="SinePositionalEncoding", num_feats=128, normalize=True), + init_cfg=None, + ): + super().__init__(init_cfg=init_cfg) + self.strides = strides + self.num_input_levels = len(in_channels) + self.num_encoder_levels = encoder.transformerlayers.attn_cfgs.num_levels + assert self.num_encoder_levels >= 1, "num_levels in attn_cfgs must be at least one" + input_conv_list = [] + # from top to down (low to high resolution) + for i in range(self.num_input_levels - 1, self.num_input_levels - self.num_encoder_levels - 1, -1): + input_conv = ConvModule( + in_channels[i], feat_channels, kernel_size=1, norm_cfg=norm_cfg, act_cfg=None, bias=True + ) + input_conv_list.append(input_conv) + self.input_convs = ModuleList(input_conv_list) + + self.encoder = build_transformer_layer_sequence(encoder) + self.postional_encoding = build_positional_encoding(positional_encoding) + # high resolution to low resolution + self.level_encoding = nn.Embedding(self.num_encoder_levels, feat_channels) + + # fpn-like structure + self.lateral_convs = ModuleList() + self.output_convs = ModuleList() + self.use_bias = norm_cfg is None + # from top to down (low to high resolution) + # fpn for the rest features that didn't pass in encoder + for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1, -1): + lateral_conv = ConvModule( + in_channels[i], feat_channels, kernel_size=1, bias=self.use_bias, norm_cfg=norm_cfg, act_cfg=None + ) + output_conv = ConvModule( + feat_channels, + feat_channels, + kernel_size=3, + stride=1, + padding=1, + bias=self.use_bias, + norm_cfg=norm_cfg, + act_cfg=act_cfg, + ) + self.lateral_convs.append(lateral_conv) + self.output_convs.append(output_conv) + + self.mask_feature = Conv2d(feat_channels, out_channels, kernel_size=1, stride=1, padding=0) + + self.num_outs = num_outs + self.point_generator = MlvlPointGenerator(strides) + + def init_weights(self): + """Initialize weights.""" + for i in range(0, self.num_encoder_levels): + xavier_init(self.input_convs[i].conv, gain=1, bias=0, distribution="uniform") + + for i in range(0, self.num_input_levels - self.num_encoder_levels): + caffe2_xavier_init(self.lateral_convs[i].conv, bias=0) + caffe2_xavier_init(self.output_convs[i].conv, bias=0) + + caffe2_xavier_init(self.mask_feature, bias=0) + + normal_init(self.level_encoding, mean=0, std=1) + for p in self.encoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + # init_weights defined in MultiScaleDeformableAttention + for layer in self.encoder.layers: + for attn in layer.attentions: + if isinstance(attn, MultiScaleDeformableAttention): + attn.init_weights() + + def forward(self, feats): + """ + Args: + feats (list[Tensor]): Feature maps of each level. Each has + shape of (batch_size, c, h, w). + + Returns: + tuple: A tuple containing the following: + + - mask_feature (Tensor): shape (batch_size, c, h, w). + - multi_scale_features (list[Tensor]): Multi scale \ + features, each in shape (batch_size, c, h, w). + """ + # generate padding mask for each level, for each image + batch_size = feats[0].shape[0] + encoder_input_list = [] + padding_mask_list = [] + level_positional_encoding_list = [] + spatial_shapes = [] + reference_points_list = [] + for i in range(self.num_encoder_levels): + level_idx = self.num_input_levels - i - 1 + feat = feats[level_idx] + feat_projected = self.input_convs[i](feat) + h, w = feat.shape[-2:] + + # no padding + padding_mask_resized = feat.new_zeros((batch_size,) + feat.shape[-2:], dtype=torch.bool) + pos_embed = self.postional_encoding(padding_mask_resized) + level_embed = self.level_encoding.weight[i] + level_pos_embed = level_embed.view(1, -1, 1, 1) + pos_embed + # (h_i * w_i, 2) + reference_points = self.point_generator.single_level_grid_priors( + feat.shape[-2:], level_idx, device=feat.device + ) + # normalize + factor = feat.new_tensor([[w, h]]) * self.strides[level_idx] + reference_points = reference_points / factor + + # shape (batch_size, c, h_i, w_i) -> (h_i * w_i, batch_size, c) + feat_projected = feat_projected.flatten(2).permute(2, 0, 1) + level_pos_embed = level_pos_embed.flatten(2).permute(2, 0, 1) + padding_mask_resized = padding_mask_resized.flatten(1) + + encoder_input_list.append(feat_projected) + padding_mask_list.append(padding_mask_resized) + level_positional_encoding_list.append(level_pos_embed) + spatial_shapes.append(feat.shape[-2:]) + reference_points_list.append(reference_points) + # shape (batch_size, total_num_query), + # total_num_query=sum([., h_i * w_i,.]) + padding_masks = torch.cat(padding_mask_list, dim=1) + # shape (total_num_query, batch_size, c) + encoder_inputs = torch.cat(encoder_input_list, dim=0) + level_positional_encodings = torch.cat(level_positional_encoding_list, dim=0) + device = encoder_inputs.device + # shape (num_encoder_levels, 2), from low + # resolution to high resolution + spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=device) + # shape (0, h_0*w_0, h_0*w_0+h_1*w_1, ...) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + reference_points = torch.cat(reference_points_list, dim=0) + reference_points = reference_points[None, :, None].repeat(batch_size, 1, self.num_encoder_levels, 1) + valid_radios = reference_points.new_ones((batch_size, self.num_encoder_levels, 2)) + # shape (num_total_query, batch_size, c) + memory = self.encoder( + query=encoder_inputs, + key=None, + value=None, + query_pos=level_positional_encodings, + key_pos=None, + attn_masks=None, + key_padding_mask=None, + query_key_padding_mask=padding_masks, + spatial_shapes=spatial_shapes, + reference_points=reference_points, + level_start_index=level_start_index, + valid_radios=valid_radios, + ) + # (num_total_query, batch_size, c) -> (batch_size, c, num_total_query) + memory = memory.permute(1, 2, 0) + + # from low resolution to high resolution + num_query_per_level = [e[0] * e[1] for e in spatial_shapes] + outs = torch.split(memory, num_query_per_level, dim=-1) + outs = [x.reshape(batch_size, -1, spatial_shapes[i][0], spatial_shapes[i][1]) for i, x in enumerate(outs)] + + for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1, -1): + x = feats[i] + cur_feat = self.lateral_convs[i](x) + y = cur_feat + F.interpolate(outs[-1], size=cur_feat.shape[-2:], mode="bilinear", align_corners=False) + y = self.output_convs[i](y) + outs.append(y) + multi_scale_features = outs[: self.num_outs] + + mask_feature = self.mask_feature(outs[-1]) + return mask_feature, multi_scale_features diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..55134e42d47a2e5dfca4c2abf68009442a85ad00 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .encoder_decoder_mask2former import EncoderDecoderMask2Former diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py new file mode 100644 index 0000000000000000000000000000000000000000..114814f0a4a320def9c537eb46346d4bd2d38f4d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py @@ -0,0 +1,271 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmseg.core import add_prefix +from mmseg.models import builder +from mmseg.models.builder import SEGMENTORS +from mmseg.models.segmentors.base import BaseSegmentor +from mmseg.ops import resize + + +@SEGMENTORS.register_module() +class EncoderDecoderMask2Former(BaseSegmentor): + """Encoder Decoder segmentors. + + EncoderDecoder typically consists of backbone, decode_head, auxiliary_head. + Note that auxiliary_head is only used for deep supervision during training, + which could be dumped during inference. + """ + + def __init__( + self, + backbone, + decode_head, + neck=None, + auxiliary_head=None, + train_cfg=None, + test_cfg=None, + pretrained=None, + init_cfg=None, + ): + super(EncoderDecoderMask2Former, self).__init__(init_cfg) + if pretrained is not None: + assert backbone.get("pretrained") is None, "both backbone and segmentor set pretrained weight" + backbone.pretrained = pretrained + self.backbone = builder.build_backbone(backbone) + if neck is not None: + self.neck = builder.build_neck(neck) + decode_head.update(train_cfg=train_cfg) + decode_head.update(test_cfg=test_cfg) + self._init_decode_head(decode_head) + self._init_auxiliary_head(auxiliary_head) + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + assert self.with_decode_head + + def _init_decode_head(self, decode_head): + """Initialize ``decode_head``""" + self.decode_head = builder.build_head(decode_head) + self.align_corners = self.decode_head.align_corners + self.num_classes = self.decode_head.num_classes + + def _init_auxiliary_head(self, auxiliary_head): + """Initialize ``auxiliary_head``""" + if auxiliary_head is not None: + if isinstance(auxiliary_head, list): + self.auxiliary_head = nn.ModuleList() + for head_cfg in auxiliary_head: + self.auxiliary_head.append(builder.build_head(head_cfg)) + else: + self.auxiliary_head = builder.build_head(auxiliary_head) + + def extract_feat(self, img): + """Extract features from images.""" + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def encode_decode(self, img, img_metas): + """Encode images with backbone and decode into a semantic segmentation + map of the same size as input.""" + x = self.extract_feat(img) + out = self._decode_head_forward_test(x, img_metas) + out = resize(input=out, size=img.shape[2:], mode="bilinear", align_corners=self.align_corners) + return out + + def _decode_head_forward_train(self, x, img_metas, gt_semantic_seg, **kwargs): + """Run forward function and calculate loss for decode head in + training.""" + losses = dict() + loss_decode = self.decode_head.forward_train(x, img_metas, gt_semantic_seg, **kwargs) + + losses.update(add_prefix(loss_decode, "decode")) + return losses + + def _decode_head_forward_test(self, x, img_metas): + """Run forward function and calculate loss for decode head in + inference.""" + seg_logits = self.decode_head.forward_test(x, img_metas, self.test_cfg) + return seg_logits + + def _auxiliary_head_forward_train(self, x, img_metas, gt_semantic_seg): + """Run forward function and calculate loss for auxiliary head in + training.""" + losses = dict() + if isinstance(self.auxiliary_head, nn.ModuleList): + for idx, aux_head in enumerate(self.auxiliary_head): + loss_aux = aux_head.forward_train(x, img_metas, gt_semantic_seg, self.train_cfg) + losses.update(add_prefix(loss_aux, f"aux_{idx}")) + else: + loss_aux = self.auxiliary_head.forward_train(x, img_metas, gt_semantic_seg, self.train_cfg) + losses.update(add_prefix(loss_aux, "aux")) + + return losses + + def forward_dummy(self, img): + """Dummy forward function.""" + seg_logit = self.encode_decode(img, None) + + return seg_logit + + def forward_train(self, img, img_metas, gt_semantic_seg, **kwargs): + """Forward function for training. + + Args: + img (Tensor): Input images. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `mmseg/datasets/pipelines/formatting.py:Collect`. + gt_semantic_seg (Tensor): Semantic segmentation masks + used if the architecture supports semantic segmentation task. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + + x = self.extract_feat(img) + + losses = dict() + + loss_decode = self._decode_head_forward_train(x, img_metas, gt_semantic_seg, **kwargs) + losses.update(loss_decode) + + if self.with_auxiliary_head: + loss_aux = self._auxiliary_head_forward_train(x, img_metas, gt_semantic_seg) + losses.update(loss_aux) + + return losses + + def slide_inference(self, img, img_meta, rescale): + """Inference by sliding-window with overlap. + + If h_crop > h_img or w_crop > w_img, the small patch will be used to + decode without padding. + """ + + h_stride, w_stride = self.test_cfg.stride + h_crop, w_crop = self.test_cfg.crop_size + batch_size, _, h_img, w_img = img.size() + num_classes = self.num_classes + h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1 + w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1 + preds = img.new_zeros((batch_size, num_classes, h_img, w_img)) + count_mat = img.new_zeros((batch_size, 1, h_img, w_img)) + for h_idx in range(h_grids): + for w_idx in range(w_grids): + y1 = h_idx * h_stride + x1 = w_idx * w_stride + y2 = min(y1 + h_crop, h_img) + x2 = min(x1 + w_crop, w_img) + y1 = max(y2 - h_crop, 0) + x1 = max(x2 - w_crop, 0) + crop_img = img[:, :, y1:y2, x1:x2] + crop_seg_logit = self.encode_decode(crop_img, img_meta) + preds += F.pad(crop_seg_logit, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2))) + + count_mat[:, :, y1:y2, x1:x2] += 1 + assert (count_mat == 0).sum() == 0 + if torch.onnx.is_in_onnx_export(): + # cast count_mat to constant while exporting to ONNX + count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device) + preds = preds / count_mat + if rescale: + preds = resize( + preds, + size=img_meta[0]["ori_shape"][:2], + mode="bilinear", + align_corners=self.align_corners, + warning=False, + ) + return preds + + def whole_inference(self, img, img_meta, rescale): + """Inference with full image.""" + + seg_logit = self.encode_decode(img, img_meta) + if rescale: + # support dynamic shape for onnx + if torch.onnx.is_in_onnx_export(): + size = img.shape[2:] + else: + size = img_meta[0]["ori_shape"][:2] + seg_logit = resize(seg_logit, size=size, mode="bilinear", align_corners=self.align_corners, warning=False) + + return seg_logit + + def inference(self, img, img_meta, rescale): + """Inference with slide/whole style. + + Args: + img (Tensor): The input image of shape (N, 3, H, W). + img_meta (dict): Image info dict where each dict has: 'img_shape', + 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `mmseg/datasets/pipelines/formatting.py:Collect`. + rescale (bool): Whether rescale back to original shape. + + Returns: + Tensor: The output segmentation map. + """ + + assert self.test_cfg.mode in ["slide", "whole"] + ori_shape = img_meta[0]["ori_shape"] + assert all(_["ori_shape"] == ori_shape for _ in img_meta) + if self.test_cfg.mode == "slide": + seg_logit = self.slide_inference(img, img_meta, rescale) + else: + seg_logit = self.whole_inference(img, img_meta, rescale) + output = F.softmax(seg_logit, dim=1) + flip = img_meta[0]["flip"] + if flip: + flip_direction = img_meta[0]["flip_direction"] + assert flip_direction in ["horizontal", "vertical"] + if flip_direction == "horizontal": + output = output.flip(dims=(3,)) + elif flip_direction == "vertical": + output = output.flip(dims=(2,)) + + return output + + def simple_test(self, img, img_meta, rescale=True): + """Simple test with single image.""" + seg_logit = self.inference(img, img_meta, rescale) + seg_pred = seg_logit.argmax(dim=1) + if torch.onnx.is_in_onnx_export(): + # our inference backend only support 4D output + seg_pred = seg_pred.unsqueeze(0) + return seg_pred + seg_pred = seg_pred.cpu().numpy() + # unravel batch dim + seg_pred = list(seg_pred) + return seg_pred + + def aug_test(self, imgs, img_metas, rescale=True): + """Test with augmentations. + + Only rescale=True is supported. + """ + # aug_test rescale all imgs back to ori_shape for now + assert rescale + # to save memory, we get augmented seg logit inplace + seg_logit = self.inference(imgs[0], img_metas[0], rescale) + for i in range(1, len(imgs)): + cur_seg_logit = self.inference(imgs[i], img_metas[i], rescale) + seg_logit += cur_seg_logit + seg_logit /= len(imgs) + seg_pred = seg_logit.argmax(dim=1) + seg_pred = seg_pred.cpu().numpy() + # unravel batch dim + seg_pred = list(seg_pred) + return seg_pred diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..88816cff94ebf10742e36fe5f55c8837fb70ea56 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .assigner import MaskHungarianAssigner +from .point_sample import get_uncertain_point_coords_with_randomness +from .positional_encoding import LearnedPositionalEncoding, SinePositionalEncoding +from .transformer import DetrTransformerDecoder, DetrTransformerDecoderLayer, DynamicConv, Transformer diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/assigner.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/assigner.py new file mode 100644 index 0000000000000000000000000000000000000000..e830e9ea8639a68a46d1211dcb25901ef21a062e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/assigner.py @@ -0,0 +1,157 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from abc import ABCMeta, abstractmethod + +import torch + +from ..builder import MASK_ASSIGNERS, build_match_cost + +try: + from scipy.optimize import linear_sum_assignment +except ImportError: + linear_sum_assignment = None + + +class AssignResult(metaclass=ABCMeta): + """Collection of assign results.""" + + def __init__(self, num_gts, gt_inds, labels): + self.num_gts = num_gts + self.gt_inds = gt_inds + self.labels = labels + + @property + def info(self): + info = { + "num_gts": self.num_gts, + "gt_inds": self.gt_inds, + "labels": self.labels, + } + return info + + +class BaseAssigner(metaclass=ABCMeta): + """Base assigner that assigns boxes to ground truth boxes.""" + + @abstractmethod + def assign(self, masks, gt_masks, gt_masks_ignore=None, gt_labels=None): + """Assign boxes to either a ground truth boxes or a negative boxes.""" + pass + + +@MASK_ASSIGNERS.register_module() +class MaskHungarianAssigner(BaseAssigner): + """Computes one-to-one matching between predictions and ground truth for + mask. + + This class computes an assignment between the targets and the predictions + based on the costs. The costs are weighted sum of three components: + classification cost, regression L1 cost and regression iou cost. The + targets don't include the no_object, so generally there are more + predictions than targets. After the one-to-one matching, the un-matched + are treated as backgrounds. Thus each query prediction will be assigned + with `0` or a positive integer indicating the ground truth index: + + - 0: negative sample, no assigned gt + - positive integer: positive sample, index (1-based) of assigned gt + + Args: + cls_cost (obj:`mmcv.ConfigDict`|dict): Classification cost config. + mask_cost (obj:`mmcv.ConfigDict`|dict): Mask cost config. + dice_cost (obj:`mmcv.ConfigDict`|dict): Dice cost config. + """ + + def __init__( + self, + cls_cost=dict(type="ClassificationCost", weight=1.0), + dice_cost=dict(type="DiceCost", weight=1.0), + mask_cost=dict(type="MaskFocalCost", weight=1.0), + ): + self.cls_cost = build_match_cost(cls_cost) + self.dice_cost = build_match_cost(dice_cost) + self.mask_cost = build_match_cost(mask_cost) + + def assign(self, cls_pred, mask_pred, gt_labels, gt_masks, img_meta, gt_masks_ignore=None, eps=1e-7): + """Computes one-to-one matching based on the weighted costs. + + This method assign each query prediction to a ground truth or + background. The `assigned_gt_inds` with -1 means don't care, + 0 means negative sample, and positive number is the index (1-based) + of assigned gt. + The assignment is done in the following steps, the order matters. + + 1. assign every prediction to -1 + 2. compute the weighted costs + 3. do Hungarian matching on CPU based on the costs + 4. assign all to 0 (background) first, then for each matched pair + between predictions and gts, treat this prediction as foreground + and assign the corresponding gt index (plus 1) to it. + + Args: + mask_pred (Tensor): Predicted mask, shape [num_query, h, w] + cls_pred (Tensor): Predicted classification logits, shape + [num_query, num_class]. + gt_masks (Tensor): Ground truth mask, shape [num_gt, h, w]. + gt_labels (Tensor): Label of `gt_masks`, shape (num_gt,). + img_meta (dict): Meta information for current image. + gt_masks_ignore (Tensor, optional): Ground truth masks that are + labelled as `ignored`. Default None. + eps (int | float, optional): A value added to the denominator for + numerical stability. Default 1e-7. + + Returns: + :obj:`AssignResult`: The assigned result. + """ + assert gt_masks_ignore is None, "Only case when gt_masks_ignore is None is supported." + num_gts, num_queries = gt_labels.shape[0], cls_pred.shape[0] + + # 1. assign -1 by default + assigned_gt_inds = cls_pred.new_full((num_queries,), -1, dtype=torch.long) + assigned_labels = cls_pred.new_full((num_queries,), -1, dtype=torch.long) + if num_gts == 0 or num_queries == 0: + # No ground truth or boxes, return empty assignment + if num_gts == 0: + # No ground truth, assign all to background + assigned_gt_inds[:] = 0 + return AssignResult(num_gts, assigned_gt_inds, labels=assigned_labels) + + # 2. compute the weighted costs + # classification and maskcost. + if self.cls_cost.weight != 0 and cls_pred is not None: + cls_cost = self.cls_cost(cls_pred, gt_labels) + else: + cls_cost = 0 + + if self.mask_cost.weight != 0: + # mask_pred shape = [nq, h, w] + # gt_mask shape = [ng, h, w] + # mask_cost shape = [nq, ng] + mask_cost = self.mask_cost(mask_pred, gt_masks) + else: + mask_cost = 0 + + if self.dice_cost.weight != 0: + dice_cost = self.dice_cost(mask_pred, gt_masks) + else: + dice_cost = 0 + cost = cls_cost + mask_cost + dice_cost + + # 3. do Hungarian matching on CPU using linear_sum_assignment + cost = cost.detach().cpu() + if linear_sum_assignment is None: + raise ImportError('Please run "pip install scipy" ' "to install scipy first.") + + matched_row_inds, matched_col_inds = linear_sum_assignment(cost) + matched_row_inds = torch.from_numpy(matched_row_inds).to(cls_pred.device) + matched_col_inds = torch.from_numpy(matched_col_inds).to(cls_pred.device) + + # 4. assign backgrounds and foregrounds + # assign all indices to backgrounds first + assigned_gt_inds[:] = 0 + # assign foregrounds based on matching results + assigned_gt_inds[matched_row_inds] = matched_col_inds + 1 + assigned_labels[matched_row_inds] = gt_labels[matched_col_inds] + return AssignResult(num_gts, assigned_gt_inds, labels=assigned_labels) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/point_sample.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/point_sample.py new file mode 100644 index 0000000000000000000000000000000000000000..7415a8cb00375fbf985dbedc67205dfe916742ad --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/point_sample.py @@ -0,0 +1,86 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +from mmcv.ops import point_sample + + +def get_uncertainty(mask_pred, labels): + """Estimate uncertainty based on pred logits. + + We estimate uncertainty as L1 distance between 0.0 and the logits + prediction in 'mask_pred' for the foreground class in `classes`. + + Args: + mask_pred (Tensor): mask predication logits, shape (num_rois, + num_classes, mask_height, mask_width). + + labels (list[Tensor]): Either predicted or ground truth label for + each predicted mask, of length num_rois. + + Returns: + scores (Tensor): Uncertainty scores with the most uncertain + locations having the highest uncertainty score, + shape (num_rois, 1, mask_height, mask_width) + """ + if mask_pred.shape[1] == 1: + gt_class_logits = mask_pred.clone() + else: + inds = torch.arange(mask_pred.shape[0], device=mask_pred.device) + gt_class_logits = mask_pred[inds, labels].unsqueeze(1) + return -torch.abs(gt_class_logits) + + +def get_uncertain_point_coords_with_randomness( + mask_pred, labels, num_points, oversample_ratio, importance_sample_ratio +): + """Get ``num_points`` most uncertain points with random points during + train. + + Sample points in [0, 1] x [0, 1] coordinate space based on their + uncertainty. The uncertainties are calculated for each point using + 'get_uncertainty()' function that takes point's logit prediction as + input. + + Args: + mask_pred (Tensor): A tensor of shape (num_rois, num_classes, + mask_height, mask_width) for class-specific or class-agnostic + prediction. + labels (list): The ground truth class for each instance. + num_points (int): The number of points to sample. + oversample_ratio (int): Oversampling parameter. + importance_sample_ratio (float): Ratio of points that are sampled + via importnace sampling. + + Returns: + point_coords (Tensor): A tensor of shape (num_rois, num_points, 2) + that contains the coordinates sampled points. + """ + assert oversample_ratio >= 1 + assert 0 <= importance_sample_ratio <= 1 + batch_size = mask_pred.shape[0] + num_sampled = int(num_points * oversample_ratio) + point_coords = torch.rand(batch_size, num_sampled, 2, device=mask_pred.device) + point_logits = point_sample(mask_pred, point_coords) + # It is crucial to calculate uncertainty based on the sampled + # prediction value for the points. Calculating uncertainties of the + # coarse predictions first and sampling them for points leads to + # incorrect results. To illustrate this: assume uncertainty func( + # logits)=-abs(logits), a sampled point between two coarse + # predictions with -1 and 1 logits has 0 logits, and therefore 0 + # uncertainty value. However, if we calculate uncertainties for the + # coarse predictions first, both will have -1 uncertainty, + # and sampled point will get -1 uncertainty. + point_uncertainties = get_uncertainty(point_logits, labels) + num_uncertain_points = int(importance_sample_ratio * num_points) + num_random_points = num_points - num_uncertain_points + idx = torch.topk(point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1] + shift = num_sampled * torch.arange(batch_size, dtype=torch.long, device=mask_pred.device) + idx += shift[:, None] + point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(batch_size, num_uncertain_points, 2) + if num_random_points > 0: + rand_roi_coords = torch.rand(batch_size, num_random_points, 2, device=mask_pred.device) + point_coords = torch.cat((point_coords, rand_roi_coords), dim=1) + return point_coords diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..aef444a9ab642305f29cc8b1cf10e398668b3766 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py @@ -0,0 +1,152 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +from mmcv.cnn.bricks.transformer import POSITIONAL_ENCODING +from mmcv.runner import BaseModule + + +@POSITIONAL_ENCODING.register_module() +class SinePositionalEncoding(BaseModule): + """Position encoding with sine and cosine functions. + + See `End-to-End Object Detection with Transformers + `_ for details. + + Args: + num_feats (int): The feature dimension for each position + along x-axis or y-axis. Note the final returned dimension + for each position is 2 times of this value. + temperature (int, optional): The temperature used for scaling + the position embedding. Defaults to 10000. + normalize (bool, optional): Whether to normalize the position + embedding. Defaults to False. + scale (float, optional): A scale factor that scales the position + embedding. The scale will be used only when `normalize` is True. + Defaults to 2*pi. + eps (float, optional): A value added to the denominator for + numerical stability. Defaults to 1e-6. + offset (float): offset add to embed when do the normalization. + Defaults to 0. + init_cfg (dict or list[dict], optional): Initialization config dict. + Default: None + """ + + def __init__( + self, num_feats, temperature=10000, normalize=False, scale=2 * math.pi, eps=1e-6, offset=0.0, init_cfg=None + ): + super(SinePositionalEncoding, self).__init__(init_cfg) + if normalize: + assert isinstance(scale, (float, int)), ( + "when normalize is set," "scale should be provided and in float or int type, " f"found {type(scale)}" + ) + self.num_feats = num_feats + self.temperature = temperature + self.normalize = normalize + self.scale = scale + self.eps = eps + self.offset = offset + + def forward(self, mask): + """Forward function for `SinePositionalEncoding`. + + Args: + mask (Tensor): ByteTensor mask. Non-zero values representing + ignored positions, while zero values means valid positions + for this image. Shape [bs, h, w]. + + Returns: + pos (Tensor): Returned position embedding with shape + [bs, num_feats*2, h, w]. + """ + # For convenience of exporting to ONNX, it's required to convert + # `masks` from bool to int. + mask = mask.to(torch.int) + not_mask = 1 - mask # logical_not + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + if self.normalize: + y_embed = (y_embed + self.offset) / (y_embed[:, -1:, :] + self.eps) * self.scale + x_embed = (x_embed + self.offset) / (x_embed[:, :, -1:] + self.eps) * self.scale + dim_t = torch.arange(self.num_feats, dtype=torch.float32, device=mask.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_feats) + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + # use `view` instead of `flatten` for dynamically exporting to ONNX + B, H, W = mask.size() + pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).view(B, H, W, -1) + pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).view(B, H, W, -1) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + return pos + + def __repr__(self): + """str: a string that describes the module""" + repr_str = self.__class__.__name__ + repr_str += f"(num_feats={self.num_feats}, " + repr_str += f"temperature={self.temperature}, " + repr_str += f"normalize={self.normalize}, " + repr_str += f"scale={self.scale}, " + repr_str += f"eps={self.eps})" + return repr_str + + +@POSITIONAL_ENCODING.register_module() +class LearnedPositionalEncoding(BaseModule): + """Position embedding with learnable embedding weights. + + Args: + num_feats (int): The feature dimension for each position + along x-axis or y-axis. The final returned dimension for + each position is 2 times of this value. + row_num_embed (int, optional): The dictionary size of row embeddings. + Default 50. + col_num_embed (int, optional): The dictionary size of col embeddings. + Default 50. + init_cfg (dict or list[dict], optional): Initialization config dict. + """ + + def __init__(self, num_feats, row_num_embed=50, col_num_embed=50, init_cfg=dict(type="Uniform", layer="Embedding")): + super(LearnedPositionalEncoding, self).__init__(init_cfg) + self.row_embed = nn.Embedding(row_num_embed, num_feats) + self.col_embed = nn.Embedding(col_num_embed, num_feats) + self.num_feats = num_feats + self.row_num_embed = row_num_embed + self.col_num_embed = col_num_embed + + def forward(self, mask): + """Forward function for `LearnedPositionalEncoding`. + + Args: + mask (Tensor): ByteTensor mask. Non-zero values representing + ignored positions, while zero values means valid positions + for this image. Shape [bs, h, w]. + + Returns: + pos (Tensor): Returned position embedding with shape + [bs, num_feats*2, h, w]. + """ + h, w = mask.shape[-2:] + x = torch.arange(w, device=mask.device) + y = torch.arange(h, device=mask.device) + x_embed = self.col_embed(x) + y_embed = self.row_embed(y) + pos = ( + torch.cat((x_embed.unsqueeze(0).repeat(h, 1, 1), y_embed.unsqueeze(1).repeat(1, w, 1)), dim=-1) + .permute(2, 0, 1) + .unsqueeze(0) + .repeat(mask.shape[0], 1, 1, 1) + ) + return pos + + def __repr__(self): + """str: a string that describes the module""" + repr_str = self.__class__.__name__ + repr_str += f"(num_feats={self.num_feats}, " + repr_str += f"row_num_embed={self.row_num_embed}, " + repr_str += f"col_num_embed={self.col_num_embed})" + return repr_str diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/transformer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..f3557d80709a870befeac96267fa7f1018666bb3 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/models/utils/transformer.py @@ -0,0 +1,989 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +import warnings +from typing import Sequence + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as cp +from mmcv.cnn import Linear, build_activation_layer, build_norm_layer, xavier_init +from mmcv.cnn.bricks.drop import build_dropout +from mmcv.cnn.bricks.registry import FEEDFORWARD_NETWORK, TRANSFORMER_LAYER, TRANSFORMER_LAYER_SEQUENCE +from mmcv.cnn.bricks.transformer import BaseTransformerLayer, TransformerLayerSequence, build_transformer_layer_sequence +from mmcv.runner.base_module import BaseModule, Sequential +from mmcv.utils import deprecated_api_warning, to_2tuple +from torch.nn.init import normal_ + +from ..builder import TRANSFORMER + +try: + from mmcv.ops.multi_scale_deform_attn import MultiScaleDeformableAttention + +except ImportError: + warnings.warn( + "`MultiScaleDeformableAttention` in MMCV has been moved to " + "`mmcv.ops.multi_scale_deform_attn`, please update your MMCV" + ) + from mmcv.cnn.bricks.transformer import MultiScaleDeformableAttention + + +class AdaptivePadding(nn.Module): + """Applies padding to input (if needed) so that input can get fully covered + by filter you specified. It support two modes "same" and "corner". The + "same" mode is same with "SAME" padding mode in TensorFlow, pad zero around + input. The "corner" mode would pad zero to bottom right. + + Args: + kernel_size (int | tuple): Size of the kernel: + stride (int | tuple): Stride of the filter. Default: 1: + dilation (int | tuple): Spacing between kernel elements. + Default: 1 + padding (str): Support "same" and "corner", "corner" mode + would pad zero to bottom right, and "same" mode would + pad zero around input. Default: "corner". + Example: + >>> kernel_size = 16 + >>> stride = 16 + >>> dilation = 1 + >>> input = torch.rand(1, 1, 15, 17) + >>> adap_pad = AdaptivePadding( + >>> kernel_size=kernel_size, + >>> stride=stride, + >>> dilation=dilation, + >>> padding="corner") + >>> out = adap_pad(input) + >>> assert (out.shape[2], out.shape[3]) == (16, 32) + >>> input = torch.rand(1, 1, 16, 17) + >>> out = adap_pad(input) + >>> assert (out.shape[2], out.shape[3]) == (16, 32) + """ + + def __init__(self, kernel_size=1, stride=1, dilation=1, padding="corner"): + + super(AdaptivePadding, self).__init__() + + assert padding in ("same", "corner") + + kernel_size = to_2tuple(kernel_size) + stride = to_2tuple(stride) + padding = to_2tuple(padding) + dilation = to_2tuple(dilation) + + self.padding = padding + self.kernel_size = kernel_size + self.stride = stride + self.dilation = dilation + + def get_pad_shape(self, input_shape): + input_h, input_w = input_shape + kernel_h, kernel_w = self.kernel_size + stride_h, stride_w = self.stride + output_h = math.ceil(input_h / stride_h) + output_w = math.ceil(input_w / stride_w) + pad_h = max((output_h - 1) * stride_h + (kernel_h - 1) * self.dilation[0] + 1 - input_h, 0) + pad_w = max((output_w - 1) * stride_w + (kernel_w - 1) * self.dilation[1] + 1 - input_w, 0) + return pad_h, pad_w + + def forward(self, x): + pad_h, pad_w = self.get_pad_shape(x.size()[-2:]) + if pad_h > 0 or pad_w > 0: + if self.padding == "corner": + x = F.pad(x, [0, pad_w, 0, pad_h]) + elif self.padding == "same": + x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2]) + return x + + +class PatchMerging(BaseModule): + """Merge patch feature map. + + This layer groups feature map by kernel_size, and applies norm and linear + layers to the grouped feature map. Our implementation uses `nn.Unfold` to + merge patch, which is about 25% faster than original implementation. + Instead, we need to modify pretrained models for compatibility. + + Args: + in_channels (int): The num of input channels. + to gets fully covered by filter and stride you specified.. + Default: True. + out_channels (int): The num of output channels. + kernel_size (int | tuple, optional): the kernel size in the unfold + layer. Defaults to 2. + stride (int | tuple, optional): the stride of the sliding blocks in the + unfold layer. Default: None. (Would be set as `kernel_size`) + padding (int | tuple | string ): The padding length of + embedding conv. When it is a string, it means the mode + of adaptive padding, support "same" and "corner" now. + Default: "corner". + dilation (int | tuple, optional): dilation parameter in the unfold + layer. Default: 1. + bias (bool, optional): Whether to add bias in linear layer or not. + Defaults: False. + norm_cfg (dict, optional): Config dict for normalization layer. + Default: dict(type='LN'). + init_cfg (dict, optional): The extra config for initialization. + Default: None. + """ + + def __init__( + self, + in_channels, + out_channels, + kernel_size=2, + stride=None, + padding="corner", + dilation=1, + bias=False, + norm_cfg=dict(type="LN"), + init_cfg=None, + ): + super().__init__(init_cfg=init_cfg) + self.in_channels = in_channels + self.out_channels = out_channels + if stride: + stride = stride + else: + stride = kernel_size + + kernel_size = to_2tuple(kernel_size) + stride = to_2tuple(stride) + dilation = to_2tuple(dilation) + + if isinstance(padding, str): + self.adap_padding = AdaptivePadding( + kernel_size=kernel_size, stride=stride, dilation=dilation, padding=padding + ) + # disable the padding of unfold + padding = 0 + else: + self.adap_padding = None + + padding = to_2tuple(padding) + self.sampler = nn.Unfold(kernel_size=kernel_size, dilation=dilation, padding=padding, stride=stride) + + sample_dim = kernel_size[0] * kernel_size[1] * in_channels + + if norm_cfg is not None: + self.norm = build_norm_layer(norm_cfg, sample_dim)[1] + else: + self.norm = None + + self.reduction = nn.Linear(sample_dim, out_channels, bias=bias) + + def forward(self, x, input_size): + """ + Args: + x (Tensor): Has shape (B, H*W, C_in). + input_size (tuple[int]): The spatial shape of x, arrange as (H, W). + Default: None. + + Returns: + tuple: Contains merged results and its spatial shape. + + - x (Tensor): Has shape (B, Merged_H * Merged_W, C_out) + - out_size (tuple[int]): Spatial shape of x, arrange as + (Merged_H, Merged_W). + """ + B, L, C = x.shape + assert isinstance(input_size, Sequence), f"Expect " f"input_size is " f"`Sequence` " f"but get {input_size}" + + H, W = input_size + assert L == H * W, "input feature has wrong size" + + x = x.view(B, H, W, C).permute([0, 3, 1, 2]) # B, C, H, W + # Use nn.Unfold to merge patch. About 25% faster than original method, + # but need to modify pretrained model for compatibility + + if self.adap_padding: + x = self.adap_padding(x) + H, W = x.shape[-2:] + + x = self.sampler(x) + # if kernel_size=2 and stride=2, x should has shape (B, 4*C, H/2*W/2) + + out_h = ( + H + 2 * self.sampler.padding[0] - self.sampler.dilation[0] * (self.sampler.kernel_size[0] - 1) - 1 + ) // self.sampler.stride[0] + 1 + out_w = ( + W + 2 * self.sampler.padding[1] - self.sampler.dilation[1] * (self.sampler.kernel_size[1] - 1) - 1 + ) // self.sampler.stride[1] + 1 + + output_size = (out_h, out_w) + x = x.transpose(1, 2) # B, H/2*W/2, 4*C + x = self.norm(x) if self.norm else x + x = self.reduction(x) + return x, output_size + + +def inverse_sigmoid(x, eps=1e-5): + """Inverse function of sigmoid. + + Args: + x (Tensor): The tensor to do the + inverse. + eps (float): EPS avoid numerical + overflow. Defaults 1e-5. + Returns: + Tensor: The x has passed the inverse + function of sigmoid, has same + shape with input. + """ + x = x.clamp(min=0, max=1) + x1 = x.clamp(min=eps) + x2 = (1 - x).clamp(min=eps) + return torch.log(x1 / x2) + + +@FEEDFORWARD_NETWORK.register_module(force=True) +class FFN(BaseModule): + """Implements feed-forward networks (FFNs) with identity connection. + Args: + embed_dims (int): The feature dimension. Same as + `MultiheadAttention`. Defaults: 256. + feedforward_channels (int): The hidden dimension of FFNs. + Defaults: 1024. + num_fcs (int, optional): The number of fully-connected layers in + FFNs. Default: 2. + act_cfg (dict, optional): The activation config for FFNs. + Default: dict(type='ReLU') + ffn_drop (float, optional): Probability of an element to be + zeroed in FFN. Default 0.0. + add_identity (bool, optional): Whether to add the + identity connection. Default: `True`. + dropout_layer (obj:`ConfigDict`): The dropout_layer used + when adding the shortcut. + init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization. + Default: None. + """ + + @deprecated_api_warning({"dropout": "ffn_drop", "add_residual": "add_identity"}, cls_name="FFN") + def __init__( + self, + embed_dims=256, + feedforward_channels=1024, + num_fcs=2, + act_cfg=dict(type="ReLU", inplace=True), + ffn_drop=0.0, + dropout_layer=None, + add_identity=True, + init_cfg=None, + with_cp=False, + **kwargs, + ): + super().__init__(init_cfg) + assert num_fcs >= 2, "num_fcs should be no less " f"than 2. got {num_fcs}." + self.embed_dims = embed_dims + self.feedforward_channels = feedforward_channels + self.num_fcs = num_fcs + self.act_cfg = act_cfg + self.activate = build_activation_layer(act_cfg) + self.with_cp = with_cp + layers = [] + in_channels = embed_dims + for _ in range(num_fcs - 1): + layers.append(Sequential(Linear(in_channels, feedforward_channels), self.activate, nn.Dropout(ffn_drop))) + in_channels = feedforward_channels + layers.append(Linear(feedforward_channels, embed_dims)) + layers.append(nn.Dropout(ffn_drop)) + self.layers = Sequential(*layers) + self.dropout_layer = build_dropout(dropout_layer) if dropout_layer else torch.nn.Identity() + self.add_identity = add_identity + + @deprecated_api_warning({"residual": "identity"}, cls_name="FFN") + def forward(self, x, identity=None): + """Forward function for `FFN`. + The function would add x to the output tensor if residue is None. + """ + + if self.with_cp and x.requires_grad: + out = cp.checkpoint(self.layers, x) + else: + out = self.layers(x) + + if not self.add_identity: + return self.dropout_layer(out) + if identity is None: + identity = x + return identity + self.dropout_layer(out) + + +@TRANSFORMER_LAYER.register_module() +class DetrTransformerDecoderLayer(BaseTransformerLayer): + """Implements decoder layer in DETR transformer. + + Args: + attn_cfgs (list[`mmcv.ConfigDict`] | list[dict] | dict )): + Configs for self_attention or cross_attention, the order + should be consistent with it in `operation_order`. If it is + a dict, it would be expand to the number of attention in + `operation_order`. + feedforward_channels (int): The hidden dimension for FFNs. + ffn_dropout (float): Probability of an element to be zeroed + in ffn. Default 0.0. + operation_order (tuple[str]): The execution order of operation + in transformer. Such as ('self_attn', 'norm', 'ffn', 'norm'). + Default：None + act_cfg (dict): The activation config for FFNs. Default: `LN` + norm_cfg (dict): Config dict for normalization layer. + Default: `LN`. + ffn_num_fcs (int): The number of fully-connected layers in FFNs. + Default：2. + """ + + def __init__( + self, + attn_cfgs, + feedforward_channels, + ffn_dropout=0.0, + operation_order=None, + act_cfg=dict(type="ReLU", inplace=True), + norm_cfg=dict(type="LN"), + ffn_num_fcs=2, + **kwargs, + ): + super(DetrTransformerDecoderLayer, self).__init__( + attn_cfgs=attn_cfgs, + feedforward_channels=feedforward_channels, + ffn_dropout=ffn_dropout, + operation_order=operation_order, + act_cfg=act_cfg, + norm_cfg=norm_cfg, + ffn_num_fcs=ffn_num_fcs, + **kwargs, + ) + assert len(operation_order) == 6 + assert set(operation_order) == set(["self_attn", "norm", "cross_attn", "ffn"]) + + +@TRANSFORMER_LAYER_SEQUENCE.register_module() +class DetrTransformerEncoder(TransformerLayerSequence): + """TransformerEncoder of DETR. + + Args: + post_norm_cfg (dict): Config of last normalization layer. Default： + `LN`. Only used when `self.pre_norm` is `True` + """ + + def __init__(self, *args, post_norm_cfg=dict(type="LN"), **kwargs): + super(DetrTransformerEncoder, self).__init__(*args, **kwargs) + if post_norm_cfg is not None: + self.post_norm = build_norm_layer(post_norm_cfg, self.embed_dims)[1] if self.pre_norm else None + else: + assert not self.pre_norm, f"Use prenorm in " f"{self.__class__.__name__}," f"Please specify post_norm_cfg" + self.post_norm = None + + def forward(self, *args, **kwargs): + """Forward function for `TransformerCoder`. + + Returns: + Tensor: forwarded results with shape [num_query, bs, embed_dims]. + """ + x = super(DetrTransformerEncoder, self).forward(*args, **kwargs) + if self.post_norm is not None: + x = self.post_norm(x) + return x + + +@TRANSFORMER_LAYER_SEQUENCE.register_module() +class DetrTransformerDecoder(TransformerLayerSequence): + """Implements the decoder in DETR transformer. + + Args: + return_intermediate (bool): Whether to return intermediate outputs. + post_norm_cfg (dict): Config of last normalization layer. Default： + `LN`. + """ + + def __init__(self, *args, post_norm_cfg=dict(type="LN"), return_intermediate=False, **kwargs): + + super(DetrTransformerDecoder, self).__init__(*args, **kwargs) + self.return_intermediate = return_intermediate + if post_norm_cfg is not None: + self.post_norm = build_norm_layer(post_norm_cfg, self.embed_dims)[1] + else: + self.post_norm = None + + def forward(self, query, *args, **kwargs): + """Forward function for `TransformerDecoder`. + + Args: + query (Tensor): Input query with shape + `(num_query, bs, embed_dims)`. + + Returns: + Tensor: Results with shape [1, num_query, bs, embed_dims] when + return_intermediate is `False`, otherwise it has shape + [num_layers, num_query, bs, embed_dims]. + """ + if not self.return_intermediate: + x = super().forward(query, *args, **kwargs) + if self.post_norm: + x = self.post_norm(x)[None] + return x + + intermediate = [] + for layer in self.layers: + query = layer(query, *args, **kwargs) + if self.return_intermediate: + if self.post_norm is not None: + intermediate.append(self.post_norm(query)) + else: + intermediate.append(query) + return torch.stack(intermediate) + + +@TRANSFORMER.register_module() +class Transformer(BaseModule): + """Implements the DETR transformer. + + Following the official DETR implementation, this module copy-paste + from torch.nn.Transformer with modifications: + + * positional encodings are passed in MultiheadAttention + * extra LN at the end of encoder is removed + * decoder returns a stack of activations from all decoding layers + + See `paper: End-to-End Object Detection with Transformers + `_ for details. + + Args: + encoder (`mmcv.ConfigDict` | Dict): Config of + TransformerEncoder. Defaults to None. + decoder ((`mmcv.ConfigDict` | Dict)): Config of + TransformerDecoder. Defaults to None + init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization. + Defaults to None. + """ + + def __init__(self, encoder=None, decoder=None, init_cfg=None): + super(Transformer, self).__init__(init_cfg=init_cfg) + self.encoder = build_transformer_layer_sequence(encoder) + self.decoder = build_transformer_layer_sequence(decoder) + self.embed_dims = self.encoder.embed_dims + + def init_weights(self): + # follow the official DETR to init parameters + for m in self.modules(): + if hasattr(m, "weight") and m.weight.dim() > 1: + xavier_init(m, distribution="uniform") + self._is_init = True + + def forward(self, x, mask, query_embed, pos_embed): + """Forward function for `Transformer`. + + Args: + x (Tensor): Input query with shape [bs, c, h, w] where + c = embed_dims. + mask (Tensor): The key_padding_mask used for encoder and decoder, + with shape [bs, h, w]. + query_embed (Tensor): The query embedding for decoder, with shape + [num_query, c]. + pos_embed (Tensor): The positional encoding for encoder and + decoder, with the same shape as `x`. + + Returns: + tuple[Tensor]: results of decoder containing the following tensor. + + - out_dec: Output from decoder. If return_intermediate_dec \ + is True output has shape [num_dec_layers, bs, + num_query, embed_dims], else has shape [1, bs, \ + num_query, embed_dims]. + - memory: Output results from encoder, with shape \ + [bs, embed_dims, h, w]. + """ + bs, c, h, w = x.shape + # use `view` instead of `flatten` for dynamically exporting to ONNX + x = x.view(bs, c, -1).permute(2, 0, 1) # [bs, c, h, w] -> [h*w, bs, c] + pos_embed = pos_embed.view(bs, c, -1).permute(2, 0, 1) + query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1) # [num_query, dim] -> [num_query, bs, dim] + mask = mask.view(bs, -1) # [bs, h, w] -> [bs, h*w] + memory = self.encoder(query=x, key=None, value=None, query_pos=pos_embed, query_key_padding_mask=mask) + target = torch.zeros_like(query_embed) + # out_dec: [num_layers, num_query, bs, dim] + out_dec = self.decoder( + query=target, key=memory, value=memory, key_pos=pos_embed, query_pos=query_embed, key_padding_mask=mask + ) + out_dec = out_dec.transpose(1, 2) + memory = memory.permute(1, 2, 0).reshape(bs, c, h, w) + return out_dec, memory + + +@TRANSFORMER_LAYER_SEQUENCE.register_module() +class DeformableDetrTransformerDecoder(TransformerLayerSequence): + """Implements the decoder in DETR transformer. + + Args: + return_intermediate (bool): Whether to return intermediate outputs. + coder_norm_cfg (dict): Config of last normalization layer. Default： + `LN`. + """ + + def __init__(self, *args, return_intermediate=False, **kwargs): + + super(DeformableDetrTransformerDecoder, self).__init__(*args, **kwargs) + self.return_intermediate = return_intermediate + + def forward(self, query, *args, reference_points=None, valid_ratios=None, reg_branches=None, **kwargs): + """Forward function for `TransformerDecoder`. + + Args: + query (Tensor): Input query with shape + `(num_query, bs, embed_dims)`. + reference_points (Tensor): The reference + points of offset. has shape + (bs, num_query, 4) when as_two_stage, + otherwise has shape ((bs, num_query, 2). + valid_ratios (Tensor): The radios of valid + points on the feature map, has shape + (bs, num_levels, 2) + reg_branch: (obj:`nn.ModuleList`): Used for + refining the regression results. Only would + be passed when with_box_refine is True, + otherwise would be passed a `None`. + + Returns: + Tensor: Results with shape [1, num_query, bs, embed_dims] when + return_intermediate is `False`, otherwise it has shape + [num_layers, num_query, bs, embed_dims]. + """ + output = query + intermediate = [] + intermediate_reference_points = [] + for lid, layer in enumerate(self.layers): + if reference_points.shape[-1] == 4: + reference_points_input = ( + reference_points[:, :, None] * torch.cat([valid_ratios, valid_ratios], -1)[:, None] + ) + else: + assert reference_points.shape[-1] == 2 + reference_points_input = reference_points[:, :, None] * valid_ratios[:, None] + output = layer(output, *args, reference_points=reference_points_input, **kwargs) + output = output.permute(1, 0, 2) + + if reg_branches is not None: + tmp = reg_branches[lid](output) + if reference_points.shape[-1] == 4: + new_reference_points = tmp + inverse_sigmoid(reference_points) + new_reference_points = new_reference_points.sigmoid() + else: + assert reference_points.shape[-1] == 2 + new_reference_points = tmp + new_reference_points[..., :2] = tmp[..., :2] + inverse_sigmoid(reference_points) + new_reference_points = new_reference_points.sigmoid() + reference_points = new_reference_points.detach() + + output = output.permute(1, 0, 2) + if self.return_intermediate: + intermediate.append(output) + intermediate_reference_points.append(reference_points) + + if self.return_intermediate: + return torch.stack(intermediate), torch.stack(intermediate_reference_points) + + return output, reference_points + + +@TRANSFORMER.register_module() +class DeformableDetrTransformer(Transformer): + """Implements the DeformableDETR transformer. + + Args: + as_two_stage (bool): Generate query from encoder features. + Default: False. + num_feature_levels (int): Number of feature maps from FPN: + Default: 4. + two_stage_num_proposals (int): Number of proposals when set + `as_two_stage` as True. Default: 300. + """ + + def __init__(self, as_two_stage=False, num_feature_levels=4, two_stage_num_proposals=300, **kwargs): + super(DeformableDetrTransformer, self).__init__(**kwargs) + self.as_two_stage = as_two_stage + self.num_feature_levels = num_feature_levels + self.two_stage_num_proposals = two_stage_num_proposals + self.embed_dims = self.encoder.embed_dims + self.init_layers() + + def init_layers(self): + """Initialize layers of the DeformableDetrTransformer.""" + self.level_embeds = nn.Parameter(torch.Tensor(self.num_feature_levels, self.embed_dims)) + + if self.as_two_stage: + self.enc_output = nn.Linear(self.embed_dims, self.embed_dims) + self.enc_output_norm = nn.LayerNorm(self.embed_dims) + self.pos_trans = nn.Linear(self.embed_dims * 2, self.embed_dims * 2) + self.pos_trans_norm = nn.LayerNorm(self.embed_dims * 2) + else: + self.reference_points = nn.Linear(self.embed_dims, 2) + + def init_weights(self): + """Initialize the transformer weights.""" + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + for m in self.modules(): + if isinstance(m, MultiScaleDeformableAttention): + m.init_weights() + if not self.as_two_stage: + xavier_init(self.reference_points, distribution="uniform", bias=0.0) + normal_(self.level_embeds) + + def gen_encoder_output_proposals(self, memory, memory_padding_mask, spatial_shapes): + """Generate proposals from encoded memory. + + Args: + memory (Tensor) : The output of encoder, + has shape (bs, num_key, embed_dim). num_key is + equal the number of points on feature map from + all level. + memory_padding_mask (Tensor): Padding mask for memory. + has shape (bs, num_key). + spatial_shapes (Tensor): The shape of all feature maps. + has shape (num_level, 2). + + Returns: + tuple: A tuple of feature map and bbox prediction. + + - output_memory (Tensor): The input of decoder, \ + has shape (bs, num_key, embed_dim). num_key is \ + equal the number of points on feature map from \ + all levels. + - output_proposals (Tensor): The normalized proposal \ + after a inverse sigmoid, has shape \ + (bs, num_keys, 4). + """ + + N, S, C = memory.shape + proposals = [] + _cur = 0 + for lvl, (H, W) in enumerate(spatial_shapes): + mask_flatten_ = memory_padding_mask[:, _cur : (_cur + H * W)].view(N, H, W, 1) + valid_H = torch.sum(~mask_flatten_[:, :, 0, 0], 1) + valid_W = torch.sum(~mask_flatten_[:, 0, :, 0], 1) + + grid_y, grid_x = torch.meshgrid( + torch.linspace(0, H - 1, H, dtype=torch.float32, device=memory.device), + torch.linspace(0, W - 1, W, dtype=torch.float32, device=memory.device), + ) + grid = torch.cat([grid_x.unsqueeze(-1), grid_y.unsqueeze(-1)], -1) + + scale = torch.cat([valid_W.unsqueeze(-1), valid_H.unsqueeze(-1)], 1).view(N, 1, 1, 2) + grid = (grid.unsqueeze(0).expand(N, -1, -1, -1) + 0.5) / scale + wh = torch.ones_like(grid) * 0.05 * (2.0**lvl) + proposal = torch.cat((grid, wh), -1).view(N, -1, 4) + proposals.append(proposal) + _cur += H * W + output_proposals = torch.cat(proposals, 1) + output_proposals_valid = ((output_proposals > 0.01) & (output_proposals < 0.99)).all(-1, keepdim=True) + output_proposals = torch.log(output_proposals / (1 - output_proposals)) + output_proposals = output_proposals.masked_fill(memory_padding_mask.unsqueeze(-1), float("inf")) + output_proposals = output_proposals.masked_fill(~output_proposals_valid, float("inf")) + + output_memory = memory + output_memory = output_memory.masked_fill(memory_padding_mask.unsqueeze(-1), float(0)) + output_memory = output_memory.masked_fill(~output_proposals_valid, float(0)) + output_memory = self.enc_output_norm(self.enc_output(output_memory)) + return output_memory, output_proposals + + @staticmethod + def get_reference_points(spatial_shapes, valid_ratios, device): + """Get the reference points used in decoder. + + Args: + spatial_shapes (Tensor): The shape of all + feature maps, has shape (num_level, 2). + valid_ratios (Tensor): The radios of valid + points on the feature map, has shape + (bs, num_levels, 2) + device (obj:`device`): The device where + reference_points should be. + + Returns: + Tensor: reference points used in decoder, has \ + shape (bs, num_keys, num_levels, 2). + """ + reference_points_list = [] + for lvl, (H, W) in enumerate(spatial_shapes): + ref_y, ref_x = torch.meshgrid( + torch.linspace(0.5, H - 0.5, H, dtype=torch.float32, device=device), + torch.linspace(0.5, W - 0.5, W, dtype=torch.float32, device=device), + ) + ref_y = ref_y.reshape(-1)[None] / (valid_ratios[:, None, lvl, 1] * H) + ref_x = ref_x.reshape(-1)[None] / (valid_ratios[:, None, lvl, 0] * W) + ref = torch.stack((ref_x, ref_y), -1) + reference_points_list.append(ref) + reference_points = torch.cat(reference_points_list, 1) + reference_points = reference_points[:, :, None] * valid_ratios[:, None] + return reference_points + + def get_valid_ratio(self, mask): + """Get the valid radios of feature maps of all level.""" + _, H, W = mask.shape + valid_H = torch.sum(~mask[:, :, 0], 1) + valid_W = torch.sum(~mask[:, 0, :], 1) + valid_ratio_h = valid_H.float() / H + valid_ratio_w = valid_W.float() / W + valid_ratio = torch.stack([valid_ratio_w, valid_ratio_h], -1) + return valid_ratio + + def get_proposal_pos_embed(self, proposals, num_pos_feats=128, temperature=10000): + """Get the position embedding of proposal.""" + scale = 2 * math.pi + dim_t = torch.arange(num_pos_feats, dtype=torch.float32, device=proposals.device) + dim_t = temperature ** (2 * (dim_t // 2) / num_pos_feats) + # N, L, 4 + proposals = proposals.sigmoid() * scale + # N, L, 4, 128 + pos = proposals[:, :, :, None] / dim_t + # N, L, 4, 64, 2 + pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()), dim=4).flatten(2) + return pos + + def forward( + self, mlvl_feats, mlvl_masks, query_embed, mlvl_pos_embeds, reg_branches=None, cls_branches=None, **kwargs + ): + """Forward function for `Transformer`. + + Args: + mlvl_feats (list(Tensor)): Input queries from + different level. Each element has shape + [bs, embed_dims, h, w]. + mlvl_masks (list(Tensor)): The key_padding_mask from + different level used for encoder and decoder, + each element has shape [bs, h, w]. + query_embed (Tensor): The query embedding for decoder, + with shape [num_query, c]. + mlvl_pos_embeds (list(Tensor)): The positional encoding + of feats from different level, has the shape + [bs, embed_dims, h, w]. + reg_branches (obj:`nn.ModuleList`): Regression heads for + feature maps from each decoder layer. Only would + be passed when + `with_box_refine` is True. Default to None. + cls_branches (obj:`nn.ModuleList`): Classification heads + for feature maps from each decoder layer. Only would + be passed when `as_two_stage` + is True. Default to None. + + + Returns: + tuple[Tensor]: results of decoder containing the following tensor. + + - inter_states: Outputs from decoder. If + return_intermediate_dec is True output has shape \ + (num_dec_layers, bs, num_query, embed_dims), else has \ + shape (1, bs, num_query, embed_dims). + - init_reference_out: The initial value of reference \ + points, has shape (bs, num_queries, 4). + - inter_references_out: The internal value of reference \ + points in decoder, has shape \ + (num_dec_layers, bs,num_query, embed_dims) + - enc_outputs_class: The classification score of \ + proposals generated from \ + encoder's feature maps, has shape \ + (batch, h*w, num_classes). \ + Only would be returned when `as_two_stage` is True, \ + otherwise None. + - enc_outputs_coord_unact: The regression results \ + generated from encoder's feature maps., has shape \ + (batch, h*w, 4). Only would \ + be returned when `as_two_stage` is True, \ + otherwise None. + """ + assert self.as_two_stage or query_embed is not None + + feat_flatten = [] + mask_flatten = [] + lvl_pos_embed_flatten = [] + spatial_shapes = [] + for lvl, (feat, mask, pos_embed) in enumerate(zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)): + bs, c, h, w = feat.shape + spatial_shape = (h, w) + spatial_shapes.append(spatial_shape) + feat = feat.flatten(2).transpose(1, 2) + mask = mask.flatten(1) + pos_embed = pos_embed.flatten(2).transpose(1, 2) + lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(1, 1, -1) + lvl_pos_embed_flatten.append(lvl_pos_embed) + feat_flatten.append(feat) + mask_flatten.append(mask) + feat_flatten = torch.cat(feat_flatten, 1) + mask_flatten = torch.cat(mask_flatten, 1) + lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1) + spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=feat_flatten.device) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + valid_ratios = torch.stack([self.get_valid_ratio(m) for m in mlvl_masks], 1) + + reference_points = self.get_reference_points(spatial_shapes, valid_ratios, device=feat.device) + + feat_flatten = feat_flatten.permute(1, 0, 2) # (H*W, bs, embed_dims) + lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(1, 0, 2) # (H*W, bs, embed_dims) + memory = self.encoder( + query=feat_flatten, + key=None, + value=None, + query_pos=lvl_pos_embed_flatten, + query_key_padding_mask=mask_flatten, + spatial_shapes=spatial_shapes, + reference_points=reference_points, + level_start_index=level_start_index, + valid_ratios=valid_ratios, + **kwargs, + ) + + memory = memory.permute(1, 0, 2) + bs, _, c = memory.shape + if self.as_two_stage: + output_memory, output_proposals = self.gen_encoder_output_proposals(memory, mask_flatten, spatial_shapes) + enc_outputs_class = cls_branches[self.decoder.num_layers](output_memory) + enc_outputs_coord_unact = reg_branches[self.decoder.num_layers](output_memory) + output_proposals + + topk = self.two_stage_num_proposals + topk_proposals = torch.topk(enc_outputs_class[..., 0], topk, dim=1)[1] + topk_coords_unact = torch.gather(enc_outputs_coord_unact, 1, topk_proposals.unsqueeze(-1).repeat(1, 1, 4)) + topk_coords_unact = topk_coords_unact.detach() + reference_points = topk_coords_unact.sigmoid() + init_reference_out = reference_points + pos_trans_out = self.pos_trans_norm(self.pos_trans(self.get_proposal_pos_embed(topk_coords_unact))) + query_pos, query = torch.split(pos_trans_out, c, dim=2) + else: + query_pos, query = torch.split(query_embed, c, dim=1) + query_pos = query_pos.unsqueeze(0).expand(bs, -1, -1) + query = query.unsqueeze(0).expand(bs, -1, -1) + reference_points = self.reference_points(query_pos).sigmoid() + init_reference_out = reference_points + + # decoder + query = query.permute(1, 0, 2) + memory = memory.permute(1, 0, 2) + query_pos = query_pos.permute(1, 0, 2) + inter_states, inter_references = self.decoder( + query=query, + key=None, + value=memory, + query_pos=query_pos, + key_padding_mask=mask_flatten, + reference_points=reference_points, + spatial_shapes=spatial_shapes, + level_start_index=level_start_index, + valid_ratios=valid_ratios, + reg_branches=reg_branches, + **kwargs, + ) + + inter_references_out = inter_references + if self.as_two_stage: + return inter_states, init_reference_out, inter_references_out, enc_outputs_class, enc_outputs_coord_unact + return inter_states, init_reference_out, inter_references_out, None, None + + +@TRANSFORMER.register_module() +class DynamicConv(BaseModule): + """Implements Dynamic Convolution. + + This module generate parameters for each sample and + use bmm to implement 1*1 convolution. Code is modified + from the `official github repo `_ . + + Args: + in_channels (int): The input feature channel. + Defaults to 256. + feat_channels (int): The inner feature channel. + Defaults to 64. + out_channels (int, optional): The output feature channel. + When not specified, it will be set to `in_channels` + by default + input_feat_shape (int): The shape of input feature. + Defaults to 7. + with_proj (bool): Project two-dimentional feature to + one-dimentional feature. Default to True. + act_cfg (dict): The activation config for DynamicConv. + norm_cfg (dict): Config dict for normalization layer. Default + layer normalization. + init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization. + Default: None. + """ + + def __init__( + self, + in_channels=256, + feat_channels=64, + out_channels=None, + input_feat_shape=7, + with_proj=True, + act_cfg=dict(type="ReLU", inplace=True), + norm_cfg=dict(type="LN"), + init_cfg=None, + ): + super(DynamicConv, self).__init__(init_cfg) + self.in_channels = in_channels + self.feat_channels = feat_channels + self.out_channels_raw = out_channels + self.input_feat_shape = input_feat_shape + self.with_proj = with_proj + self.act_cfg = act_cfg + self.norm_cfg = norm_cfg + self.out_channels = out_channels if out_channels else in_channels + + self.num_params_in = self.in_channels * self.feat_channels + self.num_params_out = self.out_channels * self.feat_channels + self.dynamic_layer = nn.Linear(self.in_channels, self.num_params_in + self.num_params_out) + + self.norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1] + self.norm_out = build_norm_layer(norm_cfg, self.out_channels)[1] + + self.activation = build_activation_layer(act_cfg) + + num_output = self.out_channels * input_feat_shape**2 + if self.with_proj: + self.fc_layer = nn.Linear(num_output, self.out_channels) + self.fc_norm = build_norm_layer(norm_cfg, self.out_channels)[1] + + def forward(self, param_feature, input_feature): + """Forward function for `DynamicConv`. + + Args: + param_feature (Tensor): The feature can be used + to generate the parameter, has shape + (num_all_proposals, in_channels). + input_feature (Tensor): Feature that + interact with parameters, has shape + (num_all_proposals, in_channels, H, W). + + Returns: + Tensor: The output feature has shape + (num_all_proposals, out_channels). + """ + input_feature = input_feature.flatten(2).permute(2, 0, 1) + + input_feature = input_feature.permute(1, 0, 2) + parameters = self.dynamic_layer(param_feature) + + param_in = parameters[:, : self.num_params_in].view(-1, self.in_channels, self.feat_channels) + param_out = parameters[:, -self.num_params_out :].view(-1, self.feat_channels, self.out_channels) + + # input_feature has shape (num_all_proposals, H*W, in_channels) + # param_in has shape (num_all_proposals, in_channels, feat_channels) + # feature has shape (num_all_proposals, H*W, feat_channels) + features = torch.bmm(input_feature, param_in) + features = self.norm_in(features) + features = self.activation(features) + + # param_out has shape (batch_size, feat_channels, out_channels) + features = torch.bmm(features, param_out) + features = self.norm_out(features) + features = self.activation(features) + + if self.with_proj: + features = features.flatten(1) + features = self.fc_layer(features) + features = self.fc_norm(features) + features = self.activation(features) + + return features diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/ops/modules/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/ops/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d482863c236f352ca6b904a30fb834e77cbc6cd8 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/ops/modules/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/fundamentalvision/Deformable-DETR/tree/main/models/ops/modules +# https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 + +from .ms_deform_attn import MSDeformAttn diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py new file mode 100644 index 0000000000000000000000000000000000000000..2495637f939f122a3efe5624c2279e7a01b8668d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py @@ -0,0 +1,185 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +import warnings + +import torch +import torch.nn.functional as F +from torch import nn +from torch.autograd import Function +from torch.cuda.amp import custom_fwd +from torch.nn.init import constant_, xavier_uniform_ + + +class MSDeformAttnFunction(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward( + ctx, value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, im2col_step + ): + output = ms_deform_attn_core_pytorch( + value, + value_spatial_shapes, + # value_level_start_index, + sampling_locations, + attention_weights, + ) + return output + + +def ms_deform_attn_core_pytorch(value, value_spatial_shapes, sampling_locations, attention_weights): + # for debug and test only, + # need to use cuda version instead + N_, S_, M_, D_ = value.shape + _, Lq_, M_, L_, P_, _ = sampling_locations.shape + value_list = value.split([H_ * W_ for H_, W_ in value_spatial_shapes], dim=1) + sampling_grids = 2 * sampling_locations - 1 + sampling_value_list = [] + for lid_, (H_, W_) in enumerate(value_spatial_shapes): + # N_, H_*W_, M_, D_ -> N_, H_*W_, M_*D_ -> N_, M_*D_, H_*W_ -> N_*M_, D_, H_, W_ + value_l_ = value_list[lid_].flatten(2).transpose(1, 2).reshape(N_ * M_, D_, H_, W_) + # N_, Lq_, M_, P_, 2 -> N_, M_, Lq_, P_, 2 -> N_*M_, Lq_, P_, 2 + sampling_grid_l_ = sampling_grids[:, :, :, lid_].transpose(1, 2).flatten(0, 1) + # N_*M_, D_, Lq_, P_ + sampling_value_l_ = F.grid_sample( + value_l_, sampling_grid_l_, mode="bilinear", padding_mode="zeros", align_corners=False + ) + sampling_value_list.append(sampling_value_l_) + # (N_, Lq_, M_, L_, P_) -> (N_, M_, Lq_, L_, P_) -> (N_, M_, 1, Lq_, L_*P_) + attention_weights = attention_weights.transpose(1, 2).reshape(N_ * M_, 1, Lq_, L_ * P_) + output = (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights).sum(-1).view(N_, M_ * D_, Lq_) + return output.transpose(1, 2).contiguous() + + +def _is_power_of_2(n): + if (not isinstance(n, int)) or (n < 0): + raise ValueError("invalid input for _is_power_of_2: {} (type: {})".format(n, type(n))) + return (n & (n - 1) == 0) and n != 0 + + +class MSDeformAttn(nn.Module): + def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4, ratio=1.0): + """Multi-Scale Deformable Attention Module. + + :param d_model hidden dimension + :param n_levels number of feature levels + :param n_heads number of attention heads + :param n_points number of sampling points per attention head per feature level + """ + super().__init__() + if d_model % n_heads != 0: + raise ValueError("d_model must be divisible by n_heads, " "but got {} and {}".format(d_model, n_heads)) + _d_per_head = d_model // n_heads + # you'd better set _d_per_head to a power of 2 + # which is more efficient in our CUDA implementation + if not _is_power_of_2(_d_per_head): + warnings.warn( + "You'd better set d_model in MSDeformAttn to make " + "the dimension of each attention head a power of 2 " + "which is more efficient in our CUDA implementation." + ) + + self.im2col_step = 64 + + self.d_model = d_model + self.n_levels = n_levels + self.n_heads = n_heads + self.n_points = n_points + self.ratio = ratio + self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2) + self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points) + self.value_proj = nn.Linear(d_model, int(d_model * ratio)) + self.output_proj = nn.Linear(int(d_model * ratio), d_model) + + self._reset_parameters() + + def _reset_parameters(self): + constant_(self.sampling_offsets.weight.data, 0.0) + thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads) + grid_init = torch.stack([thetas.cos(), thetas.sin()], -1) + grid_init = ( + (grid_init / grid_init.abs().max(-1, keepdim=True)[0]) + .view(self.n_heads, 1, 1, 2) + .repeat(1, self.n_levels, self.n_points, 1) + ) + for i in range(self.n_points): + grid_init[:, :, i, :] *= i + 1 + + with torch.no_grad(): + self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1)) + constant_(self.attention_weights.weight.data, 0.0) + constant_(self.attention_weights.bias.data, 0.0) + xavier_uniform_(self.value_proj.weight.data) + constant_(self.value_proj.bias.data, 0.0) + xavier_uniform_(self.output_proj.weight.data) + constant_(self.output_proj.bias.data, 0.0) + + def forward( + self, + query, + reference_points, + input_flatten, + input_spatial_shapes, + input_level_start_index, + input_padding_mask=None, + ): + """ + :param query (N, Length_{query}, C) + :param reference_points (N, Length_{query}, n_levels, 2), range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area + or (N, Length_{query}, n_levels, 4), add additional (w, h) to form reference boxes + :param input_flatten (N, \\sum_{l=0}^{L-1} H_l \\cdot W_l, C) + :param input_spatial_shapes (n_levels, 2), [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})] + :param input_level_start_index (n_levels, ), [0, H_0*W_0, H_0*W_0+H_1*W_1, H_0*W_0+H_1*W_1+H_2*W_2, ..., H_0*W_0+H_1*W_1+...+H_{L-1}*W_{L-1}] + :param input_padding_mask (N, \\sum_{l=0}^{L-1} H_l \\cdot W_l), True for padding elements, False for non-padding elements + + :return output (N, Length_{query}, C) + """ + # print(query.shape) + # print(reference_points.shape) + # print(input_flatten.shape) + # print(input_spatial_shapes.shape) + # print(input_level_start_index.shape) + # print(input_spatial_shapes) + # print(input_level_start_index) + + N, Len_q, _ = query.shape + N, Len_in, _ = input_flatten.shape + assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == Len_in + + value = self.value_proj(input_flatten) + if input_padding_mask is not None: + value = value.masked_fill(input_padding_mask[..., None], float(0)) + + value = value.view(N, Len_in, self.n_heads, int(self.ratio * self.d_model) // self.n_heads) + sampling_offsets = self.sampling_offsets(query).view(N, Len_q, self.n_heads, self.n_levels, self.n_points, 2) + attention_weights = self.attention_weights(query).view(N, Len_q, self.n_heads, self.n_levels * self.n_points) + attention_weights = F.softmax(attention_weights, -1).view(N, Len_q, self.n_heads, self.n_levels, self.n_points) + + if reference_points.shape[-1] == 2: + offset_normalizer = torch.stack([input_spatial_shapes[..., 1], input_spatial_shapes[..., 0]], -1) + sampling_locations = ( + reference_points[:, :, None, :, None, :] + + sampling_offsets / offset_normalizer[None, None, None, :, None, :] + ) + elif reference_points.shape[-1] == 4: + sampling_locations = ( + reference_points[:, :, None, :, None, :2] + + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5 + ) + else: + raise ValueError( + "Last dim of reference_points must be 2 or 4, but get {} instead.".format(reference_points.shape[-1]) + ) + output = MSDeformAttnFunction.apply( + value, + input_spatial_shapes, + input_level_start_index, + sampling_locations, + attention_weights, + self.im2col_step, + ) + output = self.output_proj(output) + return output diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/setup.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..578d1854d8838d5b7898dbe6782af32251a01fc4 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/setup.py @@ -0,0 +1,75 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +from typing import Any, List, Optional, Tuple + +import torch +import torch.backends.cudnn as cudnn + +from dinov2.models import build_model_from_cfg +from dinov2.utils.config import setup +import dinov2.utils.utils as dinov2_utils + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parser = argparse.ArgumentParser( + description=description, + parents=parents or [], + add_help=add_help, + ) + parser.add_argument( + "--config-file", + type=str, + help="Model configuration file", + ) + parser.add_argument( + "--pretrained-weights", + type=str, + help="Pretrained model weights", + ) + parser.add_argument( + "--output-dir", + default="", + type=str, + help="Output directory to write results and logs", + ) + parser.add_argument( + "--opts", + help="Extra configuration options", + default=[], + nargs="+", + ) + return parser + + +def get_autocast_dtype(config): + teacher_dtype_str = config.compute_precision.teacher.backbone.mixed_precision.param_dtype + if teacher_dtype_str == "fp16": + return torch.half + elif teacher_dtype_str == "bf16": + return torch.bfloat16 + else: + return torch.float + + +def build_model_for_eval(config, pretrained_weights): + model, _ = build_model_from_cfg(config, only_teacher=True) + dinov2_utils.load_pretrained_weights(model, pretrained_weights, "teacher") + model.eval() + model.cuda() + return model + + +def setup_and_build_model(args) -> Tuple[Any, torch.dtype]: + cudnn.benchmark = True + config = setup(args) + model = build_model_for_eval(config, args.pretrained_weights) + autocast_dtype = get_autocast_dtype(config) + return model, autocast_dtype diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/eval/utils.py b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..4d387fc5014a2ed869b541ba13ad6a4b1c1c1e21 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/eval/utils.py @@ -0,0 +1,146 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +from typing import Dict, Optional + +import torch +from torch import nn +from torchmetrics import MetricCollection + +from dinov2.data import DatasetWithEnumeratedTargets, SamplerType, make_data_loader +import dinov2.distributed as distributed +from dinov2.logging import MetricLogger + + +logger = logging.getLogger("dinov2") + + +class ModelWithNormalize(torch.nn.Module): + def __init__(self, model): + super().__init__() + self.model = model + + def forward(self, samples): + return nn.functional.normalize(self.model(samples), dim=1, p=2) + + +class ModelWithIntermediateLayers(nn.Module): + def __init__(self, feature_model, n_last_blocks, autocast_ctx): + super().__init__() + self.feature_model = feature_model + self.feature_model.eval() + self.n_last_blocks = n_last_blocks + self.autocast_ctx = autocast_ctx + + def forward(self, images): + with torch.inference_mode(): + with self.autocast_ctx(): + features = self.feature_model.get_intermediate_layers( + images, self.n_last_blocks, return_class_token=True + ) + return features + + +@torch.inference_mode() +def evaluate( + model: nn.Module, + data_loader, + postprocessors: Dict[str, nn.Module], + metrics: Dict[str, MetricCollection], + device: torch.device, + criterion: Optional[nn.Module] = None, +): + model.eval() + if criterion is not None: + criterion.eval() + + for metric in metrics.values(): + metric = metric.to(device) + + metric_logger = MetricLogger(delimiter=" ") + header = "Test:" + + for samples, targets, *_ in metric_logger.log_every(data_loader, 10, header): + outputs = model(samples.to(device)) + targets = targets.to(device) + + if criterion is not None: + loss = criterion(outputs, targets) + metric_logger.update(loss=loss.item()) + + for k, metric in metrics.items(): + metric_inputs = postprocessors[k](outputs, targets) + metric.update(**metric_inputs) + + metric_logger.synchronize_between_processes() + logger.info(f"Averaged stats: {metric_logger}") + + stats = {k: metric.compute() for k, metric in metrics.items()} + metric_logger_stats = {k: meter.global_avg for k, meter in metric_logger.meters.items()} + return metric_logger_stats, stats + + +def all_gather_and_flatten(tensor_rank): + tensor_all_ranks = torch.empty( + distributed.get_global_size(), + *tensor_rank.shape, + dtype=tensor_rank.dtype, + device=tensor_rank.device, + ) + tensor_list = list(tensor_all_ranks.unbind(0)) + torch.distributed.all_gather(tensor_list, tensor_rank.contiguous()) + return tensor_all_ranks.flatten(end_dim=1) + + +def extract_features(model, dataset, batch_size, num_workers, gather_on_cpu=False): + dataset_with_enumerated_targets = DatasetWithEnumeratedTargets(dataset) + sample_count = len(dataset_with_enumerated_targets) + data_loader = make_data_loader( + dataset=dataset_with_enumerated_targets, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + ) + return extract_features_with_dataloader(model, data_loader, sample_count, gather_on_cpu) + + +@torch.inference_mode() +def extract_features_with_dataloader(model, data_loader, sample_count, gather_on_cpu=False): + gather_device = torch.device("cpu") if gather_on_cpu else torch.device("cuda") + metric_logger = MetricLogger(delimiter=" ") + features, all_labels = None, None + for samples, (index, labels_rank) in metric_logger.log_every(data_loader, 10): + samples = samples.cuda(non_blocking=True) + labels_rank = labels_rank.cuda(non_blocking=True) + index = index.cuda(non_blocking=True) + features_rank = model(samples).float() + + # init storage feature matrix + if features is None: + features = torch.zeros(sample_count, features_rank.shape[-1], device=gather_device) + labels_shape = list(labels_rank.shape) + labels_shape[0] = sample_count + all_labels = torch.full(labels_shape, fill_value=-1, device=gather_device) + logger.info(f"Storing features into tensor of shape {features.shape}") + + # share indexes, features and labels between processes + index_all = all_gather_and_flatten(index).to(gather_device) + features_all_ranks = all_gather_and_flatten(features_rank).to(gather_device) + labels_all_ranks = all_gather_and_flatten(labels_rank).to(gather_device) + + # update storage feature matrix + if len(index_all) > 0: + features.index_copy_(0, index_all, features_all_ranks) + all_labels.index_copy_(0, index_all, labels_all_ranks) + + logger.info(f"Features shape: {tuple(features.shape)}") + logger.info(f"Labels shape: {tuple(all_labels.shape)}") + + assert torch.all(all_labels > -1) + + return features, all_labels diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/fsdp/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/fsdp/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..15211bb524d138d2c2291b8b390d9a8cf4085d89 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/fsdp/__init__.py @@ -0,0 +1,157 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import os +from typing import Any + +import torch +import dinov2.distributed as distributed +from functools import partial +from fvcore.common.checkpoint import Checkpointer +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from torch.distributed.fsdp import ShardingStrategy +from torch.distributed.fsdp import MixedPrecision +from torch.distributed.fsdp import StateDictType +from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler +from torch.distributed.fsdp.wrap import ModuleWrapPolicy +from torch.distributed.fsdp._runtime_utils import _reshard + + +def get_fsdp_wrapper(model_cfg, modules_to_wrap=set()): + sharding_strategy_dict = { + "NO_SHARD": ShardingStrategy.NO_SHARD, + "SHARD_GRAD_OP": ShardingStrategy.SHARD_GRAD_OP, + "FULL_SHARD": ShardingStrategy.FULL_SHARD, + } + + dtype_dict = { + "fp32": torch.float32, + "fp16": torch.float16, + "bf16": torch.bfloat16, + } + + mixed_precision_config = MixedPrecision( + param_dtype=dtype_dict[model_cfg.mixed_precision.param_dtype], + reduce_dtype=dtype_dict[model_cfg.mixed_precision.reduce_dtype], + buffer_dtype=dtype_dict[model_cfg.mixed_precision.buffer_dtype], + ) + + sharding_strategy_config = sharding_strategy_dict[model_cfg.sharding_strategy] + + local_rank = distributed.get_local_rank() + + fsdp_wrapper = partial( + FSDP, + sharding_strategy=sharding_strategy_config, + mixed_precision=mixed_precision_config, + device_id=local_rank, + sync_module_states=True, + use_orig_params=True, + auto_wrap_policy=ModuleWrapPolicy(modules_to_wrap), + ) + return fsdp_wrapper + + +def is_fsdp(x): + return isinstance(x, FSDP) + + +def is_sharded_fsdp(x): + return is_fsdp(x) and x.sharding_strategy is not ShardingStrategy.NO_SHARD + + +def free_if_fsdp(x): + if is_sharded_fsdp(x): + handles = x._handles + true_list = [True for h in handles] + _reshard(x, handles, true_list) + + +def get_fsdp_modules(x): + return FSDP.fsdp_modules(x) + + +def reshard_fsdp_model(x): + for m in get_fsdp_modules(x): + free_if_fsdp(m) + + +def rankstr(): + return f"rank_{distributed.get_global_rank()}" + + +class FSDPCheckpointer(Checkpointer): + def save(self, name: str, **kwargs: Any) -> None: + """ + Dump model and checkpointables to a file. + + Args: + name (str): name of the file. + kwargs (dict): extra arbitrary data to save. + """ + if not self.save_dir or not self.save_to_disk: + return + + data = {} + with FSDP.state_dict_type(self.model, StateDictType.LOCAL_STATE_DICT): + data["model"] = self.model.state_dict() + + # data["model"] = self.model.state_dict() + for key, obj in self.checkpointables.items(): + data[key] = obj.state_dict() + data.update(kwargs) + + basename = f"{name}.{rankstr()}.pth" + save_file = os.path.join(self.save_dir, basename) + assert os.path.basename(save_file) == basename, basename + self.logger.info("Saving checkpoint to {}".format(save_file)) + with self.path_manager.open(save_file, "wb") as f: + torch.save(data, f) + self.tag_last_checkpoint(basename) + + def load(self, *args, **kwargs): + with FSDP.state_dict_type(self.model, StateDictType.LOCAL_STATE_DICT): + return super().load(*args, **kwargs) + + def has_checkpoint(self) -> bool: + """ + Returns: + bool: whether a checkpoint exists in the target directory. + """ + save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}") + return self.path_manager.exists(save_file) + + def get_checkpoint_file(self) -> str: + """ + Returns: + str: The latest checkpoint file in target directory. + """ + save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}") + try: + with self.path_manager.open(save_file, "r") as f: + last_saved = f.read().strip() + except IOError: + # if file doesn't exist, maybe because it has just been + # deleted by a separate process + return "" + # pyre-fixme[6]: For 2nd param expected `Union[PathLike[str], str]` but got + # `Union[bytes, str]`. + return os.path.join(self.save_dir, last_saved) + + def tag_last_checkpoint(self, last_filename_basename: str) -> None: + """ + Tag the last checkpoint. + + Args: + last_filename_basename (str): the basename of the last filename. + """ + if distributed.is_enabled(): + torch.distributed.barrier() + save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}") + with self.path_manager.open(save_file, "w") as f: + f.write(last_filename_basename) # pyre-ignore + + +ShardedGradScaler = ShardedGradScaler diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/__init__.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c1fbb7932e62b885a3be4771aee8e8b4b7d1c58 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/__init__.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/backbones.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/backbones.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc6557e5c794f46d43a5f1587599559aa1e63551 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/backbones.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/classifiers.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/classifiers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7639911534c577ffaf97baef97ae54b0a9203eb2 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/classifiers.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/depthers.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/depthers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97ee1e89ca3a50b2777d078e322e296aa73b6ff2 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/depthers.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/dinotxt.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/dinotxt.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a2ab229dcafaf10fe06eb420a83c8c75623a7e7 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/dinotxt.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/utils.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11c76aeb1ecc6af9ecfa70c526be5119946ba17b Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/__pycache__/utils.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/backbones.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/backbones.py new file mode 100644 index 0000000000000000000000000000000000000000..acd30246b3008276bb59c931adadc40d9351eb87 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/backbones.py @@ -0,0 +1,174 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +from pathlib import Path +from typing import Optional, Union +from urllib.parse import urlparse + +import torch + +from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name + + +class Weights(Enum): + LVD142M = "LVD142M" + XRAY_DINO = "XRay-DINO" + + +def is_url(path: str) -> bool: + parsed = urlparse(path) + return parsed.scheme in ("https", "file") + + +def convert_path_or_url_to_url(path: str) -> str: + if is_url(path): + return path + return Path(path).expanduser().resolve().as_uri() + + +def _make_dinov2_model( + *, + arch_name: str = "vit_large", + img_size: int = 518, + patch_size: int = 14, + init_values: float = 1.0, + ffn_layer: str = "mlp", + block_chunks: int = 0, + num_register_tokens: int = 0, + interpolate_antialias: bool = False, + interpolate_offset: float = 0.1, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.LVD142M, + hash: Optional[str] = None, + check_hash: bool = False, + **kwargs, +): + from ..models import vision_transformer as vits + + model_base_name = _make_dinov2_model_name(arch_name, patch_size) + vit_kwargs = dict( + img_size=img_size, + patch_size=patch_size, + init_values=init_values, + ffn_layer=ffn_layer, + block_chunks=block_chunks, + num_register_tokens=num_register_tokens, + interpolate_antialias=interpolate_antialias, + interpolate_offset=interpolate_offset, + ) + vit_kwargs.update(**kwargs) + model = vits.__dict__[arch_name](**vit_kwargs) + + if pretrained: + if type(weights) is Weights and weights not in { + Weights.LVD142M, + Weights.XRAY_DINO, + }: + raise ValueError(f"Unsupported weights for the backbone: {weights}") + elif type(weights) is Weights: + model_full_name = _make_dinov2_model_name(arch_name, patch_size, num_register_tokens) + url = _DINOV2_BASE_URL + f"/{model_base_name}/{model_full_name}_pretrain.pth" + else: + url = convert_path_or_url_to_url(weights) + state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu", check_hash=check_hash) + model.load_state_dict(state_dict, strict=True) + + return model + + +def dinov2_vits14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-S/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model(arch_name="vit_small", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitb14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-B/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model(arch_name="vit_base", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitl14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-L/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model(arch_name="vit_large", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitg14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-g/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_giant2", + ffn_layer="swiglufused", + weights=weights, + pretrained=pretrained, + **kwargs, + ) + + +def dinov2_vits14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-S/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_small", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitb14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-B/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_base", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitl14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-L/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_large", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitg14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-g/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_giant2", + ffn_layer="swiglufused", + weights=weights, + pretrained=pretrained, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/cell_dino/__pycache__/backbones.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/cell_dino/__pycache__/backbones.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c392eef8862da5e91e0b6cc12ff56d4a699c7e2 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/cell_dino/__pycache__/backbones.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/cell_dino/backbones.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/cell_dino/backbones.py new file mode 100644 index 0000000000000000000000000000000000000000..72239894a9204c1cbb94a82705f97ab70451c4dd --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/cell_dino/backbones.py @@ -0,0 +1,182 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +from enum import Enum +from typing import Optional, Union + +import torch + + +class Weights(Enum): + CELL_DINO = "CELL-DINO" + + +def _make_cell_dino_model( + *, + arch_name: str = "vit_large", + img_size: int = 518, + patch_size: int = 14, + init_values: float = 1.0, + ffn_layer: str = "mlp", + block_chunks: int = 0, + num_register_tokens: int = 0, + interpolate_antialias: bool = False, + interpolate_offset: float = 0.1, + pretrained: bool = True, + channel_adaptive: bool = False, + weights: Union[Weights, str] = Weights.CELL_DINO, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + **kwargs, +): + from ...models import vision_transformer as vits + + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + vit_kwargs = dict( + img_size=img_size, + patch_size=patch_size, + init_values=init_values, + ffn_layer=ffn_layer, + block_chunks=block_chunks, + num_register_tokens=num_register_tokens, + interpolate_antialias=interpolate_antialias, + interpolate_offset=interpolate_offset, + channel_adaptive=channel_adaptive, + ) + vit_kwargs.update(**kwargs) + model = vits.__dict__[arch_name](**vit_kwargs) + + if pretrained: + if pretrained_path is not None: + state_dict = torch.load(pretrained_path, map_location="cpu") + else: + pretrained_url is not None + state_dict = torch.hub.load_state_dict_from_url(pretrained_url, map_location="cpu") + model.load_state_dict(state_dict, strict=True) + + return model + + +def cell_dino_hpa_vitl16( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 4, + **kwargs, +): + """ + Cell-DINO ViT-L/16 model dataset pretrained on HPA dataset. + """ + return _make_cell_dino_model( + arch_name="vit_large", + patch_size=16, + img_size=224, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + **kwargs, + ) + + +def cell_dino_hpa_vitl14( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 4, + **kwargs, +): + """ + Cell-DINO ViT-L/14 model dataset pretrained on LVD, then on HPA dataset. + """ + return _make_cell_dino_model( + arch_name="vit_large", + patch_size=14, + img_size=518, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + **kwargs, + ) + + +def cell_dino_cp_vits8( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 5, + **kwargs, +): + """ + Cell-DINO ViT-S/8 model dataset pretrained on the combined cell painting dataset. + """ + return _make_cell_dino_model( + arch_name="vit_small", + patch_size=8, + img_size=128, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + **kwargs, + ) + + +def channel_adaptive_dino_vitl16( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 1, + channel_adaptive: bool = True, + **kwargs, +): + """ + Cell-DINO ViT-L/16 model dataset pretrained on HPA dataset. + """ + return _make_cell_dino_model( + arch_name="vit_large", + patch_size=16, + img_size=224, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + channel_adaptive=channel_adaptive, + **kwargs, + ) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/classifiers.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/classifiers.py new file mode 100644 index 0000000000000000000000000000000000000000..b996f567237db149c482062496195aeed9483910 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/classifiers.py @@ -0,0 +1,268 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +from typing import Union + +import torch +import torch.nn as nn + +from .backbones import _make_dinov2_model +from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name + + +class Weights(Enum): + IMAGENET1K = "IMAGENET1K" + + +def _make_dinov2_linear_classification_head( + *, + arch_name: str = "vit_large", + patch_size: int = 14, + embed_dim: int = 1024, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + num_register_tokens: int = 0, + **kwargs, +): + if layers not in (1, 4): + raise AssertionError(f"Unsupported number of layers: {layers}") + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + linear_head = nn.Linear((1 + layers) * embed_dim, 1_000) + + if pretrained: + model_base_name = _make_dinov2_model_name(arch_name, patch_size) + model_full_name = _make_dinov2_model_name(arch_name, patch_size, num_register_tokens) + layers_str = str(layers) if layers == 4 else "" + url = _DINOV2_BASE_URL + f"/{model_base_name}/{model_full_name}_linear{layers_str}_head.pth" + state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu") + linear_head.load_state_dict(state_dict, strict=True) + + return linear_head + + +class _LinearClassifierWrapper(nn.Module): + def __init__(self, *, backbone: nn.Module, linear_head: nn.Module, layers: int = 4): + super().__init__() + self.backbone = backbone + self.linear_head = linear_head + self.layers = layers + + def forward(self, x): + if self.layers == 1: + x = self.backbone.forward_features(x) + cls_token = x["x_norm_clstoken"] + patch_tokens = x["x_norm_patchtokens"] + # fmt: off + linear_input = torch.cat([ + cls_token, + patch_tokens.mean(dim=1), + ], dim=1) + # fmt: on + elif self.layers == 4: + x = self.backbone.get_intermediate_layers(x, n=4, return_class_token=True) + # fmt: off + linear_input = torch.cat([ + x[0][1], + x[1][1], + x[2][1], + x[3][1], + x[3][0].mean(dim=1), + ], dim=1) + # fmt: on + else: + assert False, f"Unsupported number of layers: {self.layers}" + return self.linear_head(linear_input) + + +def _make_dinov2_linear_classifier( + *, + arch_name: str = "vit_large", + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + num_register_tokens: int = 0, + interpolate_antialias: bool = False, + interpolate_offset: float = 0.1, + **kwargs, +): + backbone = _make_dinov2_model( + arch_name=arch_name, + pretrained=pretrained, + num_register_tokens=num_register_tokens, + interpolate_antialias=interpolate_antialias, + interpolate_offset=interpolate_offset, + **kwargs, + ) + + embed_dim = backbone.embed_dim + patch_size = backbone.patch_size + linear_head = _make_dinov2_linear_classification_head( + arch_name=arch_name, + patch_size=patch_size, + embed_dim=embed_dim, + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=num_register_tokens, + ) + + return _LinearClassifierWrapper(backbone=backbone, linear_head=linear_head, layers=layers) + + +def dinov2_vits14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-S/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_small", + layers=layers, + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vitb14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-B/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_base", + layers=layers, + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vitl14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-L/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_large", + layers=layers, + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vitg14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-g/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_giant2", + layers=layers, + ffn_layer="swiglufused", + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vits14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-S/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_small", + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitb14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-B/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_base", + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitl14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-L/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_large", + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitg14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-g/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_giant2", + layers=layers, + ffn_layer="swiglufused", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e344877b36fee8e6a48b4b83daa04c3c99441069 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .decode_heads import BNHead, DPTHead +from .encoder_decoder import DepthEncoderDecoder diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/__init__.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3122102edaea98147b2f2afc44caf5eada972626 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/__init__.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/decode_heads.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/decode_heads.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f81ca503fc209e7d76a80a3017b1fd793682c407 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/decode_heads.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/encoder_decoder.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/encoder_decoder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d67498d7100f1b8ba237a2b09e849427fd7b2592 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/encoder_decoder.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/ops.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/ops.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00b3cd4ec1097103f9cc0cacc33ed24e2d385a1d Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/__pycache__/ops.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/decode_heads.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/decode_heads.py new file mode 100644 index 0000000000000000000000000000000000000000..1e0b84314a0ff213b711b7141821949ba86c9ed8 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/decode_heads.py @@ -0,0 +1,747 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import copy +from functools import partial +import math +import warnings + +import torch +import torch.nn as nn + +from .ops import resize + + +# XXX: (Untested) replacement for mmcv.imdenormalize() +def _imdenormalize(img, mean, std, to_bgr=True): + import numpy as np + + mean = mean.reshape(1, -1).astype(np.float64) + std = std.reshape(1, -1).astype(np.float64) + img = (img * std) + mean + if to_bgr: + img = img[::-1] + return img + + +class DepthBaseDecodeHead(nn.Module): + """Base class for BaseDecodeHead. + + Args: + in_channels (List): Input channels. + channels (int): Channels after modules, before conv_depth. + conv_layer (nn.Module): Conv layers. Default: None. + act_layer (nn.Module): Activation layers. Default: nn.ReLU. + loss_decode (dict): Config of decode loss. + Default: (). + sampler (dict|None): The config of depth map sampler. + Default: None. + align_corners (bool): align_corners argument of F.interpolate. + Default: False. + min_depth (int): Min depth in dataset setting. + Default: 1e-3. + max_depth (int): Max depth in dataset setting. + Default: None. + norm_layer (dict|None): Norm layers. + Default: None. + classify (bool): Whether predict depth in a cls.-reg. manner. + Default: False. + n_bins (int): The number of bins used in cls. step. + Default: 256. + bins_strategy (str): The discrete strategy used in cls. step. + Default: 'UD'. + norm_strategy (str): The norm strategy on cls. probability + distribution. Default: 'linear' + scale_up (str): Whether predict depth in a scale-up manner. + Default: False. + """ + + def __init__( + self, + in_channels, + conv_layer=None, + act_layer=nn.ReLU, + channels=96, + loss_decode=(), + sampler=None, + align_corners=False, + min_depth=1e-3, + max_depth=None, + norm_layer=None, + classify=False, + n_bins=256, + bins_strategy="UD", + norm_strategy="linear", + scale_up=False, + ): + super(DepthBaseDecodeHead, self).__init__() + + self.in_channels = in_channels + self.channels = channels + self.conf_layer = conv_layer + self.act_layer = act_layer + self.loss_decode = loss_decode + self.align_corners = align_corners + self.min_depth = min_depth + self.max_depth = max_depth + self.norm_layer = norm_layer + self.classify = classify + self.n_bins = n_bins + self.scale_up = scale_up + + if self.classify: + assert bins_strategy in ["UD", "SID"], "Support bins_strategy: UD, SID" + assert norm_strategy in ["linear", "softmax", "sigmoid"], "Support norm_strategy: linear, softmax, sigmoid" + + self.bins_strategy = bins_strategy + self.norm_strategy = norm_strategy + self.softmax = nn.Softmax(dim=1) + self.conv_depth = nn.Conv2d(channels, n_bins, kernel_size=3, padding=1, stride=1) + else: + self.conv_depth = nn.Conv2d(channels, 1, kernel_size=3, padding=1, stride=1) + + self.relu = nn.ReLU() + self.sigmoid = nn.Sigmoid() + + def forward(self, inputs, img_metas): + """Placeholder of forward function.""" + pass + + def forward_train(self, img, inputs, img_metas, depth_gt): + """Forward function for training. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): GT depth + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + depth_pred = self.forward(inputs, img_metas) + losses = self.losses(depth_pred, depth_gt) + + log_imgs = self.log_images(img[0], depth_pred[0], depth_gt[0], img_metas[0]) + losses.update(**log_imgs) + + return losses + + def forward_test(self, inputs, img_metas): + """Forward function for testing. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + + Returns: + Tensor: Output depth map. + """ + return self.forward(inputs, img_metas) + + def depth_pred(self, feat): + """Prediction each pixel.""" + if self.classify: + logit = self.conv_depth(feat) + + if self.bins_strategy == "UD": + bins = torch.linspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + elif self.bins_strategy == "SID": + bins = torch.logspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + + # following Adabins, default linear + if self.norm_strategy == "linear": + logit = torch.relu(logit) + eps = 0.1 + logit = logit + eps + logit = logit / logit.sum(dim=1, keepdim=True) + elif self.norm_strategy == "softmax": + logit = torch.softmax(logit, dim=1) + elif self.norm_strategy == "sigmoid": + logit = torch.sigmoid(logit) + logit = logit / logit.sum(dim=1, keepdim=True) + + output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(dim=1) + + else: + if self.scale_up: + output = self.sigmoid(self.conv_depth(feat)) * self.max_depth + else: + output = self.relu(self.conv_depth(feat)) + self.min_depth + return output + + def losses(self, depth_pred, depth_gt): + """Compute depth loss.""" + loss = dict() + depth_pred = resize( + input=depth_pred, size=depth_gt.shape[2:], mode="bilinear", align_corners=self.align_corners, warning=False + ) + if not isinstance(self.loss_decode, nn.ModuleList): + losses_decode = [self.loss_decode] + else: + losses_decode = self.loss_decode + for loss_decode in losses_decode: + if loss_decode.loss_name not in loss: + loss[loss_decode.loss_name] = loss_decode(depth_pred, depth_gt) + else: + loss[loss_decode.loss_name] += loss_decode(depth_pred, depth_gt) + return loss + + def log_images(self, img_path, depth_pred, depth_gt, img_meta): + import numpy as np + + show_img = copy.deepcopy(img_path.detach().cpu().permute(1, 2, 0)) + show_img = show_img.numpy().astype(np.float32) + show_img = _imdenormalize( + show_img, + img_meta["img_norm_cfg"]["mean"], + img_meta["img_norm_cfg"]["std"], + img_meta["img_norm_cfg"]["to_rgb"], + ) + show_img = np.clip(show_img, 0, 255) + show_img = show_img.astype(np.uint8) + show_img = show_img[:, :, ::-1] + show_img = show_img.transpose(0, 2, 1) + show_img = show_img.transpose(1, 0, 2) + + depth_pred = depth_pred / torch.max(depth_pred) + depth_gt = depth_gt / torch.max(depth_gt) + + depth_pred_color = copy.deepcopy(depth_pred.detach().cpu()) + depth_gt_color = copy.deepcopy(depth_gt.detach().cpu()) + + return {"img_rgb": show_img, "img_depth_pred": depth_pred_color, "img_depth_gt": depth_gt_color} + + +class BNHead(DepthBaseDecodeHead): + """Just a batchnorm.""" + + def __init__(self, input_transform="resize_concat", in_index=(0, 1, 2, 3), upsample=1, **kwargs): + super().__init__(**kwargs) + self.input_transform = input_transform + self.in_index = in_index + self.upsample = upsample + # self.bn = nn.SyncBatchNorm(self.in_channels) + if self.classify: + self.conv_depth = nn.Conv2d(self.channels, self.n_bins, kernel_size=1, padding=0, stride=1) + else: + self.conv_depth = nn.Conv2d(self.channels, 1, kernel_size=1, padding=0, stride=1) + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + Tensor: The transformed inputs + """ + + if "concat" in self.input_transform: + inputs = [inputs[i] for i in self.in_index] + if "resize" in self.input_transform: + inputs = [ + resize( + input=x, + size=[s * self.upsample for s in inputs[0].shape[2:]], + mode="bilinear", + align_corners=self.align_corners, + ) + for x in inputs + ] + inputs = torch.cat(inputs, dim=1) + elif self.input_transform == "multiple_select": + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def _forward_feature(self, inputs, img_metas=None, **kwargs): + """Forward function for feature maps before classifying each pixel with + ``self.cls_seg`` fc. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + feats (Tensor): A tensor of shape (batch_size, self.channels, + H, W) which is feature map for last layer of decoder head. + """ + # accept lists (for cls token) + inputs = list(inputs) + for i, x in enumerate(inputs): + if len(x) == 2: + x, cls_token = x[0], x[1] + if len(x.shape) == 2: + x = x[:, :, None, None] + cls_token = cls_token[:, :, None, None].expand_as(x) + inputs[i] = torch.cat((x, cls_token), 1) + else: + x = x[0] + if len(x.shape) == 2: + x = x[:, :, None, None] + inputs[i] = x + x = self._transform_inputs(inputs) + # feats = self.bn(x) + return x + + def forward(self, inputs, img_metas=None, **kwargs): + """Forward function.""" + output = self._forward_feature(inputs, img_metas=img_metas, **kwargs) + output = self.depth_pred(output) + return output + + +class ConvModule(nn.Module): + """A conv block that bundles conv/norm/activation layers. + + This block simplifies the usage of convolution layers, which are commonly + used with a norm layer (e.g., BatchNorm) and activation layer (e.g., ReLU). + It is based upon three build methods: `build_conv_layer()`, + `build_norm_layer()` and `build_activation_layer()`. + + Besides, we add some additional features in this module. + 1. Automatically set `bias` of the conv layer. + 2. Spectral norm is supported. + 3. More padding modes are supported. Before PyTorch 1.5, nn.Conv2d only + supports zero and circular padding, and we add "reflect" padding mode. + + Args: + in_channels (int): Number of channels in the input feature map. + Same as that in ``nn._ConvNd``. + out_channels (int): Number of channels produced by the convolution. + Same as that in ``nn._ConvNd``. + kernel_size (int | tuple[int]): Size of the convolving kernel. + Same as that in ``nn._ConvNd``. + stride (int | tuple[int]): Stride of the convolution. + Same as that in ``nn._ConvNd``. + padding (int | tuple[int]): Zero-padding added to both sides of + the input. Same as that in ``nn._ConvNd``. + dilation (int | tuple[int]): Spacing between kernel elements. + Same as that in ``nn._ConvNd``. + groups (int): Number of blocked connections from input channels to + output channels. Same as that in ``nn._ConvNd``. + bias (bool | str): If specified as `auto`, it will be decided by the + norm_layer. Bias will be set as True if `norm_layer` is None, otherwise + False. Default: "auto". + conv_layer (nn.Module): Convolution layer. Default: None, + which means using conv2d. + norm_layer (nn.Module): Normalization layer. Default: None. + act_layer (nn.Module): Activation layer. Default: nn.ReLU. + inplace (bool): Whether to use inplace mode for activation. + Default: True. + with_spectral_norm (bool): Whether use spectral norm in conv module. + Default: False. + padding_mode (str): If the `padding_mode` has not been supported by + current `Conv2d` in PyTorch, we will use our own padding layer + instead. Currently, we support ['zeros', 'circular'] with official + implementation and ['reflect'] with our own implementation. + Default: 'zeros'. + order (tuple[str]): The order of conv/norm/activation layers. It is a + sequence of "conv", "norm" and "act". Common examples are + ("conv", "norm", "act") and ("act", "conv", "norm"). + Default: ('conv', 'norm', 'act'). + """ + + _abbr_ = "conv_block" + + def __init__( + self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + bias="auto", + conv_layer=nn.Conv2d, + norm_layer=None, + act_layer=nn.ReLU, + inplace=True, + with_spectral_norm=False, + padding_mode="zeros", + order=("conv", "norm", "act"), + ): + super(ConvModule, self).__init__() + official_padding_mode = ["zeros", "circular"] + self.conv_layer = conv_layer + self.norm_layer = norm_layer + self.act_layer = act_layer + self.inplace = inplace + self.with_spectral_norm = with_spectral_norm + self.with_explicit_padding = padding_mode not in official_padding_mode + self.order = order + assert isinstance(self.order, tuple) and len(self.order) == 3 + assert set(order) == set(["conv", "norm", "act"]) + + self.with_norm = norm_layer is not None + self.with_activation = act_layer is not None + # if the conv layer is before a norm layer, bias is unnecessary. + if bias == "auto": + bias = not self.with_norm + self.with_bias = bias + + if self.with_explicit_padding: + if padding_mode == "zeros": + padding_layer = nn.ZeroPad2d + else: + raise AssertionError(f"Unsupported padding mode: {padding_mode}") + self.pad = padding_layer(padding) + + # reset padding to 0 for conv module + conv_padding = 0 if self.with_explicit_padding else padding + # build convolution layer + self.conv = self.conv_layer( + in_channels, + out_channels, + kernel_size, + stride=stride, + padding=conv_padding, + dilation=dilation, + groups=groups, + bias=bias, + ) + # export the attributes of self.conv to a higher level for convenience + self.in_channels = self.conv.in_channels + self.out_channels = self.conv.out_channels + self.kernel_size = self.conv.kernel_size + self.stride = self.conv.stride + self.padding = padding + self.dilation = self.conv.dilation + self.transposed = self.conv.transposed + self.output_padding = self.conv.output_padding + self.groups = self.conv.groups + + if self.with_spectral_norm: + self.conv = nn.utils.spectral_norm(self.conv) + + # build normalization layers + if self.with_norm: + # norm layer is after conv layer + if order.index("norm") > order.index("conv"): + norm_channels = out_channels + else: + norm_channels = in_channels + norm = partial(norm_layer, num_features=norm_channels) + self.add_module("norm", norm) + if self.with_bias: + from torch.nnModules.batchnorm import _BatchNorm + from torch.nnModules.instancenorm import _InstanceNorm + + if isinstance(norm, (_BatchNorm, _InstanceNorm)): + warnings.warn("Unnecessary conv bias before batch/instance norm") + else: + self.norm_name = None + + # build activation layer + if self.with_activation: + # nn.Tanh has no 'inplace' argument + # (nn.Tanh, nn.PReLU, nn.Sigmoid, nn.HSigmoid, nn.Swish, nn.GELU) + if not isinstance(act_layer, (nn.Tanh, nn.PReLU, nn.Sigmoid, nn.GELU)): + act_layer = partial(act_layer, inplace=inplace) + self.activate = act_layer() + + # Use msra init by default + self.init_weights() + + @property + def norm(self): + if self.norm_name: + return getattr(self, self.norm_name) + else: + return None + + def init_weights(self): + # 1. It is mainly for customized conv layers with their own + # initialization manners by calling their own ``init_weights()``, + # and we do not want ConvModule to override the initialization. + # 2. For customized conv layers without their own initialization + # manners (that is, they don't have their own ``init_weights()``) + # and PyTorch's conv layers, they will be initialized by + # this method with default ``kaiming_init``. + # Note: For PyTorch's conv layers, they will be overwritten by our + # initialization implementation using default ``kaiming_init``. + if not hasattr(self.conv, "init_weights"): + if self.with_activation and isinstance(self.act_layer, nn.LeakyReLU): + nonlinearity = "leaky_relu" + a = 0.01 # XXX: default negative_slope + else: + nonlinearity = "relu" + a = 0 + if hasattr(self.conv, "weight") and self.conv.weight is not None: + nn.init.kaiming_normal_(self.conv.weight, a=a, mode="fan_out", nonlinearity=nonlinearity) + if hasattr(self.conv, "bias") and self.conv.bias is not None: + nn.init.constant_(self.conv.bias, 0) + if self.with_norm: + if hasattr(self.norm, "weight") and self.norm.weight is not None: + nn.init.constant_(self.norm.weight, 1) + if hasattr(self.norm, "bias") and self.norm.bias is not None: + nn.init.constant_(self.norm.bias, 0) + + def forward(self, x, activate=True, norm=True): + for layer in self.order: + if layer == "conv": + if self.with_explicit_padding: + x = self.pad(x) + x = self.conv(x) + elif layer == "norm" and norm and self.with_norm: + x = self.norm(x) + elif layer == "act" and activate and self.with_activation: + x = self.activate(x) + return x + + +class Interpolate(nn.Module): + def __init__(self, scale_factor, mode, align_corners=False): + super(Interpolate, self).__init__() + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners) + return x + + +class HeadDepth(nn.Module): + def __init__(self, features): + super(HeadDepth, self).__init__() + self.head = nn.Sequential( + nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + ) + + def forward(self, x): + x = self.head(x) + return x + + +class ReassembleBlocks(nn.Module): + """ViTPostProcessBlock, process cls_token in ViT backbone output and + rearrange the feature vector to feature map. + Args: + in_channels (int): ViT feature channels. Default: 768. + out_channels (List): output channels of each stage. + Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + """ + + def __init__(self, in_channels=768, out_channels=[96, 192, 384, 768], readout_type="ignore", patch_size=16): + super(ReassembleBlocks, self).__init__() + + assert readout_type in ["ignore", "add", "project"] + self.readout_type = readout_type + self.patch_size = patch_size + + self.projects = nn.ModuleList( + [ + ConvModule( + in_channels=in_channels, + out_channels=out_channel, + kernel_size=1, + act_layer=None, + ) + for out_channel in out_channels + ] + ) + + self.resize_layers = nn.ModuleList( + [ + nn.ConvTranspose2d( + in_channels=out_channels[0], out_channels=out_channels[0], kernel_size=4, stride=4, padding=0 + ), + nn.ConvTranspose2d( + in_channels=out_channels[1], out_channels=out_channels[1], kernel_size=2, stride=2, padding=0 + ), + nn.Identity(), + nn.Conv2d( + in_channels=out_channels[3], out_channels=out_channels[3], kernel_size=3, stride=2, padding=1 + ), + ] + ) + if self.readout_type == "project": + self.readout_projects = nn.ModuleList() + for _ in range(len(self.projects)): + self.readout_projects.append(nn.Sequential(nn.Linear(2 * in_channels, in_channels), nn.GELU())) + + def forward(self, inputs): + assert isinstance(inputs, list) + out = [] + for i, x in enumerate(inputs): + assert len(x) == 2 + x, cls_token = x[0], x[1] + feature_shape = x.shape + if self.readout_type == "project": + x = x.flatten(2).permute((0, 2, 1)) + readout = cls_token.unsqueeze(1).expand_as(x) + x = self.readout_projects[i](torch.cat((x, readout), -1)) + x = x.permute(0, 2, 1).reshape(feature_shape) + elif self.readout_type == "add": + x = x.flatten(2) + cls_token.unsqueeze(-1) + x = x.reshape(feature_shape) + else: + pass + x = self.projects[i](x) + x = self.resize_layers[i](x) + out.append(x) + return out + + +class PreActResidualConvUnit(nn.Module): + """ResidualConvUnit, pre-activate residual unit. + Args: + in_channels (int): number of channels in the input feature map. + act_layer (nn.Module): activation layer. + norm_layer (nn.Module): norm layer. + stride (int): stride of the first block. Default: 1 + dilation (int): dilation rate for convs layers. Default: 1. + """ + + def __init__(self, in_channels, act_layer, norm_layer, stride=1, dilation=1): + super(PreActResidualConvUnit, self).__init__() + + self.conv1 = ConvModule( + in_channels, + in_channels, + 3, + stride=stride, + padding=dilation, + dilation=dilation, + norm_layer=norm_layer, + act_layer=act_layer, + bias=False, + order=("act", "conv", "norm"), + ) + + self.conv2 = ConvModule( + in_channels, + in_channels, + 3, + padding=1, + norm_layer=norm_layer, + act_layer=act_layer, + bias=False, + order=("act", "conv", "norm"), + ) + + def forward(self, inputs): + inputs_ = inputs.clone() + x = self.conv1(inputs) + x = self.conv2(x) + return x + inputs_ + + +class FeatureFusionBlock(nn.Module): + """FeatureFusionBlock, merge feature map from different stages. + Args: + in_channels (int): Input channels. + act_layer (nn.Module): activation layer for ResidualConvUnit. + norm_layer (nn.Module): normalization layer. + expand (bool): Whether expand the channels in post process block. + Default: False. + align_corners (bool): align_corner setting for bilinear upsample. + Default: True. + """ + + def __init__(self, in_channels, act_layer, norm_layer, expand=False, align_corners=True): + super(FeatureFusionBlock, self).__init__() + + self.in_channels = in_channels + self.expand = expand + self.align_corners = align_corners + + self.out_channels = in_channels + if self.expand: + self.out_channels = in_channels // 2 + + self.project = ConvModule(self.in_channels, self.out_channels, kernel_size=1, act_layer=None, bias=True) + + self.res_conv_unit1 = PreActResidualConvUnit( + in_channels=self.in_channels, act_layer=act_layer, norm_layer=norm_layer + ) + self.res_conv_unit2 = PreActResidualConvUnit( + in_channels=self.in_channels, act_layer=act_layer, norm_layer=norm_layer + ) + + def forward(self, *inputs): + x = inputs[0] + if len(inputs) == 2: + if x.shape != inputs[1].shape: + res = resize(inputs[1], size=(x.shape[2], x.shape[3]), mode="bilinear", align_corners=False) + else: + res = inputs[1] + x = x + self.res_conv_unit1(res) + x = self.res_conv_unit2(x) + x = resize(x, scale_factor=2, mode="bilinear", align_corners=self.align_corners) + x = self.project(x) + return x + + +class DPTHead(DepthBaseDecodeHead): + """Vision Transformers for Dense Prediction. + This head is implemented of `DPT `_. + Args: + embed_dims (int): The embed dimension of the ViT backbone. + Default: 768. + post_process_channels (List): Out channels of post process conv + layers. Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + expand_channels (bool): Whether expand the channels in post process + block. Default: False. + """ + + def __init__( + self, + embed_dims=768, + post_process_channels=[96, 192, 384, 768], + readout_type="ignore", + patch_size=16, + expand_channels=False, + **kwargs, + ): + super(DPTHead, self).__init__(**kwargs) + + self.in_channels = self.in_channels + self.expand_channels = expand_channels + self.reassemble_blocks = ReassembleBlocks(embed_dims, post_process_channels, readout_type, patch_size) + + self.post_process_channels = [ + channel * math.pow(2, i) if expand_channels else channel for i, channel in enumerate(post_process_channels) + ] + self.convs = nn.ModuleList() + for channel in self.post_process_channels: + self.convs.append(ConvModule(channel, self.channels, kernel_size=3, padding=1, act_layer=None, bias=False)) + self.fusion_blocks = nn.ModuleList() + for _ in range(len(self.convs)): + self.fusion_blocks.append(FeatureFusionBlock(self.channels, self.act_layer, self.norm_layer)) + self.fusion_blocks[0].res_conv_unit1 = None + self.project = ConvModule(self.channels, self.channels, kernel_size=3, padding=1, norm_layer=self.norm_layer) + self.num_fusion_blocks = len(self.fusion_blocks) + self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers) + self.num_post_process_channels = len(self.post_process_channels) + assert self.num_fusion_blocks == self.num_reassemble_blocks + assert self.num_reassemble_blocks == self.num_post_process_channels + self.conv_depth = HeadDepth(self.channels) + + def forward(self, inputs, img_metas): + assert len(inputs) == self.num_reassemble_blocks + x = [inp for inp in inputs] + x = self.reassemble_blocks(x) + x = [self.convs[i](feature) for i, feature in enumerate(x)] + out = self.fusion_blocks[0](x[-1]) + for i in range(1, len(self.fusion_blocks)): + out = self.fusion_blocks[i](out, x[-(i + 1)]) + out = self.project(out) + out = self.depth_pred(out) + return out diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/encoder_decoder.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/encoder_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..88f169cd8fa29393212a084077105edeb320ab62 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/encoder_decoder.py @@ -0,0 +1,351 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import OrderedDict + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .ops import resize + + +def add_prefix(inputs, prefix): + """Add prefix for dict. + + Args: + inputs (dict): The input dict with str keys. + prefix (str): The prefix to add. + + Returns: + + dict: The dict with keys updated with ``prefix``. + """ + + outputs = dict() + for name, value in inputs.items(): + outputs[f"{prefix}.{name}"] = value + + return outputs + + +class DepthEncoderDecoder(nn.Module): + """Encoder Decoder depther. + + EncoderDecoder typically consists of backbone and decode_head. + """ + + def __init__(self, backbone, decode_head): + super(DepthEncoderDecoder, self).__init__() + + self.backbone = backbone + self.decode_head = decode_head + self.align_corners = self.decode_head.align_corners + + def extract_feat(self, img): + """Extract features from images.""" + return self.backbone(img) + + def encode_decode(self, img, img_metas, rescale=True, size=None): + """Encode images with backbone and decode into a depth estimation + map of the same size as input.""" + x = self.extract_feat(img) + out = self._decode_head_forward_test(x, img_metas) + # crop the pred depth to the certain range. + out = torch.clamp(out, min=self.decode_head.min_depth, max=self.decode_head.max_depth) + if rescale: + if size is None: + if img_metas is not None: + size = img_metas[0]["ori_shape"][:2] + else: + size = img.shape[2:] + out = resize(input=out, size=size, mode="bilinear", align_corners=self.align_corners) + return out + + def _decode_head_forward_train(self, img, x, img_metas, depth_gt, **kwargs): + """Run forward function and calculate loss for decode head in + training.""" + losses = dict() + loss_decode = self.decode_head.forward_train(img, x, img_metas, depth_gt, **kwargs) + losses.update(add_prefix(loss_decode, "decode")) + return losses + + def _decode_head_forward_test(self, x, img_metas): + """Run forward function and calculate loss for decode head in + inference.""" + depth_pred = self.decode_head.forward_test(x, img_metas) + return depth_pred + + def forward_dummy(self, img): + """Dummy forward function.""" + depth = self.encode_decode(img, None) + + return depth + + def forward_train(self, img, img_metas, depth_gt, **kwargs): + """Forward function for training. + + Args: + img (Tensor): Input images. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): Depth gt + used if the architecture supports depth estimation task. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + + x = self.extract_feat(img) + + losses = dict() + + # the last of x saves the info from neck + loss_decode = self._decode_head_forward_train(img, x, img_metas, depth_gt, **kwargs) + + losses.update(loss_decode) + + return losses + + def whole_inference(self, img, img_meta, rescale, size=None): + """Inference with full image.""" + return self.encode_decode(img, img_meta, rescale, size=size) + + def slide_inference(self, img, img_meta, rescale, stride, crop_size): + """Inference by sliding-window with overlap. + + If h_crop > h_img or w_crop > w_img, the small patch will be used to + decode without padding. + """ + + h_stride, w_stride = stride + h_crop, w_crop = crop_size + batch_size, _, h_img, w_img = img.size() + h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1 + w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1 + preds = img.new_zeros((batch_size, 1, h_img, w_img)) + count_mat = img.new_zeros((batch_size, 1, h_img, w_img)) + for h_idx in range(h_grids): + for w_idx in range(w_grids): + y1 = h_idx * h_stride + x1 = w_idx * w_stride + y2 = min(y1 + h_crop, h_img) + x2 = min(x1 + w_crop, w_img) + y1 = max(y2 - h_crop, 0) + x1 = max(x2 - w_crop, 0) + crop_img = img[:, :, y1:y2, x1:x2] + depth_pred = self.encode_decode(crop_img, img_meta, rescale) + preds += F.pad(depth_pred, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2))) + + count_mat[:, :, y1:y2, x1:x2] += 1 + assert (count_mat == 0).sum() == 0 + if torch.onnx.is_in_onnx_export(): + # cast count_mat to constant while exporting to ONNX + count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device) + preds = preds / count_mat + return preds + + def inference(self, img, img_meta, rescale, size=None, mode="whole"): + """Inference with slide/whole style. + + Args: + img (Tensor): The input image of shape (N, 3, H, W). + img_meta (dict): Image info dict where each dict has: 'img_shape', + 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + rescale (bool): Whether rescale back to original shape. + + Returns: + Tensor: The output depth map. + """ + + assert mode in ["slide", "whole"] + ori_shape = img_meta[0]["ori_shape"] + assert all(_["ori_shape"] == ori_shape for _ in img_meta) + if mode == "slide": + depth_pred = self.slide_inference(img, img_meta, rescale) + else: + depth_pred = self.whole_inference(img, img_meta, rescale, size=size) + output = depth_pred + flip = img_meta[0]["flip"] + if flip: + flip_direction = img_meta[0]["flip_direction"] + assert flip_direction in ["horizontal", "vertical"] + if flip_direction == "horizontal": + output = output.flip(dims=(3,)) + elif flip_direction == "vertical": + output = output.flip(dims=(2,)) + + return output + + def simple_test(self, img, img_meta, rescale=True): + """Simple test with single image.""" + depth_pred = self.inference(img, img_meta, rescale) + if torch.onnx.is_in_onnx_export(): + # our inference backend only support 4D output + depth_pred = depth_pred.unsqueeze(0) + return depth_pred + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred + + def aug_test(self, imgs, img_metas, rescale=True): + """Test with augmentations. + + Only rescale=True is supported. + """ + # aug_test rescale all imgs back to ori_shape for now + assert rescale + # to save memory, we get augmented depth logit inplace + depth_pred = self.inference(imgs[0], img_metas[0], rescale) + for i in range(1, len(imgs)): + cur_depth_pred = self.inference(imgs[i], img_metas[i], rescale, size=depth_pred.shape[-2:]) + depth_pred += cur_depth_pred + depth_pred /= len(imgs) + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred + + def forward_test(self, imgs, img_metas, **kwargs): + """ + Args: + imgs (List[Tensor]): the outer list indicates test-time + augmentations and inner Tensor should have a shape NxCxHxW, + which contains all images in the batch. + img_metas (List[List[dict]]): the outer list indicates test-time + augs (multiscale, flip, etc.) and the inner list indicates + images in a batch. + """ + for var, name in [(imgs, "imgs"), (img_metas, "img_metas")]: + if not isinstance(var, list): + raise TypeError(f"{name} must be a list, but got " f"{type(var)}") + num_augs = len(imgs) + if num_augs != len(img_metas): + raise ValueError(f"num of augmentations ({len(imgs)}) != " f"num of image meta ({len(img_metas)})") + # all images in the same aug batch all of the same ori_shape and pad + # shape + for img_meta in img_metas: + ori_shapes = [_["ori_shape"] for _ in img_meta] + assert all(shape == ori_shapes[0] for shape in ori_shapes) + img_shapes = [_["img_shape"] for _ in img_meta] + assert all(shape == img_shapes[0] for shape in img_shapes) + pad_shapes = [_["pad_shape"] for _ in img_meta] + assert all(shape == pad_shapes[0] for shape in pad_shapes) + + if num_augs == 1: + return self.simple_test(imgs[0], img_metas[0], **kwargs) + else: + return self.aug_test(imgs, img_metas, **kwargs) + + def forward(self, img, img_metas, return_loss=True, **kwargs): + """Calls either :func:`forward_train` or :func:`forward_test` depending + on whether ``return_loss`` is ``True``. + + Note this setting will change the expected inputs. When + ``return_loss=True``, img and img_meta are single-nested (i.e. Tensor + and List[dict]), and when ``resturn_loss=False``, img and img_meta + should be double nested (i.e. List[Tensor], List[List[dict]]), with + the outer list indicating test time augmentations. + """ + if return_loss: + return self.forward_train(img, img_metas, **kwargs) + else: + return self.forward_test(img, img_metas, **kwargs) + + def train_step(self, data_batch, optimizer, **kwargs): + """The iteration step during training. + + This method defines an iteration step during training, except for the + back propagation and optimizer updating, which are done in an optimizer + hook. Note that in some complicated cases or models, the whole process + including back propagation and optimizer updating is also defined in + this method, such as GAN. + + Args: + data (dict): The output of dataloader. + optimizer (:obj:`torch.optim.Optimizer` | dict): The optimizer of + runner is passed to ``train_step()``. This argument is unused + and reserved. + + Returns: + dict: It should contain at least 3 keys: ``loss``, ``log_vars``, + ``num_samples``. + ``loss`` is a tensor for back propagation, which can be a + weighted sum of multiple losses. + ``log_vars`` contains all the variables to be sent to the + logger. + ``num_samples`` indicates the batch size (when the model is + DDP, it means the batch size on each GPU), which is used for + averaging the logs. + """ + losses = self(**data_batch) + + # split losses and images + real_losses = {} + log_imgs = {} + for k, v in losses.items(): + if "img" in k: + log_imgs[k] = v + else: + real_losses[k] = v + + loss, log_vars = self._parse_losses(real_losses) + + outputs = dict(loss=loss, log_vars=log_vars, num_samples=len(data_batch["img_metas"]), log_imgs=log_imgs) + + return outputs + + def val_step(self, data_batch, **kwargs): + """The iteration step during validation. + + This method shares the same signature as :func:`train_step`, but used + during val epochs. Note that the evaluation after training epochs is + not implemented with this method, but an evaluation hook. + """ + output = self(**data_batch, **kwargs) + return output + + @staticmethod + def _parse_losses(losses): + import torch.distributed as dist + + """Parse the raw outputs (losses) of the network. + + Args: + losses (dict): Raw output of the network, which usually contain + losses and other necessary information. + + Returns: + tuple[Tensor, dict]: (loss, log_vars), loss is the loss tensor + which may be a weighted sum of all losses, log_vars contains + all the variables to be sent to the logger. + """ + 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) + else: + raise TypeError(f"{loss_name} is not a tensor or list of tensors") + + loss = sum(_value for _key, _value in log_vars.items() if "loss" in _key) + + log_vars["loss"] = loss + 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() + + return loss, log_vars diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/ops.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/ops.py new file mode 100644 index 0000000000000000000000000000000000000000..0abb2a7040f487371b2f89875ef5fa180a87f4ae --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depth/ops.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +import torch.nn.functional as F + + +def resize(input, size=None, scale_factor=None, mode="nearest", align_corners=None, warning=False): + if warning: + if size is not None and align_corners: + input_h, input_w = tuple(int(x) for x in input.shape[2:]) + output_h, output_w = tuple(int(x) for x in size) + if output_h > input_h or output_w > output_h: + if ( + (output_h > 1 and output_w > 1 and input_h > 1 and input_w > 1) + and (output_h - 1) % (input_h - 1) + and (output_w - 1) % (input_w - 1) + ): + warnings.warn( + f"When align_corners={align_corners}, " + "the output would more aligned if " + f"input size {(input_h, input_w)} is `x+1` and " + f"out size {(output_h, output_w)} is `nx+1`" + ) + return F.interpolate(input, size, scale_factor, mode, align_corners) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depthers.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depthers.py new file mode 100644 index 0000000000000000000000000000000000000000..a08f71c838f4235811d6a68cb6a5f5cec2204438 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/depthers.py @@ -0,0 +1,246 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +from functools import partial +from typing import Optional, Tuple, Union + +import torch + +from .backbones import _make_dinov2_model +from .depth import BNHead, DepthEncoderDecoder, DPTHead +from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name, CenterPadding + + +class Weights(Enum): + NYU = "NYU" + KITTI = "KITTI" + + +def _get_depth_range(pretrained: bool, weights: Weights = Weights.NYU) -> Tuple[float, float]: + if not pretrained: # Default + return (0.001, 10.0) + + # Pretrained, set according to the training dataset for the provided weights + if weights == Weights.KITTI: + return (0.001, 80.0) + + if weights == Weights.NYU: + return (0.001, 10.0) + + return (0.001, 10.0) + + +def _make_dinov2_linear_depth_head( + *, + embed_dim: int, + layers: int, + min_depth: float, + max_depth: float, + **kwargs, +): + if layers not in (1, 4): + raise AssertionError(f"Unsupported number of layers: {layers}") + + if layers == 1: + in_index = [0] + else: + assert layers == 4 + in_index = [0, 1, 2, 3] + + return BNHead( + classify=True, + n_bins=256, + bins_strategy="UD", + norm_strategy="linear", + upsample=4, + in_channels=[embed_dim] * len(in_index), + in_index=in_index, + input_transform="resize_concat", + channels=embed_dim * len(in_index) * 2, + align_corners=False, + min_depth=0.001, + max_depth=80, + loss_decode=(), + ) + + +def _make_dinov2_linear_depther( + *, + arch_name: str = "vit_large", + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.NYU, + depth_range: Optional[Tuple[float, float]] = None, + **kwargs, +): + if layers not in (1, 4): + raise AssertionError(f"Unsupported number of layers: {layers}") + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + if depth_range is None: + depth_range = _get_depth_range(pretrained, weights) + min_depth, max_depth = depth_range + + backbone = _make_dinov2_model(arch_name=arch_name, pretrained=pretrained, **kwargs) + + embed_dim = backbone.embed_dim + patch_size = backbone.patch_size + model_name = _make_dinov2_model_name(arch_name, patch_size) + linear_depth_head = _make_dinov2_linear_depth_head( + embed_dim=embed_dim, + layers=layers, + min_depth=min_depth, + max_depth=max_depth, + ) + + layer_count = { + "vit_small": 12, + "vit_base": 12, + "vit_large": 24, + "vit_giant2": 40, + }[arch_name] + + if layers == 4: + out_index = { + "vit_small": [2, 5, 8, 11], + "vit_base": [2, 5, 8, 11], + "vit_large": [4, 11, 17, 23], + "vit_giant2": [9, 19, 29, 39], + }[arch_name] + else: + assert layers == 1 + out_index = [layer_count - 1] + + model = DepthEncoderDecoder(backbone=backbone, decode_head=linear_depth_head) + model.backbone.forward = partial( + backbone.get_intermediate_layers, + n=out_index, + reshape=True, + return_class_token=True, + norm=False, + ) + model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(patch_size)(x[0])) + + if pretrained: + layers_str = str(layers) if layers == 4 else "" + weights_str = weights.value.lower() + url = _DINOV2_BASE_URL + f"/{model_name}/{model_name}_{weights_str}_linear{layers_str}_head.pth" + checkpoint = torch.hub.load_state_dict_from_url(url, map_location="cpu") + if "state_dict" in checkpoint: + state_dict = checkpoint["state_dict"] + model.load_state_dict(state_dict, strict=False) + + return model + + +def dinov2_vits14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_small", layers=layers, pretrained=pretrained, weights=weights, **kwargs + ) + + +def dinov2_vitb14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_base", layers=layers, pretrained=pretrained, weights=weights, **kwargs + ) + + +def dinov2_vitl14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_large", layers=layers, pretrained=pretrained, weights=weights, **kwargs + ) + + +def dinov2_vitg14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_giant2", layers=layers, ffn_layer="swiglufused", pretrained=pretrained, weights=weights, **kwargs + ) + + +def _make_dinov2_dpt_depth_head(*, embed_dim: int, min_depth: float, max_depth: float): + return DPTHead( + in_channels=[embed_dim] * 4, + channels=256, + embed_dims=embed_dim, + post_process_channels=[embed_dim // 2 ** (3 - i) for i in range(4)], + readout_type="project", + min_depth=min_depth, + max_depth=max_depth, + loss_decode=(), + ) + + +def _make_dinov2_dpt_depther( + *, + arch_name: str = "vit_large", + pretrained: bool = True, + weights: Union[Weights, str] = Weights.NYU, + depth_range: Optional[Tuple[float, float]] = None, + **kwargs, +): + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + if depth_range is None: + depth_range = _get_depth_range(pretrained, weights) + min_depth, max_depth = depth_range + + backbone = _make_dinov2_model(arch_name=arch_name, pretrained=pretrained, **kwargs) + + model_name = _make_dinov2_model_name(arch_name, backbone.patch_size) + dpt_depth_head = _make_dinov2_dpt_depth_head(embed_dim=backbone.embed_dim, min_depth=min_depth, max_depth=max_depth) + + out_index = { + "vit_small": [2, 5, 8, 11], + "vit_base": [2, 5, 8, 11], + "vit_large": [4, 11, 17, 23], + "vit_giant2": [9, 19, 29, 39], + }[arch_name] + + model = DepthEncoderDecoder(backbone=backbone, decode_head=dpt_depth_head) + model.backbone.forward = partial( + backbone.get_intermediate_layers, + n=out_index, + reshape=True, + return_class_token=True, + norm=False, + ) + model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone.patch_size)(x[0])) + + if pretrained: + weights_str = weights.value.lower() + url = _DINOV2_BASE_URL + f"/{model_name}/{model_name}_{weights_str}_dpt_head.pth" + checkpoint = torch.hub.load_state_dict_from_url(url, map_location="cpu") + if "state_dict" in checkpoint: + state_dict = checkpoint["state_dict"] + model.load_state_dict(state_dict, strict=False) + + return model + + +def dinov2_vits14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther(arch_name="vit_small", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitb14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther(arch_name="vit_base", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitl14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther(arch_name="vit_large", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitg14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther( + arch_name="vit_giant2", ffn_layer="swiglufused", pretrained=pretrained, weights=weights, **kwargs + ) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/dinotxt.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/dinotxt.py new file mode 100644 index 0000000000000000000000000000000000000000..692b4cbe5612628190650a29bacd3f7442ea09e2 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/dinotxt.py @@ -0,0 +1,82 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import math + +from .backbones import dinov2_vitl14_reg +from .utils import _DINOV2_BASE_URL + + +def dinov2_vitl14_reg4_dinotxt_tet1280d20h24l(): + from .text.dinotxt_model import DinoTxtConfig, DinoTxt + from .text.dinov2_wrapper import DINOv2Wrapper + from .text.text_transformer import TextTransformer + + dinotxt_config = DinoTxtConfig( + embed_dim=2048, + vision_model_freeze_backbone=True, + vision_model_train_img_size=224, + vision_model_use_class_token=True, + vision_model_use_patch_tokens=True, + vision_model_num_head_blocks=2, + vision_model_head_blocks_drop_path=0.3, + vision_model_use_linear_projection=False, + vision_model_patch_tokens_pooler_type="mean", + vision_model_patch_token_layer=1, # which layer to take patch tokens from + # 1 - last layer, 2 - second last layer, etc. + text_model_freeze_backbone=False, + text_model_num_head_blocks=0, + text_model_head_blocks_is_causal=False, + text_model_head_blocks_drop_prob=0.0, + text_model_tokens_pooler_type="argmax", + text_model_use_linear_projection=True, + init_logit_scale=math.log(1 / 0.07), + init_logit_bias=None, + freeze_logit_scale=False, + ) + vision_backbone = DINOv2Wrapper(dinov2_vitl14_reg()) + text_backbone = TextTransformer( + context_length=77, + vocab_size=49408, + dim=1280, + num_heads=20, + num_layers=24, + ffn_ratio=4, + is_causal=True, + ls_init_value=None, + dropout_prob=0.0, + ) + model = DinoTxt(dinotxt_config, vision_backbone, text_backbone) + model.init_weights() + model.visual_model.backbone = vision_backbone + model.eval() + + visual_model_head_state_dict = torch.hub.load_state_dict_from_url( + _DINOV2_BASE_URL + "/dinov2_vitl14/dinov2_vitl14_reg4_dinotxt_tet1280d20h24l_vision_head.pth", + map_location="cpu", + ) + text_model_state_dict = torch.hub.load_state_dict_from_url( + _DINOV2_BASE_URL + "/dinov2_vitl14/dinov2_vitl14_reg4_dinotxt_tet1280d20h24l_text_encoder.pth", + map_location="cpu", + ) + model.visual_model.head.load_state_dict(visual_model_head_state_dict, strict=True) + model.text_model.load_state_dict(text_model_state_dict, strict=True) + return model + + +def get_tokenizer(): + from .text.tokenizer import Tokenizer + import requests + from io import BytesIO + + url = _DINOV2_BASE_URL + "/thirdparty/bpe_simple_vocab_16e6.txt.gz" + try: + response = requests.get(url) + response.raise_for_status() + file_buf = BytesIO(response.content) + return Tokenizer(vocab_path=file_buf) + except Exception as e: + raise FileNotFoundError(f"Failed to download file from url {url} with error last: {e}") diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/dinotxt_model.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/dinotxt_model.py new file mode 100644 index 0000000000000000000000000000000000000000..a88d8acbfc41ca545a1b793466b65acb4dea8503 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/dinotxt_model.py @@ -0,0 +1,135 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass +from typing import Optional, Tuple + +import torch +import torch.nn.functional as F +from torch import nn, Tensor + +from .vision_tower import VisionTower +from .text_tower import TextTower + + +@dataclass +class DinoTxtConfig: + embed_dim: int + vision_model_freeze_backbone: bool = True + vision_model_train_img_size: int = 224 + vision_model_use_class_token: bool = True + vision_model_use_patch_tokens: bool = False + vision_model_num_head_blocks: int = 0 + vision_model_head_blocks_drop_path: float = 0.3 + vision_model_use_linear_projection: bool = False + vision_model_patch_tokens_pooler_type: str = "mean" + vision_model_patch_token_layer: int = 1 # which layer to take patch tokens from + # 1 - last layer, 2 - second last layer, etc. + text_model_freeze_backbone: bool = False + text_model_num_head_blocks: int = 0 + text_model_head_blocks_is_causal: bool = False + text_model_head_blocks_drop_prob: float = 0.0 + text_model_tokens_pooler_type: str = "first" + text_model_use_linear_projection: bool = False + init_logit_scale: float = math.log(1 / 0.07) + init_logit_bias: Optional[float] = None + freeze_logit_scale: bool = False + + +class DinoTxt(nn.Module): + def __init__( + self, + model_config: DinoTxtConfig, + vision_backbone: nn.Module, + text_backbone: nn.Module, + ): + super().__init__() + self.model_config = model_config + self.visual_model = VisionTower( + vision_backbone, + model_config.vision_model_freeze_backbone, + model_config.embed_dim, + model_config.vision_model_num_head_blocks, + model_config.vision_model_head_blocks_drop_path, + model_config.vision_model_use_class_token, + model_config.vision_model_use_patch_tokens, + model_config.vision_model_patch_token_layer, + model_config.vision_model_patch_tokens_pooler_type, + model_config.vision_model_use_linear_projection, + ) + self.text_model = TextTower( + text_backbone, + model_config.text_model_freeze_backbone, + model_config.embed_dim, + model_config.text_model_num_head_blocks, + model_config.text_model_head_blocks_is_causal, + model_config.text_model_head_blocks_drop_prob, + model_config.text_model_tokens_pooler_type, + model_config.text_model_use_linear_projection, + ) + self.logit_scale = nn.Parameter(torch.ones(1) * model_config.init_logit_scale) + if model_config.freeze_logit_scale: + self.logit_scale.requires_grad = False + + def init_weights(self): + self.visual_model.init_weights() + self.text_model.init_weights() + + def get_visual_class_and_patch_tokens(self, image: Tensor) -> Tuple[Tensor, Tensor]: + return self.visual_model.get_class_and_patch_tokens(image) + + def encode_image( + self, + image: Tensor, + normalize: bool = False, + ) -> Tensor: + """ + Encode an image into a vector descriptor containing both global and local features. + + Args: + image (Tensor): Tensor of shape `(batch_size, rgb, height, width)`, normalized using ImageNet mean and std. + normalize (bool, optional): Whether to normalize the output vectors. Default is False. + Image features should always be normalized before comparing them with text features: + Returns: + Tensor: Tensor of shape `(batch_size, embed_dim)` containing the image features. + The first half of the vector corresponds to the global features (class token), + and the second half corresponds to the pooled patch features. + """ + features = self.visual_model(image) + return F.normalize(features, dim=-1) if normalize else features + + def encode_text(self, text: Tensor, normalize: bool = False) -> Tensor: + """ + Encode a text input into a vector descriptor. + + Args: + text (Tensor): Tensor of shape `(batch_size, seq_len)` containing token indices. + normalize (bool, optional): Whether to normalize the output vectors. Default is False. + Text features should be normalized before comparing them with image features: + Returns: + Tensor: Tensor of shape `(batch_size, embed_dim)` containing the text features. + As a consequence of the training procedure, assume that the first half of the tensor corresponds + to global image features and the second half to pooled patch features. + """ + features = self.text_model(text) + return F.normalize(features, dim=-1) if normalize else features + + def get_logits(self, image: Tensor, text: Tensor) -> Tuple[Tensor, Tensor]: + text_features = self.encode_text(text, normalize=True) + image_features = self.encode_image(image, normalize=True) + image_logits = self.logit_scale.exp() * image_features @ text_features.T + text_logits = image_logits.T + return image_logits, text_logits + + def forward( + self, + image: Tensor, + text: Tensor, + ) -> Tuple[Tensor, Tensor, Tensor]: + + text_features = self.encode_text(text, normalize=True) + image_features = self.encode_image(image, normalize=True) + return image_features, text_features, self.logit_scale.exp() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/dinov2_wrapper.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/dinov2_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..39c6e7ffc5934fc5f48a0d86ff80ca26d8cb1079 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/dinov2_wrapper.py @@ -0,0 +1,64 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Sequence + +import torch + + +class DINOv2Wrapper(torch.nn.Module): + def __init__(self, model): + super().__init__() + self.model = model + self.embed_dim = model.embed_dim + self.num_heads = model.num_heads + self.num_register_tokens = model.num_register_tokens + + # Same as the original forward, but assert is_training and rename x_norm_regtokens -> x_storage_tokens + def forward(self, img, is_training: bool): + assert is_training + H, W = img.shape[-2:] + P = self.model.patch_size + x_dict = self.model(img, is_training=True) + x_dict["h"] = h = H // P + x_dict["w"] = w = W // P + assert x_dict["x_norm_patchtokens"].shape[-2] == h * w + return x_dict + + # Same as the original get_intermediate_layers, but allow returining extra tokens (registers) + def get_intermediate_layers( + self, + x: torch.Tensor, + n: int | Sequence[int] = 1, # Layers or n last layers to take + reshape: bool = False, + return_class_token: bool = False, + return_register_tokens: bool = False, + norm=True, + ) -> tuple[torch.Tensor] | tuple[tuple[torch.Tensor, ...], ...]: + if self.model.chunked_blocks: + outputs = self.model._get_intermediate_layers_chunked(x, n) + else: + outputs = self.model._get_intermediate_layers_not_chunked(x, n) + if norm: + outputs = [self.model.norm(out) for out in outputs] + class_tokens = [out[:, 0] for out in outputs] + register_tokens = [out[:, 1 : 1 + self.model.num_register_tokens] for out in outputs] + outputs = [out[:, 1 + self.model.num_register_tokens :] for out in outputs] + if reshape: + B, _, h, w = x.shape + outputs = [ + out.reshape(B, h // self.model.patch_size, w // self.model.patch_size, -1) + .permute(0, 3, 1, 2) + .contiguous() + for out in outputs + ] + + if not return_class_token and not return_register_tokens: + return tuple(outputs) + if return_class_token and not return_register_tokens: + return tuple(zip(outputs, class_tokens)) + if not return_class_token and return_register_tokens: + return tuple(zip(outputs, register_tokens)) + return tuple(zip(outputs, class_tokens, register_tokens)) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/text_tower.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/text_tower.py new file mode 100644 index 0000000000000000000000000000000000000000..81dddff91ebf0843fc4a7b0a7188131afb8f3891 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/text_tower.py @@ -0,0 +1,104 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +from torch import nn, Tensor + +from dinov2.layers import ( + CausalAttentionBlock, +) + + +class TextHead(nn.Module): + def __init__( + self, + input_dim: int, + embed_dim: int, + num_heads: int, + num_blocks: int, + block_drop_prob: float, + is_causal: bool, + use_linear_projection: bool, + ): + super().__init__() + block_list = [nn.Identity()] + self.ln_final = nn.Identity() + if num_blocks > 0: + block_list = [ + CausalAttentionBlock( + dim=input_dim, + num_heads=num_heads, + is_causal=is_causal, + dropout_prob=block_drop_prob, + ) + for _ in range(num_blocks) + ] + self.ln_final = nn.LayerNorm(input_dim) + self.block_list = nn.ModuleList(block_list) + self.num_blocks = num_blocks + self.linear_projection = nn.Identity() + if input_dim != embed_dim or use_linear_projection: + self.linear_projection = nn.Linear(input_dim, embed_dim, bias=False) + + def init_weights(self): + if self.num_blocks > 0: + for i in range(self.num_blocks): + self.block_list[i].init_weights() + self.ln_final.reset_parameters() + if isinstance(self.linear_projection, nn.Linear): + nn.init.normal_(self.linear_projection.weight, std=self.linear_projection.in_features**-0.5) + + def forward(self, text_tokens: Tensor) -> Tensor: + for block in self.block_list: + text_tokens = block(text_tokens) + text_tokens = self.ln_final(text_tokens) + return self.linear_projection(text_tokens) + + +class TextTower(nn.Module): + def __init__( + self, + backbone: nn.Module, + freeze_backbone: bool, + embed_dim: int, + num_head_blocks: int, + head_blocks_is_causal: bool, + head_blocks_block_drop_prob: float, + tokens_pooler_type: str, + use_linear_projection: bool, + ): + super().__init__() + self.backbone = backbone + self.freeze_backbone = freeze_backbone + backbone_out_dim = backbone.embed_dim + self.backbone = backbone + self.head = TextHead( + backbone_out_dim, + embed_dim, + self.backbone.num_heads, + num_head_blocks, + head_blocks_block_drop_prob, + head_blocks_is_causal, + use_linear_projection, + ) + self.tokens_pooler_type = tokens_pooler_type + + def init_weights(self): + self.backbone.init_weights() + self.head.init_weights() + + def forward(self, token_indices: Tensor) -> Tensor: + text_tokens = self.backbone(token_indices) + text_tokens = self.head(text_tokens) + if self.tokens_pooler_type == "first": + features = text_tokens[:, 0] + elif self.tokens_pooler_type == "last": + features = text_tokens[:, -1] + elif self.tokens_pooler_type == "argmax": + assert token_indices is not None + features = text_tokens[torch.arange(text_tokens.shape[0]), token_indices.argmax(dim=-1)] + else: + raise ValueError(f"Unknown text tokens pooler type: {self.pooler_type}") + return features diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/text_transformer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/text_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..8f1ca9dea218d6f64279cbd992a53535fc1173fc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/text_transformer.py @@ -0,0 +1,72 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Callable, Optional, Tuple + +import torch +from torch import nn, Tensor + + +from dinov2.layers import CausalAttentionBlock + + +class TextTransformer(nn.Module): + def __init__( + self, + context_length: int, + vocab_size: int, + dim: int, + num_heads: int, + num_layers: int, + ffn_ratio: float, + is_causal: bool, + ls_init_value: Optional[float] = None, + act_layer: Callable = nn.GELU, + norm_layer: Callable = nn.LayerNorm, + dropout_prob: float = 0.0, + ): + super().__init__() + self.vocab_size = vocab_size + self.embed_dim = dim + self.num_heads = num_heads + + self.token_embedding = nn.Embedding(vocab_size, dim) + self.positional_embedding = nn.Parameter(torch.empty(context_length, dim)) + self.dropout = nn.Dropout(dropout_prob) + self.num_layers = num_layers + block_list = [ + CausalAttentionBlock( + dim=dim, + num_heads=num_heads, + ffn_ratio=ffn_ratio, + ls_init_value=ls_init_value, + is_causal=is_causal, + act_layer=act_layer, + norm_layer=norm_layer, + dropout_prob=dropout_prob, + ) + for _ in range(num_layers) + ] + self.blocks = nn.ModuleList(block_list) + self.ln_final = norm_layer(dim) + + def init_weights(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + init_attn_std = self.embed_dim**-0.5 + init_proj_std = (self.embed_dim**-0.5) * ((2 * self.num_layers) ** -0.5) + init_fc_std = (2 * self.embed_dim) ** -0.5 + for block in self.blocks: + block.init_weights(init_attn_std, init_proj_std, init_fc_std) + self.ln_final.reset_parameters() + + def forward(self, token_indices: Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + _, N = token_indices.size() + x = self.token_embedding(token_indices) + self.positional_embedding[:N] + x = self.dropout(x) + for block in self.blocks: + x = block(x) + x = self.ln_final(x) + return x diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/tokenizer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..98b0f2f4685b438ea2a85c1039ccbb322a0b425b --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/tokenizer.py @@ -0,0 +1,45 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +from typing import List, Union + + +from dinov2.thirdparty.CLIP.clip.simple_tokenizer import SimpleTokenizer + + +class Tokenizer(SimpleTokenizer): + def __init__(self, vocab_path: str): + SimpleTokenizer.__init__(self, bpe_path=vocab_path) + + def tokenize(self, texts: Union[str, List[str]], context_length: int = 77) -> torch.LongTensor: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + context_length : int + The context length to use; all CLIP models use 77 as the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length] + """ + if isinstance(texts, str): + texts = [texts] + sot_token = self.encoder["<|startoftext|>"] + eot_token = self.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + self.encode(text) + [eot_token] for text in texts] + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + tokens = tokens[:context_length] # Truncate + tokens[-1] = eot_token + result[i, : len(tokens)] = torch.tensor(tokens) + + return result diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/vision_tower.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/vision_tower.py new file mode 100644 index 0000000000000000000000000000000000000000..8a55bbc841d4a473941dcf08d37c4d0f37576f6e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/text/vision_tower.py @@ -0,0 +1,179 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial +from typing import Callable, Tuple + +import torch +from torch import nn, Tensor + +from dinov2.layers import ( + LayerScale, + NestedTensorBlock as AttentionBlock, + SwiGLUFFNAligned as SwiGLUFFN, +) + + +def init_weights_vit_timm(module: nn.Module, name: str = ""): + """ViT weight initialization, original timm impl (for reproducibility)""" + if isinstance(module, nn.Linear): + nn.init.trunc_normal_(module.weight, std=0.02) + if module.bias is not None: + nn.init.zeros_(module.bias) + if isinstance(module, nn.LayerNorm): + module.reset_parameters() + if isinstance(module, LayerScale): + module.reset_parameters() + if isinstance(module, nn.Conv2d): + module.reset_parameters() + + +def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module: + if not depth_first and include_root: + fn(module=module, name=name) + for child_name, child_module in module.named_children(): + child_name = ".".join((name, child_name)) if name else child_name + named_apply( + fn=fn, + module=child_module, + name=child_name, + depth_first=depth_first, + include_root=True, + ) + if depth_first and include_root: + fn(module=module, name=name) + return module + + +class VisionHead(nn.Module): + def __init__( + self, + input_dim: int, + embed_dim: int, + num_heads: int, + num_blocks: int, + blocks_drop_path: float, + use_class_token: bool, + use_patch_tokens: bool, + use_linear_projection: bool, + ): + super().__init__() + block_list = [nn.Identity()] + self.ln_final = nn.Identity() + if num_blocks > 0: + block_list = [ + AttentionBlock( + input_dim, + num_heads, + ffn_layer=partial(SwiGLUFFN, align_to=64), + init_values=1e-5, + drop_path=blocks_drop_path, + ) + for _ in range(num_blocks) + ] + self.ln_final = nn.LayerNorm(input_dim) + self.block_list = nn.ModuleList(block_list) + self.num_blocks = num_blocks + multiplier = 2 if use_class_token and use_patch_tokens else 1 + self.linear_projection = nn.Identity() + if multiplier * input_dim != embed_dim or use_linear_projection: + assert embed_dim % multiplier == 0, f"Expects {embed_dim} to be divisible by {multiplier}" + self.linear_projection = nn.Linear(input_dim, embed_dim // multiplier, bias=False) + + def init_weights(self): + if self.num_blocks > 0: + for i in range(self.num_blocks): + block = self.block_list[i] + named_apply(init_weights_vit_timm, block) + self.ln_final.reset_parameters() + if isinstance(self.linear_projection, nn.Linear): + nn.init.normal_(self.linear_projection.weight, std=self.linear_projection.in_features**-0.5) + + def forward(self, image_tokens: Tensor) -> Tensor: + for block in self.block_list: + image_tokens = block(image_tokens) + image_tokens = self.ln_final(image_tokens) + return self.linear_projection(image_tokens) + + +class VisionTower(nn.Module): + def __init__( + self, + backbone: nn.Module, + freeze_backbone: bool, + embed_dim: int, + num_head_blocks: int, + head_blocks_block_drop_path: float, + use_class_token: bool, + use_patch_tokens: bool, + patch_token_layer: int, + patch_tokens_pooler_type: str, + use_linear_projection: bool, + ): + super().__init__() + self.backbone = backbone + self.freeze_backbone = freeze_backbone + self.use_class_token = use_class_token + self.use_patch_tokens = use_patch_tokens + self.patch_token_layer = patch_token_layer + self.patch_tokens_pooler_type = patch_tokens_pooler_type + self.num_register_tokens = 0 + if hasattr(self.backbone, "num_register_tokens"): + self.num_register_tokens = self.backbone.num_register_tokens + elif hasattr(self.backbone, "n_storage_tokens"): + self.num_register_tokens = self.backbone.n_storage_tokens + backbone_out_dim = self.backbone.embed_dim + self.head = VisionHead( + backbone_out_dim, + embed_dim, + self.backbone.num_heads, + num_head_blocks, + head_blocks_block_drop_path, + use_class_token, + use_patch_tokens, + use_linear_projection, + ) + + def init_weights(self): + if not self.freeze_backbone: + self.backbone.init_weights() + self.head.init_weights() + + def get_backbone_features(self, images: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + tokens = self.backbone.get_intermediate_layers( + images, + n=self.patch_token_layer, + return_class_token=True, + return_register_tokens=True, + ) + class_token = tokens[-1][1] + patch_tokens = tokens[0][0] + register_tokens = tokens[0][2] + return class_token, patch_tokens, register_tokens + + def get_class_and_patch_tokens(self, images: Tensor) -> Tuple[Tensor, Tensor]: + class_token, patch_tokens, register_tokens = self.get_backbone_features(images) + image_tokens = self.head(torch.cat([class_token.unsqueeze(1), register_tokens, patch_tokens], dim=1)) + class_token, patch_tokens = image_tokens[:, 0], image_tokens[:, self.num_register_tokens + 1 :] + return class_token, patch_tokens + + def forward(self, images: Tensor) -> Tensor: + class_token, patch_tokens = self.get_class_and_patch_tokens(images) + features = [] + if self.use_class_token: + features.append(class_token) + if self.use_patch_tokens: + if self.patch_tokens_pooler_type == "mean": + features.append(torch.mean(patch_tokens, dim=1)) + elif self.patch_tokens_pooler_type == "max": + features.append(torch.max(patch_tokens, dim=1).values) + elif self.patch_tokens_pooler_type == "gem": + power = 3 + eps = 1e-6 + patch_tokens_power = patch_tokens.clamp(min=eps).pow(power) + features.append(torch.mean(patch_tokens_power, dim=1).pow(1 / power)) + else: + raise ValueError(f"Unknown patch tokens pooler type: {self.patch_tokens_pooler_type}") + return torch.cat(features, dim=-1) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/utils.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..7afea3273713518e891d1e6b8e86d58b4700fddc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/utils.py @@ -0,0 +1,39 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import itertools +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +_DINOV2_BASE_URL = "https://dl.fbaipublicfiles.com/dinov2" + + +def _make_dinov2_model_name(arch_name: str, patch_size: int, num_register_tokens: int = 0) -> str: + compact_arch_name = arch_name.replace("_", "")[:4] + registers_suffix = f"_reg{num_register_tokens}" if num_register_tokens else "" + return f"dinov2_{compact_arch_name}{patch_size}{registers_suffix}" + + +class CenterPadding(nn.Module): + def __init__(self, multiple): + super().__init__() + self.multiple = multiple + + def _get_pad(self, size): + new_size = math.ceil(size / self.multiple) * self.multiple + pad_size = new_size - size + pad_size_left = pad_size // 2 + pad_size_right = pad_size - pad_size_left + return pad_size_left, pad_size_right + + @torch.inference_mode() + def forward(self, x): + pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1])) + output = F.pad(x, pads) + return output diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/xray_dino/__pycache__/backbones.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/xray_dino/__pycache__/backbones.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78a95d4bd2203d53481767e35a4e771e43181281 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/xray_dino/__pycache__/backbones.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/hub/xray_dino/backbones.py b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/xray_dino/backbones.py new file mode 100644 index 0000000000000000000000000000000000000000..71a58879bf1120e55b02c49eba4c9780a313a488 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/hub/xray_dino/backbones.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the licence +# found in the LICENSE_XRAY_DINO_MODEL file in the root directory of this source tree. + +from typing import Union + +from ..backbones import Weights, _make_dinov2_model + + +def xray_dino_vitl16(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.XRAY_DINO, **kwargs): + """ + XRay-DINO ViT-L/16 model (optionally) pretrained on the XRay-DINO dataset. + """ + return _make_dinov2_model( + arch_name="vit_large", + patch_size=16, + img_size=512, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained=pretrained, + weights=weights, + hash="ad31c2b0", + check_hash=True, + **kwargs, + ) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6ba0146f890a7bfce524df7af3822accdb7e2366 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dino_head import DINOHead +from .layer_scale import LayerScale +from .mlp import Mlp +from .patch_embed import PatchEmbed +from .swiglu_ffn import SwiGLUFFN, SwiGLUFFNFused, SwiGLUFFNAligned +from .block import NestedTensorBlock, CausalAttentionBlock +from .attention import Attention, MemEffAttention diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/__init__.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..501d8011287f134a635def1b471e6b9772247eb2 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/__init__.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/attention.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/attention.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..433e4a3eca2c176f5ab3e886bbb7bbcfe70cc340 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/attention.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/block.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/block.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52e1ff9891f03151a64ff39df4a6e09722afd1d1 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/block.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/dino_head.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/dino_head.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..956b079ef0ff65d87e26c495e0a75145a7a7c6c7 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/dino_head.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/drop_path.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/drop_path.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f0388ccdba3678ad36d2df4df01011d9e9119c1 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/drop_path.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/layer_scale.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/layer_scale.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c7410422ed2bd986547c34275824993d0188547 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/layer_scale.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/mlp.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/mlp.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57935316a94efe8a798c604da346e00f8215d152 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/mlp.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/patch_embed.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/patch_embed.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9731a2f56f9bc02354c5f27dc7159077fd3c9b6a Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/patch_embed.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/swiglu_ffn.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/swiglu_ffn.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efbdf13721614706c12ec0f9849b810c11546057 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/__pycache__/swiglu_ffn.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/attention.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/attention.py new file mode 100644 index 0000000000000000000000000000000000000000..d1ca17342a03ca2a6219f2db61314d8dd09782c7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/attention.py @@ -0,0 +1,99 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py + +import logging +import os +import warnings + +import torch +from torch import nn, Tensor + + +logger = logging.getLogger("dinov2") + + +XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None +try: + if XFORMERS_ENABLED: + from xformers.ops import memory_efficient_attention, unbind + + XFORMERS_AVAILABLE = True + warnings.warn("xFormers is available (Attention)") + else: + warnings.warn("xFormers is disabled (Attention)") + raise ImportError +except ImportError: + XFORMERS_AVAILABLE = False + warnings.warn("xFormers is not available (Attention)") + + +class Attention(nn.Module): + def __init__( + self, + dim: int, + num_heads: int = 8, + qkv_bias: bool = False, + proj_bias: bool = True, + attn_drop: float = 0.0, + proj_drop: float = 0.0, + ) -> None: + super().__init__() + self.dim = dim + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = attn_drop + self.proj = nn.Linear(dim, dim, bias=proj_bias) + self.proj_drop = nn.Dropout(proj_drop) + + def init_weights( + self, init_attn_std: float | None = None, init_proj_std: float | None = None, factor: float = 1.0 + ) -> None: + init_attn_std = init_attn_std or (self.dim**-0.5) + init_proj_std = init_proj_std or init_attn_std * factor + nn.init.normal_(self.qkv.weight, std=init_attn_std) + nn.init.normal_(self.proj.weight, std=init_proj_std) + if self.qkv.bias is not None: + nn.init.zeros_(self.qkv.bias) + if self.proj.bias is not None: + nn.init.zeros_(self.proj.bias) + + def forward(self, x: Tensor, is_causal: bool = False) -> Tensor: + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads) + q, k, v = torch.unbind(qkv, 2) + q, k, v = [t.transpose(1, 2) for t in [q, k, v]] + x = nn.functional.scaled_dot_product_attention( + q, k, v, attn_mask=None, dropout_p=self.attn_drop if self.training else 0, is_causal=is_causal + ) + x = x.transpose(1, 2).contiguous().view(B, N, C) + x = self.proj_drop(self.proj(x)) + return x + + +class MemEffAttention(Attention): + def forward(self, x: Tensor, attn_bias=None) -> Tensor: + if not XFORMERS_AVAILABLE: + if attn_bias is not None: + raise AssertionError("xFormers is required for using nested tensors") + return super().forward(x) + + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads) + + q, k, v = unbind(qkv, 2) + + x = memory_efficient_attention(q, k, v, attn_bias=attn_bias) + x = x.reshape([B, N, C]) + + x = self.proj(x) + x = self.proj_drop(x) + return x diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/block.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/block.py new file mode 100644 index 0000000000000000000000000000000000000000..4bc3d12c8e8a2b3b750a7a65ed9cac18db6a1ffc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/block.py @@ -0,0 +1,316 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py + +import logging +import os +from typing import Callable, List, Any, Tuple, Dict, Optional +import warnings + +import torch +from torch import nn, Tensor + +from .attention import Attention, MemEffAttention +from .drop_path import DropPath +from .layer_scale import LayerScale +from .mlp import Mlp + + +logger = logging.getLogger("dinov2") + + +XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None +try: + if XFORMERS_ENABLED: + from xformers.ops import fmha, scaled_index_add, index_select_cat + + XFORMERS_AVAILABLE = True + warnings.warn("xFormers is available (Block)") + else: + warnings.warn("xFormers is disabled (Block)") + raise ImportError +except ImportError: + XFORMERS_AVAILABLE = False + + warnings.warn("xFormers is not available (Block)") + + +class Block(nn.Module): + def __init__( + self, + dim: int, + num_heads: int, + mlp_ratio: float = 4.0, + qkv_bias: bool = False, + proj_bias: bool = True, + ffn_bias: bool = True, + drop: float = 0.0, + attn_drop: float = 0.0, + init_values=None, + drop_path: float = 0.0, + act_layer: Callable[..., nn.Module] = nn.GELU, + norm_layer: Callable[..., nn.Module] = nn.LayerNorm, + attn_class: Callable[..., nn.Module] = Attention, + ffn_layer: Callable[..., nn.Module] = Mlp, + ) -> None: + super().__init__() + # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}") + self.norm1 = norm_layer(dim) + self.attn = attn_class( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + proj_bias=proj_bias, + attn_drop=attn_drop, + proj_drop=drop, + ) + self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity() + self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = ffn_layer( + in_features=dim, + hidden_features=mlp_hidden_dim, + act_layer=act_layer, + drop=drop, + bias=ffn_bias, + ) + self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity() + self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + self.sample_drop_ratio = drop_path + + def forward(self, x: Tensor) -> Tensor: + def attn_residual_func(x: Tensor) -> Tensor: + return self.ls1(self.attn(self.norm1(x))) + + def ffn_residual_func(x: Tensor) -> Tensor: + return self.ls2(self.mlp(self.norm2(x))) + + if self.training and self.sample_drop_ratio > 0.1: + # the overhead is compensated only for a drop path rate larger than 0.1 + x = drop_add_residual_stochastic_depth( + x, + residual_func=attn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + ) + x = drop_add_residual_stochastic_depth( + x, + residual_func=ffn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + ) + elif self.training and self.sample_drop_ratio > 0.0: + x = x + self.drop_path1(attn_residual_func(x)) + x = x + self.drop_path1(ffn_residual_func(x)) # FIXME: drop_path2 + else: + x = x + attn_residual_func(x) + x = x + ffn_residual_func(x) + return x + + +class CausalAttentionBlock(nn.Module): + def __init__( + self, + dim: int, + num_heads: int, + ffn_ratio: float = 4.0, + ls_init_value: Optional[float] = None, + is_causal: bool = True, + act_layer: Callable = nn.GELU, + norm_layer: Callable = nn.LayerNorm, + dropout_prob: float = 0.0, + ): + super().__init__() + + self.dim = dim + self.is_causal = is_causal + self.ls1 = LayerScale(dim, init_values=ls_init_value) if ls_init_value else nn.Identity() + self.attention_norm = norm_layer(dim) + self.attention = Attention(dim, num_heads, attn_drop=dropout_prob, proj_drop=dropout_prob) + + self.ffn_norm = norm_layer(dim) + ffn_hidden_dim = int(dim * ffn_ratio) + self.feed_forward = Mlp( + in_features=dim, + hidden_features=ffn_hidden_dim, + drop=dropout_prob, + act_layer=act_layer, + ) + + self.ls2 = LayerScale(dim, init_values=ls_init_value) if ls_init_value else nn.Identity() + + def init_weights( + self, + init_attn_std: float | None = None, + init_proj_std: float | None = None, + init_fc_std: float | None = None, + factor: float = 1.0, + ) -> None: + init_attn_std = init_attn_std or (self.dim**-0.5) + init_proj_std = init_proj_std or init_attn_std * factor + init_fc_std = init_fc_std or (2 * self.dim) ** -0.5 + self.attention.init_weights(init_attn_std, init_proj_std) + self.attention_norm.reset_parameters() + nn.init.normal_(self.feed_forward.fc1.weight, std=init_fc_std) + nn.init.normal_(self.feed_forward.fc2.weight, std=init_proj_std) + self.ffn_norm.reset_parameters() + + def forward( + self, + x: torch.Tensor, + ): + x_attn = x + self.ls1(self.attention(self.attention_norm(x), self.is_causal)) + x_ffn = x_attn + self.ls2(self.feed_forward(self.ffn_norm(x_attn))) + return x_ffn + + +def drop_add_residual_stochastic_depth( + x: Tensor, + residual_func: Callable[[Tensor], Tensor], + sample_drop_ratio: float = 0.0, +) -> Tensor: + # 1) extract subset using permutation + b, n, d = x.shape + sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1) + brange = (torch.randperm(b, device=x.device))[:sample_subset_size] + x_subset = x[brange] + + # 2) apply residual_func to get residual + residual = residual_func(x_subset) + + x_flat = x.flatten(1) + residual = residual.flatten(1) + + residual_scale_factor = b / sample_subset_size + + # 3) add the residual + x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor) + return x_plus_residual.view_as(x) + + +def get_branges_scales(x, sample_drop_ratio=0.0): + b, n, d = x.shape + sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1) + brange = (torch.randperm(b, device=x.device))[:sample_subset_size] + residual_scale_factor = b / sample_subset_size + return brange, residual_scale_factor + + +def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None): + if scaling_vector is None: + x_flat = x.flatten(1) + residual = residual.flatten(1) + x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor) + else: + x_plus_residual = scaled_index_add( + x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor + ) + return x_plus_residual + + +attn_bias_cache: Dict[Tuple, Any] = {} + + +def get_attn_bias_and_cat(x_list, branges=None): + """ + this will perform the index select, cat the tensors, and provide the attn_bias from cache + """ + batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list] + all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list)) + if all_shapes not in attn_bias_cache.keys(): + seqlens = [] + for b, x in zip(batch_sizes, x_list): + for _ in range(b): + seqlens.append(x.shape[1]) + attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens) + attn_bias._batch_sizes = batch_sizes + attn_bias_cache[all_shapes] = attn_bias + + if branges is not None: + cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1]) + else: + tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list) + cat_tensors = torch.cat(tensors_bs1, dim=1) + + return attn_bias_cache[all_shapes], cat_tensors + + +def drop_add_residual_stochastic_depth_list( + x_list: List[Tensor], + residual_func: Callable[[Tensor, Any], Tensor], + sample_drop_ratio: float = 0.0, + scaling_vector=None, +) -> Tensor: + # 1) generate random set of indices for dropping samples in the batch + branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list] + branges = [s[0] for s in branges_scales] + residual_scale_factors = [s[1] for s in branges_scales] + + # 2) get attention bias and index+concat the tensors + attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges) + + # 3) apply residual_func to get residual, and split the result + residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias)) # type: ignore + + outputs = [] + for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors): + outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x)) + return outputs + + +class NestedTensorBlock(Block): + def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]: + """ + x_list contains a list of tensors to nest together and run + """ + assert isinstance(self.attn, MemEffAttention) + + if self.training and self.sample_drop_ratio > 0.0: + + def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.attn(self.norm1(x), attn_bias=attn_bias) + + def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.mlp(self.norm2(x)) + + x_list = drop_add_residual_stochastic_depth_list( + x_list, + residual_func=attn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None, + ) + x_list = drop_add_residual_stochastic_depth_list( + x_list, + residual_func=ffn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None, + ) + return x_list + else: + + def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias)) + + def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.ls2(self.mlp(self.norm2(x))) + + attn_bias, x = get_attn_bias_and_cat(x_list) + x = x + attn_residual_func(x, attn_bias=attn_bias) + x = x + ffn_residual_func(x) + return attn_bias.split(x) + + def forward(self, x_or_x_list): + if isinstance(x_or_x_list, Tensor): + return super().forward(x_or_x_list) + elif isinstance(x_or_x_list, list): + if not XFORMERS_AVAILABLE: + raise AssertionError("xFormers is required for using nested tensors") + return self.forward_nested(x_or_x_list) + else: + raise AssertionError diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/dino_head.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/dino_head.py new file mode 100644 index 0000000000000000000000000000000000000000..ccca59999e1d686e1341281c61e8961f1b0e6545 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/dino_head.py @@ -0,0 +1,58 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +from torch.nn.init import trunc_normal_ +from torch.nn.utils import weight_norm + + +class DINOHead(nn.Module): + def __init__( + self, + in_dim, + out_dim, + use_bn=False, + nlayers=3, + hidden_dim=2048, + bottleneck_dim=256, + mlp_bias=True, + ): + super().__init__() + nlayers = max(nlayers, 1) + self.mlp = _build_mlp(nlayers, in_dim, bottleneck_dim, hidden_dim=hidden_dim, use_bn=use_bn, bias=mlp_bias) + self.apply(self._init_weights) + self.last_layer = weight_norm(nn.Linear(bottleneck_dim, out_dim, bias=False)) + self.last_layer.weight_g.data.fill_(1) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x): + x = self.mlp(x) + eps = 1e-6 if x.dtype == torch.float16 else 1e-12 + x = nn.functional.normalize(x, dim=-1, p=2, eps=eps) + x = self.last_layer(x) + return x + + +def _build_mlp(nlayers, in_dim, bottleneck_dim, hidden_dim=None, use_bn=False, bias=True): + if nlayers == 1: + return nn.Linear(in_dim, bottleneck_dim, bias=bias) + else: + layers = [nn.Linear(in_dim, hidden_dim, bias=bias)] + if use_bn: + layers.append(nn.BatchNorm1d(hidden_dim)) + layers.append(nn.GELU()) + for _ in range(nlayers - 2): + layers.append(nn.Linear(hidden_dim, hidden_dim, bias=bias)) + if use_bn: + layers.append(nn.BatchNorm1d(hidden_dim)) + layers.append(nn.GELU()) + layers.append(nn.Linear(hidden_dim, bottleneck_dim, bias=bias)) + return nn.Sequential(*layers) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/drop_path.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/drop_path.py new file mode 100644 index 0000000000000000000000000000000000000000..4bb1487b0eed4cb14dc0d5d1ee57a2acc78de34a --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/drop_path.py @@ -0,0 +1,34 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py + + +from torch import nn + + +def drop_path(x, drop_prob: float = 0.0, training: bool = False): + if drop_prob == 0.0 or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0: + random_tensor.div_(keep_prob) + output = x * random_tensor + return output + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).""" + + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/layer_scale.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/layer_scale.py new file mode 100644 index 0000000000000000000000000000000000000000..994f31fcaef782f3b819dbde4e8a10e812507508 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/layer_scale.py @@ -0,0 +1,34 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# Modified from: https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/vision_transformer.py#L103-L110 + +from typing import Optional, Union + +import torch +from torch import Tensor +from torch import nn + + +class LayerScale(nn.Module): + def __init__( + self, + dim: int, + init_values: Union[float, Tensor] = 1e-5, + inplace: bool = False, + device: Optional[torch.device] = None, + dtype: Optional[torch.dtype] = None, + ) -> None: + super().__init__() + self.inplace = inplace + self.init_values = init_values + self.gamma = nn.Parameter(torch.empty(dim, device=device, dtype=dtype)) + self.reset_parameters() + + def reset_parameters(self): + nn.init.constant_(self.gamma, self.init_values) + + def forward(self, x: Tensor) -> Tensor: + return x.mul_(self.gamma) if self.inplace else x * self.gamma diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/mlp.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/mlp.py new file mode 100644 index 0000000000000000000000000000000000000000..0965768a9aef04ac6b81322f4dd60cf035159e91 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/mlp.py @@ -0,0 +1,40 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/mlp.py + + +from typing import Callable, Optional + +from torch import Tensor, nn + + +class Mlp(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = nn.GELU, + drop: float = 0.0, + bias: bool = True, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features, bias=bias) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features, bias=bias) + self.drop = nn.Dropout(drop) + + def forward(self, x: Tensor) -> Tensor: + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/patch_embed.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/patch_embed.py new file mode 100644 index 0000000000000000000000000000000000000000..8c3aaf46c523ab1ae27430419187bbad11e302ab --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/patch_embed.py @@ -0,0 +1,88 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py + +from typing import Callable, Optional, Tuple, Union + +from torch import Tensor +import torch.nn as nn + + +def make_2tuple(x): + if isinstance(x, tuple): + assert len(x) == 2 + return x + + assert isinstance(x, int) + return (x, x) + + +class PatchEmbed(nn.Module): + """ + 2D image to patch embedding: (B,C,H,W) -> (B,N,D) + + Args: + img_size: Image size. + patch_size: Patch token size. + in_chans: Number of input image channels. + embed_dim: Number of linear projection output channels. + norm_layer: Normalization layer. + """ + + def __init__( + self, + img_size: Union[int, Tuple[int, int]] = 224, + patch_size: Union[int, Tuple[int, int]] = 16, + in_chans: int = 3, + embed_dim: int = 768, + norm_layer: Optional[Callable] = None, + flatten_embedding: bool = True, + ) -> None: + super().__init__() + + image_HW = make_2tuple(img_size) + patch_HW = make_2tuple(patch_size) + patch_grid_size = ( + image_HW[0] // patch_HW[0], + image_HW[1] // patch_HW[1], + ) + + self.img_size = image_HW + self.patch_size = patch_HW + self.patches_resolution = patch_grid_size + self.num_patches = patch_grid_size[0] * patch_grid_size[1] + + self.in_chans = in_chans + self.embed_dim = embed_dim + + self.flatten_embedding = flatten_embedding + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW) + self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity() + + def forward(self, x: Tensor) -> Tensor: + _, _, H, W = x.shape + patch_H, patch_W = self.patch_size + + assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}" + assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}" + + x = self.proj(x) # B C H W + H, W = x.size(2), x.size(3) + x = x.flatten(2).transpose(1, 2) # B HW C + x = self.norm(x) + if not self.flatten_embedding: + x = x.reshape(-1, H, W, self.embed_dim) # B H W C + return x + + def flops(self) -> float: + Ho, Wo = self.patches_resolution + flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1]) + if self.norm is not None: + flops += Ho * Wo * self.embed_dim + return flops diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/layers/swiglu_ffn.py b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/swiglu_ffn.py new file mode 100644 index 0000000000000000000000000000000000000000..64bbe8a9cb0e93b4c2e2c92ab297e114cdf179c7 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/layers/swiglu_ffn.py @@ -0,0 +1,100 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import os +from typing import Callable, Optional +import warnings + +from torch import Tensor, nn +import torch.nn.functional as F + + +class SwiGLUFFN(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = None, + drop: float = 0.0, + bias: bool = True, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias) + self.w3 = nn.Linear(hidden_features, out_features, bias=bias) + + def forward(self, x: Tensor) -> Tensor: + x12 = self.w12(x) + x1, x2 = x12.chunk(2, dim=-1) + hidden = F.silu(x1) * x2 + return self.w3(hidden) + + +XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None +try: + if XFORMERS_ENABLED: + from xformers.ops import SwiGLU + + XFORMERS_AVAILABLE = True + warnings.warn("xFormers is available (SwiGLU)") + else: + warnings.warn("xFormers is disabled (SwiGLU)") + raise ImportError +except ImportError: + SwiGLU = SwiGLUFFN + XFORMERS_AVAILABLE = False + + warnings.warn("xFormers is not available (SwiGLU)") + + +class SwiGLUFFNFused(SwiGLU): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = None, + drop: float = 0.0, + bias: bool = True, + ) -> None: + out_features = out_features or in_features + hidden_features = hidden_features or in_features + hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8 + super().__init__( + in_features=in_features, + hidden_features=hidden_features, + out_features=out_features, + bias=bias, + ) + + +class SwiGLUFFNAligned(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = nn.GELU, + drop: float = 0.0, + bias: bool = True, + align_to: int = 8, + device=None, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + d = int(hidden_features * 2 / 3) + swiglu_hidden_features = d + (-d % align_to) + self.w1 = nn.Linear(in_features, swiglu_hidden_features, bias=bias, device=device) + self.w2 = nn.Linear(in_features, swiglu_hidden_features, bias=bias, device=device) + self.w3 = nn.Linear(swiglu_hidden_features, out_features, bias=bias, device=device) + + def forward(self, x: Tensor) -> Tensor: + x1 = self.w1(x) + x2 = self.w2(x) + hidden = F.silu(x1) * x2 + return self.w3(hidden) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/logging/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/logging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6a317c3695153e85ea564987e251e91790d7149b --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/logging/__init__.py @@ -0,0 +1,102 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import functools +import logging +import os +import sys +from typing import Optional + +import dinov2.distributed as distributed +from .helpers import MetricLogger, SmoothedValue + + +# So that calling _configure_logger multiple times won't add many handlers +@functools.lru_cache() +def _configure_logger( + name: Optional[str] = None, + *, + level: int = logging.DEBUG, + output: Optional[str] = None, +): + """ + Configure a logger. + + Adapted from Detectron2. + + Args: + name: The name of the logger to configure. + level: The logging level to use. + output: A file name or a directory to save log. If None, will not save log file. + If ends with ".txt" or ".log", assumed to be a file name. + Otherwise, logs will be saved to `output/log.txt`. + + Returns: + The configured logger. + """ + + logger = logging.getLogger(name) + logger.setLevel(level) + logger.propagate = False + + # Loosely match Google glog format: + # [IWEF]yyyymmdd hh:mm:ss.uuuuuu threadid file:line] msg + # but use a shorter timestamp and include the logger name: + # [IWEF]yyyymmdd hh:mm:ss logger threadid file:line] msg + fmt_prefix = "%(levelname).1s%(asctime)s %(process)s %(name)s %(filename)s:%(lineno)s] " + fmt_message = "%(message)s" + fmt = fmt_prefix + fmt_message + datefmt = "%Y%m%d %H:%M:%S" + formatter = logging.Formatter(fmt=fmt, datefmt=datefmt) + + # stdout logging for main worker only + if distributed.is_main_process(): + handler = logging.StreamHandler(stream=sys.stdout) + handler.setLevel(logging.DEBUG) + handler.setFormatter(formatter) + logger.addHandler(handler) + + # file logging for all workers + if output: + if os.path.splitext(output)[-1] in (".txt", ".log"): + filename = output + else: + filename = os.path.join(output, "logs", "log.txt") + + if not distributed.is_main_process(): + global_rank = distributed.get_global_rank() + filename = filename + ".rank{}".format(global_rank) + + os.makedirs(os.path.dirname(filename), exist_ok=True) + + handler = logging.StreamHandler(open(filename, "a")) + handler.setLevel(logging.DEBUG) + handler.setFormatter(formatter) + logger.addHandler(handler) + + return logger + + +def setup_logging( + output: Optional[str] = None, + *, + name: Optional[str] = None, + level: int = logging.DEBUG, + capture_warnings: bool = True, +) -> None: + """ + Setup logging. + + Args: + output: A file name or a directory to save log files. If None, log + files will not be saved. If output ends with ".txt" or ".log", it + is assumed to be a file name. + Otherwise, logs will be saved to `output/log.txt`. + name: The name of the logger to configure, by default the root logger. + level: The logging level to use. + capture_warnings: Whether warnings should be captured as logs. + """ + logging.captureWarnings(capture_warnings) + _configure_logger(name, level=level, output=output) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/logging/helpers.py b/torch_cache/facebookresearch_dinov2_main/dinov2/logging/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..2db38a3c83c457635648b8d21dc7828598a3b65c --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/logging/helpers.py @@ -0,0 +1,194 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import defaultdict, deque +import datetime +import json +import logging +import time + +import torch + +import dinov2.distributed as distributed + + +logger = logging.getLogger("dinov2") + + +class MetricLogger(object): + def __init__(self, delimiter="\t", output_file=None): + self.meters = defaultdict(SmoothedValue) + self.delimiter = delimiter + self.output_file = output_file + + def update(self, **kwargs): + for k, v in kwargs.items(): + if isinstance(v, torch.Tensor): + v = v.item() + assert isinstance(v, (float, int)) + 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 dump_in_output_file(self, iteration, iter_time, data_time): + if self.output_file is None or not distributed.is_main_process(): + return + dict_to_dump = dict( + iteration=iteration, + iter_time=iter_time, + data_time=data_time, + ) + dict_to_dump.update({k: v.median for k, v in self.meters.items()}) + with open(self.output_file, "a") as f: + f.write(json.dumps(dict_to_dump) + "\n") + pass + + def log_every(self, iterable, print_freq, header=None, n_iterations=None, start_iteration=0): + i = start_iteration + if not header: + header = "" + start_time = time.time() + end = time.time() + iter_time = SmoothedValue(fmt="{avg:.6f}") + data_time = SmoothedValue(fmt="{avg:.6f}") + + if n_iterations is None: + n_iterations = len(iterable) + + space_fmt = ":" + str(len(str(n_iterations))) + "d" + + log_list = [ + header, + "[{0" + space_fmt + "}/{1}]", + "eta: {eta}", + "{meters}", + "time: {time}", + "data: {data}", + ] + if torch.cuda.is_available(): + log_list += ["max mem: {memory:.0f}"] + + log_msg = self.delimiter.join(log_list) + MB = 1024.0 * 1024.0 + for obj in iterable: + data_time.update(time.time() - end) + yield obj + iter_time.update(time.time() - end) + if i % print_freq == 0 or i == n_iterations - 1: + self.dump_in_output_file(iteration=i, iter_time=iter_time.avg, data_time=data_time.avg) + eta_seconds = iter_time.global_avg * (n_iterations - i) + eta_string = str(datetime.timedelta(seconds=int(eta_seconds))) + if torch.cuda.is_available(): + logger.info( + log_msg.format( + i, + n_iterations, + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + memory=torch.cuda.max_memory_allocated() / MB, + ) + ) + else: + logger.info( + log_msg.format( + i, + n_iterations, + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + ) + ) + i += 1 + end = time.time() + if i >= n_iterations: + break + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + logger.info("{} Total time: {} ({:.6f} s / it)".format(header, total_time_str, total_time / n_iterations)) + + +class SmoothedValue: + """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): + if fmt is None: + fmt = "{median:.4f} ({global_avg:.4f})" + self.deque = deque(maxlen=window_size) + self.total = 0.0 + self.count = 0 + self.fmt = fmt + + def update(self, value, num=1): + self.deque.append(value) + self.count += num + self.total += value * num + + def synchronize_between_processes(self): + """ + Distributed synchronization of the metric + Warning: does not synchronize the deque! + """ + if not distributed.is_enabled(): + return + t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda") + torch.distributed.barrier() + torch.distributed.all_reduce(t) + t = t.tolist() + self.count = int(t[0]) + self.total = t[1] + + @property + def median(self): + d = torch.tensor(list(self.deque)) + return d.median().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, + ) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/loss/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7804992e49494009b7f85021225bad3c0f57a220 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dino_clstoken_loss import DINOLoss +from .ibot_patch_loss import iBOTPatchLoss +from .koleo_loss import KoLeoLoss diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/loss/dino_clstoken_loss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/dino_clstoken_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..bcb8e63dc4a583f5e5edc6d8ad2914a2a6b0b059 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/dino_clstoken_loss.py @@ -0,0 +1,99 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.distributed as dist +import torch.nn.functional as F +from torch import nn + + +class DINOLoss(nn.Module): + def __init__( + self, + out_dim, + student_temp=0.1, + center_momentum=0.9, + ): + super().__init__() + self.student_temp = student_temp + self.center_momentum = center_momentum + self.register_buffer("center", torch.zeros(1, out_dim)) + self.updated = True + self.reduce_handle = None + self.len_teacher_output = None + self.async_batch_center = None + + @torch.no_grad() + def softmax_center_teacher(self, teacher_output, teacher_temp): + self.apply_center_update() + # teacher centering and sharpening + return F.softmax((teacher_output - self.center) / teacher_temp, dim=-1) + + @torch.no_grad() + def sinkhorn_knopp_teacher(self, teacher_output, teacher_temp, n_iterations=3): + teacher_output = teacher_output.float() + world_size = dist.get_world_size() if dist.is_initialized() else 1 + Q = torch.exp(teacher_output / teacher_temp).t() # Q is K-by-B for consistency with notations from our paper + B = Q.shape[1] * world_size # number of samples to assign + K = Q.shape[0] # how many prototypes + + # make the matrix sums to 1 + sum_Q = torch.sum(Q) + if dist.is_initialized(): + dist.all_reduce(sum_Q) + Q /= sum_Q + + for it in range(n_iterations): + # normalize each row: total weight per prototype must be 1/K + sum_of_rows = torch.sum(Q, dim=1, keepdim=True) + if dist.is_initialized(): + dist.all_reduce(sum_of_rows) + Q /= sum_of_rows + Q /= K + + # normalize each column: total weight per sample must be 1/B + Q /= torch.sum(Q, dim=0, keepdim=True) + Q /= B + + Q *= B # the columns must sum to 1 so that Q is an assignment + return Q.t() + + def forward(self, student_output_list, teacher_out_softmaxed_centered_list): + """ + Cross-entropy between softmax outputs of the teacher and student networks. + """ + # TODO: Use cross_entropy_distribution here + total_loss = 0 + for s in student_output_list: + lsm = F.log_softmax(s / self.student_temp, dim=-1) + for t in teacher_out_softmaxed_centered_list: + loss = torch.sum(t * lsm, dim=-1) + total_loss -= loss.mean() + return total_loss + + @torch.no_grad() + def update_center(self, teacher_output): + self.reduce_center_update(teacher_output) + + @torch.no_grad() + def reduce_center_update(self, teacher_output): + self.updated = False + self.len_teacher_output = len(teacher_output) + self.async_batch_center = torch.sum(teacher_output, dim=0, keepdim=True) + if dist.is_initialized(): + self.reduce_handle = dist.all_reduce(self.async_batch_center, async_op=True) + + @torch.no_grad() + def apply_center_update(self): + if self.updated is False: + world_size = dist.get_world_size() if dist.is_initialized() else 1 + + if self.reduce_handle is not None: + self.reduce_handle.wait() + _t = self.async_batch_center / (self.len_teacher_output * world_size) + + self.center = self.center * self.center_momentum + _t * (1 - self.center_momentum) + + self.updated = True diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/loss/ibot_patch_loss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/ibot_patch_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..a15212b62ca351b777784bef290d2d11a6d9f423 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/ibot_patch_loss.py @@ -0,0 +1,151 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.distributed as dist +import torch.nn.functional as F +from torch import nn + +import logging + + +logger = logging.getLogger("dinov2") + + +try: + from xformers.ops import cross_entropy + + def lossfunc(t, s, temp): + s = s.float() + t = t.float() + if s.ndim == 2: + return -cross_entropy(s.unsqueeze(0), t.unsqueeze(0), temp, bw_inplace=True).squeeze(0) + elif s.ndim == 3: + return -cross_entropy(s, t, temp, bw_inplace=True) + +except ImportError: + + def lossfunc(t, s, temp): + return torch.sum(t * F.log_softmax(s / temp, dim=-1), dim=-1) + + +class iBOTPatchLoss(nn.Module): + def __init__(self, patch_out_dim, student_temp=0.1, center_momentum=0.9): + super().__init__() + self.student_temp = student_temp + self.center_momentum = center_momentum + self.register_buffer("center", torch.zeros(1, 1, patch_out_dim)) + self.updated = True + self.reduce_handle = None + self.len_teacher_patch_tokens = None + self.async_batch_center = None + + @torch.no_grad() + def softmax_center_teacher(self, teacher_patch_tokens, teacher_temp): + self.apply_center_update() + # teacher centering and sharpening + # + # WARNING: + # as self.center is a float32, everything gets casted to float32 afterwards + # + # teacher_patch_tokens = teacher_patch_tokens.float() + # return F.softmax((teacher_patch_tokens.sub_(self.center.to(teacher_patch_tokens.dtype))).mul_(1 / teacher_temp), dim=-1) + + return F.softmax((teacher_patch_tokens - self.center) / teacher_temp, dim=-1) + + # this is experimental, keep everything in float16 and let's see what happens: + # return F.softmax((teacher_patch_tokens.sub_(self.center)) / teacher_temp, dim=-1) + + @torch.no_grad() + def sinkhorn_knopp_teacher(self, teacher_output, teacher_temp, n_masked_patches_tensor, n_iterations=3): + teacher_output = teacher_output.float() + # world_size = dist.get_world_size() if dist.is_initialized() else 1 + Q = torch.exp(teacher_output / teacher_temp).t() # Q is K-by-B for consistency with notations from our paper + # B = Q.shape[1] * world_size # number of samples to assign + B = n_masked_patches_tensor + dist.all_reduce(B) + K = Q.shape[0] # how many prototypes + + # make the matrix sums to 1 + sum_Q = torch.sum(Q) + if dist.is_initialized(): + dist.all_reduce(sum_Q) + Q /= sum_Q + + for it in range(n_iterations): + # normalize each row: total weight per prototype must be 1/K + sum_of_rows = torch.sum(Q, dim=1, keepdim=True) + if dist.is_initialized(): + dist.all_reduce(sum_of_rows) + Q /= sum_of_rows + Q /= K + + # normalize each column: total weight per sample must be 1/B + Q /= torch.sum(Q, dim=0, keepdim=True) + Q /= B + + Q *= B # the columns must sum to 1 so that Q is an assignment + return Q.t() + + def forward(self, student_patch_tokens, teacher_patch_tokens, student_masks_flat): + """ + Cross-entropy between softmax outputs of the teacher and student networks. + student_patch_tokens: (B, N, D) tensor + teacher_patch_tokens: (B, N, D) tensor + student_masks_flat: (B, N) tensor + """ + t = teacher_patch_tokens + s = student_patch_tokens + loss = torch.sum(t * F.log_softmax(s / self.student_temp, dim=-1), dim=-1) + loss = torch.sum(loss * student_masks_flat.float(), dim=-1) / student_masks_flat.sum(dim=-1).clamp(min=1.0) + return -loss.mean() + + def forward_masked( + self, + student_patch_tokens_masked, + teacher_patch_tokens_masked, + student_masks_flat, + n_masked_patches=None, + masks_weight=None, + ): + t = teacher_patch_tokens_masked + s = student_patch_tokens_masked + # loss = torch.sum(t * F.log_softmax(s / self.student_temp, dim=-1), dim=-1) + loss = lossfunc(t, s, self.student_temp) + if masks_weight is None: + masks_weight = ( + (1 / student_masks_flat.sum(-1).clamp(min=1.0)) + .unsqueeze(-1) + .expand_as(student_masks_flat)[student_masks_flat] + ) + if n_masked_patches is not None: + loss = loss[:n_masked_patches] + loss = loss * masks_weight + return -loss.sum() / student_masks_flat.shape[0] + + @torch.no_grad() + def update_center(self, teacher_patch_tokens): + self.reduce_center_update(teacher_patch_tokens) + + @torch.no_grad() + def reduce_center_update(self, teacher_patch_tokens): + self.updated = False + self.len_teacher_patch_tokens = len(teacher_patch_tokens) + self.async_batch_center = torch.sum(teacher_patch_tokens.mean(1), dim=0, keepdim=True) + if dist.is_initialized(): + self.reduce_handle = dist.all_reduce(self.async_batch_center, async_op=True) + + @torch.no_grad() + def apply_center_update(self): + if self.updated is False: + world_size = dist.get_world_size() if dist.is_initialized() else 1 + + if self.reduce_handle is not None: + self.reduce_handle.wait() + _t = self.async_batch_center / (self.len_teacher_patch_tokens * world_size) + + self.center = self.center * self.center_momentum + _t * (1 - self.center_momentum) + + self.updated = True diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/loss/koleo_loss.py b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/koleo_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..eee89e002f885c1a1c15a60688e23e27c9c76053 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/loss/koleo_loss.py @@ -0,0 +1,48 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F + +# import torch.distributed as dist + + +logger = logging.getLogger("dinov2") + + +class KoLeoLoss(nn.Module): + """Kozachenko-Leonenko entropic loss regularizer from Sablayrolles et al. - 2018 - Spreading vectors for similarity search""" + + def __init__(self): + super().__init__() + self.pdist = nn.PairwiseDistance(2, eps=1e-8) + + def pairwise_NNs_inner(self, x): + """ + Pairwise nearest neighbors for L2-normalized vectors. + Uses Torch rather than Faiss to remain on GPU. + """ + # parwise dot products (= inverse distance) + dots = torch.mm(x, x.t()) + n = x.shape[0] + dots.view(-1)[:: (n + 1)].fill_(-1) # Trick to fill diagonal with -1 + # max inner prod -> min distance + _, I = torch.max(dots, dim=1) # noqa: E741 + return I + + def forward(self, student_output, eps=1e-8): + """ + Args: + student_output (BxD): backbone output of student + """ + with torch.cuda.amp.autocast(enabled=False): + student_output = F.normalize(student_output, eps=eps, p=2, dim=-1) + I = self.pairwise_NNs_inner(student_output) # noqa: E741 + distances = self.pdist(student_output, student_output[I]) # BxD, BxD -> B + loss = -torch.log(distances + eps).mean() + return loss diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/models/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..52bd39f74b0cb45695bcf68847b2f32d3d5bfb79 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/models/__init__.py @@ -0,0 +1,45 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging + +from . import vision_transformer as vits + + +logger = logging.getLogger("dinov2") + + +def build_model(args, only_teacher=False, img_size=224): + args.arch = args.arch.removesuffix("_memeff") + if "vit" in args.arch: + vit_kwargs = dict( + img_size=img_size, + patch_size=args.patch_size, + init_values=args.layerscale, + ffn_layer=args.ffn_layer, + block_chunks=args.block_chunks, + qkv_bias=args.qkv_bias, + proj_bias=args.proj_bias, + ffn_bias=args.ffn_bias, + num_register_tokens=args.num_register_tokens, + interpolate_offset=args.interpolate_offset, + interpolate_antialias=args.interpolate_antialias, + in_chans=args.in_chans, + channel_adaptive=args.channel_adaptive, + ) + teacher = vits.__dict__[args.arch](**vit_kwargs) + if only_teacher: + return teacher, teacher.embed_dim + student = vits.__dict__[args.arch]( + **vit_kwargs, + drop_path_rate=args.drop_path_rate, + drop_path_uniform=args.drop_path_uniform, + ) + embed_dim = student.embed_dim + return student, teacher, embed_dim + + +def build_model_from_cfg(cfg, only_teacher=False): + return build_model(cfg.student, only_teacher=only_teacher, img_size=cfg.crops.global_crops_size) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/models/__pycache__/__init__.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/models/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8dea221dbdb3c1d43f27f35b2df63faff914eef4 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/models/__pycache__/__init__.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/models/__pycache__/vision_transformer.cpython-310.pyc b/torch_cache/facebookresearch_dinov2_main/dinov2/models/__pycache__/vision_transformer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4002897b6ec7dd8616d3928bbd1fb9d222c7e00 Binary files /dev/null and b/torch_cache/facebookresearch_dinov2_main/dinov2/models/__pycache__/vision_transformer.cpython-310.pyc differ diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/models/vision_transformer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/models/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..bff8ab54f148e91dd189a5ce7ca21b75fca8c851 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/models/vision_transformer.py @@ -0,0 +1,428 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/main/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py + +from functools import partial +import math +import logging +from typing import Sequence, Tuple, Union, Callable + +import numpy as np +import torch +import torch.nn as nn +import torch.utils.checkpoint +from torch.nn.init import trunc_normal_ + +from dinov2.layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block + + +logger = logging.getLogger("dinov2") + + +def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module: + if not depth_first and include_root: + fn(module=module, name=name) + for child_name, child_module in module.named_children(): + child_name = ".".join((name, child_name)) if name else child_name + named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True) + if depth_first and include_root: + fn(module=module, name=name) + return module + + +class BlockChunk(nn.ModuleList): + def forward(self, x): + for b in self: + x = b(x) + return x + + +class DinoVisionTransformer(nn.Module): + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=True, + ffn_bias=True, + proj_bias=True, + drop_path_rate=0.0, + drop_path_uniform=False, + init_values=None, # for layerscale: None or 0 => no layerscale + embed_layer=PatchEmbed, + act_layer=nn.GELU, + block_fn=Block, + ffn_layer="mlp", + block_chunks=1, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + channel_adaptive=False, + ): + """ + Args: + img_size (int, tuple): input image size + patch_size (int, tuple): patch size + in_chans (int): number of input channels + embed_dim (int): embedding dimension + depth (int): depth of transformer + num_heads (int): number of attention heads + mlp_ratio (int): ratio of mlp hidden dim to embedding dim + qkv_bias (bool): enable bias for qkv if True + proj_bias (bool): enable bias for proj in attn if True + ffn_bias (bool): enable bias for ffn if True + drop_path_rate (float): stochastic depth rate + drop_path_uniform (bool): apply uniform drop rate across blocks + weight_init (str): weight init scheme + init_values (float): layer-scale init values + embed_layer (nn.Module): patch embedding layer + act_layer (nn.Module): MLP activation layer + block_fn (nn.Module): transformer block class + ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity" + block_chunks: (int) split block sequence into block_chunks units for FSDP wrap + num_register_tokens: (int) number of extra cls tokens (so-called "registers") + interpolate_antialias: (str) flag to apply anti-aliasing when interpolating positional embeddings + interpolate_offset: (float) work-around offset to apply when interpolating positional embeddings + """ + super().__init__() + norm_layer = partial(nn.LayerNorm, eps=1e-6) + + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.num_tokens = 1 + self.n_blocks = depth + self.num_heads = num_heads + self.patch_size = patch_size + self.num_register_tokens = num_register_tokens + self.interpolate_antialias = interpolate_antialias + self.interpolate_offset = interpolate_offset + self.bag_of_channels = channel_adaptive + + self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim)) + assert num_register_tokens >= 0 + self.register_tokens = ( + nn.Parameter(torch.zeros(1, num_register_tokens, embed_dim)) if num_register_tokens else None + ) + + if drop_path_uniform is True: + dpr = [drop_path_rate] * depth + else: + dpr = np.linspace(0, drop_path_rate, depth).tolist() # stochastic depth decay rule + + if ffn_layer == "mlp": + logger.info("using MLP layer as FFN") + ffn_layer = Mlp + elif ffn_layer == "swiglufused" or ffn_layer == "swiglu": + logger.info("using SwiGLU layer as FFN") + ffn_layer = SwiGLUFFNFused + elif ffn_layer == "identity": + logger.info("using Identity layer as FFN") + + def f(*args, **kwargs): + return nn.Identity() + + ffn_layer = f + else: + raise NotImplementedError + + blocks_list = [ + block_fn( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + proj_bias=proj_bias, + ffn_bias=ffn_bias, + drop_path=dpr[i], + norm_layer=norm_layer, + act_layer=act_layer, + ffn_layer=ffn_layer, + init_values=init_values, + ) + for i in range(depth) + ] + if block_chunks > 0: + self.chunked_blocks = True + chunked_blocks = [] + chunksize = depth // block_chunks + for i in range(0, depth, chunksize): + # this is to keep the block index consistent if we chunk the block list + chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize]) + self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks]) + else: + self.chunked_blocks = False + self.blocks = nn.ModuleList(blocks_list) + + self.norm = norm_layer(embed_dim) + self.head = nn.Identity() + + self.mask_token = nn.Parameter(torch.zeros(1, embed_dim)) + + self.init_weights() + + def init_weights(self): + trunc_normal_(self.pos_embed, std=0.02) + nn.init.normal_(self.cls_token, std=1e-6) + if self.register_tokens is not None: + nn.init.normal_(self.register_tokens, std=1e-6) + named_apply(init_weights_vit_timm, self) + + def interpolate_pos_encoding(self, x, w, h): + previous_dtype = x.dtype + npatch = x.shape[1] - 1 + N = self.pos_embed.shape[1] - 1 + if npatch == N and w == h: + return self.pos_embed + pos_embed = self.pos_embed.float() + class_pos_embed = pos_embed[:, 0] + patch_pos_embed = pos_embed[:, 1:] + dim = x.shape[-1] + w0 = w // self.patch_size + h0 = h // self.patch_size + M = int(math.sqrt(N)) # Recover the number of patches in each dimension + assert N == M * M + kwargs = {} + if self.interpolate_offset: + # Historical kludge: add a small number to avoid floating point error in the interpolation, see https://github.com/facebookresearch/dino/issues/8 + # Note: still needed for backward-compatibility, the underlying operators are using both output size and scale factors + sx = float(w0 + self.interpolate_offset) / M + sy = float(h0 + self.interpolate_offset) / M + kwargs["scale_factor"] = (sx, sy) + else: + # Simply specify an output size instead of a scale factor + kwargs["size"] = (w0, h0) + patch_pos_embed = nn.functional.interpolate( + patch_pos_embed.reshape(1, M, M, dim).permute(0, 3, 1, 2), + mode="bicubic", + antialias=self.interpolate_antialias, + **kwargs, + ) + assert (w0, h0) == patch_pos_embed.shape[-2:] + patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim) + return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype) + + def prepare_tokens_with_masks(self, x, masks=None): + B, nc, w, h = x.shape + x = self.patch_embed(x) + if masks is not None: + x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x) + + x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1) + x = x + self.interpolate_pos_encoding(x, w, h) + + if self.register_tokens is not None: + x = torch.cat( + ( + x[:, :1], + self.register_tokens.expand(x.shape[0], -1, -1), + x[:, 1:], + ), + dim=1, + ) + + return x + + def forward_features_list(self, x_list, masks_list): + x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)] + for blk in self.blocks: + x = blk(x) + + all_x = x + output = [] + for x, masks in zip(all_x, masks_list): + x_norm = self.norm(x) + output.append( + { + "x_norm_clstoken": x_norm[:, 0], + "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1], + "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :], + "x_prenorm": x, + "masks": masks, + } + ) + return output + + def forward_features(self, x, masks=None): + if isinstance(x, list): + return self.forward_features_list(x, masks) + + x = self.prepare_tokens_with_masks(x, masks) + + for blk in self.blocks: + x = blk(x) + + x_norm = self.norm(x) + return { + "x_norm_clstoken": x_norm[:, 0], + "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1], + "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :], + "x_prenorm": x, + "masks": masks, + } + + def _get_intermediate_layers_not_chunked(self, x, n=1): + x = self.prepare_tokens_with_masks(x) + # If n is an int, take the n last blocks. If it's a list, take them + output, total_block_len = [], len(self.blocks) + blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n + for i, blk in enumerate(self.blocks): + x = blk(x) + if i in blocks_to_take: + output.append(x) + assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found" + return output + + def _get_intermediate_layers_chunked(self, x, n=1): + x = self.prepare_tokens_with_masks(x) + output, i, total_block_len = [], 0, len(self.blocks[-1]) + # If n is an int, take the n last blocks. If it's a list, take them + blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n + for block_chunk in self.blocks: + for blk in block_chunk[i:]: # Passing the nn.Identity() + x = blk(x) + if i in blocks_to_take: + output.append(x) + i += 1 + assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found" + return output + + def get_intermediate_layers( + self, + x: torch.Tensor, + n: Union[int, Sequence] = 1, # Layers or n last layers to take + reshape: bool = False, + return_class_token: bool = False, + norm=True, + ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]: + + if self.bag_of_channels: + B, C, H, W = x.shape + x = x.reshape(B * C, 1, H, W) # passing channels to batch dimension to get encodings for each channel + + if self.chunked_blocks: + outputs = self._get_intermediate_layers_chunked(x, n) + else: + outputs = self._get_intermediate_layers_not_chunked(x, n) + if norm: + outputs = [self.norm(out) for out in outputs] + class_tokens = [out[:, 0] for out in outputs] + outputs = [out[:, 1 + self.num_register_tokens :] for out in outputs] + if reshape: + B, _, w, h = x.shape + outputs = [ + out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous() + for out in outputs + ] + + if self.bag_of_channels: + output = tuple(zip(outputs, class_tokens)) + output = list( + zip(*output) + ) # unzip the tuple: (list of patch_tokens per block, list of class tokens per block) + patch_tokens_per_block = output[0] # [BLOCK1, BLOCK2, ...] where BLOCK1.shape: B*C, N, D + cls_tokens_per_block = output[1] # [BLOCK1, BLOCK2, ...] where BLOCK1.shape: B*C, D + patch_tokens_per_block = [ + patch_tokens.reshape(B, C, patch_tokens.shape[-2], patch_tokens.shape[-1]) + for patch_tokens in patch_tokens_per_block + ] # [BLOCK1, BLOCK2, ...] where BLOCK1.shape: B, C, N, D + cls_tokens_per_block = [cls_tokens.reshape(B, -1) for cls_tokens in cls_tokens_per_block] + output = tuple(zip(patch_tokens_per_block, cls_tokens_per_block)) + return output + + if return_class_token: + return tuple(zip(outputs, class_tokens)) + return tuple(outputs) + + def forward(self, *args, is_training=False, **kwargs): + ret = self.forward_features(*args, **kwargs) + if is_training: + return ret + else: + return self.head(ret["x_norm_clstoken"]) + + +def init_weights_vit_timm(module: nn.Module, name: str = ""): + """ViT weight initialization, original timm impl (for reproducibility)""" + if isinstance(module, nn.Linear): + trunc_normal_(module.weight, std=0.02) + if module.bias is not None: + nn.init.zeros_(module.bias) + + +def vit_small(patch_size=16, num_register_tokens=0, in_chans=3, channel_adaptive=False, **kwargs): + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=384, + depth=12, + num_heads=6, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + in_chans=in_chans, + channel_adaptive=channel_adaptive, + **kwargs, + ) + return model + + +def vit_base(patch_size=16, num_register_tokens=0, in_chans=3, channel_adaptive=False, **kwargs): + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + in_chans=in_chans, + channel_adaptive=channel_adaptive, + **kwargs, + ) + return model + + +def vit_large(patch_size=16, num_register_tokens=0, in_chans=3, channel_adaptive=False, **kwargs): + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=1024, + depth=24, + num_heads=16, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + in_chans=in_chans, + channel_adaptive=channel_adaptive, + **kwargs, + ) + return model + + +def vit_giant2(patch_size=16, num_register_tokens=0, in_chans=3, channel_adaptive=False, **kwargs): + """ + Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64 + """ + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=1536, + depth=40, + num_heads=24, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + in_chans=in_chans, + channel_adaptive=channel_adaptive, + **kwargs, + ) + return model diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/cell_dino/knn.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/cell_dino/knn.py new file mode 100644 index 0000000000000000000000000000000000000000..51054429d8a8f5748bec844893a33462841b2806 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/cell_dino/knn.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.cell_dino.knn import get_args_parser as get_knn_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.cell_dino.knn import main as knn_main + + self._setup_args() + knn_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for k-NN Cell-DINO and Channel-Adaptive DINO evaluation" + knn_args_parser = get_knn_args_parser(add_help=False) + parents = [knn_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:knn Cell-DINO") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/cell_dino/linear.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/cell_dino/linear.py new file mode 100644 index 0000000000000000000000000000000000000000..0bfc97c5aff235f0364d023f776a3f4d82f5dc70 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/cell_dino/linear.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.cell_dino.linear import get_args_parser as get_linear_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.cell_dino.linear import main as linear_main + + self._setup_args() + linear_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 linear Cell-DINO and Channel-Adaptive DINO evaluation" + linear_args_parser = get_linear_args_parser(add_help=False) + parents = [linear_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:linear Cell-DINO") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/knn.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/knn.py new file mode 100644 index 0000000000000000000000000000000000000000..04a1d802045229374df5e765596e87a6af8433cf --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/knn.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.knn import get_args_parser as get_knn_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.knn import main as knn_main + + self._setup_args() + knn_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 k-NN evaluation" + knn_args_parser = get_knn_args_parser(add_help=False) + parents = [knn_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:knn") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/linear.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/linear.py new file mode 100644 index 0000000000000000000000000000000000000000..7e33e22711561b4be7a5ae7c7c710cf7f6426676 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/linear.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.linear import get_args_parser as get_linear_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.linear import main as linear_main + + self._setup_args() + linear_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 linear evaluation" + linear_args_parser = get_linear_args_parser(add_help=False) + parents = [linear_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:linear") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/log_regression.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/log_regression.py new file mode 100644 index 0000000000000000000000000000000000000000..00d659c6de5c3e836c59fc7666084953ab5838f1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/eval/log_regression.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.log_regression import get_args_parser as get_log_regression_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.log_regression import main as log_regression_main + + self._setup_args() + log_regression_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 logistic evaluation" + log_regression_args_parser = get_log_regression_args_parser(add_help=False) + parents = [log_regression_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:logreg") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/submit.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/submit.py new file mode 100644 index 0000000000000000000000000000000000000000..7b1fed71ecb30cd5a5bc0bdcba4a0b2a15f31cc9 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/submit.py @@ -0,0 +1,122 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os +from pathlib import Path +from typing import List, Optional + +import submitit + +from dinov2.utils.cluster import ( + get_slurm_executor_parameters, + get_slurm_partition, + get_user_checkpoint_path, +) + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +) -> argparse.ArgumentParser: + parents = parents or [] + slurm_partition = get_slurm_partition() + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--ngpus", + "--gpus", + "--gpus-per-node", + default=8, + type=int, + help="Number of GPUs to request on each node", + ) + parser.add_argument( + "--nodes", + "--nnodes", + default=1, + type=int, + help="Number of nodes to request", + ) + parser.add_argument( + "--timeout", + default=2800, + type=int, + help="Duration of the job", + ) + parser.add_argument( + "--partition", + default=slurm_partition, + type=str, + help="Partition where to submit", + ) + parser.add_argument( + "--use-volta32", + action="store_true", + help="Request V100-32GB GPUs", + ) + parser.add_argument( + "--comment", + default="", + type=str, + help="Comment to pass to scheduler, e.g. priority message", + ) + parser.add_argument( + "--exclude", + default="", + type=str, + help="Nodes to exclude", + ) + return parser + + +def get_shared_folder() -> Path: + user_checkpoint_path = get_user_checkpoint_path() + if user_checkpoint_path is None: + raise RuntimeError("Path to user checkpoint cannot be determined") + path = user_checkpoint_path / "experiments" + path.mkdir(exist_ok=True) + return path + + +def submit_jobs(task_class, args, name: str): + if not args.output_dir: + args.output_dir = str(get_shared_folder() / "%j") + + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + executor = submitit.AutoExecutor(folder=args.output_dir, slurm_max_num_timeout=30) + + kwargs = {} + if args.use_volta32: + kwargs["slurm_constraint"] = "volta32gb" + if args.comment: + kwargs["slurm_comment"] = args.comment + if args.exclude: + kwargs["slurm_exclude"] = args.exclude + + executor_params = get_slurm_executor_parameters( + nodes=args.nodes, + num_gpus_per_node=args.ngpus, + timeout_min=args.timeout, # max is 60 * 72 + slurm_signal_delay_s=120, + slurm_partition=args.partition, + **kwargs, + ) + executor.update_parameters(name=name, **executor_params) + + task = task_class(args) + job = executor.submit(task) + + logger.info(f"Submitted job_id: {job.job_id}") + str_output_dir = os.path.abspath(args.output_dir).replace("%j", str(job.job_id)) + logger.info(f"Logs and checkpoints will be saved at: {str_output_dir}") diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/run/train/train.py b/torch_cache/facebookresearch_dinov2_main/dinov2/run/train/train.py new file mode 100644 index 0000000000000000000000000000000000000000..b8dac7b827538042d65239896cb1dd22a866858e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/run/train/train.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.logging import setup_logging +from dinov2.train import get_args_parser as get_train_args_parser +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Trainer(object): + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.train import main as train_main + + self._setup_args() + train_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 training" + train_args_parser = get_train_args_parser(add_help=False) + parents = [train_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Trainer, args, name="dinov2:train") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/thirdparty/CLIP/LICENSE b/torch_cache/facebookresearch_dinov2_main/dinov2/thirdparty/CLIP/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..bcd5b9213222e06ce10c74401e22709f17e6dff1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/thirdparty/CLIP/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 OpenAI + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/thirdparty/CLIP/clip/simple_tokenizer.py b/torch_cache/facebookresearch_dinov2_main/dinov2/thirdparty/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..c57529b72d994d5035a69c2140705dd0f40d0ff1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/thirdparty/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,140 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8 + n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r"\s+", " ", text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split("\n") + merges = merges[1 : 49152 - 256 - 2 + 1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v + "" for v in vocab] + for merge in merges: + vocab.append("".join(merge)) + vocab.extend(["<|startoftext|>", "<|endoftext|>"]) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {"<|startoftext|>": "<|startoftext|>", "<|endoftext|>": "<|endoftext|>"} + self.pat = re.compile( + r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", + re.IGNORECASE, + ) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + (token[-1] + "",) + pairs = get_pairs(word) + + if not pairs: + return token + "" + + while True: + bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf"))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except Exception: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word) - 1 and word[i + 1] == second: + new_word.append(first + second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = " ".join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = "".join(self.byte_encoder[b] for b in token.encode("utf-8")) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(" ")) + return bpe_tokens + + def decode(self, tokens): + text = "".join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode("utf-8", errors="replace").replace("", " ") + return text diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/train/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/train/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6fcf1b28b4d82f743647affbebca3b0a12458a28 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/train/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .train import get_args_parser, main +from .ssl_meta_arch import SSLMetaArch diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/train/ssl_meta_arch.py b/torch_cache/facebookresearch_dinov2_main/dinov2/train/ssl_meta_arch.py new file mode 100644 index 0000000000000000000000000000000000000000..172143be2c8289ae7c6d9117d4a538ac0dc843ad --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/train/ssl_meta_arch.py @@ -0,0 +1,400 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial +import logging + +import torch +from torch import nn + +from dinov2.loss import DINOLoss, iBOTPatchLoss, KoLeoLoss +from dinov2.models import build_model_from_cfg +from dinov2.layers import DINOHead +from dinov2.utils.utils import has_batchnorms +from dinov2.utils.param_groups import get_params_groups_with_decay, fuse_params_groups +from dinov2.fsdp import get_fsdp_wrapper, ShardedGradScaler, get_fsdp_modules, reshard_fsdp_model + +from dinov2.models.vision_transformer import BlockChunk + + +try: + from xformers.ops import fmha +except ImportError: + raise AssertionError("xFormers is required for training") + + +logger = logging.getLogger("dinov2") + + +class SSLMetaArch(nn.Module): + def __init__(self, cfg): + super().__init__() + self.cfg = cfg + self.fp16_scaler = ShardedGradScaler() if cfg.compute_precision.grad_scaler else None + + student_model_dict = dict() + teacher_model_dict = dict() + + student_backbone, teacher_backbone, embed_dim = build_model_from_cfg(cfg) + student_model_dict["backbone"] = student_backbone + teacher_model_dict["backbone"] = teacher_backbone + logger.info(f"OPTIONS -- architecture : embed_dim: {embed_dim}") + + if cfg.student.pretrained_weights: + chkpt = torch.load(cfg.student.pretrained_weights) + logger.info(f"OPTIONS -- pretrained weights: loading from {cfg.student.pretrained_weights}") + student_backbone.load_state_dict(chkpt["model"], strict=False) + + self.embed_dim = embed_dim + self.dino_out_dim = cfg.dino.head_n_prototypes + + self.do_dino = cfg.dino.loss_weight > 0 + self.do_koleo = cfg.dino.koleo_loss_weight > 0 + self.do_ibot = cfg.ibot.loss_weight > 0 + self.ibot_separate_head = cfg.ibot.separate_head + + logger.info("OPTIONS -- DINO") + if self.do_dino: + logger.info(f"OPTIONS -- DINO -- loss_weight: {cfg.dino.loss_weight}") + logger.info(f"OPTIONS -- DINO -- head_n_prototypes: {cfg.dino.head_n_prototypes}") + logger.info(f"OPTIONS -- DINO -- head_bottleneck_dim: {cfg.dino.head_bottleneck_dim}") + logger.info(f"OPTIONS -- DINO -- head_hidden_dim: {cfg.dino.head_hidden_dim}") + self.dino_loss_weight = cfg.dino.loss_weight + dino_head = partial( + DINOHead, + in_dim=embed_dim, + out_dim=cfg.dino.head_n_prototypes, + hidden_dim=cfg.dino.head_hidden_dim, + bottleneck_dim=cfg.dino.head_bottleneck_dim, + nlayers=cfg.dino.head_nlayers, + ) + self.dino_loss = DINOLoss(self.dino_out_dim) + if self.do_koleo: + logger.info("OPTIONS -- DINO -- applying KOLEO regularization") + self.koleo_loss = KoLeoLoss() + + else: + logger.info("OPTIONS -- DINO -- not using DINO") + + if self.do_dino or self.do_ibot: + student_model_dict["dino_head"] = dino_head() + teacher_model_dict["dino_head"] = dino_head() + + logger.info("OPTIONS -- IBOT") + logger.info(f"OPTIONS -- IBOT -- loss_weight: {cfg.ibot.loss_weight}") + logger.info(f"OPTIONS -- IBOT masking -- ibot_mask_ratio_tuple: {cfg.ibot.mask_ratio_min_max}") + logger.info(f"OPTIONS -- IBOT masking -- ibot_mask_sample_probability: {cfg.ibot.mask_sample_probability}") + if self.do_ibot: + self.ibot_loss_weight = cfg.ibot.loss_weight + assert max(cfg.ibot.mask_ratio_min_max) > 0, "please provide a positive mask ratio tuple for ibot" + assert cfg.ibot.mask_sample_probability > 0, "please provide a positive mask probability for ibot" + self.ibot_out_dim = cfg.ibot.head_n_prototypes if self.ibot_separate_head else cfg.dino.head_n_prototypes + self.ibot_patch_loss = iBOTPatchLoss(self.ibot_out_dim) + if self.ibot_separate_head: + logger.info(f"OPTIONS -- IBOT -- loss_weight: {cfg.ibot.loss_weight}") + logger.info(f"OPTIONS -- IBOT -- head_n_prototypes: {cfg.ibot.head_n_prototypes}") + logger.info(f"OPTIONS -- IBOT -- head_bottleneck_dim: {cfg.ibot.head_bottleneck_dim}") + logger.info(f"OPTIONS -- IBOT -- head_hidden_dim: {cfg.ibot.head_hidden_dim}") + ibot_head = partial( + DINOHead, + in_dim=embed_dim, + out_dim=cfg.ibot.head_n_prototypes, + hidden_dim=cfg.ibot.head_hidden_dim, + bottleneck_dim=cfg.ibot.head_bottleneck_dim, + nlayers=cfg.ibot.head_nlayers, + ) + student_model_dict["ibot_head"] = ibot_head() + teacher_model_dict["ibot_head"] = ibot_head() + else: + logger.info("OPTIONS -- IBOT -- head shared with DINO") + + self.need_to_synchronize_fsdp_streams = True + + self.student = nn.ModuleDict(student_model_dict) + self.teacher = nn.ModuleDict(teacher_model_dict) + + # there is no backpropagation through the teacher, so no need for gradients + for p in self.teacher.parameters(): + p.requires_grad = False + logger.info(f"Student and Teacher are built: they are both {cfg.student.arch} network.") + + def forward(self, inputs): + raise NotImplementedError + + def backprop_loss(self, loss): + if self.fp16_scaler is not None: + self.fp16_scaler.scale(loss).backward() + else: + loss.backward() + + def forward_backward(self, images, teacher_temp): + n_global_crops = 2 + assert n_global_crops == 2 + n_local_crops = self.cfg.crops.local_crops_number + + global_crops = images["collated_global_crops"].cuda(non_blocking=True) + local_crops = images["collated_local_crops"].cuda(non_blocking=True) + + masks = images["collated_masks"].cuda(non_blocking=True) + mask_indices_list = images["mask_indices_list"].cuda(non_blocking=True) + n_masked_patches_tensor = images["n_masked_patches"].cuda(non_blocking=True) + n_masked_patches = mask_indices_list.shape[0] + upperbound = images["upperbound"] + masks_weight = images["masks_weight"].cuda(non_blocking=True) + + n_local_crops_loss_terms = max(n_local_crops * n_global_crops, 1) + n_global_crops_loss_terms = (n_global_crops - 1) * n_global_crops + + do_dino = self.do_dino + do_ibot = self.do_ibot + + # loss scales + ibot_loss_scale = 1.0 / n_global_crops + + # teacher output + @torch.no_grad() + def get_teacher_output(): + x, n_global_crops_teacher = global_crops, n_global_crops + teacher_backbone_output_dict = self.teacher.backbone(x, is_training=True) + teacher_cls_tokens = teacher_backbone_output_dict["x_norm_clstoken"] + teacher_cls_tokens = teacher_cls_tokens.chunk(n_global_crops_teacher) + # watch out: these are chunked and cat'd in reverse so A is matched to B in the global crops dino loss + teacher_cls_tokens = torch.cat((teacher_cls_tokens[1], teacher_cls_tokens[0])) + ibot_teacher_patch_tokens = teacher_backbone_output_dict["x_norm_patchtokens"] + _dim = ibot_teacher_patch_tokens.shape[-1] + n_cls_tokens = teacher_cls_tokens.shape[0] + + if do_ibot and not self.ibot_separate_head: + buffer_tensor_teacher = ibot_teacher_patch_tokens.new_zeros(upperbound + n_cls_tokens, _dim) + buffer_tensor_teacher[:n_cls_tokens].copy_(teacher_cls_tokens) + torch.index_select( + ibot_teacher_patch_tokens.flatten(0, 1), + dim=0, + index=mask_indices_list, + out=buffer_tensor_teacher[n_cls_tokens : n_cls_tokens + n_masked_patches], + ) + tokens_after_head = self.teacher.dino_head(buffer_tensor_teacher) + teacher_cls_tokens_after_head = tokens_after_head[:n_cls_tokens] + masked_teacher_patch_tokens_after_head = tokens_after_head[ + n_cls_tokens : n_cls_tokens + n_masked_patches + ] + elif do_ibot and self.ibot_separate_head: + buffer_tensor_teacher = ibot_teacher_patch_tokens.new_zeros(upperbound, _dim) + torch.index_select( + ibot_teacher_patch_tokens.flatten(0, 1), + dim=0, + index=mask_indices_list, + out=buffer_tensor_teacher[:n_masked_patches], + ) + teacher_cls_tokens_after_head = self.teacher.dino_head(teacher_cls_tokens) + masked_teacher_patch_tokens_after_head = self.teacher.ibot_head(buffer_tensor_teacher)[ + :n_masked_patches + ] + else: + teacher_cls_tokens_after_head = self.teacher.dino_head(teacher_cls_tokens) + masked_teacher_ibot_softmaxed_centered = None + + if self.cfg.train.centering == "centering": + teacher_dino_softmaxed_centered_list = self.dino_loss.softmax_center_teacher( + teacher_cls_tokens_after_head, teacher_temp=teacher_temp + ).view(n_global_crops_teacher, -1, *teacher_cls_tokens_after_head.shape[1:]) + self.dino_loss.update_center(teacher_cls_tokens_after_head) + if do_ibot: + masked_teacher_patch_tokens_after_head = masked_teacher_patch_tokens_after_head.unsqueeze(0) + masked_teacher_ibot_softmaxed_centered = self.ibot_patch_loss.softmax_center_teacher( + masked_teacher_patch_tokens_after_head[:, :n_masked_patches], teacher_temp=teacher_temp + ) + masked_teacher_ibot_softmaxed_centered = masked_teacher_ibot_softmaxed_centered.squeeze(0) + self.ibot_patch_loss.update_center(masked_teacher_patch_tokens_after_head[:n_masked_patches]) + + elif self.cfg.train.centering == "sinkhorn_knopp": + teacher_dino_softmaxed_centered_list = self.dino_loss.sinkhorn_knopp_teacher( + teacher_cls_tokens_after_head, teacher_temp=teacher_temp + ).view(n_global_crops_teacher, -1, *teacher_cls_tokens_after_head.shape[1:]) + + if do_ibot: + masked_teacher_ibot_softmaxed_centered = self.ibot_patch_loss.sinkhorn_knopp_teacher( + masked_teacher_patch_tokens_after_head, + teacher_temp=teacher_temp, + n_masked_patches_tensor=n_masked_patches_tensor, + ) + + else: + raise NotImplementedError + + return teacher_dino_softmaxed_centered_list, masked_teacher_ibot_softmaxed_centered + + teacher_dino_softmaxed_centered_list, masked_teacher_ibot_softmaxed_centered = get_teacher_output() + reshard_fsdp_model(self.teacher) + + loss_dict = {} + + loss_accumulator = 0 # for backprop + student_global_backbone_output_dict, student_local_backbone_output_dict = self.student.backbone( + [global_crops, local_crops], masks=[masks, None], is_training=True + ) + + inputs_for_student_head_list = [] + + # 1a: local crops cls tokens + student_local_cls_tokens = student_local_backbone_output_dict["x_norm_clstoken"] + inputs_for_student_head_list.append(student_local_cls_tokens.unsqueeze(0)) + + # 1b: global crops cls tokens + student_global_cls_tokens = student_global_backbone_output_dict["x_norm_clstoken"] + inputs_for_student_head_list.append(student_global_cls_tokens.unsqueeze(0)) + + # 1c: global crops patch tokens + if do_ibot: + _dim = student_global_backbone_output_dict["x_norm_clstoken"].shape[-1] + ibot_student_patch_tokens = student_global_backbone_output_dict["x_norm_patchtokens"] + buffer_tensor_patch_tokens = ibot_student_patch_tokens.new_zeros(upperbound, _dim) + buffer_tensor_patch_tokens[:n_masked_patches].copy_( + torch.index_select(ibot_student_patch_tokens.flatten(0, 1), dim=0, index=mask_indices_list) + ) + if not self.ibot_separate_head: + inputs_for_student_head_list.append(buffer_tensor_patch_tokens.unsqueeze(0)) + else: + student_global_masked_patch_tokens_after_head = self.student.ibot_head(buffer_tensor_patch_tokens)[ + :n_masked_patches + ] + + # 2: run + _attn_bias, cat_inputs = fmha.BlockDiagonalMask.from_tensor_list(inputs_for_student_head_list) + outputs_list = _attn_bias.split(self.student.dino_head(cat_inputs)) + + # 3a: local crops cls tokens + student_local_cls_tokens_after_head = outputs_list.pop(0).squeeze(0) + + # 3b: global crops cls tokens + student_global_cls_tokens_after_head = outputs_list.pop(0).squeeze(0) + + # 3c: global crops patch tokens + if do_ibot and not self.ibot_separate_head: + student_global_masked_patch_tokens_after_head = outputs_list.pop(0).squeeze(0)[:n_masked_patches] + + if n_local_crops > 0: + dino_local_crops_loss = self.dino_loss( + student_output_list=student_local_cls_tokens_after_head.chunk(n_local_crops), + teacher_out_softmaxed_centered_list=teacher_dino_softmaxed_centered_list, + ) / (n_global_crops_loss_terms + n_local_crops_loss_terms) + + # store for display + loss_dict["dino_local_crops_loss"] = dino_local_crops_loss + + # accumulate loss + loss_accumulator += self.dino_loss_weight * dino_local_crops_loss + + # process global crops + loss_scales = 2 # this is here since we process global crops together + + if do_dino: + # compute loss + dino_global_crops_loss = ( + self.dino_loss( + student_output_list=[student_global_cls_tokens_after_head], + teacher_out_softmaxed_centered_list=[ + teacher_dino_softmaxed_centered_list.flatten(0, 1) + ], # these were chunked and stacked in reverse so A is matched to B + ) + * loss_scales + / (n_global_crops_loss_terms + n_local_crops_loss_terms) + ) + + loss_dict["dino_global_crops_loss"] = dino_global_crops_loss + + # accumulate loss + loss_accumulator += self.dino_loss_weight * dino_global_crops_loss + + student_cls_tokens = student_global_cls_tokens + + if self.do_koleo: + koleo_loss = self.cfg.dino.koleo_loss_weight * sum( + self.koleo_loss(p) for p in student_cls_tokens.chunk(2) + ) # we don't apply koleo loss between cls tokens of a same image + loss_accumulator += koleo_loss + loss_dict["koleo_loss"] = ( + koleo_loss / loss_scales + ) # this is to display the same losses as before but we can remove eventually + + if do_ibot: + # compute loss + ibot_patch_loss = ( + self.ibot_patch_loss.forward_masked( + student_global_masked_patch_tokens_after_head, + masked_teacher_ibot_softmaxed_centered, + student_masks_flat=masks, + n_masked_patches=n_masked_patches, + masks_weight=masks_weight, + ) + * loss_scales + * ibot_loss_scale + ) + + # store for display + loss_dict["ibot_loss"] = ibot_patch_loss / 2 + + # accumulate loss + loss_accumulator += self.ibot_loss_weight * ibot_patch_loss + + self.backprop_loss(loss_accumulator) + + self.fsdp_synchronize_streams() + + return loss_dict + + def fsdp_synchronize_streams(self): + if self.need_to_synchronize_fsdp_streams: + torch.cuda.synchronize() + self.student.dino_head._streams = ( + self.teacher.dino_head._streams + ) = self.student.backbone._streams = self.teacher.backbone._streams + self.need_to_synchronize_fsdp_streams = False + + def update_teacher(self, m): + student_param_list = [] + teacher_param_list = [] + with torch.no_grad(): + for k in self.student.keys(): + for ms, mt in zip(get_fsdp_modules(self.student[k]), get_fsdp_modules(self.teacher[k])): + student_param_list += ms.params + teacher_param_list += mt.params + torch._foreach_mul_(teacher_param_list, m) + torch._foreach_add_(teacher_param_list, student_param_list, alpha=1 - m) + + def train(self): + super().train() + self.teacher.eval() + + def get_maybe_fused_params_for_submodel(self, m): + params_groups = get_params_groups_with_decay( + model=m, + lr_decay_rate=self.cfg.optim.layerwise_decay, + patch_embed_lr_mult=self.cfg.optim.patch_embed_lr_mult, + ) + fused_params_groups = fuse_params_groups(params_groups) + logger.info("fusing param groups") + + for g in fused_params_groups: + g["foreach"] = True + return fused_params_groups + + def get_params_groups(self): + all_params_groups = [] + for m in self.student.values(): + all_params_groups += self.get_maybe_fused_params_for_submodel(m) + return all_params_groups + + def prepare_for_distributed_training(self): + logger.info("DISTRIBUTED FSDP -- preparing model for distributed training") + if has_batchnorms(self.student): + raise NotImplementedError + # below will synchronize all student subnetworks across gpus: + for k, v in self.student.items(): + self.teacher[k].load_state_dict(self.student[k].state_dict()) + student_model_cfg = self.cfg.compute_precision.student[k] + self.student[k] = get_fsdp_wrapper(student_model_cfg, modules_to_wrap={BlockChunk})(self.student[k]) + teacher_model_cfg = self.cfg.compute_precision.teacher[k] + self.teacher[k] = get_fsdp_wrapper(teacher_model_cfg, modules_to_wrap={BlockChunk})(self.teacher[k]) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/train/train.py b/torch_cache/facebookresearch_dinov2_main/dinov2/train/train.py new file mode 100644 index 0000000000000000000000000000000000000000..a0888a037fdecfee131c6ba9a5b523a495e102c5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/train/train.py @@ -0,0 +1,327 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +import logging +import math +import os +from functools import partial + +from fvcore.common.checkpoint import PeriodicCheckpointer +import torch + +from dinov2.data import SamplerType, make_data_loader, make_dataset +from dinov2.data import collate_data_and_cast, DataAugmentationDINO, CellAugmentationDINO, MaskingGenerator +import dinov2.distributed as distributed +from dinov2.fsdp import FSDPCheckpointer +from dinov2.logging import MetricLogger +from dinov2.utils.config import setup +from dinov2.utils.utils import CosineScheduler + +from dinov2.train.ssl_meta_arch import SSLMetaArch + + +torch.backends.cuda.matmul.allow_tf32 = True # PyTorch 1.12 sets this to False by default +logger = logging.getLogger("dinov2") + + +def get_args_parser(add_help: bool = True): + parser = argparse.ArgumentParser("DINOv2 training", add_help=add_help) + parser.add_argument("--config-file", default="", metavar="FILE", help="path to config file") + parser.add_argument( + "--no-resume", + action="store_true", + help="Whether to not attempt to resume from the checkpoint directory. ", + ) + parser.add_argument("--eval-only", action="store_true", help="perform evaluation only") + parser.add_argument("--eval", type=str, default="", help="Eval type to perform") + parser.add_argument( + "opts", + help=""" +Modify config options at the end of the command. For Yacs configs, use +space-separated "PATH.KEY VALUE" pairs. +For python-based LazyConfig, use "path.key=value". + """.strip(), + default=None, + nargs=argparse.REMAINDER, + ) + parser.add_argument( + "--output-dir", + "--output_dir", + default="", + type=str, + help="Output directory to save logs and checkpoints", + ) + + return parser + + +def build_optimizer(cfg, params_groups): + return torch.optim.AdamW(params_groups, betas=(cfg.optim.adamw_beta1, cfg.optim.adamw_beta2)) + + +def build_schedulers(cfg): + OFFICIAL_EPOCH_LENGTH = cfg.train.OFFICIAL_EPOCH_LENGTH + lr = dict( + base_value=cfg.optim["lr"], + final_value=cfg.optim["min_lr"], + total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH, + warmup_iters=cfg.optim["warmup_epochs"] * OFFICIAL_EPOCH_LENGTH, + start_warmup_value=0, + ) + wd = dict( + base_value=cfg.optim["weight_decay"], + final_value=cfg.optim["weight_decay_end"], + total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH, + ) + momentum = dict( + base_value=cfg.teacher["momentum_teacher"], + final_value=cfg.teacher["final_momentum_teacher"], + total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH, + ) + teacher_temp = dict( + base_value=cfg.teacher["teacher_temp"], + final_value=cfg.teacher["teacher_temp"], + total_iters=cfg.teacher["warmup_teacher_temp_epochs"] * OFFICIAL_EPOCH_LENGTH, + warmup_iters=cfg.teacher["warmup_teacher_temp_epochs"] * OFFICIAL_EPOCH_LENGTH, + start_warmup_value=cfg.teacher["warmup_teacher_temp"], + ) + + lr_schedule = CosineScheduler(**lr) + wd_schedule = CosineScheduler(**wd) + momentum_schedule = CosineScheduler(**momentum) + teacher_temp_schedule = CosineScheduler(**teacher_temp) + last_layer_lr_schedule = CosineScheduler(**lr) + + last_layer_lr_schedule.schedule[ + : cfg.optim["freeze_last_layer_epochs"] * OFFICIAL_EPOCH_LENGTH + ] = 0 # mimicking the original schedules + + logger.info("Schedulers ready.") + + return ( + lr_schedule, + wd_schedule, + momentum_schedule, + teacher_temp_schedule, + last_layer_lr_schedule, + ) + + +def apply_optim_scheduler(optimizer, lr, wd, last_layer_lr): + for param_group in optimizer.param_groups: + is_last_layer = param_group["is_last_layer"] + lr_multiplier = param_group["lr_multiplier"] + wd_multiplier = param_group["wd_multiplier"] + param_group["weight_decay"] = wd * wd_multiplier + param_group["lr"] = (last_layer_lr if is_last_layer else lr) * lr_multiplier + + +def do_test(cfg, model, iteration): + new_state_dict = model.teacher.state_dict() + + if distributed.is_main_process(): + iterstring = str(iteration) + eval_dir = os.path.join(cfg.train.output_dir, "eval", iterstring) + os.makedirs(eval_dir, exist_ok=True) + # save teacher checkpoint + teacher_ckp_path = os.path.join(eval_dir, "teacher_checkpoint.pth") + torch.save({"teacher": new_state_dict}, teacher_ckp_path) + + +def do_train(cfg, model, resume=False): + model.train() + inputs_dtype = torch.half + fp16_scaler = model.fp16_scaler # for mixed precision training + + # setup optimizer + + optimizer = build_optimizer(cfg, model.get_params_groups()) + ( + lr_schedule, + wd_schedule, + momentum_schedule, + teacher_temp_schedule, + last_layer_lr_schedule, + ) = build_schedulers(cfg) + + # checkpointer + checkpointer = FSDPCheckpointer(model, cfg.train.output_dir, optimizer=optimizer, save_to_disk=True) + + start_iter = checkpointer.resume_or_load(cfg.MODEL.WEIGHTS, resume=resume).get("iteration", -1) + 1 + + OFFICIAL_EPOCH_LENGTH = cfg.train.OFFICIAL_EPOCH_LENGTH + max_iter = cfg.optim.epochs * OFFICIAL_EPOCH_LENGTH + + periodic_checkpointer = PeriodicCheckpointer( + checkpointer, + period=3 * OFFICIAL_EPOCH_LENGTH, + max_iter=max_iter, + max_to_keep=3, + ) + + # setup data preprocessing + + img_size = cfg.crops.global_crops_size + patch_size = cfg.student.patch_size + n_tokens = (img_size // patch_size) ** 2 + mask_generator = MaskingGenerator( + input_size=(img_size // patch_size, img_size // patch_size), + max_num_patches=0.5 * img_size // patch_size * img_size // patch_size, + ) + + if cfg.train.cell_augmentation: + data_transform = CellAugmentationDINO( + cfg.crops.global_crops_scale, + cfg.crops.local_crops_scale, + cfg.crops.local_crops_number, + global_crops_size=cfg.crops.global_crops_size, + local_crops_size=cfg.crops.local_crops_size, + ) + else: + data_transform = DataAugmentationDINO( + cfg.crops.global_crops_scale, + cfg.crops.local_crops_scale, + cfg.crops.local_crops_number, + global_crops_size=cfg.crops.global_crops_size, + local_crops_size=cfg.crops.local_crops_size, + ) + + collate_fn = partial( + collate_data_and_cast, + mask_ratio_tuple=cfg.ibot.mask_ratio_min_max, + mask_probability=cfg.ibot.mask_sample_probability, + n_tokens=n_tokens, + mask_generator=mask_generator, + dtype=inputs_dtype, + ) + + # setup data loader + + dataset = make_dataset( + dataset_str=cfg.train.dataset_path, + transform=data_transform, + target_transform=lambda _: (), + ) + # sampler_type = SamplerType.INFINITE + sampler_type = SamplerType.SHARDED_INFINITE + data_loader = make_data_loader( + dataset=dataset, + batch_size=cfg.train.batch_size_per_gpu, + num_workers=cfg.train.num_workers, + shuffle=True, + seed=start_iter, # TODO: Fix this -- cfg.train.seed + sampler_type=sampler_type, + sampler_advance=0, # TODO(qas): fix this -- start_iter * cfg.train.batch_size_per_gpu, + drop_last=True, + collate_fn=collate_fn, + ) + + # training loop + + iteration = start_iter + + logger.info("Starting training from iteration {}".format(start_iter)) + metrics_file = os.path.join(cfg.train.output_dir, "training_metrics.json") + metric_logger = MetricLogger(delimiter=" ", output_file=metrics_file) + header = "Training" + + for data in metric_logger.log_every( + data_loader, + 10, + header, + max_iter, + start_iter, + ): + current_batch_size = data["collated_global_crops"].shape[0] / 2 + if iteration > max_iter: + return + + # apply schedules + + lr = lr_schedule[iteration] + wd = wd_schedule[iteration] + mom = momentum_schedule[iteration] + teacher_temp = teacher_temp_schedule[iteration] + last_layer_lr = last_layer_lr_schedule[iteration] + apply_optim_scheduler(optimizer, lr, wd, last_layer_lr) + + # compute losses + + optimizer.zero_grad(set_to_none=True) + loss_dict = model.forward_backward(data, teacher_temp=teacher_temp) + + # clip gradients + + if fp16_scaler is not None: + if cfg.optim.clip_grad: + fp16_scaler.unscale_(optimizer) + for v in model.student.values(): + v.clip_grad_norm_(cfg.optim.clip_grad) + fp16_scaler.step(optimizer) + fp16_scaler.update() + else: + if cfg.optim.clip_grad: + for v in model.student.values(): + v.clip_grad_norm_(cfg.optim.clip_grad) + optimizer.step() + + # perform teacher EMA update + + model.update_teacher(mom) + + # logging + + if distributed.get_global_size() > 1: + for v in loss_dict.values(): + torch.distributed.all_reduce(v) + loss_dict_reduced = {k: v.item() / distributed.get_global_size() for k, v in loss_dict.items()} + + if math.isnan(sum(loss_dict_reduced.values())): + logger.info("NaN detected") + raise AssertionError + losses_reduced = sum(loss for loss in loss_dict_reduced.values()) + + metric_logger.update(lr=lr) + metric_logger.update(wd=wd) + metric_logger.update(mom=mom) + metric_logger.update(last_layer_lr=last_layer_lr) + metric_logger.update(current_batch_size=current_batch_size) + metric_logger.update(total_loss=losses_reduced, **loss_dict_reduced) + + # checkpointing and testing + + if cfg.evaluation.eval_period_iterations > 0 and (iteration + 1) % cfg.evaluation.eval_period_iterations == 0: + do_test(cfg, model, f"training_{iteration}") + torch.cuda.synchronize() + periodic_checkpointer.step(iteration) + + iteration = iteration + 1 + metric_logger.synchronize_between_processes() + return {k: meter.global_avg for k, meter in metric_logger.meters.items()} + + +def main(args): + cfg = setup(args) + + model = SSLMetaArch(cfg).to(torch.device("cuda")) + model.prepare_for_distributed_training() + + logger.info("Model:\n{}".format(model)) + if args.eval_only: + iteration = ( + FSDPCheckpointer(model, save_dir=cfg.train.output_dir) + .resume_or_load(cfg.MODEL.WEIGHTS, resume=not args.no_resume) + .get("iteration", -1) + + 1 + ) + return do_test(cfg, model, f"manual_{iteration}") + + do_train(cfg, model, resume=not args.no_resume) + + +if __name__ == "__main__": + args = get_args_parser(add_help=True).parse_args() + main(args) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/__init__.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40afb43678d1db842a67445d79260c338a1c1ab5 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/checkpoint.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..5afa11f99f6a1a45a57b8ca08f15b4106ceb592b --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/checkpoint.py @@ -0,0 +1,63 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +from typing import Any + +from fvcore.common.checkpoint import Checkpointer, PeriodicCheckpointer +from torch import nn + +import dinov2.distributed as dist + + +class PeriodicCheckpointerWithCleanup(PeriodicCheckpointer): + @property + def does_write(self) -> bool: + """See https://github.com/facebookresearch/fvcore/blob/main/fvcore/common/checkpoint.py#L114""" + return self.checkpointer.save_dir and self.checkpointer.save_to_disk + + def save_best(self, **kwargs: Any) -> None: + """Same argument as `Checkpointer.save`, to save a model named like `model_best.pth`""" + self.checkpointer.save(f"{self.file_prefix}_best", **kwargs) + + def has_checkpoint(self) -> bool: + return self.checkpointer.has_checkpoint() + + def get_checkpoint_file(self) -> str: # returns "" if the file does not exist + return self.checkpointer.get_checkpoint_file() + + def load(self, path: str, checkpointables=None) -> dict[str, Any]: + return self.checkpointer.load(path=path, checkpointables=checkpointables) + + def step(self, iteration: int, **kwargs: Any) -> None: + if not self.does_write: # step also removes files, so should be deactivated when object does not write + return + super().step(iteration=iteration, **kwargs) + + +def resume_or_load(checkpointer: Checkpointer, path: str, *, resume: bool = True) -> dict[str, Any]: + """ + If `resume` is True, this method attempts to resume from the last + checkpoint, if exists. Otherwise, load checkpoint from the given path. + Similar to Checkpointer.resume_or_load in fvcore + https://github.com/facebookresearch/fvcore/blob/main/fvcore/common/checkpoint.py#L208 + but always reload checkpointables, in case we want to resume the training in a new job. + """ + if resume and checkpointer.has_checkpoint(): + path = checkpointer.get_checkpoint_file() + return checkpointer.load(path) + + +def build_periodic_checkpointer( + model: nn.Module, + save_dir="", + *, + period: int, + max_iter=None, + max_to_keep=None, + **checkpointables: Any, +) -> PeriodicCheckpointerWithCleanup: + """Util to build a `PeriodicCheckpointerWithCleanup`.""" + checkpointer = Checkpointer(model, save_dir, **checkpointables, save_to_disk=dist.is_main_process()) + return PeriodicCheckpointerWithCleanup(checkpointer, period, max_iter=max_iter, max_to_keep=max_to_keep) diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/cluster.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/cluster.py new file mode 100644 index 0000000000000000000000000000000000000000..a9dfba92795a899495cc46c0f6890aa4604a4efc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/cluster.py @@ -0,0 +1,95 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +import os +from pathlib import Path +from typing import Any, Dict, Optional + + +class ClusterType(Enum): + AWS = "aws" + FAIR = "fair" + RSC = "rsc" + + +def _guess_cluster_type() -> ClusterType: + uname = os.uname() + if uname.sysname == "Linux": + if uname.release.endswith("-aws"): + # Linux kernel versions on AWS instances are of the form "5.4.0-1051-aws" + return ClusterType.AWS + elif uname.nodename.startswith("rsc"): + # Linux kernel versions on RSC instances are standard ones but hostnames start with "rsc" + return ClusterType.RSC + + return ClusterType.FAIR + + +def get_cluster_type(cluster_type: Optional[ClusterType] = None) -> Optional[ClusterType]: + if cluster_type is None: + return _guess_cluster_type() + + return cluster_type + + +def get_checkpoint_path(cluster_type: Optional[ClusterType] = None) -> Optional[Path]: + cluster_type = get_cluster_type(cluster_type) + if cluster_type is None: + return None + + CHECKPOINT_DIRNAMES = { + ClusterType.AWS: "checkpoints", + ClusterType.FAIR: "checkpoint", + ClusterType.RSC: "checkpoint/dino", + } + return Path("/") / CHECKPOINT_DIRNAMES[cluster_type] + + +def get_user_checkpoint_path(cluster_type: Optional[ClusterType] = None) -> Optional[Path]: + checkpoint_path = get_checkpoint_path(cluster_type) + if checkpoint_path is None: + return None + + username = os.environ.get("USER") + assert username is not None + return checkpoint_path / username + + +def get_slurm_partition(cluster_type: Optional[ClusterType] = None) -> Optional[str]: + cluster_type = get_cluster_type(cluster_type) + if cluster_type is None: + return None + + SLURM_PARTITIONS = { + ClusterType.AWS: "learnaccel", + ClusterType.FAIR: "learnaccel", + ClusterType.RSC: "learn", + } + return SLURM_PARTITIONS[cluster_type] + + +def get_slurm_executor_parameters( + nodes: int, num_gpus_per_node: int, cluster_type: Optional[ClusterType] = None, **kwargs +) -> Dict[str, Any]: + # create default parameters + params = { + "mem_gb": 0, # Requests all memory on a node, see https://slurm.schedmd.com/sbatch.html + "gpus_per_node": num_gpus_per_node, + "tasks_per_node": num_gpus_per_node, # one task per GPU + "cpus_per_task": 10, + "nodes": nodes, + "slurm_partition": get_slurm_partition(cluster_type), + } + # apply cluster-specific adjustments + cluster_type = get_cluster_type(cluster_type) + if cluster_type == ClusterType.AWS: + params["cpus_per_task"] = 12 + del params["mem_gb"] + elif cluster_type == ClusterType.RSC: + params["cpus_per_task"] = 12 + # set additional parameters / apply overrides + params.update(kwargs) + return params diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/config.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/config.py new file mode 100644 index 0000000000000000000000000000000000000000..ce148db58b30f32f28d2683ae12da40fc19ab138 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/config.py @@ -0,0 +1,72 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +import logging +import os + +from omegaconf import OmegaConf + +import dinov2.distributed as distributed +from dinov2.logging import setup_logging +from dinov2.utils import utils +from dinov2.configs import dinov2_default_config + + +logger = logging.getLogger("dinov2") + + +def apply_scaling_rules_to_cfg(cfg): # to fix + if cfg.optim.scaling_rule == "sqrt_wrt_1024": + base_lr = cfg.optim.base_lr + cfg.optim.lr = base_lr + cfg.optim.lr *= math.sqrt(cfg.train.batch_size_per_gpu * distributed.get_global_size() / 1024.0) + logger.info(f"sqrt scaling learning rate; base: {base_lr}, new: {cfg.optim.lr}") + else: + raise NotImplementedError + return cfg + + +def write_config(cfg, output_dir, name="config.yaml"): + logger.info(OmegaConf.to_yaml(cfg)) + saved_cfg_path = os.path.join(output_dir, name) + with open(saved_cfg_path, "w") as f: + OmegaConf.save(config=cfg, f=f) + return saved_cfg_path + + +def get_cfg_from_args(args): + args.output_dir = os.path.abspath(args.output_dir) + args.opts += [f"train.output_dir={args.output_dir}"] + default_cfg = OmegaConf.create(dinov2_default_config) + cfg = OmegaConf.load(args.config_file) + cfg = OmegaConf.merge(default_cfg, cfg, OmegaConf.from_cli(args.opts)) + return cfg + + +def default_setup(args): + distributed.enable(overwrite=True) + seed = getattr(args, "seed", 0) + rank = distributed.get_global_rank() + + global logger + setup_logging(output=args.output_dir, level=logging.INFO) + logger = logging.getLogger("dinov2") + + utils.fix_random_seeds(seed + rank) + logger.info("git:\n {}\n".format(utils.get_sha())) + logger.info("\n".join("%s: %s" % (k, str(v)) for k, v in sorted(dict(vars(args)).items()))) + + +def setup(args): + """ + Create configs and perform basic setups. + """ + cfg = get_cfg_from_args(args) + os.makedirs(args.output_dir, exist_ok=True) + default_setup(args) + apply_scaling_rules_to_cfg(cfg) + write_config(cfg, args.output_dir) + return cfg diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/dtype.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/dtype.py new file mode 100644 index 0000000000000000000000000000000000000000..a6fafb391cb5bf6f28663a388b9bc4034acf042e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/dtype.py @@ -0,0 +1,37 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + + +from typing import Dict, Union + +import numpy as np +import torch + + +TypeSpec = Union[str, np.dtype, torch.dtype] + + +_NUMPY_TO_TORCH_DTYPE: Dict[np.dtype, torch.dtype] = { + np.dtype("bool"): torch.bool, + np.dtype("uint8"): torch.uint8, + np.dtype("int8"): torch.int8, + np.dtype("int16"): torch.int16, + np.dtype("int32"): torch.int32, + np.dtype("int64"): torch.int64, + np.dtype("float16"): torch.float16, + np.dtype("float32"): torch.float32, + np.dtype("float64"): torch.float64, + np.dtype("complex64"): torch.complex64, + np.dtype("complex128"): torch.complex128, +} + + +def as_torch_dtype(dtype: TypeSpec) -> torch.dtype: + if isinstance(dtype, torch.dtype): + return dtype + if isinstance(dtype, str): + dtype = np.dtype(dtype) + assert isinstance(dtype, np.dtype), f"Expected an instance of nunpy dtype, got {type(dtype)}" + return _NUMPY_TO_TORCH_DTYPE[dtype] diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/param_groups.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/param_groups.py new file mode 100644 index 0000000000000000000000000000000000000000..07b5cea91c003c9fe472ce9d64d5a828b5e0d19b --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/param_groups.py @@ -0,0 +1,103 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import defaultdict +import logging + + +logger = logging.getLogger("dinov2") + + +def get_vit_lr_decay_rate(name, lr_decay_rate=1.0, num_layers=12, force_is_backbone=False, chunked_blocks=False): + """ + Calculate lr decay rate for different ViT blocks. + Args: + name (string): parameter name. + lr_decay_rate (float): base lr decay rate. + num_layers (int): number of ViT blocks. + Returns: + lr decay rate for the given parameter. + """ + layer_id = num_layers + 1 + if name.startswith("backbone") or force_is_backbone: + if ( + ".pos_embed" in name + or ".patch_embed" in name + or ".mask_token" in name + or ".cls_token" in name + or ".register_tokens" in name + ): + layer_id = 0 + elif force_is_backbone and ( + "pos_embed" in name + or "patch_embed" in name + or "mask_token" in name + or "cls_token" in name + or "register_tokens" in name + ): + layer_id = 0 + elif ".blocks." in name and ".residual." not in name: + layer_id = int(name[name.find(".blocks.") :].split(".")[2]) + 1 + elif chunked_blocks and "blocks." in name and "residual." not in name: + layer_id = int(name[name.find("blocks.") :].split(".")[2]) + 1 + elif "blocks." in name and "residual." not in name: + layer_id = int(name[name.find("blocks.") :].split(".")[1]) + 1 + + return lr_decay_rate ** (num_layers + 1 - layer_id) + + +def get_params_groups_with_decay(model, lr_decay_rate=1.0, patch_embed_lr_mult=1.0): + chunked_blocks = False + if hasattr(model, "n_blocks"): + logger.info("chunked fsdp") + n_blocks = model.n_blocks + chunked_blocks = model.chunked_blocks + elif hasattr(model, "blocks"): + logger.info("first code branch") + n_blocks = len(model.blocks) + elif hasattr(model, "backbone"): + logger.info("second code branch") + n_blocks = len(model.backbone.blocks) + else: + logger.info("else code branch") + n_blocks = 0 + all_param_groups = [] + + for name, param in model.named_parameters(): + name = name.replace("_fsdp_wrapped_module.", "") + if not param.requires_grad: + continue + decay_rate = get_vit_lr_decay_rate( + name, lr_decay_rate, num_layers=n_blocks, force_is_backbone=n_blocks > 0, chunked_blocks=chunked_blocks + ) + d = {"params": param, "is_last_layer": False, "lr_multiplier": decay_rate, "wd_multiplier": 1.0, "name": name} + + if "last_layer" in name: + d.update({"is_last_layer": True}) + + if name.endswith(".bias") or "norm" in name or "gamma" in name: + d.update({"wd_multiplier": 0.0}) + + if "patch_embed" in name: + d.update({"lr_multiplier": d["lr_multiplier"] * patch_embed_lr_mult}) + + all_param_groups.append(d) + logger.info(f"""{name}: lr_multiplier: {d["lr_multiplier"]}, wd_multiplier: {d["wd_multiplier"]}""") + + return all_param_groups + + +def fuse_params_groups(all_params_groups, keys=("lr_multiplier", "wd_multiplier", "is_last_layer")): + fused_params_groups = defaultdict(lambda: {"params": []}) + for d in all_params_groups: + identifier = "" + for k in keys: + identifier += k + str(d[k]) + "_" + + for k in keys: + fused_params_groups[identifier][k] = d[k] + fused_params_groups[identifier]["params"].append(d["params"]) + + return fused_params_groups.values() diff --git a/torch_cache/facebookresearch_dinov2_main/dinov2/utils/utils.py b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..dfa5c8ecca6317b7c8d46b2ebd70a234274160d2 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/dinov2/utils/utils.py @@ -0,0 +1,95 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import random +import subprocess +from urllib.parse import urlparse + +import numpy as np +import torch +from torch import nn + + +logger = logging.getLogger("dinov2") + + +def load_pretrained_weights(model, pretrained_weights, checkpoint_key): + if urlparse(pretrained_weights).scheme: # If it looks like an URL + state_dict = torch.hub.load_state_dict_from_url(pretrained_weights, map_location="cpu") + else: + state_dict = torch.load(pretrained_weights, map_location="cpu") + if checkpoint_key is not None and checkpoint_key in state_dict: + logger.info(f"Take key {checkpoint_key} in provided checkpoint dict") + state_dict = state_dict[checkpoint_key] + # remove `module.` prefix + state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()} + # remove `backbone.` prefix induced by multicrop wrapper + state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items()} + msg = model.load_state_dict(state_dict, strict=False) + logger.info("Pretrained weights found at {} and loaded with msg: {}".format(pretrained_weights, msg)) + + +def fix_random_seeds(seed=31): + """ + Fix random seeds. + """ + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + random.seed(seed) + + +def get_sha(): + cwd = os.path.dirname(os.path.abspath(__file__)) + + def _run(command): + return subprocess.check_output(command, cwd=cwd).decode("ascii").strip() + + sha = "N/A" + diff = "clean" + branch = "N/A" + try: + sha = _run(["git", "rev-parse", "HEAD"]) + subprocess.check_output(["git", "diff"], cwd=cwd) + diff = _run(["git", "diff-index", "HEAD"]) + diff = "has uncommitted changes" if diff else "clean" + branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"]) + except Exception: + pass + message = f"sha: {sha}, status: {diff}, branch: {branch}" + return message + + +class CosineScheduler(object): + def __init__(self, base_value, final_value, total_iters, warmup_iters=0, start_warmup_value=0, freeze_iters=0): + super().__init__() + self.final_value = final_value + self.total_iters = total_iters + + freeze_schedule = np.zeros((freeze_iters)) + + warmup_schedule = np.linspace(start_warmup_value, base_value, warmup_iters) + + iters = np.arange(total_iters - warmup_iters - freeze_iters) + schedule = final_value + 0.5 * (base_value - final_value) * (1 + np.cos(np.pi * iters / len(iters))) + self.schedule = np.concatenate((freeze_schedule, warmup_schedule, schedule)) + + assert len(self.schedule) == self.total_iters + + def __getitem__(self, it): + if it >= self.total_iters: + return self.final_value + else: + return self.schedule[it] + + +def has_batchnorms(model): + bn_types = (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d, nn.SyncBatchNorm) + for name, module in model.named_modules(): + if isinstance(module, bn_types): + return True + return False diff --git a/torch_cache/facebookresearch_dinov2_main/docs/Cell-DINO.png b/torch_cache/facebookresearch_dinov2_main/docs/Cell-DINO.png new file mode 100644 index 0000000000000000000000000000000000000000..afc0e14657a78e2b3e40a70189b94aba2ed344e4 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/docs/Cell-DINO.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:709d2fba153499262d190e22126b10337a4f76c137849d9f65cd0ade8f8d91aa +size 1101690 diff --git a/torch_cache/facebookresearch_dinov2_main/docs/ChannelAdaptiveDINO.png b/torch_cache/facebookresearch_dinov2_main/docs/ChannelAdaptiveDINO.png new file mode 100644 index 0000000000000000000000000000000000000000..0b44be0e4810bec317201bf5707ab7ccaf358fb1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/docs/ChannelAdaptiveDINO.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:29e92f5853abbd9126eab3956022b0e969b83aaaba7e4397d6679f5b279153d2 +size 665674 diff --git a/torch_cache/facebookresearch_dinov2_main/docs/README_CELL_DINO.md b/torch_cache/facebookresearch_dinov2_main/docs/README_CELL_DINO.md new file mode 100644 index 0000000000000000000000000000000000000000..6a9a2f34807ef2933abe606b3f87400516d2affd --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/docs/README_CELL_DINO.md @@ -0,0 +1,152 @@ + +# Cell-DINO: Self-Supervised Image-based Embeddings for Cell Fluorescent Microscopy + +Théo Moutakanni*, Camille Couprie*, Seungeun Yi*, Elouan Gardes*, Piotr Bojanowski*, Hugo Touvron*, Michael Doron, Zitong S. Chen, Nikita Moshkov, Mathilde Caron, Armand Joulin, Wolfgang M. Pernice, Juan C. Caicedo + +[[`BibTeX`](#citing-cell-dino)] + +**[*Meta AI Research, FAIR](https://ai.facebook.com/research/)** + +PyTorch implementation and pretrained models for Cell-DINO. + +The contents of this repo, including the code and model weights, are intended for research use only. It is not for use in medical procedures, including any diagnostics, treatment, or curative applications. Do not use this model for any clinical purpose or as a substitute for professional medical judgement. + +![teaser](Cell-DINO.png) + +## Pretrained models + +One model pretrained on HPA single cell, one model pretrained on HPA Field of View, one model pretrained on HPA Field of View at a larger resolution and one model pretrained on the combined cell painting dataset are released, see dowload instructions at the end of README.md, section "DINO for Biology". + +## Installation + +Follow instructions in the DINOv2 README or build the following environment: +```shell +conda create -n py310 python=3.10 +conda activate py310 +pip install -r requirements.txt +pip install -U scikit-learn +``` + +## Data preparation + +The HPA-FoV and HPA single cell (HPAone) datasets are available [here](https://www.ebi.ac.uk/biostudies/bioimages/studies/S-BIAD2443) +The folder also contains three sample images ("sample_images") that can be dowloaded to test quickly inference in the provided notebook in notebooks/cell_dino + +THe required files for HPA single cell (dataloader : HPAone.py) are: + +fixed_size_masked_single_cells_HPA +varied_size_masked_single_cells_HPA +varied_size_masked_single_cells_pretrain_20240507.csv +fixed_size_masked_single_cells_evaluation_20240507.csv +fixed_size_masked_single_cells_pretrain_20240507.csv + +:warning: To execute the commands provided in the next sections for training and evaluation, the `dinov2` package should be included in the Python module search path, i.e. simply prefix the command to run with `PYTHONPATH=.`. + +## Training + +### Fast setup: training DINOv2 ViT-L/16 on HPA single cell dataset + +Run CellDINO training on 4 A100-80GB nodes (32 GPUs) in a SLURM cluster environment with submitit: + +```shell +python dinov2/run/train/train.py \ + --nodes 4 \ + --config-file dinov2/configs/train/cell_dino/vitl16_hpaone.yaml \ + --output-dir \ + train.dataset_path=HPAone:split=ALL:root= +``` + +Training time is approximately 2 days on 4 A100 GPU nodes and the resulting checkpoint should reach 78.5 F1 accuracy for protein localization with a linear evaluation. + +The training code saves the weights of the teacher in the `eval` folder every 9000 iterations for evaluation. + +## Evaluation + +The training code regularly saves the teacher weights. In order to evaluate the model, run the following evaluation on a single node: + +### Linear classification with data augmentation on HPAone or HPAFov (replace 'HPAone' by 'HPAFoV'): + +```shell +PYTHONPATH=.:dinov2/data python dinov2/run/eval/cell_dino/linear.py \ + --config-file dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml \ + --pretrained-weights /eval/training_44999/teacher_checkpoint.pth \ + --output-dir /eval/training_44999/linear \ + --train-dataset HPAone:split=TRAIN:mode=PROTEIN_LOCALIZATION:root= \ + --val-dataset HPAone:split=VAL:mode=PROTEIN_LOCALIZATION:root \ + --val-metric-type mean_per_class_multilabel_f1 \ + --loss-type binary_cross_entropy \ + --avgpool \ +``` + +We release the weights from evaluating the different models: + +The performance of the provided pretrained model weights can be evaluated as follows on HPAone and HPAFoV (replace 'HPAone' by 'HPAFoV', and make sure to load the correct model weights) for the protein localization task: + +```shell +PYTHONPATH=.:dinov2/data python dinov2/run/eval/linear_celldino.py \ + --config-file dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml \ + --pretrained-weights \ + --output-dir \ + --train-dataset HPAone:split=TRAIN:mode=PROTEIN_LOCALIZATION:root= \ + --val-dataset HPAone:split=VAL:mode=PROTEIN_LOCALIZATION:root=root \ + --val-metric-type mean_per_class_multilabel_f1 \ + --loss-type binary_cross_entropy \ + --avgpool \ +``` + +and + +```shell +PYTHONPATH=.:dinov2/data python dinov2/run/eval/cell_dino/linear.py \ + --config-file dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml \ + --pretrained-weights \ + --output-dir \ + --train-dataset HPAone:split=TRAIN:mode=CELL_TYPE:root= \ + --val-dataset HPAone:split=VAL:mode=CELL_TYPE:root=root \ + --val-metric-type mean_per_class_multiclass_f1 \ + --avgpool \ +``` + +for the cell line classification task. + +### knn evaluation on HPAone: + +```shell +PYTHONPATH=.:dinov2/data python dinov2/run/eval/cell_dino/knn.py \ +--config-file dinov2/configs/eval/cell_dino/vitl16_pretrain.yaml \ +--pretrained-weights \ +--output-dir \ +--train-dataset HPAone:split=TRAIN:mode=CELL_TYPE:root= \ +--val-dataset HPAone:split=VAL:mode=CELL_TYPE:root= \ +--metric-type mean_per_class_multiclass_f1 \ +--crop-size 384 \ +--batch-size 256 \ +--resize-size 0 \ +--nb_knn 1 \ +``` + +for the cell line classification task. +For the knn evaluation on HPAFoV, replace 'HPAone' by 'HPAFoV' in the command above. +For protein localization, don't forget to change the metric type to mean_per_class_multilabel_f1. + +## License + +Cell-DINO code is released under the CC by NC licence See [LICENSE_CELL_DINO_CODE](LICENSE_CELL_DINO_CODE) for additional details. +Model weights will be released under the FAIR Non-Commercial Research License. See [LICENSE_CELL_DINO_MODELS](LICENSE_CELL_DINO_MODELS) for additional details. + +## Contributing + +See [contributing](CONTRIBUTING.md) and the [code of conduct](CODE_OF_CONDUCT.md). + +## Citing Cell-DINO + +If you find this repository useful, please consider giving a star :star: and citation :t-rex:: + +``` +@misc{, + title={Cell-DINO: Self-Supervised Image-based Embeddings for Cell Fluorescent Microscopy}, + author={Moutakanni, Th\'eo and Couprie, Camille and Yi, Seungeun and Gardes, Elouan Gardes and Bojanowski, Piotr and Touvron, Hugo and Doron, Michael and Chen, Zitong S. and Moshkov, Nikita and Caron, Mathilde and Joulin, Armand and Pernice, Wolfgang M. and Caicedo, Juan C.}, + journal={in review to PloS One on Computational Biology}, + year={2025} +} +``` diff --git a/torch_cache/facebookresearch_dinov2_main/docs/README_CHANNEL_ADAPTIVE_DINO.md b/torch_cache/facebookresearch_dinov2_main/docs/README_CHANNEL_ADAPTIVE_DINO.md new file mode 100644 index 0000000000000000000000000000000000000000..7acb9e9524f51ebe9607b9d674f9ff3c16ae1828 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/docs/README_CHANNEL_ADAPTIVE_DINO.md @@ -0,0 +1,156 @@ + +# Scaling Channel-Adaptive Self-Supervised Learning + + [[`Paper `](https://openreview.net/forum?id=pT8sgtRVAf))] [[`BibTeX`](#citing-channeladaptivedino-and-dinov2)] + +**[Meta AI Research, FAIR](https://ai.facebook.com/research/)** + +Alice V. De Lorenci, Seungeun Yi, Théo Moutakanni, Piotr Bojanowski, Camille Couprie, Juan C. Caicedo, Wolfgang M. Pernice, + +with special thanks to Elouan Gardes for his contributions to the codebase. + +PyTorch implementation and pretrained model for ChannelAdaptive-DINO. + +The contents of this repo, including the code and model weights, are intended for research use only. It is not for use in medical procedures, including any diagnostics, treatment, or curative applications. Do not use this model for any clinical purpose or as a substitute for professional medical judgement. + +![teaser](ChannelAdaptiveDINO.png) + +## Pretrained model + +You can download the model weights trained on the Extended CHAMMI dataset (combination of five cell microscopy datasets with variable numbers of channels) on torchhub. + +## Installation + +Follow instructions in the DINOv2 README. There are two additionnal dependencies to pandas and tifffile. + +## What is included / not included + +This repository includes the Bag of Channel implementation, not the Hierarchical attention approach. + +## Data preparation + +The CHAMMI dataset is available [here](https://github.com/chaudatascience/channel_adaptive_models). + +The HPA-FoV dataset is available [here](https://www.ebi.ac.uk/biostudies/bioimages/studies/S-BIAD2443) + +Content: a directory new_512_whole_images and two csv files: + +"whole_images_512_test.csv" + +"whole_images_512_train.csv" + + +:warning: To execute the commands provided in the next sections for training and evaluation, the `dinov2` package should be included in the Python module search path, i.e. simply prefix the command to run with `PYTHONPATH=.`. + +## Training + +### Fast setup: training Channel-Adaptive DINO ViT-L/16 on HPA single cell dataset + +Run Channel-Adaptive DINO training on 4 A100-80GB nodes (32 GPUs) in a SLURM cluster environment with submitit: + +```shell +python dinov2/run/train/train.py \ + --nodes 4 \ + --config-file dinov2/configs/train/cell_dino/vitl16_boc_hpafov.yaml \ + --output-dir \ + train.dataset_path=HPAFoV:split=TRAIN:root=:wildcard=SEPARATE_CHANNELS" +``` + +Training time is approximately 2 days. +The training code saves the weights of the teacher in the `eval` folder every 12500 iterations for evaluation. +This example only performs pretraining on the HPA-FoV dataset. + +## Evaluation + +The training code regularly saves the teacher weights. In order to evaluate the model, run the following evaluation on a single node: + +### Linear Evaluation on HPAFoV + +```shell +PYTHONPATH=.:dinov2/data python dinov2/run/eval/cell_dino/linear.py \ + --config-file dinov2/configs/eval/cell_dino/vitl16_channel_adaptive_pretrain.yaml \ + --pretrained-weights /eval/training_359999/teacher_checkpoint.pth \ + --output-dir /eval/training_359999/linear \ + --train-dataset HPAFoV:split=TRAIN:mode=PROTEIN_LOCALIZATION:root= \ + --val-dataset HPAFoV:split=VAL:mode=PROTEIN_LOCALIZATION:root= \ + --val-metric-type mean_per_class_multilabel_f1 \ + --loss-type binary_cross_entropy \ + --bag-of-channels \ + --crop-size 384 \ + --n-last-blocks 4 \ + --batch-size 32 \ + --epoch-length 145 \ + --epochs 30 \ + --avgpool \ +``` + +### KNN classification on CHAMMI + +Go to the docs directory, modifify some paths in launcher_knn_eval_on_chammi.sh and run + +```shell +./launcher_knn_eval_on_chammi.sh WTC TASK_ONE ; +./launcher_knn_eval_on_chammi.sh WTC TASK_TWO ; +./launcher_knn_eval_on_chammi.sh HPA TASK_ONE ; +./launcher_knn_eval_on_chammi.sh HPA TASK_TWO ; +./launcher_knn_eval_on_chammi.sh HPA TASK_THREE ; +./launcher_knn_eval_on_chammi.sh CP TASK_ONE ; +./launcher_knn_eval_on_chammi.sh CP TASK_TWO ; +./launcher_knn_eval_on_chammi.sh CP TASK_THREE ; +./launcher_knn_eval_on_chammi.sh CP TASK_FOUR ; +``` + +### Linear classification on CHAMMI + +Go to the docs directory, modifify some paths in launcher_CHAMMI_eval.sh and run + +```shell +./launcher_CHAMMI_eval.sh WTC TASK_ONE ; +./launcher_CHAMMI_eval.sh WTC TASK_TWO ; +./launcher_CHAMMI_eval.sh HPA TASK_ONE ; +./launcher_CHAMMI_eval.sh HPA TASK_TWO ; +./launcher_CHAMMI_eval.sh HPA TASK_THREE ; +./launcher_CHAMMI_eval.sh CP TASK_ONE ; +./launcher_CHAMMI_eval.sh CP TASK_TWO ; +./launcher_CHAMMI_eval.sh CP TASK_THREE ; +./launcher_CHAMMI_eval.sh CP TASK_FOUR ; +``` + +| | WTC - Task 1 | WTC - Task 2 | HPA - Task 1 | HPA - Task 2 | HPA - Task 3 | CP - Task 1 | CP - Task 2 | CP - Task 3 | CP - Task 4 | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| knn reproduced | 80.3 | 79.3 | 91.6 | 61.4 | 29.0 | 89.8 | 57.6 | 23.4 | 18.4 | +| knn paper | 79.4 | 79.0 | 86.6 | 59.3 | 29.6 | 92.6 | 57.6 | 22.1 | 18.5 | +| Linear reproduced | 89.9 | 87.9 | 92.7 | 87.2 | 66.2 | 89.9 | 59.8 | 26.6 | 32.5| +| Linear paper | 90.5 | 89.2 | 88.3 | 84.7 | 65.0 | 90.5 | 60.5 | 25.8 | 32.7| + + +## License + +Cell-DINO code is released under the CC by NC licence See [LICENSE_CELL_DINO_CODE](LICENSE_CELL_DINO_CODE) for additional details. +Model weights will be released under the FAIR Non-Commercial Research License. See [LICENSE_CELL_DINO_MODELS](LICENSE_CELL_DINO_MODELS) for additional details. + +## Contributing + +See [contributing](CONTRIBUTING.md) and the [code of conduct](CODE_OF_CONDUCT.md). + +## Citing ChannelAdaptiveDINO and DINOv2 + +If you find this repository useful, please consider giving a star :star: and citation :t-rex:: + +``` +@misc{Delorenci2025scaling, + title={Scaling Channel-Adaptive Self-Supervised Learning}, + author={V. De Lorenci, Alice and Yi, Seungeun and Moutakanni, Theo and Bojanowski, Piotr and Couprie, Camille and Caicedo, Juan C. and Pernice, Wolfgang M.}, + journal={TMLR}, + year={2025} +} +``` + +``` +@misc{oquab2023dinov2, + title={DINOv2: Learning Robust Visual Features without Supervision}, + author={Oquab, Maxime and Darcet, Timothée and Moutakanni, Theo and Vo, Huy V. and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and Howes, Russell and Huang, Po-Yao and Xu, Hu and Sharma, Vasu and Li, Shang-Wen and Galuba, Wojciech and Rabbat, Mike and Assran, Mido and Ballas, Nicolas and Synnaeve, Gabriel and Misra, Ishan and Jegou, Herve and Mairal, Julien and Labatut, Patrick and Joulin, Armand and Bojanowski, Piotr}, + journal={arXiv:2304.07193}, + year={2023} +} +``` diff --git a/torch_cache/facebookresearch_dinov2_main/hubconf.py b/torch_cache/facebookresearch_dinov2_main/hubconf.py new file mode 100644 index 0000000000000000000000000000000000000000..ea63f34bd57fe1d5657c67d01b785e343b3bf3e3 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/hubconf.py @@ -0,0 +1,17 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + + +from dinov2.hub.backbones import dinov2_vitb14, dinov2_vitg14, dinov2_vitl14, dinov2_vits14 +from dinov2.hub.backbones import dinov2_vitb14_reg, dinov2_vitg14_reg, dinov2_vitl14_reg, dinov2_vits14_reg +from dinov2.hub.cell_dino.backbones import cell_dino_cp_vits8, cell_dino_hpa_vitl16, cell_dino_hpa_vitl14, channel_adaptive_dino_vitl16 +from dinov2.hub.xray_dino.backbones import xray_dino_vitl16 +from dinov2.hub.classifiers import dinov2_vitb14_lc, dinov2_vitg14_lc, dinov2_vitl14_lc, dinov2_vits14_lc +from dinov2.hub.classifiers import dinov2_vitb14_reg_lc, dinov2_vitg14_reg_lc, dinov2_vitl14_reg_lc, dinov2_vits14_reg_lc +from dinov2.hub.depthers import dinov2_vitb14_ld, dinov2_vitg14_ld, dinov2_vitl14_ld, dinov2_vits14_ld +from dinov2.hub.depthers import dinov2_vitb14_dd, dinov2_vitg14_dd, dinov2_vitl14_dd, dinov2_vits14_dd +from dinov2.hub.dinotxt import dinov2_vitl14_reg4_dinotxt_tet1280d20h24l + +dependencies = ["torch"] diff --git a/torch_cache/facebookresearch_dinov2_main/notebooks/cell_dino/inference.ipynb b/torch_cache/facebookresearch_dinov2_main/notebooks/cell_dino/inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7b6362540949fb0496e527614bdf4357bb67b1c1 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/notebooks/cell_dino/inference.ipynb @@ -0,0 +1,179 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "6c3f1fe9-af40-4a57-aff0-99313d722f34", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) Meta Platforms, Inc. and affiliates.\n", + "# This source code is licensed under the CC-by-NC licence,\n", + "# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfe8d7c4-995c-44b4-a8d1-97be2badce8c", + "metadata": {}, + "outputs": [], + "source": [ + "SAMPLE_IMAGES_DIR = \"sample_images/\" # path to directory with cell images.\n", + "REPO_DIR=\"\" # path to the dinov2 repo.\n", + "# Also define the urls of the pretrained models CPurl, SCurl, FOVurl used in the next cell. Instructions to get the models urls are in the README.md." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70b2a71b-8fb2-4ec3-8cd1-21d6f770f704", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "cell_dino_vits8 = torch.hub.load(REPO_DIR, 'cell_dino_cp_vits8', source='local', pretrained_url=CPurl)\n", + "cell_dino_vitl16_sc = torch.hub.load(REPO_DIR, 'cell_dino_hpa_vitl16', source='local', pretrained_url=SCurl)\n", + "cell_dino_vitl16_fov = torch.hub.load(REPO_DIR, 'cell_dino_hpa_vitl16', source='local', pretrained_url=FOVurl)\n", + "#channel_adaptive_dino_vitl16 = torch.hub.load(REPO_DIR, 'channel_adaptive_dino_vitl16', source='local', pretrained_url=CAurl)\n", + "# cell_dino_vitl14 = torch.hub.load(REPO_DIR, 'cell_dino_hpa_vitl14', source='local', pretrained_url=HRurl)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6899c21-c4c2-43d4-8cdc-f6cce2c3686b", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "from dinov2.hub.cell_dino.backbones import cell_dino_hpa_vitl16, cell_dino_cp_vits8\n", + "from functools import partial\n", + "from dinov2.eval.utils import ModelWithIntermediateLayers\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "\n", + "class self_normalize(object):\n", + " def __call__(self, x):\n", + " x = x / 255\n", + " m = x.mean((-2, -1), keepdim=True)\n", + " s = x.std((-2, -1), unbiased=False, keepdim=True)\n", + " x -= m\n", + " x /= s + 1e-7\n", + " return x\n", + "\n", + "normalize = self_normalize()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "779ecbb7-3247-4b9e-9248-25c8cbd74d24", + "metadata": {}, + "outputs": [], + "source": [ + "# ---------------------- Example inference on HPA-FoV dataset --------------------------\n", + "\n", + "# 1- Read one human protein atlas HPA-FoV image (4 channels)\n", + "img = torchvision.io.read_image(SAMPLE_IMAGES_DIR + \"HPA_FoV_00070df0-bbc3-11e8-b2bc-ac1f6b6435d0.png\")\n", + "\n", + "# 2- Normalise image as it was done for training\n", + "img_hpa_fov = img.unsqueeze(0).to(device=DEVICE)\n", + "img_hpa_fov = normalize(img_hpa_fov)\n", + "\n", + "# 3- Load model\n", + "cell_dino_model = cell_dino_vitl16_fov\n", + "cell_dino_model.to(device=DEVICE)\n", + "cell_dino_model.eval()\n", + "\n", + "# 4- Inference\n", + "features = cell_dino_model(img_hpa_fov)\n", + "print(features)\n", + "\n", + "# 5- [Optional] feature extractor as used for linear evaluation\n", + "autocast_ctx = partial(torch.cuda.amp.autocast, enabled=True, dtype=torch.float)\n", + "model_with_interm_layers = ModelWithIntermediateLayers(cell_dino_model, 4, autocast_ctx)\n", + "features_with_interm_layers = model_with_interm_layers(img_hpa_fov)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85e67e67-5824-4135-8ca2-f8396cf95cb2", + "metadata": {}, + "outputs": [], + "source": [ + "# ---------------------- Example inference on cell painting data --------------------------\n", + "\n", + "# 1- Read one cell painting image (5 channels)\n", + "img = torchvision.io.read_image(SAMPLE_IMAGES_DIR + \"CP_BBBC036_24277_a06_1_976@140x149.png\")\n", + "img5_channels = torch.zeros([1, 5, 160, 160])\n", + "for c in range(5):\n", + " img5_channels[0, c] = img[0, :, 160 * c : 160 * (c + 1)]\n", + "img5_channels = img5_channels.to(device=DEVICE)\n", + "\n", + "# 2- Normalise image as it was done for training\n", + "img5_channels = normalize(img5_channels)\n", + "\n", + "# 3- Load model\n", + "cell_dino_model = cell_dino_vits8\n", + "cell_dino_model.to(device=DEVICE)\n", + "cell_dino_model.eval()\n", + "\n", + "# 4- Inference\n", + "features = cell_dino_model(img5_channels)\n", + "print(features[0,0:10])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ada26fcc-fd27-4dbf-983c-bbe06fe04b6f", + "metadata": {}, + "outputs": [], + "source": [ + "# ---------------------- Example inference on HPA single cell dataset --------------------------\n", + "\n", + "# Read one human protein atlas HPA single cell image (4 channels)\n", + "img = torchvision.io.read_image(SAMPLE_IMAGES_DIR + \"HPA_single_cell_00285ce4-bba0-11e8-b2b9-ac1f6b6435d0_15.png\")\n", + "\n", + "# 2- Normalise image as it was done for training\n", + "img_hpa = img.unsqueeze(0).to(device=DEVICE)\n", + "img_hpa = normalize(img_hpa)\n", + "\n", + "# 3- Load model\n", + "cell_dino_model = cell_dino_vitl16_sc\n", + "cell_dino_model.to(device=DEVICE)\n", + "cell_dino_model.eval()\n", + "\n", + "# 4- Inference\n", + "features = cell_dino_model(img_hpa)\n", + "print(features)\n", + "\n", + "torch.save(features.cpu(), \"sample_features_hpa.pt\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mypy310env)", + "language": "python", + "name": "mypy310env" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/torch_cache/facebookresearch_dinov2_main/notebooks/depth_estimation.ipynb b/torch_cache/facebookresearch_dinov2_main/notebooks/depth_estimation.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..853caa7245876eadc7c02e5d0347c97b1bd00079 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/notebooks/depth_estimation.ipynb @@ -0,0 +1,482 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) Meta Platforms, Inc. and affiliates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Depth Estimation \"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "INSTALL = False # Switch this to install dependencies\n", + "if INSTALL: # Try installing package with extras\n", + " REPO_URL = \"https://github.com/facebookresearch/dinov2\"\n", + " !{sys.executable} -m pip install -e {REPO_URL}'[extras]' --extra-index-url https://download.pytorch.org/whl/cu117 --extra-index-url https://pypi.nvidia.com\n", + "else:\n", + " REPO_PATH = \"\" # Specify a local path to the repository (or use installed package instead)\n", + " sys.path.append(REPO_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import itertools\n", + "from functools import partial\n", + "\n", + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "from dinov2.eval.depth.models import build_depther\n", + "\n", + "\n", + "class CenterPadding(torch.nn.Module):\n", + " def __init__(self, multiple):\n", + " super().__init__()\n", + " self.multiple = multiple\n", + "\n", + " def _get_pad(self, size):\n", + " new_size = math.ceil(size / self.multiple) * self.multiple\n", + " pad_size = new_size - size\n", + " pad_size_left = pad_size // 2\n", + " pad_size_right = pad_size - pad_size_left\n", + " return pad_size_left, pad_size_right\n", + "\n", + " @torch.inference_mode()\n", + " def forward(self, x):\n", + " pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1]))\n", + " output = F.pad(x, pads)\n", + " return output\n", + "\n", + "\n", + "def create_depther(cfg, backbone_model, backbone_size, head_type):\n", + " train_cfg = cfg.get(\"train_cfg\")\n", + " test_cfg = cfg.get(\"test_cfg\")\n", + " depther = build_depther(cfg.model, train_cfg=train_cfg, test_cfg=test_cfg)\n", + "\n", + " depther.backbone.forward = partial(\n", + " backbone_model.get_intermediate_layers,\n", + " n=cfg.model.backbone.out_indices,\n", + " reshape=True,\n", + " return_class_token=cfg.model.backbone.output_cls_token,\n", + " norm=cfg.model.backbone.final_norm,\n", + " )\n", + "\n", + " if hasattr(backbone_model, \"patch_size\"):\n", + " depther.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone_model.patch_size)(x[0]))\n", + "\n", + " return depther" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load pretrained backbone" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /private/home/plabatut/.cache/torch/hub/facebookresearch_dinov2_main\n" + ] + }, + { + "data": { + "text/plain": [ + "DinoVisionTransformer(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 384, kernel_size=(14, 14), stride=(14, 14))\n", + " (norm): Identity()\n", + " )\n", + " (blocks): ModuleList(\n", + " (0-11): 12 x NestedTensorBlock(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MemEffAttention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ls1): LayerScale()\n", + " (drop_path1): Identity()\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ls2): LayerScale()\n", + " (drop_path2): Identity()\n", + " )\n", + " )\n", + " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (head): Identity()\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "BACKBONE_SIZE = \"small\" # in (\"small\", \"base\", \"large\" or \"giant\")\n", + "\n", + "\n", + "backbone_archs = {\n", + " \"small\": \"vits14\",\n", + " \"base\": \"vitb14\",\n", + " \"large\": \"vitl14\",\n", + " \"giant\": \"vitg14\",\n", + "}\n", + "backbone_arch = backbone_archs[BACKBONE_SIZE]\n", + "backbone_name = f\"dinov2_{backbone_arch}\"\n", + "\n", + "backbone_model = torch.hub.load(repo_or_dir=\"facebookresearch/dinov2\", model=backbone_name)\n", + "backbone_model.eval()\n", + "backbone_model.cuda()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load pretrained depth head" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "load checkpoint from http path: https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_nyu_dpt_head.pth\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading: \"https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_nyu_dpt_head.pth\" to /private/home/plabatut/.cache/torch/hub/checkpoints/dinov2_vits14_nyu_dpt_head.pth\n", + "100%|██████████| 160M/160M [00:06<00:00, 27.2MB/s] \n" + ] + }, + { + "data": { + "text/plain": [ + "DepthEncoderDecoder(\n", + " (backbone): DinoVisionTransformer()\n", + " (decode_head): DPTHead(\n", + " align_corners=False\n", + " (loss_decode): ModuleList(\n", + " (0): SigLoss()\n", + " (1): GradientLoss()\n", + " )\n", + " (conv_depth): HeadDepth(\n", + " (head): Sequential(\n", + " (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): Interpolate()\n", + " (2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): Conv2d(32, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (relu): ReLU()\n", + " (sigmoid): Sigmoid()\n", + " (reassemble_blocks): ReassembleBlocks(\n", + " (projects): ModuleList(\n", + " (0): ConvModule(\n", + " (conv): Conv2d(384, 48, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (1): ConvModule(\n", + " (conv): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (2): ConvModule(\n", + " (conv): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (3): ConvModule(\n", + " (conv): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (resize_layers): ModuleList(\n", + " (0): ConvTranspose2d(48, 48, kernel_size=(4, 4), stride=(4, 4))\n", + " (1): ConvTranspose2d(96, 96, kernel_size=(2, 2), stride=(2, 2))\n", + " (2): Identity()\n", + " (3): Conv2d(384, 384, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " )\n", + " (readout_projects): ModuleList(\n", + " (0-3): 4 x Sequential(\n", + " (0): Linear(in_features=768, out_features=384, bias=True)\n", + " (1): GELU(approximate='none')\n", + " )\n", + " )\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvModule(\n", + " (conv): Conv2d(48, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " )\n", + " (1): ConvModule(\n", + " (conv): Conv2d(96, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " )\n", + " (2): ConvModule(\n", + " (conv): Conv2d(192, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " )\n", + " (3): ConvModule(\n", + " (conv): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (fusion_blocks): ModuleList(\n", + " (0): FeatureFusionBlock(\n", + " (project): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (res_conv_unit1): None\n", + " (res_conv_unit2): PreActResidualConvUnit(\n", + " (conv1): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " (conv2): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (1-3): 3 x FeatureFusionBlock(\n", + " (project): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (res_conv_unit1): PreActResidualConvUnit(\n", + " (conv1): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " (conv2): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (res_conv_unit2): PreActResidualConvUnit(\n", + " (conv1): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " (conv2): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (project): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import urllib\n", + "\n", + "import mmcv\n", + "from mmcv.runner import load_checkpoint\n", + "\n", + "\n", + "def load_config_from_url(url: str) -> str:\n", + " with urllib.request.urlopen(url) as f:\n", + " return f.read().decode()\n", + "\n", + "\n", + "HEAD_DATASET = \"nyu\" # in (\"nyu\", \"kitti\")\n", + "HEAD_TYPE = \"dpt\" # in (\"linear\", \"linear4\", \"dpt\")\n", + "\n", + "\n", + "DINOV2_BASE_URL = \"https://dl.fbaipublicfiles.com/dinov2\"\n", + "head_config_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_config.py\"\n", + "head_checkpoint_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_head.pth\"\n", + "\n", + "cfg_str = load_config_from_url(head_config_url)\n", + "cfg = mmcv.Config.fromstring(cfg_str, file_format=\".py\")\n", + "\n", + "model = create_depther(\n", + " cfg,\n", + " backbone_model=backbone_model,\n", + " backbone_size=BACKBONE_SIZE,\n", + " head_type=HEAD_TYPE,\n", + ")\n", + "\n", + "load_checkpoint(model, head_checkpoint_url, map_location=\"cpu\")\n", + "model.eval()\n", + "model.cuda()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load sample image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import urllib\n", + "\n", + "from PIL import Image\n", + "\n", + "\n", + "def load_image_from_url(url: str) -> Image:\n", + " with urllib.request.urlopen(url) as f:\n", + " return Image.open(f).convert(\"RGB\")\n", + "\n", + "\n", + "EXAMPLE_IMAGE_URL = \"https://dl.fbaipublicfiles.com/dinov2/images/example.jpg\"\n", + "\n", + "\n", + "image = load_image_from_url(EXAMPLE_IMAGE_URL)\n", + "display(image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Estimate depth on sample image" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "from torchvision import transforms\n", + "\n", + "\n", + "def make_depth_transform() -> transforms.Compose:\n", + " return transforms.Compose([\n", + " transforms.ToTensor(),\n", + " lambda x: 255.0 * x[:3], # Discard alpha component and scale by 255\n", + " transforms.Normalize(\n", + " mean=(123.675, 116.28, 103.53),\n", + " std=(58.395, 57.12, 57.375),\n", + " ),\n", + " ])\n", + "\n", + "\n", + "def render_depth(values, colormap_name=\"magma_r\") -> Image:\n", + " min_value, max_value = values.min(), values.max()\n", + " normalized_values = (values - min_value) / (max_value - min_value)\n", + "\n", + " colormap = matplotlib.colormaps[colormap_name]\n", + " colors = colormap(normalized_values, bytes=True) # ((1)xhxwx4)\n", + " colors = colors[:, :, :3] # Discard alpha component\n", + " return Image.fromarray(colors)\n", + "\n", + "\n", + "transform = make_depth_transform()\n", + "\n", + "scale_factor = 1\n", + "rescaled_image = image.resize((scale_factor * image.width, scale_factor * image.height))\n", + "transformed_image = transform(rescaled_image)\n", + "batch = transformed_image.unsqueeze(0).cuda() # Make a batch of one image\n", + "\n", + "with torch.inference_mode():\n", + " result = model.whole_inference(batch, img_meta=None, rescale=True)\n", + "\n", + "depth_image = render_depth(result.squeeze().cpu())\n", + "display(depth_image)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/torch_cache/facebookresearch_dinov2_main/notebooks/dinotxt.ipynb b/torch_cache/facebookresearch_dinov2_main/notebooks/dinotxt.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d10204229f6db34c190912b1ce65d3c82c7d83ab --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/notebooks/dinotxt.ipynb @@ -0,0 +1,379 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "f75733e2", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "INSTALL = False # Switch this to install dependencies\n", + "if INSTALL: # Try installing package with extras\n", + " REPO_URL = \"https://github.com/facebookresearch/dinov2\"\n", + " !{sys.executable} -m pip install -e {REPO_URL}'[extras]' --extra-index-url https://download.pytorch.org/whl/cu117 --extra-index-url https://pypi.nvidia.com\n", + "else:\n", + " REPO_PATH = \"\" # Specify a local path to the repository (or use installed package instead)\n", + " sys.path.append(REPO_PATH)" + ] + }, + { + "cell_type": "markdown", + "id": "ff529826", + "metadata": {}, + "source": [ + "## Load pretrained dino.txt vision head and text model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d20749e6", + "metadata": {}, + "outputs": [], + "source": [ + "from dinov2.hub.dinotxt import dinov2_vitl14_reg4_dinotxt_tet1280d20h24l, get_tokenizer\n", + "model = dinov2_vitl14_reg4_dinotxt_tet1280d20h24l().cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09c04bb1", + "metadata": {}, + "outputs": [], + "source": [ + "tokenizer = get_tokenizer()" + ] + }, + { + "cell_type": "markdown", + "id": "b85bdd35", + "metadata": {}, + "source": [ + "## Load sample image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d48a6cf", + "metadata": {}, + "outputs": [], + "source": [ + "import urllib\n", + "from PIL import Image\n", + "\n", + "def load_image_from_url(url: str) -> Image:\n", + " with urllib.request.urlopen(url) as f:\n", + " return Image.open(f).convert(\"RGB\")\n", + "\n", + "\n", + "EXAMPLE_IMAGE_URL = \"https://dl.fbaipublicfiles.com/dinov2/images/example.jpg\"\n", + "img_pil = load_image_from_url(EXAMPLE_IMAGE_URL)\n", + "display(img_pil)" + ] + }, + { + "cell_type": "markdown", + "id": "127d7e9d", + "metadata": {}, + "source": [ + "## Get Zero-shot classification scores on sample image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf2aa337", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from dinov2.data.transforms import make_classification_eval_transform\n", + "\n", + "image_preprocess = make_classification_eval_transform()\n", + "image_tensor = torch.stack([image_preprocess(img_pil)], dim=0).cuda()\n", + "texts = [\"photo of dogs\", \"photo of a chair\", \"photo of a bowl\", \"photo of a tupperware\"]\n", + "class_names = [\"dog\", \"chair\", \"bowl\", \"tupperware\"]\n", + "tokenized_texts_tensor = tokenizer.tokenize(texts).cuda()\n", + "with torch.autocast('cuda', dtype=torch.float):\n", + " with torch.no_grad():\n", + " image_features = model.encode_image(image_tensor)\n", + " text_features = model.encode_text(tokenized_texts_tensor)\n", + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "similarity = (\n", + " text_features.cpu().float().numpy() @ image_features.cpu().float().numpy().T\n", + ")\n", + "print(similarity) " + ] + }, + { + "cell_type": "markdown", + "id": "c96f5edc", + "metadata": {}, + "source": [ + "## Get patch embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "098f7339", + "metadata": {}, + "outputs": [], + "source": [ + "with torch.autocast('cuda', dtype=torch.float):\n", + " with torch.no_grad():\n", + " image_class_tokens, image_patch_tokens = model.get_visual_class_and_patch_tokens(image_tensor)\n", + " text_features_aligned_to_patch = model.encode_text(tokenized_texts_tensor)[:, 1024:] # Part of text features that is aligned to patch features" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "244138fb", + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn.functional as F\n", + "\n", + "B, P, D = image_patch_tokens.shape\n", + "H = W = int(P**0.5) \n", + "x = image_patch_tokens.movedim(2, 1).unflatten(2, (H, W)).float() # [B, D, H, W]\n", + "x = F.interpolate(x, size=(480, 640), mode=\"bicubic\", align_corners=False)\n", + "x = F.normalize(x, p=2, dim=1)\n", + "y = F.normalize(text_features_aligned_to_patch.float(), p=2, dim=1)\n", + "per_patch_similarity_to_text = torch.einsum(\"bdhw,cd->bchw\", x, y)\n", + "pred_idx = per_patch_similarity_to_text.argmax(1).squeeze(0)" + ] + }, + { + "cell_type": "markdown", + "id": "02b6c903", + "metadata": {}, + "source": [ + "# Zero-shot classification on ImageNet1k " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ddf76eb0", + "metadata": {}, + "outputs": [], + "source": [ + "# https://raw.githubusercontent.com/kantharajucn/CLIP-imagenet-evaluation/refs/heads/main/classes.py\n", + "imagenet_clip_class_names= [\"tench\", \"goldfish\", \"great white shark\", \"tiger shark\", \"hammerhead shark\", \"electric ray\", \"stingray\", \"rooster\", \"hen\", \"ostrich\", \"brambling\", \"goldfinch\", \"house finch\", \"junco\", \"indigo bunting\", \"American robin\", \"bulbul\", \"jay\", \"magpie\", \"chickadee\", \"American dipper\", \"kite (bird of prey)\", \"bald eagle\", \"vulture\", \"great grey owl\", \"fire salamander\", \"smooth newt\", \"newt\", \"spotted salamander\", \"axolotl\", \"American bullfrog\", \"tree frog\", \"tailed frog\", \"loggerhead sea turtle\", \"leatherback sea turtle\", \"mud turtle\", \"terrapin\", \"box turtle\", \"banded gecko\", \"green iguana\", \"Carolina anole\", \"desert grassland whiptail lizard\", \"agama\", \"frilled-necked lizard\", \"alligator lizard\", \"Gila monster\", \"European green lizard\", \"chameleon\", \"Komodo dragon\", \"Nile crocodile\", \"American alligator\", \"triceratops\", \"worm snake\", \"ring-necked snake\", \"eastern hog-nosed snake\", \"smooth green snake\", \"kingsnake\", \"garter snake\", \"water snake\", \"vine snake\", \"night snake\", \"boa constrictor\", \"African rock python\", \"Indian cobra\", \"green mamba\", \"sea snake\", \"Saharan horned viper\", \"eastern diamondback rattlesnake\", \"sidewinder rattlesnake\", \"trilobite\", \"harvestman\", \"scorpion\", \"yellow garden spider\", \"barn spider\", \"European garden spider\", \"southern black widow\", \"tarantula\", \"wolf spider\", \"tick\", \"centipede\", \"black grouse\", \"ptarmigan\", \"ruffed grouse\", \"prairie grouse\", \"peafowl\", \"quail\", \"partridge\", \"african grey parrot\", \"macaw\", \"sulphur-crested cockatoo\", \"lorikeet\", \"coucal\", \"bee eater\", \"hornbill\", \"hummingbird\", \"jacamar\", \"toucan\", \"duck\", \"red-breasted merganser\", \"goose\", \"black swan\", \"tusker\", \"echidna\", \"platypus\", \"wallaby\", \"koala\", \"wombat\", \"jellyfish\", \"sea anemone\", \"brain coral\", \"flatworm\", \"nematode\", \"conch\", \"snail\", \"slug\", \"sea slug\", \"chiton\", \"chambered nautilus\", \"Dungeness crab\", \"rock crab\", \"fiddler crab\", \"red king crab\", \"American lobster\", \"spiny lobster\", \"crayfish\", \"hermit crab\", \"isopod\", \"white stork\", \"black stork\", \"spoonbill\", \"flamingo\", \"little blue heron\", \"great egret\", \"bittern bird\", \"crane bird\", \"limpkin\", \"common gallinule\", \"American coot\", \"bustard\", \"ruddy turnstone\", \"dunlin\", \"common redshank\", \"dowitcher\", \"oystercatcher\", \"pelican\", \"king penguin\", \"albatross\", \"grey whale\", \"killer whale\", \"dugong\", \"sea lion\", \"Chihuahua\", \"Japanese Chin\", \"Maltese\", \"Pekingese\", \"Shih Tzu\", \"King Charles Spaniel\", \"Papillon\", \"toy terrier\", \"Rhodesian Ridgeback\", \"Afghan Hound\", \"Basset Hound\", \"Beagle\", \"Bloodhound\", \"Bluetick Coonhound\", \"Black and Tan Coonhound\", \"Treeing Walker Coonhound\", \"English foxhound\", \"Redbone Coonhound\", \"borzoi\", \"Irish Wolfhound\", \"Italian Greyhound\", \"Whippet\", \"Ibizan Hound\", \"Norwegian Elkhound\", \"Otterhound\", \"Saluki\", \"Scottish Deerhound\", \"Weimaraner\", \"Staffordshire Bull Terrier\", \"American Staffordshire Terrier\", \"Bedlington Terrier\", \"Border Terrier\", \"Kerry Blue Terrier\", \"Irish Terrier\", \"Norfolk Terrier\", \"Norwich Terrier\", \"Yorkshire Terrier\", \"Wire Fox Terrier\", \"Lakeland Terrier\", \"Sealyham Terrier\", \"Airedale Terrier\", \"Cairn Terrier\", \"Australian Terrier\", \"Dandie Dinmont Terrier\", \"Boston Terrier\", \"Miniature Schnauzer\", \"Giant Schnauzer\", \"Standard Schnauzer\", \"Scottish Terrier\", \"Tibetan Terrier\", \"Australian Silky Terrier\", \"Soft-coated Wheaten Terrier\", \"West Highland White Terrier\", \"Lhasa Apso\", \"Flat-Coated Retriever\", \"Curly-coated Retriever\", \"Golden Retriever\", \"Labrador Retriever\", \"Chesapeake Bay Retriever\", \"German Shorthaired Pointer\", \"Vizsla\", \"English Setter\", \"Irish Setter\", \"Gordon Setter\", \"Brittany dog\", \"Clumber Spaniel\", \"English Springer Spaniel\", \"Welsh Springer Spaniel\", \"Cocker Spaniel\", \"Sussex Spaniel\", \"Irish Water Spaniel\", \"Kuvasz\", \"Schipperke\", \"Groenendael dog\", \"Malinois\", \"Briard\", \"Australian Kelpie\", \"Komondor\", \"Old English Sheepdog\", \"Shetland Sheepdog\", \"collie\", \"Border Collie\", \"Bouvier des Flandres dog\", \"Rottweiler\", \"German Shepherd Dog\", \"Dobermann\", \"Miniature Pinscher\", \"Greater Swiss Mountain Dog\", \"Bernese Mountain Dog\", \"Appenzeller Sennenhund\", \"Entlebucher Sennenhund\", \"Boxer\", \"Bullmastiff\", \"Tibetan Mastiff\", \"French Bulldog\", \"Great Dane\", \"St. Bernard\", \"husky\", \"Alaskan Malamute\", \"Siberian Husky\", \"Dalmatian\", \"Affenpinscher\", \"Basenji\", \"pug\", \"Leonberger\", \"Newfoundland dog\", \"Great Pyrenees dog\", \"Samoyed\", \"Pomeranian\", \"Chow Chow\", \"Keeshond\", \"brussels griffon\", \"Pembroke Welsh Corgi\", \"Cardigan Welsh Corgi\", \"Toy Poodle\", \"Miniature Poodle\", \"Standard Poodle\", \"Mexican hairless dog (xoloitzcuintli)\", \"grey wolf\", \"Alaskan tundra wolf\", \"red wolf or maned wolf\", \"coyote\", \"dingo\", \"dhole\", \"African wild dog\", \"hyena\", \"red fox\", \"kit fox\", \"Arctic fox\", \"grey fox\", \"tabby cat\", \"tiger cat\", \"Persian cat\", \"Siamese cat\", \"Egyptian Mau\", \"cougar\", \"lynx\", \"leopard\", \"snow leopard\", \"jaguar\", \"lion\", \"tiger\", \"cheetah\", \"brown bear\", \"American black bear\", \"polar bear\", \"sloth bear\", \"mongoose\", \"meerkat\", \"tiger beetle\", \"ladybug\", \"ground beetle\", \"longhorn beetle\", \"leaf beetle\", \"dung beetle\", \"rhinoceros beetle\", \"weevil\", \"fly\", \"bee\", \"ant\", \"grasshopper\", \"cricket insect\", \"stick insect\", \"cockroach\", \"praying mantis\", \"cicada\", \"leafhopper\", \"lacewing\", \"dragonfly\", \"damselfly\", \"red admiral butterfly\", \"ringlet butterfly\", \"monarch butterfly\", \"small white butterfly\", \"sulphur butterfly\", \"gossamer-winged butterfly\", \"starfish\", \"sea urchin\", \"sea cucumber\", \"cottontail rabbit\", \"hare\", \"Angora rabbit\", \"hamster\", \"porcupine\", \"fox squirrel\", \"marmot\", \"beaver\", \"guinea pig\", \"common sorrel horse\", \"zebra\", \"pig\", \"wild boar\", \"warthog\", \"hippopotamus\", \"ox\", \"water buffalo\", \"bison\", \"ram (adult male sheep)\", \"bighorn sheep\", \"Alpine ibex\", \"hartebeest\", \"impala (antelope)\", \"gazelle\", \"arabian camel\", \"llama\", \"weasel\", \"mink\", \"European polecat\", \"black-footed ferret\", \"otter\", \"skunk\", \"badger\", \"armadillo\", \"three-toed sloth\", \"orangutan\", \"gorilla\", \"chimpanzee\", \"gibbon\", \"siamang\", \"guenon\", \"patas monkey\", \"baboon\", \"macaque\", \"langur\", \"black-and-white colobus\", \"proboscis monkey\", \"marmoset\", \"white-headed capuchin\", \"howler monkey\", \"titi monkey\", \"Geoffroy's spider monkey\", \"common squirrel monkey\", \"ring-tailed lemur\", \"indri\", \"Asian elephant\", \"African bush elephant\", \"red panda\", \"giant panda\", \"snoek fish\", \"eel\", \"silver salmon\", \"rock beauty fish\", \"clownfish\", \"sturgeon\", \"gar fish\", \"lionfish\", \"pufferfish\", \"abacus\", \"abaya\", \"academic gown\", \"accordion\", \"acoustic guitar\", \"aircraft carrier\", \"airliner\", \"airship\", \"altar\", \"ambulance\", \"amphibious vehicle\", \"analog clock\", \"apiary\", \"apron\", \"trash can\", \"assault rifle\", \"backpack\", \"bakery\", \"balance beam\", \"balloon\", \"ballpoint pen\", \"Band-Aid\", \"banjo\", \"baluster / handrail\", \"barbell\", \"barber chair\", \"barbershop\", \"barn\", \"barometer\", \"barrel\", \"wheelbarrow\", \"baseball\", \"basketball\", \"bassinet\", \"bassoon\", \"swimming cap\", \"bath towel\", \"bathtub\", \"station wagon\", \"lighthouse\", \"beaker\", \"military hat (bearskin or shako)\", \"beer bottle\", \"beer glass\", \"bell tower\", \"baby bib\", \"tandem bicycle\", \"bikini\", \"ring binder\", \"binoculars\", \"birdhouse\", \"boathouse\", \"bobsleigh\", \"bolo tie\", \"poke bonnet\", \"bookcase\", \"bookstore\", \"bottle cap\", \"hunting bow\", \"bow tie\", \"brass memorial plaque\", \"bra\", \"breakwater\", \"breastplate\", \"broom\", \"bucket\", \"buckle\", \"bulletproof vest\", \"high-speed train\", \"butcher shop\", \"taxicab\", \"cauldron\", \"candle\", \"cannon\", \"canoe\", \"can opener\", \"cardigan\", \"car mirror\", \"carousel\", \"tool kit\", \"cardboard box / carton\", \"car wheel\", \"automated teller machine\", \"cassette\", \"cassette player\", \"castle\", \"catamaran\", \"CD player\", \"cello\", \"mobile phone\", \"chain\", \"chain-link fence\", \"chain mail\", \"chainsaw\", \"storage chest\", \"chiffonier\", \"bell or wind chime\", \"china cabinet\", \"Christmas stocking\", \"church\", \"movie theater\", \"cleaver\", \"cliff dwelling\", \"cloak\", \"clogs\", \"cocktail shaker\", \"coffee mug\", \"coffeemaker\", \"spiral or coil\", \"combination lock\", \"computer keyboard\", \"candy store\", \"container ship\", \"convertible\", \"corkscrew\", \"cornet\", \"cowboy boot\", \"cowboy hat\", \"cradle\", \"construction crane\", \"crash helmet\", \"crate\", \"infant bed\", \"Crock Pot\", \"croquet ball\", \"crutch\", \"cuirass\", \"dam\", \"desk\", \"desktop computer\", \"rotary dial telephone\", \"diaper\", \"digital clock\", \"digital watch\", \"dining table\", \"dishcloth\", \"dishwasher\", \"disc brake\", \"dock\", \"dog sled\", \"dome\", \"doormat\", \"drilling rig\", \"drum\", \"drumstick\", \"dumbbell\", \"Dutch oven\", \"electric fan\", \"electric guitar\", \"electric locomotive\", \"entertainment center\", \"envelope\", \"espresso machine\", \"face powder\", \"feather boa\", \"filing cabinet\", \"fireboat\", \"fire truck\", \"fire screen\", \"flagpole\", \"flute\", \"folding chair\", \"football helmet\", \"forklift\", \"fountain\", \"fountain pen\", \"four-poster bed\", \"freight car\", \"French horn\", \"frying pan\", \"fur coat\", \"garbage truck\", \"gas mask or respirator\", \"gas pump\", \"goblet\", \"go-kart\", \"golf ball\", \"golf cart\", \"gondola\", \"gong\", \"gown\", \"grand piano\", \"greenhouse\", \"radiator grille\", \"grocery store\", \"guillotine\", \"hair clip\", \"hair spray\", \"half-track\", \"hammer\", \"hamper\", \"hair dryer\", \"hand-held computer\", \"handkerchief\", \"hard disk drive\", \"harmonica\", \"harp\", \"combine harvester\", \"hatchet\", \"holster\", \"home theater\", \"honeycomb\", \"hook\", \"hoop skirt\", \"gymnastic horizontal bar\", \"horse-drawn vehicle\", \"hourglass\", \"iPod\", \"clothes iron\", \"carved pumpkin\", \"jeans\", \"jeep\", \"T-shirt\", \"jigsaw puzzle\", \"rickshaw\", \"joystick\", \"kimono\", \"knee pad\", \"knot\", \"lab coat\", \"ladle\", \"lampshade\", \"laptop computer\", \"lawn mower\", \"lens cap\", \"letter opener\", \"library\", \"lifeboat\", \"lighter\", \"limousine\", \"ocean liner\", \"lipstick\", \"slip-on shoe\", \"lotion\", \"music speaker\", \"loupe magnifying glass\", \"sawmill\", \"magnetic compass\", \"messenger bag\", \"mailbox\", \"tights\", \"one-piece bathing suit\", \"manhole cover\", \"maraca\", \"marimba\", \"mask\", \"matchstick\", \"maypole\", \"maze\", \"measuring cup\", \"medicine cabinet\", \"megalith\", \"microphone\", \"microwave oven\", \"military uniform\", \"milk can\", \"minibus\", \"miniskirt\", \"minivan\", \"missile\", \"mitten\", \"mixing bowl\", \"mobile home\", \"ford model t\", \"modem\", \"monastery\", \"monitor\", \"moped\", \"mortar and pestle\", \"graduation cap\", \"mosque\", \"mosquito net\", \"vespa\", \"mountain bike\", \"tent\", \"computer mouse\", \"mousetrap\", \"moving van\", \"muzzle\", \"metal nail\", \"neck brace\", \"necklace\", \"baby pacifier\", \"notebook computer\", \"obelisk\", \"oboe\", \"ocarina\", \"odometer\", \"oil filter\", \"pipe organ\", \"oscilloscope\", \"overskirt\", \"bullock cart\", \"oxygen mask\", \"product packet / packaging\", \"paddle\", \"paddle wheel\", \"padlock\", \"paintbrush\", \"pajamas\", \"palace\", \"pan flute\", \"paper towel\", \"parachute\", \"parallel bars\", \"park bench\", \"parking meter\", \"railroad car\", \"patio\", \"payphone\", \"pedestal\", \"pencil case\", \"pencil sharpener\", \"perfume\", \"Petri dish\", \"photocopier\", \"plectrum\", \"Pickelhaube\", \"picket fence\", \"pickup truck\", \"pier\", \"piggy bank\", \"pill bottle\", \"pillow\", \"ping-pong ball\", \"pinwheel\", \"pirate ship\", \"drink pitcher\", \"block plane\", \"planetarium\", \"plastic bag\", \"plate rack\", \"farm plow\", \"plunger\", \"Polaroid camera\", \"pole\", \"police van\", \"poncho\", \"pool table\", \"soda bottle\", \"plant pot\", \"potter's wheel\", \"power drill\", \"prayer rug\", \"printer\", \"prison\", \"missile\", \"projector\", \"hockey puck\", \"punching bag\", \"purse\", \"quill\", \"quilt\", \"race car\", \"racket\", \"radiator\", \"radio\", \"radio telescope\", \"rain barrel\", \"recreational vehicle\", \"fishing casting reel\", \"reflex camera\", \"refrigerator\", \"remote control\", \"restaurant\", \"revolver\", \"rifle\", \"rocking chair\", \"rotisserie\", \"eraser\", \"rugby ball\", \"ruler measuring stick\", \"sneaker\", \"safe\", \"safety pin\", \"salt shaker\", \"sandal\", \"sarong\", \"saxophone\", \"scabbard\", \"weighing scale\", \"school bus\", \"schooner\", \"scoreboard\", \"CRT monitor\", \"screw\", \"screwdriver\", \"seat belt\", \"sewing machine\", \"shield\", \"shoe store\", \"shoji screen / room divider\", \"shopping basket\", \"shopping cart\", \"shovel\", \"shower cap\", \"shower curtain\", \"ski\", \"balaclava ski mask\", \"sleeping bag\", \"slide rule\", \"sliding door\", \"slot machine\", \"snorkel\", \"snowmobile\", \"snowplow\", \"soap dispenser\", \"soccer ball\", \"sock\", \"solar thermal collector\", \"sombrero\", \"soup bowl\", \"keyboard space bar\", \"space heater\", \"space shuttle\", \"spatula\", \"motorboat\", \"spider web\", \"spindle\", \"sports car\", \"spotlight\", \"stage\", \"steam locomotive\", \"through arch bridge\", \"steel drum\", \"stethoscope\", \"scarf\", \"stone wall\", \"stopwatch\", \"stove\", \"strainer\", \"tram\", \"stretcher\", \"couch\", \"stupa\", \"submarine\", \"suit\", \"sundial\", \"sunglasses\", \"sunglasses\", \"sunscreen\", \"suspension bridge\", \"mop\", \"sweatshirt\", \"swim trunks / shorts\", \"swing\", \"electrical switch\", \"syringe\", \"table lamp\", \"tank\", \"tape player\", \"teapot\", \"teddy bear\", \"television\", \"tennis ball\", \"thatched roof\", \"front curtain\", \"thimble\", \"threshing machine\", \"throne\", \"tile roof\", \"toaster\", \"tobacco shop\", \"toilet seat\", \"torch\", \"totem pole\", \"tow truck\", \"toy store\", \"tractor\", \"semi-trailer truck\", \"tray\", \"trench coat\", \"tricycle\", \"trimaran\", \"tripod\", \"triumphal arch\", \"trolleybus\", \"trombone\", \"hot tub\", \"turnstile\", \"typewriter keyboard\", \"umbrella\", \"unicycle\", \"upright piano\", \"vacuum cleaner\", \"vase\", \"vaulted or arched ceiling\", \"velvet fabric\", \"vending machine\", \"vestment\", \"viaduct\", \"violin\", \"volleyball\", \"waffle iron\", \"wall clock\", \"wallet\", \"wardrobe\", \"military aircraft\", \"sink\", \"washing machine\", \"water bottle\", \"water jug\", \"water tower\", \"whiskey jug\", \"whistle\", \"hair wig\", \"window screen\", \"window shade\", \"Windsor tie\", \"wine bottle\", \"airplane wing\", \"wok\", \"wooden spoon\", \"wool\", \"split-rail fence\", \"shipwreck\", \"sailboat\", \"yurt\", \"website\", \"comic book\", \"crossword\", \"traffic or street sign\", \"traffic light\", \"dust jacket\", \"menu\", \"plate\", \"guacamole\", \"consomme\", \"hot pot\", \"trifle\", \"ice cream\", \"popsicle\", \"baguette\", \"bagel\", \"pretzel\", \"cheeseburger\", \"hot dog\", \"mashed potatoes\", \"cabbage\", \"broccoli\", \"cauliflower\", \"zucchini\", \"spaghetti squash\", \"acorn squash\", \"butternut squash\", \"cucumber\", \"artichoke\", \"bell pepper\", \"cardoon\", \"mushroom\", \"Granny Smith apple\", \"strawberry\", \"orange\", \"lemon\", \"fig\", \"pineapple\", \"banana\", \"jackfruit\", \"cherimoya (custard apple)\", \"pomegranate\", \"hay\", \"carbonara\", \"chocolate syrup\", \"dough\", \"meatloaf\", \"pizza\", \"pot pie\", \"burrito\", \"red wine\", \"espresso\", \"tea cup\", \"eggnog\", \"mountain\", \"bubble\", \"cliff\", \"coral reef\", \"geyser\", \"lakeshore\", \"promontory\", \"sandbar\", \"beach\", \"valley\", \"volcano\", \"baseball player\", \"bridegroom\", \"scuba diver\", \"rapeseed\", \"daisy\", \"yellow lady's slipper\", \"corn\", \"acorn\", \"rose hip\", \"horse chestnut seed\", \"coral fungus\", \"agaric\", \"gyromitra\", \"stinkhorn mushroom\", \"earth star fungus\", \"hen of the woods mushroom\", \"bolete\", \"corn cob\", \"toilet paper\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e077342", + "metadata": {}, + "outputs": [], + "source": [ + "# The following comes from here: https://github.com/mlfoundations/open_clip/blob/main/src/open_clip/zero_shot_metadata.py\n", + "# Original reference: https://github.com/openai/CLIP/blob/main/notebooks/Prompt_Engineering_for_ImageNet.ipynb\n", + "openai_imagenet_templates = (\n", + " lambda c: f\"a bad photo of a {c}.\",\n", + " lambda c: f\"a photo of many {c}.\",\n", + " lambda c: f\"a sculpture of a {c}.\",\n", + " lambda c: f\"a photo of the hard to see {c}.\",\n", + " lambda c: f\"a low resolution photo of the {c}.\",\n", + " lambda c: f\"a rendering of a {c}.\",\n", + " lambda c: f\"graffiti of a {c}.\",\n", + " lambda c: f\"a bad photo of the {c}.\",\n", + " lambda c: f\"a cropped photo of the {c}.\",\n", + " lambda c: f\"a tattoo of a {c}.\",\n", + " lambda c: f\"the embroidered {c}.\",\n", + " lambda c: f\"a photo of a hard to see {c}.\",\n", + " lambda c: f\"a bright photo of a {c}.\",\n", + " lambda c: f\"a photo of a clean {c}.\",\n", + " lambda c: f\"a photo of a dirty {c}.\",\n", + " lambda c: f\"a dark photo of the {c}.\",\n", + " lambda c: f\"a drawing of a {c}.\",\n", + " lambda c: f\"a photo of my {c}.\",\n", + " lambda c: f\"the plastic {c}.\",\n", + " lambda c: f\"a photo of the cool {c}.\",\n", + " lambda c: f\"a close-up photo of a {c}.\",\n", + " lambda c: f\"a black and white photo of the {c}.\",\n", + " lambda c: f\"a painting of the {c}.\",\n", + " lambda c: f\"a painting of a {c}.\",\n", + " lambda c: f\"a pixelated photo of the {c}.\",\n", + " lambda c: f\"a sculpture of the {c}.\",\n", + " lambda c: f\"a bright photo of the {c}.\",\n", + " lambda c: f\"a cropped photo of a {c}.\",\n", + " lambda c: f\"a plastic {c}.\",\n", + " lambda c: f\"a photo of the dirty {c}.\",\n", + " lambda c: f\"a jpeg corrupted photo of a {c}.\",\n", + " lambda c: f\"a blurry photo of the {c}.\",\n", + " lambda c: f\"a photo of the {c}.\",\n", + " lambda c: f\"a good photo of the {c}.\",\n", + " lambda c: f\"a rendering of the {c}.\",\n", + " lambda c: f\"a {c} in a video game.\",\n", + " lambda c: f\"a photo of one {c}.\",\n", + " lambda c: f\"a doodle of a {c}.\",\n", + " lambda c: f\"a close-up photo of the {c}.\",\n", + " lambda c: f\"a photo of a {c}.\",\n", + " lambda c: f\"the origami {c}.\",\n", + " lambda c: f\"the {c} in a video game.\",\n", + " lambda c: f\"a sketch of a {c}.\",\n", + " lambda c: f\"a doodle of the {c}.\",\n", + " lambda c: f\"a origami {c}.\",\n", + " lambda c: f\"a low resolution photo of a {c}.\",\n", + " lambda c: f\"the toy {c}.\",\n", + " lambda c: f\"a rendition of the {c}.\",\n", + " lambda c: f\"a photo of the clean {c}.\",\n", + " lambda c: f\"a photo of a large {c}.\",\n", + " lambda c: f\"a rendition of a {c}.\",\n", + " lambda c: f\"a photo of a nice {c}.\",\n", + " lambda c: f\"a photo of a weird {c}.\",\n", + " lambda c: f\"a blurry photo of a {c}.\",\n", + " lambda c: f\"a cartoon {c}.\",\n", + " lambda c: f\"art of a {c}.\",\n", + " lambda c: f\"a sketch of the {c}.\",\n", + " lambda c: f\"a embroidered {c}.\",\n", + " lambda c: f\"a pixelated photo of a {c}.\",\n", + " lambda c: f\"itap of the {c}.\",\n", + " lambda c: f\"a jpeg corrupted photo of the {c}.\",\n", + " lambda c: f\"a good photo of a {c}.\",\n", + " lambda c: f\"a plushie {c}.\",\n", + " lambda c: f\"a photo of the nice {c}.\",\n", + " lambda c: f\"a photo of the small {c}.\",\n", + " lambda c: f\"a photo of the weird {c}.\",\n", + " lambda c: f\"the cartoon {c}.\",\n", + " lambda c: f\"art of the {c}.\",\n", + " lambda c: f\"a drawing of the {c}.\",\n", + " lambda c: f\"a photo of the large {c}.\",\n", + " lambda c: f\"a black and white photo of a {c}.\",\n", + " lambda c: f\"the plushie {c}.\",\n", + " lambda c: f\"a dark photo of a {c}.\",\n", + " lambda c: f\"itap of a {c}.\",\n", + " lambda c: f\"graffiti of the {c}.\",\n", + " lambda c: f\"a toy {c}.\",\n", + " lambda c: f\"itap of my {c}.\",\n", + " lambda c: f\"a photo of a cool {c}.\",\n", + " lambda c: f\"a photo of a small {c}.\",\n", + " lambda c: f\"a tattoo of the {c}.\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c080a969", + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision.datasets import ImageFolder\n", + "# Please update the following directory to the root of ImageNet1k val dataset.\n", + "imagenet_val_root_dir = \"\"\n", + "val_dataset = ImageFolder(imagenet_val_root_dir, image_preprocess)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0cc1d9d9", + "metadata": {}, + "outputs": [], + "source": [ + "def zeroshot_classifier(classnames, templates, tokenizer):\n", + " with torch.no_grad():\n", + " zeroshot_weights = []\n", + " for classname in classnames:\n", + " texts = [template(classname) for template in templates] #format with class\n", + " texts = tokenizer.tokenize(texts).cuda() #tokenize\n", + " class_embeddings = model.encode_text(texts) #embed with text encoder\n", + " class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)\n", + " class_embedding = class_embeddings.mean(dim=0)\n", + " class_embedding /= class_embedding.norm()\n", + " zeroshot_weights.append(class_embedding)\n", + " zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()\n", + " return zeroshot_weights\n", + "zeroshot_weights = zeroshot_classifier(imagenet_clip_class_names, openai_imagenet_templates, tokenizer)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7e3523e", + "metadata": {}, + "outputs": [], + "source": [ + "class_name_to_ids = {class_name:idx for idx, class_name in enumerate(imagenet_clip_class_names)}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eef6c047", + "metadata": {}, + "outputs": [], + "source": [ + "def accuracy(output, target, topk=(1,)):\n", + " pred = output.topk(max(topk), 1, True, True)[1].t()\n", + " correct = pred.eq(target.view(1, -1).expand_as(pred))\n", + " return [correct[:k].reshape(-1).sum(0, keepdim=True) for k in topk]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d2a9ff8", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.notebook import tqdm\n", + "\n", + "images = []\n", + "class_ids = []\n", + "batch_size = 64\n", + "num_workers = 8\n", + "top1, top5, n = 0., 0., 0.\n", + "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True)\n", + "for images, targets in tqdm(val_loader):\n", + " with torch.autocast('cuda', dtype=torch.float):\n", + " with torch.no_grad():\n", + " image_features = model.encode_image(images.cuda())\n", + " image_features /= image_features.norm(dim=-1, keepdim=True)\n", + " logits = 100. * image_features @ zeroshot_weights\n", + " acc1, acc5 = accuracy(logits, targets.cuda(), topk=(1, 5))\n", + " top1 += acc1\n", + " top5 += acc5\n", + " n += len(images)\n", + " images = []\n", + " class_ids = []\n", + "top1 = (top1.item() / n) * 100\n", + "top5 = (top5.item() / n) * 100 \n", + "print(f\"Top-1 accuracy: {top1}\")\n", + "print(f\"Top-5 accuracy: {top5}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fairvit-py311-ptnightly-xformers-20250129", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/torch_cache/facebookresearch_dinov2_main/notebooks/semantic_segmentation.ipynb b/torch_cache/facebookresearch_dinov2_main/notebooks/semantic_segmentation.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b1431632049f873b21b7a946c35815e7c609a131 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/notebooks/semantic_segmentation.ipynb @@ -0,0 +1,1476 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b470389d-a897-416e-9601-aeacb39cd694", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) Meta Platforms, Inc. and affiliates." + ] + }, + { + "cell_type": "markdown", + "id": "eb5c8577-7dff-41b1-9b04-2dca12940e02", + "metadata": {}, + "source": [ + "# Semantic Segmentation \"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "febdf412-5ad0-4bbc-9530-754f92dcc491", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "INSTALL = False # Switch this to install dependencies\n", + "if INSTALL: # Try installing package with extras\n", + " REPO_URL = \"https://github.com/facebookresearch/dinov2\"\n", + " !{sys.executable} -m pip install -e {REPO_URL}'[extras]' --extra-index-url https://download.pytorch.org/whl/cu117 --extra-index-url https://pypi.nvidia.com\n", + "else:\n", + " REPO_PATH = \"\" # Specify a local path to the repository (or use installed package instead)\n", + " sys.path.append(REPO_PATH)" + ] + }, + { + "cell_type": "markdown", + "id": "efdf378b-0591-4879-9db6-6a4ab582d49f", + "metadata": {}, + "source": [ + "## Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "90223c04-e7da-4738-bb16-d4f7025aa3eb", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import itertools\n", + "from functools import partial\n", + "\n", + "import torch\n", + "import torch.nn.functional as F\n", + "from mmseg.apis import init_segmentor, inference_segmentor\n", + "\n", + "import dinov2.eval.segmentation.models\n", + "\n", + "\n", + "class CenterPadding(torch.nn.Module):\n", + " def __init__(self, multiple):\n", + " super().__init__()\n", + " self.multiple = multiple\n", + "\n", + " def _get_pad(self, size):\n", + " new_size = math.ceil(size / self.multiple) * self.multiple\n", + " pad_size = new_size - size\n", + " pad_size_left = pad_size // 2\n", + " pad_size_right = pad_size - pad_size_left\n", + " return pad_size_left, pad_size_right\n", + "\n", + " @torch.inference_mode()\n", + " def forward(self, x):\n", + " pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1]))\n", + " output = F.pad(x, pads)\n", + " return output\n", + "\n", + "\n", + "def create_segmenter(cfg, backbone_model):\n", + " model = init_segmentor(cfg)\n", + " model.backbone.forward = partial(\n", + " backbone_model.get_intermediate_layers,\n", + " n=cfg.model.backbone.out_indices,\n", + " reshape=True,\n", + " )\n", + " if hasattr(backbone_model, \"patch_size\"):\n", + " model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone_model.patch_size)(x[0]))\n", + " model.init_weights()\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "id": "a5724efc-b2b8-46ed-94e1-7fee59a39ed9", + "metadata": {}, + "source": [ + "## Load pretrained backbone" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2d51b932-1157-45ce-997f-572ad417a12f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /private/home/plabatut/.cache/torch/hub/facebookresearch_dinov2_main\n", + "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/layers/swiglu_ffn.py:43: UserWarning: xFormers is available (SwiGLU)\n", + " warnings.warn(\"xFormers is available (SwiGLU)\")\n", + "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/layers/attention.py:27: UserWarning: xFormers is available (Attention)\n", + " warnings.warn(\"xFormers is available (Attention)\")\n", + "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/layers/block.py:33: UserWarning: xFormers is available (Block)\n", + " warnings.warn(\"xFormers is available (Block)\")\n" + ] + }, + { + "data": { + "text/plain": [ + "DinoVisionTransformer(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 384, kernel_size=(14, 14), stride=(14, 14))\n", + " (norm): Identity()\n", + " )\n", + " (blocks): ModuleList(\n", + " (0-11): 12 x NestedTensorBlock(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MemEffAttention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ls1): LayerScale()\n", + " (drop_path1): Identity()\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ls2): LayerScale()\n", + " (drop_path2): Identity()\n", + " )\n", + " )\n", + " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (head): Identity()\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "BACKBONE_SIZE = \"small\" # in (\"small\", \"base\", \"large\" or \"giant\")\n", + "\n", + "\n", + "backbone_archs = {\n", + " \"small\": \"vits14\",\n", + " \"base\": \"vitb14\",\n", + " \"large\": \"vitl14\",\n", + " \"giant\": \"vitg14\",\n", + "}\n", + "backbone_arch = backbone_archs[BACKBONE_SIZE]\n", + "backbone_name = f\"dinov2_{backbone_arch}\"\n", + "\n", + "backbone_model = torch.hub.load(repo_or_dir=\"facebookresearch/dinov2\", model=backbone_name)\n", + "backbone_model.eval()\n", + "backbone_model.cuda()" + ] + }, + { + "cell_type": "markdown", + "id": "c1c90501-d6ef-436e-b1a1-72e63b0534e3", + "metadata": {}, + "source": [ + "## Load pretrained segmentation head" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0bf0b7f-ad98-4cfb-8120-f076df8f8933", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/private/home/plabatut/.conda/envs/dinov2-extras-conda/lib/python3.9/site-packages/mmseg/models/losses/cross_entropy_loss.py:235: UserWarning: Default ``avg_non_ignore`` is False, if you would like to ignore the certain label and average loss over non-ignore labels, which is the same with PyTorch official cross_entropy, set ``avg_non_ignore=True``.\n", + " warnings.warn(\n", + "2023-08-31 06:29:03,743 - mmcv - INFO - initialize BNHead with init_cfg {'type': 'Normal', 'std': 0.01, 'override': {'name': 'conv_seg'}}\n", + "2023-08-31 06:29:03,744 - mmcv - INFO - \n", + "decode_head.conv_seg.weight - torch.Size([21, 1536, 1, 1]): \n", + "NormalInit: mean=0, std=0.01, bias=0 \n", + " \n", + "2023-08-31 06:29:03,745 - mmcv - INFO - \n", + "decode_head.conv_seg.bias - torch.Size([21]): \n", + "NormalInit: mean=0, std=0.01, bias=0 \n", + " \n", + "2023-08-31 06:29:03,745 - mmcv - INFO - \n", + "decode_head.bn.weight - torch.Size([1536]): \n", + "The value is the same before and after calling `init_weights` of EncoderDecoder \n", + " \n", + "2023-08-31 06:29:03,746 - mmcv - INFO - \n", + "decode_head.bn.bias - torch.Size([1536]): \n", + "The value is the same before and after calling `init_weights` of EncoderDecoder \n", + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "scales: [1.0, 1.32, 1.73]\n", + "load checkpoint from http path: https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_voc2012_ms_head.pth\n" + ] + }, + { + "data": { + "text/plain": [ + "EncoderDecoder(\n", + " (backbone): DinoVisionTransformer()\n", + " (decode_head): BNHead(\n", + " input_transform=resize_concat, ignore_index=255, align_corners=False\n", + " (loss_decode): CrossEntropyLoss(avg_non_ignore=False)\n", + " (conv_seg): Conv2d(1536, 21, kernel_size=(1, 1), stride=(1, 1))\n", + " (bn): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " init_cfg={'type': 'Normal', 'std': 0.01, 'override': {'name': 'conv_seg'}}\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import urllib\n", + "\n", + "import mmcv\n", + "from mmcv.runner import load_checkpoint\n", + "\n", + "\n", + "def load_config_from_url(url: str) -> str:\n", + " with urllib.request.urlopen(url) as f:\n", + " return f.read().decode()\n", + "\n", + "\n", + "HEAD_SCALE_COUNT = 3 # more scales: slower but better results, in (1,2,3,4,5)\n", + "HEAD_DATASET = \"voc2012\" # in (\"ade20k\", \"voc2012\")\n", + "HEAD_TYPE = \"ms\" # in (\"ms, \"linear\")\n", + "\n", + "\n", + "DINOV2_BASE_URL = \"https://dl.fbaipublicfiles.com/dinov2\"\n", + "head_config_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_config.py\"\n", + "head_checkpoint_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_head.pth\"\n", + "\n", + "cfg_str = load_config_from_url(head_config_url)\n", + "cfg = mmcv.Config.fromstring(cfg_str, file_format=\".py\")\n", + "if HEAD_TYPE == \"ms\":\n", + " cfg.data.test.pipeline[1][\"img_ratios\"] = cfg.data.test.pipeline[1][\"img_ratios\"][:HEAD_SCALE_COUNT]\n", + " print(\"scales:\", cfg.data.test.pipeline[1][\"img_ratios\"])\n", + "\n", + "model = create_segmenter(cfg, backbone_model=backbone_model)\n", + "load_checkpoint(model, head_checkpoint_url, map_location=\"cpu\")\n", + "model.cuda()\n", + "model.eval()" + ] + }, + { + "cell_type": "markdown", + "id": "2dc1b106-d28c-41cc-9ddd-f558d66a4715", + "metadata": {}, + "source": [ + "## Load sample image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "44511634-8243-4662-a512-4531014adb32", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import urllib\n", + "\n", + "from PIL import Image\n", + "\n", + "\n", + "def load_image_from_url(url: str) -> Image:\n", + " with urllib.request.urlopen(url) as f:\n", + " return Image.open(f).convert(\"RGB\")\n", + "\n", + "\n", + "EXAMPLE_IMAGE_URL = \"https://dl.fbaipublicfiles.com/dinov2/images/example.jpg\"\n", + "\n", + "\n", + "image = load_image_from_url(EXAMPLE_IMAGE_URL)\n", + "display(image)" + ] + }, + { + "cell_type": "markdown", + "id": "7e3240cb-54d0-438d-99e8-8c1af534f830", + "metadata": {}, + "source": [ + "## Semantic segmentation on sample image" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "49226d5b-83fc-4cfb-ba06-407bb2c0d96f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "import dinov2.eval.segmentation.utils.colormaps as colormaps\n", + "\n", + "\n", + "DATASET_COLORMAPS = {\n", + " \"ade20k\": colormaps.ADE20K_COLORMAP,\n", + " \"voc2012\": colormaps.VOC2012_COLORMAP,\n", + "}\n", + "\n", + "\n", + "def render_segmentation(segmentation_logits, dataset):\n", + " colormap = DATASET_COLORMAPS[dataset]\n", + " colormap_array = np.array(colormap, dtype=np.uint8)\n", + " segmentation_values = colormap_array[segmentation_logits + 1]\n", + " return Image.fromarray(segmentation_values)\n", + "\n", + "\n", + "array = np.array(image)[:, :, ::-1] # BGR\n", + "segmentation_logits = inference_segmentor(model, array)[0]\n", + "segmented_image = render_segmentation(segmentation_logits, HEAD_DATASET)\n", + "display(segmented_image)" + ] + }, + { + "cell_type": "markdown", + "id": "de40012e-a01e-4e73-bb71-3048f16d41c8", + "metadata": {}, + "source": [ + "## Load pretrained segmentation model (Mask2Former)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ff2cbbbe-c53c-4e5b-977f-c2a7d93f4b8c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py:222: UserWarning: Default ``avg_non_ignore`` is False, if you would like to ignore the certain label and average loss over non-ignore labels, which is the same with PyTorch official cross_entropy, set ``avg_non_ignore=True``.\n", + " warnings.warn(\n", + "/private/home/plabatut/.conda/envs/dinov2-extras-conda/lib/python3.9/site-packages/mmcv/ops/multi_scale_deform_attn.py:209: UserWarning: You'd better set embed_dims in MultiScaleDeformAttention to make the dimension of each attention head a power of 2 which is more efficient in our CUDA implementation.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "load checkpoint from http path: https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_ade20k_m2f.pth\n" + ] + }, + { + "data": { + "text/plain": [ + "EncoderDecoderMask2Former(\n", + " (backbone): ViTAdapter(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 1536, kernel_size=(14, 14), stride=(14, 14))\n", + " (norm): Identity()\n", + " )\n", + " (pos_drop): Dropout(p=0.0, inplace=False)\n", + " (blocks): Sequential(\n", + " (0): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (1): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (2): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (3): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (4): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (5): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (6): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (7): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (8): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (9): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (10): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (11): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (12): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (13): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (14): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (15): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (16): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (17): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (18): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (19): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (20): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (21): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (22): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (23): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (24): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (25): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (26): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (27): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (28): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (29): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (30): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (31): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (32): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (33): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (34): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (35): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (36): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (37): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (38): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (39): Block(\n", + " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath()\n", + " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): SwiGLUFFN(\n", + " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n", + " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " )\n", + " (norm_pre): Identity()\n", + " (spm): SpatialPriorModule(\n", + " (stem): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (4): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): ReLU(inplace=True)\n", + " (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (7): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv2): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (conv3): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (conv4): Sequential(\n", + " (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fc1): Conv2d(64, 1536, kernel_size=(1, 1), stride=(1, 1))\n", + " (fc2): Conv2d(128, 1536, kernel_size=(1, 1), stride=(1, 1))\n", + " (fc3): Conv2d(256, 1536, kernel_size=(1, 1), stride=(1, 1))\n", + " (fc4): Conv2d(256, 1536, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (interactions): Sequential(\n", + " (0): InteractionBlockWithCls(\n", + " (injector): Injector(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (extractor): Extractor(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " (ffn): ConvFFN(\n", + " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dwconv): DWConv(\n", + " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n", + " )\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (drop_path): DropPath()\n", + " )\n", + " )\n", + " (1): InteractionBlockWithCls(\n", + " (injector): Injector(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (extractor): Extractor(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " (ffn): ConvFFN(\n", + " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dwconv): DWConv(\n", + " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n", + " )\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (drop_path): DropPath()\n", + " )\n", + " )\n", + " (2): InteractionBlockWithCls(\n", + " (injector): Injector(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (extractor): Extractor(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " (ffn): ConvFFN(\n", + " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dwconv): DWConv(\n", + " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n", + " )\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (drop_path): DropPath()\n", + " )\n", + " )\n", + " (3): InteractionBlockWithCls(\n", + " (injector): Injector(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (extractor): Extractor(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " (ffn): ConvFFN(\n", + " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dwconv): DWConv(\n", + " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n", + " )\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (drop_path): DropPath()\n", + " )\n", + " (extra_extractors): Sequential(\n", + " (0): Extractor(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " (ffn): ConvFFN(\n", + " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dwconv): DWConv(\n", + " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n", + " )\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (drop_path): DropPath()\n", + " )\n", + " (1): Extractor(\n", + " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n", + " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n", + " )\n", + " (ffn): ConvFFN(\n", + " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dwconv): DWConv(\n", + " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n", + " )\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n", + " (drop_path): DropPath()\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (up): ConvTranspose2d(1536, 1536, kernel_size=(2, 2), stride=(2, 2))\n", + " (norm1): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (norm2): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (norm3): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (norm4): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (decode_head): Mask2FormerHead(\n", + " input_transform=multiple_select, ignore_index=255, align_corners=False\n", + " (loss_decode): CrossEntropyLoss(avg_non_ignore=False)\n", + " (conv_seg): None\n", + " (dropout): Dropout2d(p=0.1, inplace=False)\n", + " (pixel_decoder): MSDeformAttnPixelDecoder(\n", + " (input_convs): ModuleList(\n", + " (0-2): 3 x ConvModule(\n", + " (conv): Conv2d(1536, 1536, kernel_size=(1, 1), stride=(1, 1))\n", + " (gn): GroupNorm(32, 1536, eps=1e-05, affine=True)\n", + " )\n", + " )\n", + " (encoder): DetrTransformerEncoder(\n", + " (layers): ModuleList(\n", + " (0-5): 6 x BaseTransformerLayer(\n", + " (attentions): ModuleList(\n", + " (0): MultiScaleDeformableAttention(\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sampling_offsets): Linear(in_features=1536, out_features=768, bias=True)\n", + " (attention_weights): Linear(in_features=1536, out_features=384, bias=True)\n", + " (value_proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (output_proj): Linear(in_features=1536, out_features=1536, bias=True)\n", + " )\n", + " )\n", + " (ffns): ModuleList(\n", + " (0): FFN(\n", + " (activate): ReLU(inplace=True)\n", + " (layers): Sequential(\n", + " (0): Sequential(\n", + " (0): Linear(in_features=1536, out_features=6144, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): Linear(in_features=6144, out_features=1536, bias=True)\n", + " (2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (dropout_layer): Identity()\n", + " )\n", + " )\n", + " (norms): ModuleList(\n", + " (0-1): 2 x LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (postional_encoding): SinePositionalEncoding(num_feats=768, temperature=10000, normalize=True, scale=6.283185307179586, eps=1e-06)\n", + " (level_encoding): Embedding(3, 1536)\n", + " (lateral_convs): ModuleList(\n", + " (0): ConvModule(\n", + " (conv): Conv2d(1536, 1536, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn): GroupNorm(32, 1536, eps=1e-05, affine=True)\n", + " )\n", + " )\n", + " (output_convs): ModuleList(\n", + " (0): ConvModule(\n", + " (conv): Conv2d(1536, 1536, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn): GroupNorm(32, 1536, eps=1e-05, affine=True)\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (mask_feature): Conv2d(1536, 1536, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (transformer_decoder): DetrTransformerDecoder(\n", + " (layers): ModuleList(\n", + " (0-8): 9 x DetrTransformerDecoderLayer(\n", + " (attentions): ModuleList(\n", + " (0-1): 2 x MultiheadAttention(\n", + " (attn): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=1536, out_features=1536, bias=True)\n", + " )\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (dropout_layer): Identity()\n", + " )\n", + " )\n", + " (ffns): ModuleList(\n", + " (0): FFN(\n", + " (activate): ReLU(inplace=True)\n", + " (layers): Sequential(\n", + " (0): Sequential(\n", + " (0): Linear(in_features=1536, out_features=6144, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): Linear(in_features=6144, out_features=1536, bias=True)\n", + " (2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (dropout_layer): Identity()\n", + " )\n", + " )\n", + " (norms): ModuleList(\n", + " (0-2): 3 x LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " (post_norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (decoder_input_projs): ModuleList(\n", + " (0-2): 3 x Identity()\n", + " )\n", + " (decoder_positional_encoding): SinePositionalEncoding(num_feats=768, temperature=10000, normalize=True, scale=6.283185307179586, eps=1e-06)\n", + " (query_embed): Embedding(100, 1536)\n", + " (query_feat): Embedding(100, 1536)\n", + " (level_embed): Embedding(3, 1536)\n", + " (cls_embed): Linear(in_features=1536, out_features=151, bias=True)\n", + " (mask_embed): Sequential(\n", + " (0): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=1536, out_features=1536, bias=True)\n", + " (3): ReLU(inplace=True)\n", + " (4): Linear(in_features=1536, out_features=1536, bias=True)\n", + " )\n", + " (loss_cls): CrossEntropyLoss(avg_non_ignore=False)\n", + " (loss_mask): CrossEntropyLoss(avg_non_ignore=False)\n", + " (loss_dice): DiceLoss()\n", + " )\n", + ")" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import dinov2.eval.segmentation_m2f.models.segmentors\n", + "\n", + "CONFIG_URL = f\"{DINOV2_BASE_URL}/dinov2_vitg14/dinov2_vitg14_ade20k_m2f_config.py\"\n", + "CHECKPOINT_URL = f\"{DINOV2_BASE_URL}/dinov2_vitg14/dinov2_vitg14_ade20k_m2f.pth\"\n", + "\n", + "cfg_str = load_config_from_url(CONFIG_URL)\n", + "cfg = mmcv.Config.fromstring(cfg_str, file_format=\".py\")\n", + "\n", + "model = init_segmentor(cfg)\n", + "load_checkpoint(model, CHECKPOINT_URL, map_location=\"cpu\")\n", + "model.cuda()\n", + "model.eval()" + ] + }, + { + "cell_type": "markdown", + "id": "53c0309f-df2b-4912-bca5-e57d8b3875b3", + "metadata": {}, + "source": [ + "## Semantic segmentation on sample image" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f4abb13b-0e5a-4a40-8d44-21da4286ba7d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/private/home/plabatut/.conda/envs/dinov2-extras-conda/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1678402374358/work/aten/src/ATen/native/TensorShape.cpp:3483.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "array = np.array(image)[:, :, ::-1] # BGR\n", + "segmentation_logits = inference_segmentor(model, array)[0]\n", + "segmented_image = render_segmentation(segmentation_logits, \"ade20k\")\n", + "display(segmented_image)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/torch_cache/facebookresearch_dinov2_main/pyproject.toml b/torch_cache/facebookresearch_dinov2_main/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..b724ba5be524e4e43349b11ca37f0dc556aa005d --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/pyproject.toml @@ -0,0 +1,29 @@ +[tool.black] +line-length = 120 + +[tool.pylint.master] +persistent = false +score = false + +[tool.pylint.messages_control] +disable = "all" +enable = [ + "miscellaneous", + "similarities", +] + +[tool.pylint.similarities] +ignore-comments = true +ignore-docstrings = true +ignore-imports = true +min-similarity-lines = 8 + +[tool.pylint.reports] +reports = false + +[tool.pylint.miscellaneous] +notes = [ + "FIXME", + "XXX", + "TODO", +] diff --git a/torch_cache/facebookresearch_dinov2_main/requirements-dev.txt b/torch_cache/facebookresearch_dinov2_main/requirements-dev.txt new file mode 100644 index 0000000000000000000000000000000000000000..e8b34df6cedf2fea0d1103811471615c7b540f3e --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/requirements-dev.txt @@ -0,0 +1,3 @@ +black==22.6.0 +flake8==5.0.4 +pylint==2.15.0 diff --git a/torch_cache/facebookresearch_dinov2_main/requirements-extras.txt b/torch_cache/facebookresearch_dinov2_main/requirements-extras.txt new file mode 100644 index 0000000000000000000000000000000000000000..0dde94888e47d5e8eaec5754f55a214d3ca027cc --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/requirements-extras.txt @@ -0,0 +1,2 @@ +mmcv-full==1.5.0 +mmsegmentation==0.27.0 diff --git a/torch_cache/facebookresearch_dinov2_main/requirements.txt b/torch_cache/facebookresearch_dinov2_main/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f77a9677e9a102f6a8508276a154dfade5cd61be --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/requirements.txt @@ -0,0 +1,11 @@ +--extra-index-url https://download.pytorch.org/whl/cu117 +torch==2.0.0 +torchvision==0.15.0 +omegaconf +torchmetrics==0.10.3 +fvcore +iopath +xformers==0.0.18 +submitit +--extra-index-url https://pypi.nvidia.com +cuml-cu11 diff --git a/torch_cache/facebookresearch_dinov2_main/scripts/cell_dino/launcher_knn_eval_on_chammi.sh b/torch_cache/facebookresearch_dinov2_main/scripts/cell_dino/launcher_knn_eval_on_chammi.sh new file mode 100644 index 0000000000000000000000000000000000000000..192f5128a4249bd39d30d542f7d2aa14fa5cd237 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/scripts/cell_dino/launcher_knn_eval_on_chammi.sh @@ -0,0 +1,38 @@ +#!/bin/bash +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# 1 : modify CHANNEL_AGNOSTIC_CELL_MODEL, CHAMMI_DATA_PATH and OUTPUT_DIR below +# 2 : call this script with the two arguments specified below + +#Arguments: +# $1 : dataset, e.g CP +# $2 : task number, e.g TASK_TWO + +CHAMMI_DATA_PATH="" +CHANNEL_AGNOSTIC_CELL_MODEL="path_to_model/model.pth" +OUTPUT_DIR=YOUR_OUTPUT_PATH_$1_$2 + +if [ "$2" == "TASK_FOUR" ]; then + OTHER_ARG="--leave-one-out-dataset $CHAMMI_DATA_PATH/CP/enriched_meta.csv" +elif [ "$1" == "HPA" -a "$2" == "TASK_THREE" ]; then + OTHER_ARG="--leave-one-out-dataset $CHAMMI_DATA_PATH/CHAMMI/HPA/enriched_meta.csv" +else + OTHER_ARG="" +fi +echo $OTHER_ARG + +PYTHONPATH=..:../../dinov2/data python ../../dinov2/run/eval/cell_dino/knn.py \ +--config-file ../../dinov2/configs/eval/cell_dino/vitl16_channel_adaptive_pretrain.yaml \ +--pretrained-weights $CHANNEL_AGNOSTIC_CELL_MODEL \ +--output-dir $OUTPUT_DIR \ +--train-dataset CHAMMI_$1:split=TRAIN:root=$CHAMMI_DATA_PATH \ +--val-dataset CHAMMI_$1:split=$2:root=$CHAMMI_DATA_PATH \ +--metric-type mean_per_class_multiclass_f1 \ +--crop-size 224 \ +--batch-size 32 \ +--resize-size 256 \ +--bag-of-channels \ +$OTHER_ARG \ diff --git a/torch_cache/facebookresearch_dinov2_main/scripts/cell_dino/launcher_linear_eval_on_chammi.sh b/torch_cache/facebookresearch_dinov2_main/scripts/cell_dino/launcher_linear_eval_on_chammi.sh new file mode 100644 index 0000000000000000000000000000000000000000..20ca3c9179130eef14671c77167c34edbcb9a521 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/scripts/cell_dino/launcher_linear_eval_on_chammi.sh @@ -0,0 +1,44 @@ +#!/bin/bash +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# 1 : modify CHANNEL_AGNOSTIC_CELL_MODEL, CHAMMI_DATA_PATH and OUTPUT_DIR below +# 2 : call this script with the two arguments specified below + +#Arguments: +# $1 : dataset, e.g CP +# $2 : task number, e.g TASK_TWO + +CHAMMI_DATA_PATH="" +CHANNEL_AGNOSTIC_CELL_MODEL="path_to_model/model.pth" +OUTPUTDIR=YOUR_OUTPUT_PATH_$1_$2 + +if [ "$2" == "TASK_FOUR" ]; then + OTHER_ARG="--leave-one-out-dataset $CHAMMI_DATA_PATH/CP/enriched_meta.csv" +elif [ "$1" == "HPA" -a "$2" == "TASK_THREE" ]; then + OTHER_ARG="--leave-one-out-dataset $CHAMMI_DATA_PATH/HPA/enriched_meta.csv" +else + OTHER_ARG="" +fi + +if [ $1 != "CP" ]; then + OTHER_ARG="$OTHER_ARG --resize-size 256" +fi + +PYTHONPATH=..:../../dinov2/data python ../../dinov2/run/eval/cell_dino/linear.py \ +--config-file ../../dinov2/configs/eval/cell_dino/vitl16_channel_adaptive_pretrain.yaml \ +--pretrained-weights $CHANNEL_AGNOSTIC_CELL_MODEL \ +--output-dir $OUTPUTDIR \ +--train-dataset CHAMMI_$1:split=TRAIN:root=$CHAMMI_DATA_PATH \ +--val-dataset CHAMMI_$1:split=$2:root=$CHAMMI_DATA_PATH \ +--val-metric-type mean_per_class_multiclass_f1 \ +--bag-of-channels \ +--crop-size 224 \ +--n-last-blocks 1 \ +--avgpool \ +--batch-size 128 \ +--epoch-length 30 \ +--epochs 10 \ +$OTHER_ARG \ diff --git a/torch_cache/facebookresearch_dinov2_main/scripts/lint.sh b/torch_cache/facebookresearch_dinov2_main/scripts/lint.sh new file mode 100644 index 0000000000000000000000000000000000000000..1aa7e9e770b401d5156e72d8e09ed8f357411132 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/scripts/lint.sh @@ -0,0 +1,28 @@ +#!/bin/sh + +if [ -n "$1" ]; then + echo "linting \"$1\"" +fi + +echo "running black" +if [ -n "$1" ]; then + black "$1" +else + black dinov2 +fi + +echo "running flake8" +if [ -n "$1" ]; then + flake8 "$1" +else + flake8 +fi + +echo "running pylint" +if [ -n "$1" ]; then + pylint "$1" +else + pylint dinov2 +fi + +exit 0 diff --git a/torch_cache/facebookresearch_dinov2_main/setup.cfg b/torch_cache/facebookresearch_dinov2_main/setup.cfg new file mode 100644 index 0000000000000000000000000000000000000000..a1bca351ca3660135bca235752c05a5ff06554bb --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/setup.cfg @@ -0,0 +1,8 @@ +[flake8] +max-line-length = 120 +ignore = E203,E501,W503 +per-file-ignores = + __init__.py:F401 + hubconf.py:F401 +exclude = + venv diff --git a/torch_cache/facebookresearch_dinov2_main/setup.py b/torch_cache/facebookresearch_dinov2_main/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..72aceedbff532392dbf6e9374f7dccabdbfd7d56 --- /dev/null +++ b/torch_cache/facebookresearch_dinov2_main/setup.py @@ -0,0 +1,88 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from pathlib import Path +import re +from typing import List, Tuple + +from setuptools import setup, find_packages + + +NAME = "dinov2" +DESCRIPTION = "PyTorch code and models for the DINOv2 self-supervised learning method." + +URL = "https://github.com/facebookresearch/dinov2" +AUTHOR = "FAIR" +REQUIRES_PYTHON = ">=3.9.0" +HERE = Path(__file__).parent + + +try: + with open(HERE / "README.md", encoding="utf-8") as f: + long_description = "\n" + f.read() +except FileNotFoundError: + long_description = DESCRIPTION + + +def get_requirements(path: str = HERE / "requirements.txt") -> Tuple[List[str], List[str]]: + requirements = [] + extra_indices = [] + with open(path) as f: + for line in f.readlines(): + line = line.rstrip("\r\n") + if line.startswith("--extra-index-url "): + extra_indices.append(line[18:]) + continue + requirements.append(line) + return requirements, extra_indices + + +def get_package_version() -> str: + with open(HERE / "dinov2/__init__.py") as f: + result = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", f.read(), re.M) + if result: + return result.group(1) + raise RuntimeError("Can't get package version") + + +requirements, extra_indices = get_requirements() +version = get_package_version() +dev_requirements, _ = get_requirements(HERE / "requirements-dev.txt") +extras_requirements, _ = get_requirements(HERE / "requirements-extras.txt") + + +setup( + name=NAME, + version=version, + description=DESCRIPTION, + long_description=long_description, + long_description_content_type="text/markdown", + author=AUTHOR, + python_requires=REQUIRES_PYTHON, + url=URL, + packages=find_packages(), + package_data={ + "": ["*.yaml"], + }, + install_requires=requirements, + extras_require={ + "dev": dev_requirements, + "extras": extras_requirements, + }, + dependency_links=extra_indices, + install_package_data=True, + license="Apache", + license_files=("LICENSE",), + classifiers=[ + # Trove classifiers: https://github.com/pypa/trove-classifiers/blob/main/src/trove_classifiers/__init__.py + "Development Status :: 3 - Alpha", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: Apache Software License", + "Programming Language :: Python :: 3.9", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Software Development :: Libraries :: Python Modules", + ], +) diff --git a/torch_cache/trusted_list b/torch_cache/trusted_list new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391