diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..53aee21b9a286bf9d1904e9527c3f0b047f4f0ea 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,4 @@ 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 +*.mp4 filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..b1cb0f6c1091680de2adba6c89847113dfd38b4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +**/__pycache__/** +.DS_Store +gradio_cached_examples/** +*.png +*.jpeg \ No newline at end of file diff --git a/GroundingDINO/.gitignore b/GroundingDINO/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..fdc0e71e1652c8f8c4efadf08090f8c18974b230 --- /dev/null +++ b/GroundingDINO/.gitignore @@ -0,0 +1,146 @@ +# IDE +.idea/ +.vscode/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# vscode +.vscode/ +output/ +outputs/ +subs/ +logs/ + +grounding/config/configs +grounding/version.py + +vis/ +tmp/ \ No newline at end of file diff --git a/GroundingDINO/LICENSE b/GroundingDINO/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f1460f5e6ad1e90abb720a1536a46e3d057686a9 --- /dev/null +++ b/GroundingDINO/LICENSE @@ -0,0 +1,201 @@ + 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 2023 - present, IDEA Research. + + 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/GroundingDINO/README.md b/GroundingDINO/README.md new file mode 100644 index 0000000000000000000000000000000000000000..91c14ffdd136198b2d14d5a601ba766e2326d1a7 --- /dev/null +++ b/GroundingDINO/README.md @@ -0,0 +1,367 @@ +
+ +
+ +# :sauropod: Grounding DINO + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/zero-shot-object-detection-on-mscoco)](https://paperswithcode.com/sota/zero-shot-object-detection-on-mscoco?p=grounding-dino-marrying-dino-with-grounded) [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/zero-shot-object-detection-on-odinw)](https://paperswithcode.com/sota/zero-shot-object-detection-on-odinw?p=grounding-dino-marrying-dino-with-grounded) \ +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/object-detection-on-coco-minival)](https://paperswithcode.com/sota/object-detection-on-coco-minival?p=grounding-dino-marrying-dino-with-grounded) [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/object-detection-on-coco)](https://paperswithcode.com/sota/object-detection-on-coco?p=grounding-dino-marrying-dino-with-grounded) + + +**[IDEA-CVR, IDEA-Research](https://github.com/IDEA-Research)** + +[Shilong Liu](http://www.lsl.zone/), [Zhaoyang Zeng](https://scholar.google.com/citations?user=U_cvvUwAAAAJ&hl=zh-CN&oi=ao), [Tianhe Ren](https://rentainhe.github.io/), [Feng Li](https://scholar.google.com/citations?user=ybRe9GcAAAAJ&hl=zh-CN), [Hao Zhang](https://scholar.google.com/citations?user=B8hPxMQAAAAJ&hl=zh-CN), [Jie Yang](https://github.com/yangjie-cv), [Chunyuan Li](https://scholar.google.com/citations?user=Zd7WmXUAAAAJ&hl=zh-CN&oi=ao), [Jianwei Yang](https://jwyang.github.io/), [Hang Su](https://scholar.google.com/citations?hl=en&user=dxN1_X0AAAAJ&view_op=list_works&sortby=pubdate), [Jun Zhu](https://scholar.google.com/citations?hl=en&user=axsP38wAAAAJ), [Lei Zhang](https://www.leizhang.org/):email:. + + +[[`Paper`](https://arxiv.org/abs/2303.05499)] [[`Demo`](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)] [[`BibTex`](#black_nib-citation)] + + +PyTorch implementation and pretrained models for Grounding DINO. For details, see the paper **[Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection](https://arxiv.org/abs/2303.05499)**. + +## :sun_with_face: Helpful Tutorial + +- :grapes: [[Read our arXiv Paper](https://arxiv.org/abs/2303.05499)] +- :apple: [[Watch our simple introduction video on YouTube](https://youtu.be/wxWDt5UiwY8)] +- :blossom:  [[Try the Colab Demo](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb)] +- :sunflower: [[Try our Official Huggingface Demo](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)] +- :maple_leaf: [[Watch the Step by Step Tutorial about GroundingDINO by Roboflow AI](https://youtu.be/cMa77r3YrDk)] +- :mushroom: [[GroundingDINO: Automated Dataset Annotation and Evaluation by Roboflow AI](https://youtu.be/C4NqaRBz_Kw)] +- :hibiscus: [[Accelerate Image Annotation with SAM and GroundingDINO by Roboflow AI](https://youtu.be/oEQYStnF2l8)] +- :white_flower: [[Autodistill: Train YOLOv8 with ZERO Annotations based on Grounding-DINO and Grounded-SAM by Roboflow AI](https://github.com/autodistill/autodistill)] + + + + + + +## :sparkles: Highlight Projects + +- [Semantic-SAM: a universal image segmentation model to enable segment and recognize anything at any desired granularity.](https://github.com/UX-Decoder/Semantic-SAM), +- [DetGPT: Detect What You Need via Reasoning](https://github.com/OptimalScale/DetGPT) +- [Grounded-SAM: Marrying Grounding DINO with Segment Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything) +- [Grounding DINO with Stable Diffusion](demo/image_editing_with_groundingdino_stablediffusion.ipynb) +- [Grounding DINO with GLIGEN for Controllable Image Editing](demo/image_editing_with_groundingdino_gligen.ipynb) +- [OpenSeeD: A Simple and Strong Openset Segmentation Model](https://github.com/IDEA-Research/OpenSeeD) +- [SEEM: Segment Everything Everywhere All at Once](https://github.com/UX-Decoder/Segment-Everything-Everywhere-All-At-Once) +- [X-GPT: Conversational Visual Agent supported by X-Decoder](https://github.com/microsoft/X-Decoder/tree/xgpt) +- [GLIGEN: Open-Set Grounded Text-to-Image Generation](https://github.com/gligen/GLIGEN) +- [LLaVA: Large Language and Vision Assistant](https://github.com/haotian-liu/LLaVA) + + + + + + + + +## :bulb: Highlight + +- **Open-Set Detection.** Detect **everything** with language! +- **High Performancce.** COCO zero-shot **52.5 AP** (training without COCO data!). COCO fine-tune **63.0 AP**. +- **Flexible.** Collaboration with Stable Diffusion for Image Editting. + + + + +## :fire: News +- **`2023/07/18`**: We release [Semantic-SAM](https://github.com/UX-Decoder/Semantic-SAM), a universal image segmentation model to enable segment and recognize anything at any desired granularity. **Code** and **checkpoint** are available! +- **`2023/06/17`**: We provide an example to evaluate Grounding DINO on COCO zero-shot performance. +- **`2023/04/15`**: Refer to [CV in the Wild Readings](https://github.com/Computer-Vision-in-the-Wild/CVinW_Readings) for those who are interested in open-set recognition! +- **`2023/04/08`**: We release [demos](demo/image_editing_with_groundingdino_gligen.ipynb) to combine [Grounding DINO](https://arxiv.org/abs/2303.05499) with [GLIGEN](https://github.com/gligen/GLIGEN) for more controllable image editings. +- **`2023/04/08`**: We release [demos](demo/image_editing_with_groundingdino_stablediffusion.ipynb) to combine [Grounding DINO](https://arxiv.org/abs/2303.05499) with [Stable Diffusion](https://github.com/Stability-AI/StableDiffusion) for image editings. +- **`2023/04/06`**: We build a new demo by marrying GroundingDINO with [Segment-Anything](https://github.com/facebookresearch/segment-anything) named **[Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything)** aims to support segmentation in GroundingDINO. +- **`2023/03/28`**: A YouTube [video](https://youtu.be/cMa77r3YrDk) about Grounding DINO and basic object detection prompt engineering. [[SkalskiP](https://github.com/SkalskiP)] +- **`2023/03/28`**: Add a [demo](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo) on Hugging Face Space! +- **`2023/03/27`**: Support CPU-only mode. Now the model can run on machines without GPUs. +- **`2023/03/25`**: A [demo](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb) for Grounding DINO is available at Colab. [[SkalskiP](https://github.com/SkalskiP)] +- **`2023/03/22`**: Code is available Now! + +
+ +Description + + Paper introduction. +ODinW +Marrying Grounding DINO and GLIGEN +gd_gligen +
+ +## :star: Explanations/Tips for Grounding DINO Inputs and Outputs +- Grounding DINO accepts an `(image, text)` pair as inputs. +- It outputs `900` (by default) object boxes. Each box has similarity scores across all input words. (as shown in Figures below.) +- We defaultly choose the boxes whose highest similarities are higher than a `box_threshold`. +- We extract the words whose similarities are higher than the `text_threshold` as predicted labels. +- If you want to obtain objects of specific phrases, like the `dogs` in the sentence `two dogs with a stick.`, you can select the boxes with highest text similarities with `dogs` as final outputs. +- Note that each word can be split to **more than one** tokens with different tokenlizers. The number of words in a sentence may not equal to the number of text tokens. +- We suggest separating different category names with `.` for Grounding DINO. +![model_explain1](.asset/model_explan1.PNG) +![model_explain2](.asset/model_explan2.PNG) + +## :label: TODO + +- [x] Release inference code and demo. +- [x] Release checkpoints. +- [x] Grounding DINO with Stable Diffusion and GLIGEN demos. +- [ ] Release training codes. + +## :hammer_and_wrench: Install + +**Note:** + +0. If you have a CUDA environment, please make sure the environment variable `CUDA_HOME` is set. It will be compiled under CPU-only mode if no CUDA available. + +Please make sure following the installation steps strictly, otherwise the program may produce: +```bash +NameError: name '_C' is not defined +``` + +If this happened, please reinstalled the groundingDINO by reclone the git and do all the installation steps again. + +#### how to check cuda: +```bash +echo $CUDA_HOME +``` +If it print nothing, then it means you haven't set up the path/ + +Run this so the environment variable will be set under current shell. +```bash +export CUDA_HOME=/path/to/cuda-11.3 +``` + +Notice the version of cuda should be aligned with your CUDA runtime, for there might exists multiple cuda at the same time. + +If you want to set the CUDA_HOME permanently, store it using: + +```bash +echo 'export CUDA_HOME=/path/to/cuda' >> ~/.bashrc +``` +after that, source the bashrc file and check CUDA_HOME: +```bash +source ~/.bashrc +echo $CUDA_HOME +``` + +In this example, /path/to/cuda-11.3 should be replaced with the path where your CUDA toolkit is installed. You can find this by typing **which nvcc** in your terminal: + +For instance, +if the output is /usr/local/cuda/bin/nvcc, then: +```bash +export CUDA_HOME=/usr/local/cuda +``` +**Installation:** + +1.Clone the GroundingDINO repository from GitHub. + +```bash +git clone https://github.com/IDEA-Research/GroundingDINO.git +``` + +2. Change the current directory to the GroundingDINO folder. + +```bash +cd GroundingDINO/ +``` + +3. Install the required dependencies in the current directory. + +```bash +pip install -e . +``` + +4. Download pre-trained model weights. + +```bash +mkdir weights +cd weights +wget -q https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth +cd .. +``` + +## :arrow_forward: Demo +Check your GPU ID (only if you're using a GPU) + +```bash +nvidia-smi +``` +Replace `{GPU ID}`, `image_you_want_to_detect.jpg`, and `"dir you want to save the output"` with appropriate values in the following command +```bash +CUDA_VISIBLE_DEVICES={GPU ID} python demo/inference_on_a_image.py \ +-c groundingdino/config/GroundingDINO_SwinT_OGC.py \ +-p weights/groundingdino_swint_ogc.pth \ +-i image_you_want_to_detect.jpg \ +-o "dir you want to save the output" \ +-t "chair" + [--cpu-only] # open it for cpu mode +``` + +If you would like to specify the phrases to detect, here is a demo: +```bash +CUDA_VISIBLE_DEVICES={GPU ID} python demo/inference_on_a_image.py \ +-c groundingdino/config/GroundingDINO_SwinT_OGC.py \ +-p ./groundingdino_swint_ogc.pth \ +-i .asset/cat_dog.jpeg \ +-o logs/1111 \ +-t "There is a cat and a dog in the image ." \ +--token_spans "[[[9, 10], [11, 14]], [[19, 20], [21, 24]]]" + [--cpu-only] # open it for cpu mode +``` +The token_spans specify the start and end positions of a phrases. For example, the first phrase is `[[9, 10], [11, 14]]`. `"There is a cat and a dog in the image ."[9:10] = 'a'`, `"There is a cat and a dog in the image ."[11:14] = 'cat'`. Hence it refers to the phrase `a cat` . Similarly, the `[[19, 20], [21, 24]]` refers to the phrase `a dog`. + +See the `demo/inference_on_a_image.py` for more details. + +**Running with Python:** + +```python +from groundingdino.util.inference import load_model, load_image, predict, annotate +import cv2 + +model = load_model("groundingdino/config/GroundingDINO_SwinT_OGC.py", "weights/groundingdino_swint_ogc.pth") +IMAGE_PATH = "weights/dog-3.jpeg" +TEXT_PROMPT = "chair . person . dog ." +BOX_TRESHOLD = 0.35 +TEXT_TRESHOLD = 0.25 + +image_source, image = load_image(IMAGE_PATH) + +boxes, logits, phrases = predict( + model=model, + image=image, + caption=TEXT_PROMPT, + box_threshold=BOX_TRESHOLD, + text_threshold=TEXT_TRESHOLD +) + +annotated_frame = annotate(image_source=image_source, boxes=boxes, logits=logits, phrases=phrases) +cv2.imwrite("annotated_image.jpg", annotated_frame) +``` +**Web UI** + +We also provide a demo code to integrate Grounding DINO with Gradio Web UI. See the file `demo/gradio_app.py` for more details. + +**Notebooks** + +- We release [demos](demo/image_editing_with_groundingdino_gligen.ipynb) to combine [Grounding DINO](https://arxiv.org/abs/2303.05499) with [GLIGEN](https://github.com/gligen/GLIGEN) for more controllable image editings. +- We release [demos](demo/image_editing_with_groundingdino_stablediffusion.ipynb) to combine [Grounding DINO](https://arxiv.org/abs/2303.05499) with [Stable Diffusion](https://github.com/Stability-AI/StableDiffusion) for image editings. + +## COCO Zero-shot Evaluations + +We provide an example to evaluate Grounding DINO zero-shot performance on COCO. The results should be **48.5**. + +```bash +CUDA_VISIBLE_DEVICES=0 \ +python demo/test_ap_on_coco.py \ + -c groundingdino/config/GroundingDINO_SwinT_OGC.py \ + -p weights/groundingdino_swint_ogc.pth \ + --anno_path /path/to/annoataions/ie/instances_val2017.json \ + --image_dir /path/to/imagedir/ie/val2017 +``` + + +## :luggage: Checkpoints + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
namebackboneDatabox AP on COCOCheckpointConfig
1GroundingDINO-TSwin-TO365,GoldG,Cap4M48.4 (zero-shot) / 57.2 (fine-tune)GitHub link | HF linklink
2GroundingDINO-BSwin-BCOCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO56.7 GitHub link | HF link + link
+ +## :medal_military: Results + +
+ +COCO Object Detection Results + +COCO +
+ +
+ +ODinW Object Detection Results + +ODinW +
+ +
+ +Marrying Grounding DINO with Stable Diffusion for Image Editing + +See our example notebook for more details. +GD_SD +
+ + +
+ +Marrying Grounding DINO with GLIGEN for more Detailed Image Editing. + +See our example notebook for more details. +GD_GLIGEN +
+ +## :sauropod: Model: Grounding DINO + +Includes: a text backbone, an image backbone, a feature enhancer, a language-guided query selection, and a cross-modality decoder. + +![arch](.asset/arch.png) + + +## :hearts: Acknowledgement + +Our model is related to [DINO](https://github.com/IDEA-Research/DINO) and [GLIP](https://github.com/microsoft/GLIP). Thanks for their great work! + +We also thank great previous work including DETR, Deformable DETR, SMCA, Conditional DETR, Anchor DETR, Dynamic DETR, DAB-DETR, DN-DETR, etc. More related work are available at [Awesome Detection Transformer](https://github.com/IDEACVR/awesome-detection-transformer). A new toolbox [detrex](https://github.com/IDEA-Research/detrex) is available as well. + +Thanks [Stable Diffusion](https://github.com/Stability-AI/StableDiffusion) and [GLIGEN](https://github.com/gligen/GLIGEN) for their awesome models. + + +## :black_nib: Citation + +If you find our work helpful for your research, please consider citing the following BibTeX entry. + +```bibtex +@article{liu2023grounding, + title={Grounding dino: Marrying dino with grounded pre-training for open-set object detection}, + author={Liu, Shilong and Zeng, Zhaoyang and Ren, Tianhe and Li, Feng and Zhang, Hao and Yang, Jie and Li, Chunyuan and Yang, Jianwei and Su, Hang and Zhu, Jun and others}, + journal={arXiv preprint arXiv:2303.05499}, + year={2023} +} +``` + + + + diff --git a/GroundingDINO/demo/create_coco_dataset.py b/GroundingDINO/demo/create_coco_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..a0bb02a7e586d4fb4587635da545ff774f688f18 --- /dev/null +++ b/GroundingDINO/demo/create_coco_dataset.py @@ -0,0 +1,83 @@ +import typer +from groundingdino.util.inference import load_model, load_image, predict +from tqdm import tqdm +import torchvision +import torch +import fiftyone as fo + + +def main( + image_directory: str = 'test_grounding_dino', + text_prompt: str = 'bus, car', + box_threshold: float = 0.15, + text_threshold: float = 0.10, + export_dataset: bool = False, + view_dataset: bool = False, + export_annotated_images: bool = True, + weights_path : str = "groundingdino_swint_ogc.pth", + config_path: str = "../../GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py", + subsample: int = None, + ): + + model = load_model(config_path, weights_path) + + dataset = fo.Dataset.from_images_dir(image_directory) + + samples = [] + + if subsample is not None: + + if subsample < len(dataset): + dataset = dataset.take(subsample).clone() + + for sample in tqdm(dataset): + + image_source, image = load_image(sample.filepath) + + boxes, logits, phrases = predict( + model=model, + image=image, + caption=text_prompt, + box_threshold=box_threshold, + text_threshold=text_threshold, + ) + + detections = [] + + for box, logit, phrase in zip(boxes, logits, phrases): + + rel_box = torchvision.ops.box_convert(box, 'cxcywh', 'xywh') + + detections.append( + fo.Detection( + label=phrase, + bounding_box=rel_box, + confidence=logit, + )) + + # Store detections in a field name of your choice + sample["detections"] = fo.Detections(detections=detections) + sample.save() + + # loads the voxel fiftyone UI ready for viewing the dataset. + if view_dataset: + session = fo.launch_app(dataset) + session.wait() + + # exports COCO dataset ready for training + if export_dataset: + dataset.export( + 'coco_dataset', + dataset_type=fo.types.COCODetectionDataset, + ) + + # saves bounding boxes plotted on the input images to disk + if export_annotated_images: + dataset.draw_labels( + 'images_with_bounding_boxes', + label_fields=['detections'] + ) + + +if __name__ == '__main__': + typer.run(main) diff --git a/GroundingDINO/demo/gradio_app.py b/GroundingDINO/demo/gradio_app.py new file mode 100644 index 0000000000000000000000000000000000000000..c1f5463aedfd783cba18eed4a4efe3e37720e57f --- /dev/null +++ b/GroundingDINO/demo/gradio_app.py @@ -0,0 +1,125 @@ +import argparse +from functools import partial +import cv2 +import requests +import os +from io import BytesIO +from PIL import Image +import numpy as np +from pathlib import Path + + +import warnings + +import torch + +# prepare the environment +os.system("python setup.py build develop --user") +os.system("pip install packaging==21.3") +os.system("pip install gradio") + + +warnings.filterwarnings("ignore") + +import gradio as gr + +from groundingdino.models import build_model +from groundingdino.util.slconfig import SLConfig +from groundingdino.util.utils import clean_state_dict +from groundingdino.util.inference import annotate, load_image, predict +import groundingdino.datasets.transforms as T + +from huggingface_hub import hf_hub_download + + + +# Use this command for evaluate the Grounding DINO model +config_file = "groundingdino/config/GroundingDINO_SwinT_OGC.py" +ckpt_repo_id = "ShilongLiu/GroundingDINO" +ckpt_filenmae = "groundingdino_swint_ogc.pth" + + +def load_model_hf(model_config_path, repo_id, filename, device='cpu'): + args = SLConfig.fromfile(model_config_path) + model = build_model(args) + args.device = device + + cache_file = hf_hub_download(repo_id=repo_id, filename=filename) + checkpoint = torch.load(cache_file, map_location='cpu') + log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False) + print("Model loaded from {} \n => {}".format(cache_file, log)) + _ = model.eval() + return model + +def image_transform_grounding(init_image): + transform = T.Compose([ + T.RandomResize([800], max_size=1333), + T.ToTensor(), + T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + ]) + image, _ = transform(init_image, None) # 3, h, w + return init_image, image + +def image_transform_grounding_for_vis(init_image): + transform = T.Compose([ + T.RandomResize([800], max_size=1333), + ]) + image, _ = transform(init_image, None) # 3, h, w + return image + +model = load_model_hf(config_file, ckpt_repo_id, ckpt_filenmae) + +def run_grounding(input_image, grounding_caption, box_threshold, text_threshold): + init_image = input_image.convert("RGB") + original_size = init_image.size + + _, image_tensor = image_transform_grounding(init_image) + image_pil: Image = image_transform_grounding_for_vis(init_image) + + # run grounidng + boxes, logits, phrases = predict(model, image_tensor, grounding_caption, box_threshold, text_threshold, device='cpu') + annotated_frame = annotate(image_source=np.asarray(image_pil), boxes=boxes, logits=logits, phrases=phrases) + image_with_box = Image.fromarray(cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)) + + + return image_with_box + +if __name__ == "__main__": + + parser = argparse.ArgumentParser("Grounding DINO demo", add_help=True) + parser.add_argument("--debug", action="store_true", help="using debug mode") + parser.add_argument("--share", action="store_true", help="share the app") + args = parser.parse_args() + + block = gr.Blocks().queue() + with block: + gr.Markdown("# [Grounding DINO](https://github.com/IDEA-Research/GroundingDINO)") + gr.Markdown("### Open-World Detection with Grounding DINO") + + with gr.Row(): + with gr.Column(): + input_image = gr.Image(source='upload', type="pil") + grounding_caption = gr.Textbox(label="Detection Prompt") + run_button = gr.Button(label="Run") + with gr.Accordion("Advanced options", open=False): + box_threshold = gr.Slider( + label="Box Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.001 + ) + text_threshold = gr.Slider( + label="Text Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.001 + ) + + with gr.Column(): + gallery = gr.outputs.Image( + type="pil", + # label="grounding results" + ).style(full_width=True, full_height=True) + # gallery = gr.Gallery(label="Generated images", show_label=False).style( + # grid=[1], height="auto", container=True, full_width=True, full_height=True) + + run_button.click(fn=run_grounding, inputs=[ + input_image, grounding_caption, box_threshold, text_threshold], outputs=[gallery]) + + + block.launch(server_name='0.0.0.0', server_port=7579, debug=args.debug, share=args.share) + diff --git a/GroundingDINO/demo/image_editing_with_groundingdino_gligen.ipynb b/GroundingDINO/demo/image_editing_with_groundingdino_gligen.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3c71b5702b3e424f81781ca16c1e039fd3e39f5a --- /dev/null +++ b/GroundingDINO/demo/image_editing_with_groundingdino_gligen.ipynb @@ -0,0 +1,703 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Marrying Grounding DINO with GLIGEN for Image Editing\n", + "\n", + "\n", + "[![Grounding DINO](https://badges.aleen42.com/src/github.svg)](https://github.com/IDEA-Research/GroundingDINO)\n", + "[![GLIGEN](https://badges.aleen42.com/src/github.svg)](https://github.com/gligen/GLIGEN)\n", + "\n", + "\n", + "[![arXiv](https://img.shields.io/badge/arXiv-2303.05499-b31b1b.svg)](https://arxiv.org/abs/2303.05499) \n", + "[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/wxWDt5UiwY8)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb)\n", + "[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/cMa77r3YrDk)\n", + "[![HuggingFace space](https://img.shields.io/badge/🤗-HuggingFace%20Space-cyan.svg)](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![gdgligen](https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/GD_GLIGEN.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Build environment\n", + "\n", + "**GLIGEN uses a modified diffusers. We highly recommoned to use new conda virtural environment for the notebook!**\n", + "\n", + "To do this, please run the following commands and rerun the notebook with the new environment:\n", + "\n", + "```bash\n", + "conda create -n gligen_diffusers python=3.10\n", + "conda activate gligen_diffusers\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "Requirement already satisfied: diffusers in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (0.14.0)\n", + "Requirement already satisfied: transformers in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (4.27.4)\n", + "Requirement already satisfied: accelerate in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (0.18.0)\n", + "Requirement already satisfied: scipy in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (1.7.3)\n", + "Requirement already satisfied: safetensors in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (0.3.0)\n", + "Requirement already satisfied: requests in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (2.28.1)\n", + "Requirement already satisfied: Pillow in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (9.2.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (2022.7.25)\n", + "Requirement already satisfied: numpy in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (1.21.6)\n", + "Requirement already satisfied: filelock in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (3.9.0)\n", + "Requirement already satisfied: huggingface-hub>=0.10.0 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (0.13.3)\n", + "Requirement already satisfied: importlib-metadata in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (4.12.0)\n", + "Requirement already satisfied: tqdm>=4.27 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from transformers) (4.64.0)\n", + "Requirement already satisfied: tokenizers!=0.11.3,<0.14,>=0.11.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from transformers) (0.13.3)\n", + "Requirement already satisfied: packaging>=20.0 in /home/liushilong/.local/lib/python3.7/site-packages (from transformers) (21.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from transformers) (6.0)\n", + "Requirement already satisfied: torch>=1.4.0 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from accelerate) (1.12.1+cu113)\n", + "Requirement already satisfied: psutil in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from accelerate) (5.9.4)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from huggingface-hub>=0.10.0->diffusers) (4.3.0)\n", + "Requirement already satisfied: pyparsing>=2.0.2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from packaging>=20.0->transformers) (3.0.9)\n", + "Requirement already satisfied: zipp>=0.5 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from importlib-metadata->diffusers) (3.8.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (3.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (2022.6.15)\n", + "Requirement already satisfied: charset-normalizer<3,>=2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (2.1.0)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (1.26.11)\n" + ] + } + ], + "source": [ + "! pip install diffusers transformers accelerate scipy safetensors" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/liushilong/code/groundingDINO_github/demo\n", + "fatal: destination path 'diffusers' already exists and is not an empty directory.\n", + "Obtaining file:///home/liushilong/code/groundingDINO_github/demo/diffusers\n", + " Installing build dependencies ... \u001b[?25ldone\n", + "\u001b[?25h Checking if build backend supports build_editable ... \u001b[?25ldone\n", + "\u001b[?25h Getting requirements to build editable ... \u001b[?25ldone\n", + "\u001b[?25h Preparing editable metadata (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: Pillow in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (9.2.0)\n", + "Requirement already satisfied: filelock in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (3.9.0)\n", + "Requirement already satisfied: huggingface-hub>=0.13.2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (0.13.3)\n", + "Requirement already satisfied: numpy in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (1.21.6)\n", + "Requirement already satisfied: regex!=2019.12.17 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (2022.7.25)\n", + "Requirement already satisfied: requests in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (2.28.1)\n", + "Requirement already satisfied: importlib-metadata in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers==0.15.0.dev0) (4.12.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from huggingface-hub>=0.13.2->diffusers==0.15.0.dev0) (6.0)\n", + "Requirement already satisfied: packaging>=20.9 in /home/liushilong/.local/lib/python3.7/site-packages (from huggingface-hub>=0.13.2->diffusers==0.15.0.dev0) (21.0)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from huggingface-hub>=0.13.2->diffusers==0.15.0.dev0) (4.3.0)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from huggingface-hub>=0.13.2->diffusers==0.15.0.dev0) (4.64.0)\n", + "Requirement already satisfied: zipp>=0.5 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from importlib-metadata->diffusers==0.15.0.dev0) (3.8.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers==0.15.0.dev0) (2022.6.15)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers==0.15.0.dev0) (3.3)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers==0.15.0.dev0) (1.26.11)\n", + "Requirement already satisfied: charset-normalizer<3,>=2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers==0.15.0.dev0) (2.1.0)\n", + "Requirement already satisfied: pyparsing>=2.0.2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from packaging>=20.9->huggingface-hub>=0.13.2->diffusers==0.15.0.dev0) (3.0.9)\n", + "Building wheels for collected packages: diffusers\n", + " Building editable for diffusers (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for diffusers: filename=diffusers-0.15.0.dev0-0.editable-py3-none-any.whl size=11144 sha256=9fe81ae4227df8b6e117161b35214dcea3f0a416d7833a14dc288d82cd655e78\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-_gavg55g/wheels/72/c9/f3/415f9981a289ad0e26f1f6be84a2e461090bce24395f25d065\n", + "Successfully built diffusers\n", + "Installing collected packages: diffusers\n", + " Attempting uninstall: diffusers\n", + " Found existing installation: diffusers 0.15.0.dev0\n", + " Uninstalling diffusers-0.15.0.dev0:\n", + " Successfully uninstalled diffusers-0.15.0.dev0\n", + "Successfully installed diffusers-0.15.0.dev0\n" + ] + } + ], + "source": [ + "# install gligen_diffusers\n", + "! pwd\n", + "! git clone git@github.com:gligen/diffusers.git\n", + "! python -m pip install -e diffusers" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "# setup device. If you have a GPU, you can change this to \"0\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "from functools import partial\n", + "import cv2\n", + "import requests\n", + "\n", + "from io import BytesIO\n", + "from PIL import Image\n", + "import numpy as np\n", + "from pathlib import Path\n", + "import random\n", + "\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "\n", + "import torch\n", + "from torchvision.ops import box_convert\n", + "\n", + "from groundingdino.models import build_model\n", + "from groundingdino.util.slconfig import SLConfig\n", + "from groundingdino.util.utils import clean_state_dict\n", + "from groundingdino.util.inference import annotate, load_image, predict\n", + "import groundingdino.datasets.transforms as T\n", + "\n", + "from huggingface_hub import hf_hub_download\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load grounding dino models" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def load_model_hf(repo_id, filename, ckpt_config_filename, device='cpu'):\n", + " cache_config_file = hf_hub_download(repo_id=repo_id, filename=ckpt_config_filename)\n", + "\n", + " args = SLConfig.fromfile(cache_config_file) \n", + " model = build_model(args)\n", + " args.device = device\n", + "\n", + " cache_file = hf_hub_download(repo_id=repo_id, filename=filename)\n", + " checkpoint = torch.load(cache_file, map_location='cpu')\n", + " log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)\n", + " print(\"Model loaded from {} \\n => {}\".format(cache_file, log))\n", + " _ = model.eval()\n", + " return model " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Use this command for evaluate the Grounding DINO model\n", + "# Or you can download the model by yourself\n", + "ckpt_repo_id = \"ShilongLiu/GroundingDINO\"\n", + "ckpt_filenmae = \"groundingdino_swint_ogc.pth\"\n", + "ckpt_config_filename = \"GroundingDINO_SwinT_OGC.cfg.py\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "final text_encoder_type: bert-base-uncased\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias']\n", + "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded from /home/liushilong/.cache/huggingface/hub/models--ShilongLiu--GroundingDINO/snapshots/d6b1ecf62f56b2affe410ed025352a07b57d4661/groundingdino_swint_ogc.pth \n", + " => _IncompatibleKeys(missing_keys=[], unexpected_keys=['label_enc.weight'])\n" + ] + } + ], + "source": [ + "model = load_model_hf(ckpt_repo_id, ckpt_filenmae, ckpt_config_filename)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load GLIGEN inpainting models" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "safety_checker/model.safetensors not found\n", + "`text_config_dict` is provided which will be used to initialize `CLIPTextConfig`. The value `text_config[\"id2label\"]` will be overriden.\n" + ] + }, + { + "data": { + "text/plain": [ + "StableDiffusionGLIGENPipeline {\n", + " \"_class_name\": \"StableDiffusionGLIGENPipeline\",\n", + " \"_diffusers_version\": \"0.15.0.dev0\",\n", + " \"feature_extractor\": [\n", + " \"transformers\",\n", + " \"CLIPFeatureExtractor\"\n", + " ],\n", + " \"requires_safety_checker\": true,\n", + " \"safety_checker\": [\n", + " \"stable_diffusion\",\n", + " \"StableDiffusionSafetyChecker\"\n", + " ],\n", + " \"scheduler\": [\n", + " \"diffusers\",\n", + " \"PNDMScheduler\"\n", + " ],\n", + " \"text_encoder\": [\n", + " \"transformers\",\n", + " \"CLIPTextModel\"\n", + " ],\n", + " \"tokenizer\": [\n", + " \"transformers\",\n", + " \"CLIPTokenizer\"\n", + " ],\n", + " \"unet\": [\n", + " \"diffusers\",\n", + " \"UNet2DConditionModel\"\n", + " ],\n", + " \"vae\": [\n", + " \"diffusers\",\n", + " \"AutoencoderKL\"\n", + " ]\n", + "}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from diffusers import StableDiffusionGLIGENPipeline\n", + "\n", + "\n", + "pipe = StableDiffusionGLIGENPipeline.from_pretrained(\"gligen/diffusers-inpainting-text-box\", revision=\"fp16\", torch_dtype=torch.float16)\n", + "pipe.to(\"cuda\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load demo image" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "metadata": {}, + "outputs": [], + "source": [ + "image_url = 'https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/art_dog_birthdaycake.png'\n", + "local_image_path = 'art_dog_birthdaycake.png'" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image downloaded from url: https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/art_dog_birthdaycake.png and saved to: art_dog_birthdaycake.png.\n" + ] + } + ], + "source": [ + "import io\n", + "\n", + "\n", + "def download_image(url, image_file_path):\n", + " r = requests.get(url, timeout=4.0)\n", + " if r.status_code != requests.codes.ok:\n", + " assert False, 'Status code error: {}.'.format(r.status_code)\n", + "\n", + " with Image.open(io.BytesIO(r.content)) as im:\n", + " im.save(image_file_path)\n", + "\n", + " print('Image downloaded from url: {} and saved to: {}.'.format(url, image_file_path))\n", + "\n", + "download_image(image_url, local_image_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run Grounding DINO" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import supervision as sv\n", + "\n", + "\n", + "TEXT_PROMPT = \"dog. cake.\"\n", + "BOX_TRESHOLD = 0.35\n", + "TEXT_TRESHOLD = 0.25\n", + "\n", + "image_source, image = load_image(local_image_path)\n", + "\n", + "boxes, logits, phrases = predict(\n", + " model=model, \n", + " image=image, \n", + " caption=TEXT_PROMPT, \n", + " box_threshold=BOX_TRESHOLD, \n", + " text_threshold=TEXT_TRESHOLD\n", + ")\n", + "\n", + "annotated_frame = annotate(image_source=image_source, boxes=boxes, logits=logits, phrases=phrases)\n", + "annotated_frame = annotated_frame[...,::-1] # BGR to RGB\n", + "\n", + "# image_source: np.ndarray\n", + "# annotated_frame: np.ndarray" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_masks_with_grounding(image_source, boxes):\n", + " h, w, _ = image_source.shape\n", + " boxes_unnorm = boxes * torch.Tensor([w, h, w, h])\n", + " boxes_xyxy = box_convert(boxes=boxes_unnorm, in_fmt=\"cxcywh\", out_fmt=\"xyxy\").numpy()\n", + " mask = np.zeros_like(image_source)\n", + " for box in boxes_xyxy:\n", + " x0, y0, x1, y1 = box\n", + " mask[int(y0):int(y1), int(x0):int(x1), :] = 255\n", + " return mask" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [], + "source": [ + "image_mask = generate_masks_with_grounding(image_source, boxes)" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 207, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(image_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(annotated_frame)" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfsAAAH9CAIAAACSsEKYAAAFF0lEQVR4nO3UwQ0CMRAEwfPln7P5IJHAyQt0VQTzGPV1AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMWdMDvtHee3oCb2u5KDzmnh4AwCGKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAVig9QofgAFYoPUKH4ABWKD1Ch+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfKzpAX9i7z09AX7SWip0zj09AIBDFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfoELxASoUH6BC8QEqFB+gQvEBKhQfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAOS9jpgflGS2p8wAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(image_mask)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image Inpainting" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [], + "source": [ + "image_source = Image.fromarray(image_source)\n", + "annotated_frame = Image.fromarray(annotated_frame)\n", + "image_mask = Image.fromarray(image_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [], + "source": [ + "image_source_for_inpaint = image_source.resize((512, 512))\n", + "image_mask_for_inpaint = image_mask.resize((512, 512))" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 212, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_box = len(boxes)\n", + "num_box" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.18195317685604095,\n", + " 0.3042256236076355,\n", + " 0.4422861933708191,\n", + " 0.5236865282058716],\n", + " [0.21554315090179443,\n", + " 0.6760779619216919,\n", + " 0.7596603631973267,\n", + " 0.934249758720398]]" + ] + }, + "execution_count": 213, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xyxy_boxes = box_convert(boxes=boxes, in_fmt=\"cxcywh\", out_fmt=\"xyxy\").tolist()\n", + "xyxy_boxes[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [], + "source": [ + "# define prompts for each box\n", + "gligen_phrases = ['a cat', 'a rose']" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:08<00:00, 5.95it/s]\n" + ] + } + ], + "source": [ + "prompt = \"'a cat', 'a rose'\"\n", + "\n", + "num_box = len(boxes)\n", + "\n", + "image_inpainting = pipe(\n", + " prompt,\n", + " num_images_per_prompt = 2,\n", + " gligen_phrases = gligen_phrases,\n", + " gligen_inpaint_image = image_source_for_inpaint,\n", + " gligen_boxes = xyxy_boxes,\n", + " gligen_scheduled_sampling_beta=1,\n", + " output_type=\"numpy\",\n", + " num_inference_steps=50\n", + ").images" + ] + }, + { + "cell_type": "code", + "execution_count": 216, + "metadata": {}, + "outputs": [], + "source": [ + "# 0..1 to 0..255, and convert to uint8\n", + "image_inpainting = (image_inpainting * 255).astype(np.uint8)" + ] + }, + { + "cell_type": "code", + "execution_count": 220, + "metadata": {}, + "outputs": [], + "source": [ + "image_inpainting = np.concatenate(image_inpainting, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 223, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(image_inpainting).resize((image_source.size[0]*2, image_source.size[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/GroundingDINO/demo/image_editing_with_groundingdino_stablediffusion.ipynb b/GroundingDINO/demo/image_editing_with_groundingdino_stablediffusion.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..caf5d98aa229df872ef142ad02af806873c04071 --- /dev/null +++ b/GroundingDINO/demo/image_editing_with_groundingdino_stablediffusion.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Marrying Grounding DINO with Stable Diffusion for Image Editing\n", + "\n", + "\n", + "[![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/IDEA-Research/GroundingDINO)\n", + "[![arXiv](https://img.shields.io/badge/arXiv-2303.05499-b31b1b.svg)](https://arxiv.org/abs/2303.05499) \n", + "[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/wxWDt5UiwY8)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb)\n", + "[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/cMa77r3YrDk)\n", + "[![HuggingFace space](https://img.shields.io/badge/🤗-HuggingFace%20Space-cyan.svg)](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![gdsd](https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/gdsd_example.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Install diffusers " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "Requirement already satisfied: diffusers in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (0.14.0)\n", + "Requirement already satisfied: transformers in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (4.27.4)\n", + "Requirement already satisfied: accelerate in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (0.18.0)\n", + "Requirement already satisfied: scipy in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (1.7.3)\n", + "Requirement already satisfied: safetensors in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (0.3.0)\n", + "Requirement already satisfied: requests in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (2.28.1)\n", + "Requirement already satisfied: Pillow in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (9.2.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (2022.7.25)\n", + "Requirement already satisfied: numpy in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (1.21.6)\n", + "Requirement already satisfied: filelock in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (3.9.0)\n", + "Requirement already satisfied: huggingface-hub>=0.10.0 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (0.13.3)\n", + "Requirement already satisfied: importlib-metadata in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from diffusers) (4.12.0)\n", + "Requirement already satisfied: tqdm>=4.27 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from transformers) (4.64.0)\n", + "Requirement already satisfied: tokenizers!=0.11.3,<0.14,>=0.11.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from transformers) (0.13.3)\n", + "Requirement already satisfied: packaging>=20.0 in /home/liushilong/.local/lib/python3.7/site-packages (from transformers) (21.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from transformers) (6.0)\n", + "Requirement already satisfied: torch>=1.4.0 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from accelerate) (1.12.1+cu113)\n", + "Requirement already satisfied: psutil in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from accelerate) (5.9.4)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from huggingface-hub>=0.10.0->diffusers) (4.3.0)\n", + "Requirement already satisfied: pyparsing>=2.0.2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from packaging>=20.0->transformers) (3.0.9)\n", + "Requirement already satisfied: zipp>=0.5 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from importlib-metadata->diffusers) (3.8.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (3.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (2022.6.15)\n", + "Requirement already satisfied: charset-normalizer<3,>=2 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (2.1.0)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/liushilong/anaconda3/envs/ideadet2/lib/python3.7/site-packages (from requests->diffusers) (1.26.11)\n" + ] + } + ], + "source": [ + "! pip install diffusers transformers accelerate scipy safetensors" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "from functools import partial\n", + "import cv2\n", + "import requests\n", + "\n", + "from io import BytesIO\n", + "from PIL import Image\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "\n", + "import torch\n", + "from torchvision.ops import box_convert\n", + "\n", + "from groundingdino.models import build_model\n", + "from groundingdino.util.slconfig import SLConfig\n", + "from groundingdino.util.utils import clean_state_dict\n", + "from groundingdino.util.inference import annotate, load_image, predict\n", + "import groundingdino.datasets.transforms as T\n", + "\n", + "from huggingface_hub import hf_hub_download\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load grounding dino models" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def load_model_hf(repo_id, filename, ckpt_config_filename, device='cpu'):\n", + " cache_config_file = hf_hub_download(repo_id=repo_id, filename=ckpt_config_filename)\n", + "\n", + " args = SLConfig.fromfile(cache_config_file) \n", + " model = build_model(args)\n", + " args.device = device\n", + "\n", + " cache_file = hf_hub_download(repo_id=repo_id, filename=filename)\n", + " checkpoint = torch.load(cache_file, map_location='cpu')\n", + " log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)\n", + " print(\"Model loaded from {} \\n => {}\".format(cache_file, log))\n", + " _ = model.eval()\n", + " return model " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Use this command for evaluate the Grounding DINO model\n", + "# Or you can download the model by yourself\n", + "ckpt_repo_id = \"ShilongLiu/GroundingDINO\"\n", + "ckpt_filenmae = \"groundingdino_swint_ogc.pth\"\n", + "ckpt_config_filename = \"GroundingDINO_SwinT_OGC.cfg.py\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "final text_encoder_type: bert-base-uncased\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias']\n", + "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded from /home/liushilong/.cache/huggingface/hub/models--ShilongLiu--GroundingDINO/snapshots/4d4409dc29f29629f4ebb808a68ea67be53886b6/groundingdino_swint_ogc.pth \n", + " => _IncompatibleKeys(missing_keys=[], unexpected_keys=['label_enc.weight'])\n" + ] + } + ], + "source": [ + "model = load_model_hf(ckpt_repo_id, ckpt_filenmae, ckpt_config_filename)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load stable diffusion inpainting models" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 13 files: 100%|██████████| 13/13 [00:00<00:00, 44656.80it/s]\n" + ] + } + ], + "source": [ + "from diffusers import StableDiffusionInpaintPipeline\n", + "\n", + "pipe = StableDiffusionInpaintPipeline.from_pretrained(\n", + " \"stabilityai/stable-diffusion-2-inpainting\",\n", + " torch_dtype=torch.float16,\n", + ")\n", + "\n", + "pipe = pipe.to(\"cuda\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load demo image" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "image_url = 'https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/cats.png'\n", + "local_image_path = 'cats.png'" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image downloaded from url: https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/cats.png and saved to: cats.png.\n" + ] + } + ], + "source": [ + "import io\n", + "\n", + "\n", + "def download_image(url, image_file_path):\n", + " r = requests.get(url, timeout=4.0)\n", + " if r.status_code != requests.codes.ok:\n", + " assert False, 'Status code error: {}.'.format(r.status_code)\n", + "\n", + " with Image.open(io.BytesIO(r.content)) as im:\n", + " im.save(image_file_path)\n", + "\n", + " print('Image downloaded from url: {} and saved to: {}.'.format(url, image_file_path))\n", + "\n", + "download_image(image_url, local_image_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run Grounding DINO" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import supervision as sv\n", + "\n", + "\n", + "TEXT_PROMPT = \"the black cat .\"\n", + "BOX_TRESHOLD = 0.45\n", + "TEXT_TRESHOLD = 0.25\n", + "\n", + "image_source, image = load_image(local_image_path)\n", + "\n", + "boxes, logits, phrases = predict(\n", + " model=model, \n", + " image=image, \n", + " caption=TEXT_PROMPT, \n", + " box_threshold=BOX_TRESHOLD, \n", + " text_threshold=TEXT_TRESHOLD\n", + ")\n", + "\n", + "annotated_frame = annotate(image_source=image_source, boxes=boxes, logits=logits, phrases=phrases)\n", + "annotated_frame = annotated_frame[...,::-1] # BGR to RGB\n", + "\n", + "# image_source: np.ndarray\n", + "# annotated_frame: np.ndarray" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_masks_with_grounding(image_source, boxes):\n", + " h, w, _ = image_source.shape\n", + " boxes_unnorm = boxes * torch.Tensor([w, h, w, h])\n", + " boxes_xyxy = box_convert(boxes=boxes_unnorm, in_fmt=\"cxcywh\", out_fmt=\"xyxy\").numpy()\n", + " mask = np.zeros_like(image_source)\n", + " for box in boxes_xyxy:\n", + " x0, y0, x1, y1 = box\n", + " mask[int(y0):int(y1), int(x0):int(x1), :] = 255\n", + " return mask" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [], + "source": [ + "image_mask = generate_masks_with_grounding(image_source, boxes)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(image_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(annotated_frame)" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(image_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [], + "source": [ + "# image_source" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image Inpainting" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "image_source = Image.fromarray(image_source)\n", + "annotated_frame = Image.fromarray(annotated_frame)\n", + "image_mask = Image.fromarray(image_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "image_source_for_inpaint = image_source.resize((512, 512))\n", + "image_mask_for_inpaint = image_mask.resize((512, 512))" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:02<00:00, 22.20it/s]\n" + ] + } + ], + "source": [ + "prompt = \"a cute dinosaur\"\n", + "#image and mask_image should be PIL images.\n", + "#The mask structure is white for inpainting and black for keeping as is\n", + "image_inpainting = pipe(prompt=prompt, image=image_source_for_inpaint, mask_image=image_mask_for_inpaint).images[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "image_inpainting = image_inpainting.resize((image_source.size[0], image_source.size[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image_inpainting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/GroundingDINO/demo/inference_on_a_image.py b/GroundingDINO/demo/inference_on_a_image.py new file mode 100644 index 0000000000000000000000000000000000000000..63f09bd18c87d5e307e8139712fc79f7d1f730c9 --- /dev/null +++ b/GroundingDINO/demo/inference_on_a_image.py @@ -0,0 +1,214 @@ +import argparse +import os +import sys + +import numpy as np +import torch +from PIL import Image, ImageDraw, ImageFont + +import groundingdino.datasets.transforms as T +from groundingdino.models import build_model +from groundingdino.util import box_ops +from groundingdino.util.slconfig import SLConfig +from groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap +from groundingdino.util.vl_utils import create_positive_map_from_span + + +def plot_boxes_to_image(image_pil, tgt): + H, W = tgt["size"] + boxes = tgt["boxes"] + labels = tgt["labels"] + assert len(boxes) == len(labels), "boxes and labels must have same length" + + draw = ImageDraw.Draw(image_pil) + mask = Image.new("L", image_pil.size, 0) + mask_draw = ImageDraw.Draw(mask) + + # draw boxes and masks + for box, label in zip(boxes, labels): + # from 0..1 to 0..W, 0..H + box = box * torch.Tensor([W, H, W, H]) + # from xywh to xyxy + box[:2] -= box[2:] / 2 + box[2:] += box[:2] + # random color + color = tuple(np.random.randint(0, 255, size=3).tolist()) + # draw + x0, y0, x1, y1 = box + x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1) + + draw.rectangle([x0, y0, x1, y1], outline=color, width=6) + # draw.text((x0, y0), str(label), fill=color) + + font = ImageFont.load_default() + if hasattr(font, "getbbox"): + bbox = draw.textbbox((x0, y0), str(label), font) + else: + w, h = draw.textsize(str(label), font) + bbox = (x0, y0, w + x0, y0 + h) + # bbox = draw.textbbox((x0, y0), str(label)) + draw.rectangle(bbox, fill=color) + draw.text((x0, y0), str(label), fill="white") + + mask_draw.rectangle([x0, y0, x1, y1], fill=255, width=6) + + return image_pil, mask + + +def load_image(image_path): + # load image + image_pil = Image.open(image_path).convert("RGB") # load image + + transform = T.Compose( + [ + T.RandomResize([800], max_size=1333), + T.ToTensor(), + T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), + ] + ) + image, _ = transform(image_pil, None) # 3, h, w + return image_pil, image + + +def load_model(model_config_path, model_checkpoint_path, cpu_only=False): + args = SLConfig.fromfile(model_config_path) + args.device = "cuda" if not cpu_only else "cpu" + model = build_model(args) + checkpoint = torch.load(model_checkpoint_path, map_location="cpu") + load_res = model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False) + print(load_res) + _ = model.eval() + return model + + +def get_grounding_output(model, image, caption, box_threshold, text_threshold=None, with_logits=True, cpu_only=False, token_spans=None): + assert text_threshold is not None or token_spans is not None, "text_threshould and token_spans should not be None at the same time!" + caption = caption.lower() + caption = caption.strip() + if not caption.endswith("."): + caption = caption + "." + device = "cuda" if not cpu_only else "cpu" + model = model.to(device) + image = image.to(device) + with torch.no_grad(): + outputs = model(image[None], captions=[caption]) + logits = outputs["pred_logits"].sigmoid()[0] # (nq, 256) + boxes = outputs["pred_boxes"][0] # (nq, 4) + + # filter output + if token_spans is None: + logits_filt = logits.cpu().clone() + boxes_filt = boxes.cpu().clone() + filt_mask = logits_filt.max(dim=1)[0] > box_threshold + logits_filt = logits_filt[filt_mask] # num_filt, 256 + boxes_filt = boxes_filt[filt_mask] # num_filt, 4 + + # get phrase + tokenlizer = model.tokenizer + tokenized = tokenlizer(caption) + # build pred + pred_phrases = [] + for logit, box in zip(logits_filt, boxes_filt): + pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer) + if with_logits: + pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})") + else: + pred_phrases.append(pred_phrase) + else: + # given-phrase mode + positive_maps = create_positive_map_from_span( + model.tokenizer(text_prompt), + token_span=token_spans + ).to(image.device) # n_phrase, 256 + + logits_for_phrases = positive_maps @ logits.T # n_phrase, nq + all_logits = [] + all_phrases = [] + all_boxes = [] + for (token_span, logit_phr) in zip(token_spans, logits_for_phrases): + # get phrase + phrase = ' '.join([caption[_s:_e] for (_s, _e) in token_span]) + # get mask + filt_mask = logit_phr > box_threshold + # filt box + all_boxes.append(boxes[filt_mask]) + # filt logits + all_logits.append(logit_phr[filt_mask]) + if with_logits: + logit_phr_num = logit_phr[filt_mask] + all_phrases.extend([phrase + f"({str(logit.item())[:4]})" for logit in logit_phr_num]) + else: + all_phrases.extend([phrase for _ in range(len(filt_mask))]) + boxes_filt = torch.cat(all_boxes, dim=0).cpu() + pred_phrases = all_phrases + + + return boxes_filt, pred_phrases + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser("Grounding DINO example", add_help=True) + parser.add_argument("--config_file", "-c", type=str, required=True, help="path to config file") + parser.add_argument( + "--checkpoint_path", "-p", type=str, required=True, help="path to checkpoint file" + ) + parser.add_argument("--image_path", "-i", type=str, required=True, help="path to image file") + parser.add_argument("--text_prompt", "-t", type=str, required=True, help="text prompt") + parser.add_argument( + "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory" + ) + + parser.add_argument("--box_threshold", type=float, default=0.3, help="box threshold") + parser.add_argument("--text_threshold", type=float, default=0.25, help="text threshold") + parser.add_argument("--token_spans", type=str, default=None, help= + "The positions of start and end positions of phrases of interest. \ + For example, a caption is 'a cat and a dog', \ + if you would like to detect 'cat', the token_spans should be '[[[2, 5]], ]', since 'a cat and a dog'[2:5] is 'cat'. \ + if you would like to detect 'a cat', the token_spans should be '[[[0, 1], [2, 5]], ]', since 'a cat and a dog'[0:1] is 'a', and 'a cat and a dog'[2:5] is 'cat'. \ + ") + + parser.add_argument("--cpu-only", action="store_true", help="running on cpu only!, default=False") + args = parser.parse_args() + + # cfg + config_file = args.config_file # change the path of the model config file + checkpoint_path = args.checkpoint_path # change the path of the model + image_path = args.image_path + text_prompt = args.text_prompt + output_dir = args.output_dir + box_threshold = args.box_threshold + text_threshold = args.text_threshold + token_spans = args.token_spans + + # make dir + os.makedirs(output_dir, exist_ok=True) + # load image + image_pil, image = load_image(image_path) + # load model + model = load_model(config_file, checkpoint_path, cpu_only=args.cpu_only) + + # visualize raw image + image_pil.save(os.path.join(output_dir, "raw_image.jpg")) + + # set the text_threshold to None if token_spans is set. + if token_spans is not None: + text_threshold = None + print("Using token_spans. Set the text_threshold to None.") + + + # run model + boxes_filt, pred_phrases = get_grounding_output( + model, image, text_prompt, box_threshold, text_threshold, cpu_only=args.cpu_only, token_spans=eval(f"{token_spans}") + ) + + # visualize pred + size = image_pil.size + pred_dict = { + "boxes": boxes_filt, + "size": [size[1], size[0]], # H,W + "labels": pred_phrases, + } + # import ipdb; ipdb.set_trace() + image_with_box = plot_boxes_to_image(image_pil, pred_dict)[0] + image_with_box.save(os.path.join(output_dir, "pred.jpg")) diff --git a/GroundingDINO/demo/test_ap_on_coco.py b/GroundingDINO/demo/test_ap_on_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..f1e532fc65ad179da6f196d08259a821935af83c --- /dev/null +++ b/GroundingDINO/demo/test_ap_on_coco.py @@ -0,0 +1,233 @@ +import argparse +import os +import sys +import time + +import numpy as np +import torch +import torch.nn as nn +from torch.utils.data import DataLoader, DistributedSampler + +from groundingdino.models import build_model +import groundingdino.datasets.transforms as T +from groundingdino.util import box_ops, get_tokenlizer +from groundingdino.util.misc import clean_state_dict, collate_fn +from groundingdino.util.slconfig import SLConfig + +# from torchvision.datasets import CocoDetection +import torchvision + +from groundingdino.util.vl_utils import build_captions_and_token_span, create_positive_map_from_span +from groundingdino.datasets.cocogrounding_eval import CocoGroundingEvaluator + + +def load_model(model_config_path: str, model_checkpoint_path: str, device: str = "cuda"): + args = SLConfig.fromfile(model_config_path) + args.device = device + model = build_model(args) + checkpoint = torch.load(model_checkpoint_path, map_location="cpu") + model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False) + model.eval() + return model + + +class CocoDetection(torchvision.datasets.CocoDetection): + def __init__(self, img_folder, ann_file, transforms): + super().__init__(img_folder, ann_file) + self._transforms = transforms + + def __getitem__(self, idx): + img, target = super().__getitem__(idx) # target: list + + # import ipdb; ipdb.set_trace() + + w, h = img.size + boxes = [obj["bbox"] for obj in target] + boxes = torch.as_tensor(boxes, dtype=torch.float32).reshape(-1, 4) + boxes[:, 2:] += boxes[:, :2] # xywh -> xyxy + boxes[:, 0::2].clamp_(min=0, max=w) + boxes[:, 1::2].clamp_(min=0, max=h) + # filt invalid boxes/masks/keypoints + keep = (boxes[:, 3] > boxes[:, 1]) & (boxes[:, 2] > boxes[:, 0]) + boxes = boxes[keep] + + target_new = {} + image_id = self.ids[idx] + target_new["image_id"] = image_id + target_new["boxes"] = boxes + target_new["orig_size"] = torch.as_tensor([int(h), int(w)]) + + if self._transforms is not None: + img, target = self._transforms(img, target_new) + + return img, target + + +class PostProcessCocoGrounding(nn.Module): + """ This module converts the model's output into the format expected by the coco api""" + + def __init__(self, num_select=300, coco_api=None, tokenlizer=None) -> None: + super().__init__() + self.num_select = num_select + + assert coco_api is not None + category_dict = coco_api.dataset['categories'] + cat_list = [item['name'] for item in category_dict] + captions, cat2tokenspan = build_captions_and_token_span(cat_list, True) + tokenspanlist = [cat2tokenspan[cat] for cat in cat_list] + positive_map = create_positive_map_from_span( + tokenlizer(captions), tokenspanlist) # 80, 256. normed + + id_map = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10, 10: 11, 11: 13, 12: 14, 13: 15, 14: 16, 15: 17, 16: 18, 17: 19, 18: 20, 19: 21, 20: 22, 21: 23, 22: 24, 23: 25, 24: 27, 25: 28, 26: 31, 27: 32, 28: 33, 29: 34, 30: 35, 31: 36, 32: 37, 33: 38, 34: 39, 35: 40, 36: 41, 37: 42, 38: 43, 39: 44, 40: 46, + 41: 47, 42: 48, 43: 49, 44: 50, 45: 51, 46: 52, 47: 53, 48: 54, 49: 55, 50: 56, 51: 57, 52: 58, 53: 59, 54: 60, 55: 61, 56: 62, 57: 63, 58: 64, 59: 65, 60: 67, 61: 70, 62: 72, 63: 73, 64: 74, 65: 75, 66: 76, 67: 77, 68: 78, 69: 79, 70: 80, 71: 81, 72: 82, 73: 84, 74: 85, 75: 86, 76: 87, 77: 88, 78: 89, 79: 90} + + # build a mapping from label_id to pos_map + new_pos_map = torch.zeros((91, 256)) + for k, v in id_map.items(): + new_pos_map[v] = positive_map[k] + self.positive_map = new_pos_map + + @torch.no_grad() + def forward(self, outputs, target_sizes, not_to_xyxy=False): + """ Perform the computation + Parameters: + outputs: raw outputs of the model + target_sizes: tensor of dimension [batch_size x 2] containing the size of each images of the batch + For evaluation, this must be the original image size (before any data augmentation) + For visualization, this should be the image size after data augment, but before padding + """ + num_select = self.num_select + out_logits, out_bbox = outputs['pred_logits'], outputs['pred_boxes'] + + # pos map to logit + prob_to_token = out_logits.sigmoid() # bs, 100, 256 + pos_maps = self.positive_map.to(prob_to_token.device) + # (bs, 100, 256) @ (91, 256).T -> (bs, 100, 91) + prob_to_label = prob_to_token @ pos_maps.T + + # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO': + # import ipdb; ipdb.set_trace() + + assert len(out_logits) == len(target_sizes) + assert target_sizes.shape[1] == 2 + + prob = prob_to_label + topk_values, topk_indexes = torch.topk( + prob.view(out_logits.shape[0], -1), num_select, dim=1) + scores = topk_values + topk_boxes = topk_indexes // prob.shape[2] + labels = topk_indexes % prob.shape[2] + + if not_to_xyxy: + boxes = out_bbox + else: + boxes = box_ops.box_cxcywh_to_xyxy(out_bbox) + + boxes = torch.gather( + boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4)) + + # and from relative [0, 1] to absolute [0, height] coordinates + img_h, img_w = target_sizes.unbind(1) + scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1) + boxes = boxes * scale_fct[:, None, :] + + results = [{'scores': s, 'labels': l, 'boxes': b} + for s, l, b in zip(scores, labels, boxes)] + + return results + + +def main(args): + # config + cfg = SLConfig.fromfile(args.config_file) + + # build model + model = load_model(args.config_file, args.checkpoint_path) + model = model.to(args.device) + model = model.eval() + + # build dataloader + transform = T.Compose( + [ + T.RandomResize([800], max_size=1333), + T.ToTensor(), + T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), + ] + ) + dataset = CocoDetection( + args.image_dir, args.anno_path, transforms=transform) + data_loader = DataLoader( + dataset, batch_size=1, shuffle=False, num_workers=args.num_workers, collate_fn=collate_fn) + + # build post processor + tokenlizer = get_tokenlizer.get_tokenlizer(cfg.text_encoder_type) + postprocessor = PostProcessCocoGrounding( + coco_api=dataset.coco, tokenlizer=tokenlizer) + + # build evaluator + evaluator = CocoGroundingEvaluator( + dataset.coco, iou_types=("bbox",), useCats=True) + + # build captions + category_dict = dataset.coco.dataset['categories'] + cat_list = [item['name'] for item in category_dict] + caption = " . ".join(cat_list) + ' .' + print("Input text prompt:", caption) + + # run inference + start = time.time() + for i, (images, targets) in enumerate(data_loader): + # get images and captions + images = images.tensors.to(args.device) + bs = images.shape[0] + input_captions = [caption] * bs + + # feed to the model + outputs = model(images, captions=input_captions) + + orig_target_sizes = torch.stack( + [t["orig_size"] for t in targets], dim=0).to(images.device) + results = postprocessor(outputs, orig_target_sizes) + cocogrounding_res = { + target["image_id"]: output for target, output in zip(targets, results)} + evaluator.update(cocogrounding_res) + + if (i+1) % 30 == 0: + used_time = time.time() - start + eta = len(data_loader) / (i+1e-5) * used_time - used_time + print( + f"processed {i}/{len(data_loader)} images. time: {used_time:.2f}s, ETA: {eta:.2f}s") + + evaluator.synchronize_between_processes() + evaluator.accumulate() + evaluator.summarize() + + print("Final results:", evaluator.coco_eval["bbox"].stats.tolist()) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + "Grounding DINO eval on COCO", add_help=True) + # load model + parser.add_argument("--config_file", "-c", type=str, + required=True, help="path to config file") + parser.add_argument( + "--checkpoint_path", "-p", type=str, required=True, help="path to checkpoint file" + ) + parser.add_argument("--device", type=str, default="cuda", + help="running device (default: cuda)") + + # post processing + parser.add_argument("--num_select", type=int, default=300, + help="number of topk to select") + + # coco info + parser.add_argument("--anno_path", type=str, + required=True, help="coco root") + parser.add_argument("--image_dir", type=str, + required=True, help="coco image dir") + parser.add_argument("--num_workers", type=int, default=4, + help="number of workers for dataloader") + args = parser.parse_args() + + main(args) diff --git a/GroundingDINO/environment.yaml b/GroundingDINO/environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3ac1937dc2eda9b6ea7a3853a37633d8ae215ad5 --- /dev/null +++ b/GroundingDINO/environment.yaml @@ -0,0 +1,248 @@ +name: dino +channels: + - pytorch + - nvidia + - conda-forge + - defaults +dependencies: + - addict=2.4.0=pyhd8ed1ab_2 + - aiohttp=3.8.5=py39ha55989b_0 + - aiosignal=1.3.1=pyhd8ed1ab_0 + - asttokens=2.0.5=pyhd3eb1b0_0 + - async-timeout=4.0.3=pyhd8ed1ab_0 + - attrs=23.1.0=pyh71513ae_1 + - aws-c-auth=0.7.0=h6f3c987_2 + - aws-c-cal=0.6.0=h6ba3258_0 + - aws-c-common=0.8.23=hcfcfb64_0 + - aws-c-compression=0.2.17=h420beca_1 + - aws-c-event-stream=0.3.1=had47b81_1 + - aws-c-http=0.7.11=h72ba615_0 + - aws-c-io=0.13.28=ha35c040_0 + - aws-c-mqtt=0.8.14=h4941efa_2 + - aws-c-s3=0.3.13=he04eaa7_2 + - aws-c-sdkutils=0.1.11=h420beca_1 + - aws-checksums=0.1.16=h420beca_1 + - aws-crt-cpp=0.20.3=h247a981_4 + - aws-sdk-cpp=1.10.57=h1a0519f_17 + - backcall=0.2.0=pyhd3eb1b0_0 + - blas=2.118=mkl + - blas-devel=3.9.0=18_win64_mkl + - brotli=1.0.9=hcfcfb64_9 + - brotli-bin=1.0.9=hcfcfb64_9 + - brotli-python=1.0.9=py39h99910a6_9 + - bzip2=1.0.8=h8ffe710_4 + - c-ares=1.19.1=hcfcfb64_0 + - ca-certificates=2023.08.22=haa95532_0 + - certifi=2023.7.22=py39haa95532_0 + - charset-normalizer=3.2.0=pyhd8ed1ab_0 + - click=8.1.7=win_pyh7428d3b_0 + - colorama=0.4.6=pyhd8ed1ab_0 + - comm=0.1.2=py39haa95532_0 + - contourpy=1.1.1=py39h1f6ef14_1 + - cuda-cccl=12.2.140=0 + - cuda-cudart=11.8.89=0 + - cuda-cudart-dev=11.8.89=0 + - cuda-cupti=11.8.87=0 + - cuda-libraries=11.8.0=0 + - cuda-libraries-dev=11.8.0=0 + - cuda-nvrtc=11.8.89=0 + - cuda-nvrtc-dev=11.8.89=0 + - cuda-nvtx=11.8.86=0 + - cuda-profiler-api=12.2.140=0 + - cuda-runtime=11.8.0=0 + - cycler=0.11.0=pyhd8ed1ab_0 + - cython=3.0.0=py39h2bbff1b_0 + - dataclasses=0.8=pyhc8e2a94_3 + - datasets=2.14.5=pyhd8ed1ab_0 + - debugpy=1.6.7=py39hd77b12b_0 + - decorator=5.1.1=pyhd3eb1b0_0 + - dill=0.3.7=pyhd8ed1ab_0 + - exceptiongroup=1.0.4=py39haa95532_0 + - executing=0.8.3=pyhd3eb1b0_0 + - filelock=3.12.4=pyhd8ed1ab_0 + - fonttools=4.42.1=py39ha55989b_0 + - freeglut=3.2.2=h63175ca_2 + - freetype=2.12.1=hdaf720e_2 + - frozenlist=1.4.0=py39ha55989b_1 + - fsspec=2023.6.0=pyh1a96a4e_0 + - gettext=0.21.1=h5728263_0 + - glib=2.78.0=h12be248_0 + - glib-tools=2.78.0=h12be248_0 + - gst-plugins-base=1.22.6=h001b923_1 + - gstreamer=1.22.6=hb4038d2_1 + - huggingface_hub=0.17.3=pyhd8ed1ab_0 + - icu=70.1=h0e60522_0 + - idna=3.4=pyhd8ed1ab_0 + - importlib-metadata=6.8.0=pyha770c72_0 + - importlib-resources=6.1.0=pyhd8ed1ab_0 + - importlib_metadata=6.8.0=hd8ed1ab_0 + - importlib_resources=6.1.0=pyhd8ed1ab_0 + - intel-openmp=2023.2.0=h57928b3_49503 + - ipykernel=6.25.0=py39h9909e9c_0 + - ipython=8.15.0=py39haa95532_0 + - jasper=2.0.33=hc2e4405_1 + - jedi=0.18.1=py39haa95532_1 + - jinja2=3.1.2=pyhd8ed1ab_1 + - joblib=1.3.2=pyhd8ed1ab_0 + - jpeg=9e=hcfcfb64_3 + - jupyter_client=8.1.0=py39haa95532_0 + - jupyter_core=5.3.0=py39haa95532_0 + - kiwisolver=1.4.5=py39h1f6ef14_1 + - krb5=1.20.1=heb0366b_0 + - lcms2=2.14=h90d422f_0 + - lerc=4.0.0=h63175ca_0 + - libabseil=20230125.3=cxx17_h63175ca_0 + - libarrow=12.0.1=h12e5d06_5_cpu + - libblas=3.9.0=18_win64_mkl + - libbrotlicommon=1.0.9=hcfcfb64_9 + - libbrotlidec=1.0.9=hcfcfb64_9 + - libbrotlienc=1.0.9=hcfcfb64_9 + - libcblas=3.9.0=18_win64_mkl + - libclang=15.0.7=default_h77d9078_3 + - libclang13=15.0.7=default_h77d9078_3 + - libcrc32c=1.1.2=h0e60522_0 + - libcublas=11.11.3.6=0 + - libcublas-dev=11.11.3.6=0 + - libcufft=10.9.0.58=0 + - libcufft-dev=10.9.0.58=0 + - libcurand=10.3.3.141=0 + - libcurand-dev=10.3.3.141=0 + - libcurl=8.1.2=h68f0423_0 + - libcusolver=11.4.1.48=0 + - libcusolver-dev=11.4.1.48=0 + - libcusparse=11.7.5.86=0 + - libcusparse-dev=11.7.5.86=0 + - libdeflate=1.14=hcfcfb64_0 + - libevent=2.1.12=h3671451_1 + - libffi=3.4.2=h8ffe710_5 + - libglib=2.78.0=he8f3873_0 + - libgoogle-cloud=2.12.0=h00b2bdc_1 + - libgrpc=1.54.3=ha177ca7_0 + - libhwloc=2.9.3=default_haede6df_1009 + - libiconv=1.17=h8ffe710_0 + - liblapack=3.9.0=18_win64_mkl + - liblapacke=3.9.0=18_win64_mkl + - libnpp=11.8.0.86=0 + - libnpp-dev=11.8.0.86=0 + - libnvjpeg=11.9.0.86=0 + - libnvjpeg-dev=11.9.0.86=0 + - libogg=1.3.4=h8ffe710_1 + - libopencv=4.5.3=py39h488c12c_8 + - libpng=1.6.39=h19919ed_0 + - libprotobuf=3.21.12=h12be248_2 + - libsodium=1.0.18=h62dcd97_0 + - libsqlite=3.43.0=hcfcfb64_0 + - libssh2=1.11.0=h7dfc565_0 + - libthrift=0.18.1=h06f6336_2 + - libtiff=4.4.0=hc4f729c_5 + - libutf8proc=2.8.0=h82a8f57_0 + - libuv=1.44.2=hcfcfb64_1 + - libvorbis=1.3.7=h0e60522_0 + - libwebp-base=1.3.2=hcfcfb64_0 + - libxcb=1.13=hcd874cb_1004 + - libxml2=2.11.5=hc3477c8_1 + - libzlib=1.2.13=hcfcfb64_5 + - lz4-c=1.9.4=hcfcfb64_0 + - m2w64-gcc-libgfortran=5.3.0=6 + - m2w64-gcc-libs=5.3.0=7 + - m2w64-gcc-libs-core=5.3.0=7 + - m2w64-gmp=6.1.0=2 + - m2w64-libwinpthread-git=5.0.0.4634.697f757=2 + - markupsafe=2.1.3=py39ha55989b_1 + - matplotlib-base=3.8.0=py39hf19769e_1 + - matplotlib-inline=0.1.6=py39haa95532_0 + - mkl=2022.1.0=h6a75c08_874 + - mkl-devel=2022.1.0=h57928b3_875 + - mkl-include=2022.1.0=h6a75c08_874 + - mpmath=1.3.0=pyhd8ed1ab_0 + - msys2-conda-epoch=20160418=1 + - multidict=6.0.4=py39ha55989b_0 + - multiprocess=0.70.15=py39ha55989b_1 + - munkres=1.1.4=pyh9f0ad1d_0 + - nest-asyncio=1.5.6=py39haa95532_0 + - networkx=3.1=pyhd8ed1ab_0 + - numpy=1.26.0=py39hddb5d58_0 + - opencv=4.5.3=py39hcbf5309_8 + - openjpeg=2.5.0=hc9384bd_1 + - openssl=3.1.3=hcfcfb64_0 + - orc=1.9.0=hada7b9e_1 + - packaging=23.1=pyhd8ed1ab_0 + - pandas=2.1.1=py39h32e6231_0 + - parso=0.8.3=pyhd3eb1b0_0 + - pcre2=10.40=h17e33f8_0 + - pickleshare=0.7.5=pyhd3eb1b0_1003 + - pillow=9.2.0=py39h595c93f_3 + - pip=23.2.1=pyhd8ed1ab_0 + - platformdirs=3.10.0=pyhd8ed1ab_0 + - prompt-toolkit=3.0.36=py39haa95532_0 + - psutil=5.9.0=py39h2bbff1b_0 + - pthread-stubs=0.4=hcd874cb_1001 + - pthreads-win32=2.9.1=hfa6e2cd_3 + - pure_eval=0.2.2=pyhd3eb1b0_0 + - py-opencv=4.5.3=py39h00e5391_8 + - pyarrow=12.0.1=py39hca4e8af_5_cpu + - pycocotools=2.0.6=py39hc266a54_1 + - pygments=2.15.1=py39haa95532_1 + - pyparsing=3.1.1=pyhd8ed1ab_0 + - pysocks=1.7.1=pyh0701188_6 + - python=3.9.18=h4de0772_0_cpython + - python-dateutil=2.8.2=pyhd8ed1ab_0 + - python-tzdata=2023.3=pyhd8ed1ab_0 + - python-xxhash=3.3.0=py39ha55989b_1 + - python_abi=3.9=4_cp39 + - pytorch=2.0.1=py3.9_cuda11.8_cudnn8_0 + - pytorch-cuda=11.8=h24eeafa_5 + - pytorch-mutex=1.0=cuda + - pytz=2023.3.post1=pyhd8ed1ab_0 + - pywin32=305=py39h2bbff1b_0 + - pyyaml=6.0.1=py39ha55989b_1 + - pyzmq=25.1.0=py39hd77b12b_0 + - qt-main=5.15.8=h720456b_6 + - re2=2023.03.02=hd4eee63_0 + - regex=2023.8.8=py39ha55989b_1 + - requests=2.31.0=pyhd8ed1ab_0 + - sacremoses=0.0.53=pyhd8ed1ab_0 + - safetensors=0.3.3=py39hf21820d_1 + - setuptools=68.2.2=pyhd8ed1ab_0 + - six=1.16.0=pyh6c4a22f_0 + - snappy=1.1.10=hfb803bf_0 + - stack_data=0.2.0=pyhd3eb1b0_0 + - sympy=1.12=pyh04b8f61_3 + - tbb=2021.10.0=h91493d7_1 + - timm=0.9.7=pyhd8ed1ab_0 + - tk=8.6.13=hcfcfb64_0 + - tokenizers=0.13.3=py39hca44cb7_0 + - tomli=2.0.1=pyhd8ed1ab_0 + - tornado=6.3.2=py39h2bbff1b_0 + - tqdm=4.66.1=pyhd8ed1ab_0 + - traitlets=5.7.1=py39haa95532_0 + - transformers=4.33.2=pyhd8ed1ab_0 + - typing-extensions=4.8.0=hd8ed1ab_0 + - typing_extensions=4.8.0=pyha770c72_0 + - tzdata=2023c=h71feb2d_0 + - ucrt=10.0.22621.0=h57928b3_0 + - unicodedata2=15.0.0=py39ha55989b_1 + - urllib3=2.0.5=pyhd8ed1ab_0 + - vc=14.3=h64f974e_17 + - vc14_runtime=14.36.32532=hdcecf7f_17 + - vs2015_runtime=14.36.32532=h05e6639_17 + - wcwidth=0.2.5=pyhd3eb1b0_0 + - wheel=0.41.2=pyhd8ed1ab_0 + - win_inet_pton=1.1.0=pyhd8ed1ab_6 + - xorg-libxau=1.0.11=hcd874cb_0 + - xorg-libxdmcp=1.1.3=hcd874cb_0 + - xxhash=0.8.2=hcfcfb64_0 + - xz=5.2.6=h8d14728_0 + - yaml=0.2.5=h8ffe710_2 + - yapf=0.40.1=pyhd8ed1ab_0 + - yarl=1.9.2=py39ha55989b_0 + - zeromq=4.3.4=hd77b12b_0 + - zipp=3.17.0=pyhd8ed1ab_0 + - zlib=1.2.13=hcfcfb64_5 + - zstd=1.5.5=h12be248_0 + - pip: + - opencv-python==4.8.0.76 + - supervision==0.6.0 + - torchaudio==2.0.2 + - torchvision==0.15.2 +prefix: C:\Users\Makoto\miniconda3\envs\dino diff --git a/GroundingDINO/groundingdino/__init__.py b/GroundingDINO/groundingdino/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/GroundingDINO/groundingdino/config/GroundingDINO_SwinB_cfg.py b/GroundingDINO/groundingdino/config/GroundingDINO_SwinB_cfg.py new file mode 100644 index 0000000000000000000000000000000000000000..f490c4bbd598a35de43d36ceafcbd769e7ff21bf --- /dev/null +++ b/GroundingDINO/groundingdino/config/GroundingDINO_SwinB_cfg.py @@ -0,0 +1,43 @@ +batch_size = 1 +modelname = "groundingdino" +backbone = "swin_B_384_22k" +position_embedding = "sine" +pe_temperatureH = 20 +pe_temperatureW = 20 +return_interm_indices = [1, 2, 3] +backbone_freeze_keywords = None +enc_layers = 6 +dec_layers = 6 +pre_norm = False +dim_feedforward = 2048 +hidden_dim = 256 +dropout = 0.0 +nheads = 8 +num_queries = 900 +query_dim = 4 +num_patterns = 0 +num_feature_levels = 4 +enc_n_points = 4 +dec_n_points = 4 +two_stage_type = "standard" +two_stage_bbox_embed_share = False +two_stage_class_embed_share = False +transformer_activation = "relu" +dec_pred_bbox_embed_share = True +dn_box_noise_scale = 1.0 +dn_label_noise_ratio = 0.5 +dn_label_coef = 1.0 +dn_bbox_coef = 1.0 +embed_init_tgt = True +dn_labelbook_size = 2000 +max_text_len = 256 +text_encoder_type = "bert-base-uncased" +use_text_enhancer = True +use_fusion_layer = True +use_checkpoint = True +use_transformer_ckpt = True +use_text_cross_attention = True +text_dropout = 0.0 +fusion_dropout = 0.0 +fusion_droppath = 0.1 +sub_sentence_present = True diff --git a/GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py b/GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py new file mode 100644 index 0000000000000000000000000000000000000000..9158d5f6260ec74bded95377d382387430d7cd70 --- /dev/null +++ b/GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py @@ -0,0 +1,43 @@ +batch_size = 1 +modelname = "groundingdino" +backbone = "swin_T_224_1k" +position_embedding = "sine" +pe_temperatureH = 20 +pe_temperatureW = 20 +return_interm_indices = [1, 2, 3] +backbone_freeze_keywords = None +enc_layers = 6 +dec_layers = 6 +pre_norm = False +dim_feedforward = 2048 +hidden_dim = 256 +dropout = 0.0 +nheads = 8 +num_queries = 900 +query_dim = 4 +num_patterns = 0 +num_feature_levels = 4 +enc_n_points = 4 +dec_n_points = 4 +two_stage_type = "standard" +two_stage_bbox_embed_share = False +two_stage_class_embed_share = False +transformer_activation = "relu" +dec_pred_bbox_embed_share = True +dn_box_noise_scale = 1.0 +dn_label_noise_ratio = 0.5 +dn_label_coef = 1.0 +dn_bbox_coef = 1.0 +embed_init_tgt = True +dn_labelbook_size = 2000 +max_text_len = 256 +text_encoder_type = "bert-base-uncased" +use_text_enhancer = True +use_fusion_layer = True +use_checkpoint = True +use_transformer_ckpt = True +use_text_cross_attention = True +text_dropout = 0.0 +fusion_dropout = 0.0 +fusion_droppath = 0.1 +sub_sentence_present = True diff --git a/GroundingDINO/groundingdino/config/__init__.py b/GroundingDINO/groundingdino/config/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/GroundingDINO/groundingdino/datasets/__init__.py b/GroundingDINO/groundingdino/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/GroundingDINO/groundingdino/datasets/cocogrounding_eval.py b/GroundingDINO/groundingdino/datasets/cocogrounding_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..7693a182d86fcb2b7f707d28371849f019b883c3 --- /dev/null +++ b/GroundingDINO/groundingdino/datasets/cocogrounding_eval.py @@ -0,0 +1,269 @@ +# ------------------------------------------------------------------------ +# Grounding DINO. Midified by Shilong Liu. +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Copyright (c) Aishwarya Kamath & Nicolas Carion. Licensed under the Apache License 2.0. All Rights Reserved +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +COCO evaluator that works in distributed mode. + +Mostly copy-paste from https://github.com/pytorch/vision/blob/edfd5a7/references/detection/coco_eval.py +The difference is that there is less copy-pasting from pycocotools +in the end of the file, as python3 can suppress prints with contextlib +""" +import contextlib +import copy +import os + +import numpy as np +import pycocotools.mask as mask_util +import torch +from pycocotools.coco import COCO +from pycocotools.cocoeval import COCOeval + +from groundingdino.util.misc import all_gather + + +class CocoGroundingEvaluator(object): + def __init__(self, coco_gt, iou_types, useCats=True): + assert isinstance(iou_types, (list, tuple)) + coco_gt = copy.deepcopy(coco_gt) + self.coco_gt = coco_gt + + self.iou_types = iou_types + self.coco_eval = {} + for iou_type in iou_types: + self.coco_eval[iou_type] = COCOeval(coco_gt, iouType=iou_type) + self.coco_eval[iou_type].useCats = useCats + + self.img_ids = [] + self.eval_imgs = {k: [] for k in iou_types} + self.useCats = useCats + + def update(self, predictions): + img_ids = list(np.unique(list(predictions.keys()))) + self.img_ids.extend(img_ids) + + for iou_type in self.iou_types: + results = self.prepare(predictions, iou_type) + + # suppress pycocotools prints + with open(os.devnull, "w") as devnull: + with contextlib.redirect_stdout(devnull): + coco_dt = COCO.loadRes(self.coco_gt, results) if results else COCO() + + coco_eval = self.coco_eval[iou_type] + + coco_eval.cocoDt = coco_dt + coco_eval.params.imgIds = list(img_ids) + coco_eval.params.useCats = self.useCats + img_ids, eval_imgs = evaluate(coco_eval) + + self.eval_imgs[iou_type].append(eval_imgs) + + def synchronize_between_processes(self): + for iou_type in self.iou_types: + self.eval_imgs[iou_type] = np.concatenate(self.eval_imgs[iou_type], 2) + create_common_coco_eval(self.coco_eval[iou_type], self.img_ids, self.eval_imgs[iou_type]) + + def accumulate(self): + for coco_eval in self.coco_eval.values(): + coco_eval.accumulate() + + def summarize(self): + for iou_type, coco_eval in self.coco_eval.items(): + print("IoU metric: {}".format(iou_type)) + coco_eval.summarize() + + def prepare(self, predictions, iou_type): + if iou_type == "bbox": + return self.prepare_for_coco_detection(predictions) + elif iou_type == "segm": + return self.prepare_for_coco_segmentation(predictions) + elif iou_type == "keypoints": + return self.prepare_for_coco_keypoint(predictions) + else: + raise ValueError("Unknown iou type {}".format(iou_type)) + + def prepare_for_coco_detection(self, predictions): + coco_results = [] + for original_id, prediction in predictions.items(): + if len(prediction) == 0: + continue + + boxes = prediction["boxes"] + boxes = convert_to_xywh(boxes).tolist() + scores = prediction["scores"].tolist() + labels = prediction["labels"].tolist() + + coco_results.extend( + [ + { + "image_id": original_id, + "category_id": labels[k], + "bbox": box, + "score": scores[k], + } + for k, box in enumerate(boxes) + ] + ) + return coco_results + + def prepare_for_coco_segmentation(self, predictions): + coco_results = [] + for original_id, prediction in predictions.items(): + if len(prediction) == 0: + continue + + scores = prediction["scores"] + labels = prediction["labels"] + masks = prediction["masks"] + + masks = masks > 0.5 + + scores = prediction["scores"].tolist() + labels = prediction["labels"].tolist() + + rles = [ + mask_util.encode(np.array(mask[0, :, :, np.newaxis], dtype=np.uint8, order="F"))[0] + for mask in masks + ] + for rle in rles: + rle["counts"] = rle["counts"].decode("utf-8") + + coco_results.extend( + [ + { + "image_id": original_id, + "category_id": labels[k], + "segmentation": rle, + "score": scores[k], + } + for k, rle in enumerate(rles) + ] + ) + return coco_results + + def prepare_for_coco_keypoint(self, predictions): + coco_results = [] + for original_id, prediction in predictions.items(): + if len(prediction) == 0: + continue + + boxes = prediction["boxes"] + boxes = convert_to_xywh(boxes).tolist() + scores = prediction["scores"].tolist() + labels = prediction["labels"].tolist() + keypoints = prediction["keypoints"] + keypoints = keypoints.flatten(start_dim=1).tolist() + + coco_results.extend( + [ + { + "image_id": original_id, + "category_id": labels[k], + "keypoints": keypoint, + "score": scores[k], + } + for k, keypoint in enumerate(keypoints) + ] + ) + return coco_results + + +def convert_to_xywh(boxes): + xmin, ymin, xmax, ymax = boxes.unbind(1) + return torch.stack((xmin, ymin, xmax - xmin, ymax - ymin), dim=1) + + +def merge(img_ids, eval_imgs): + all_img_ids = all_gather(img_ids) + all_eval_imgs = all_gather(eval_imgs) + + merged_img_ids = [] + for p in all_img_ids: + merged_img_ids.extend(p) + + merged_eval_imgs = [] + for p in all_eval_imgs: + merged_eval_imgs.append(p) + + merged_img_ids = np.array(merged_img_ids) + merged_eval_imgs = np.concatenate(merged_eval_imgs, 2) + + # keep only unique (and in sorted order) images + merged_img_ids, idx = np.unique(merged_img_ids, return_index=True) + merged_eval_imgs = merged_eval_imgs[..., idx] + + return merged_img_ids, merged_eval_imgs + + +def create_common_coco_eval(coco_eval, img_ids, eval_imgs): + img_ids, eval_imgs = merge(img_ids, eval_imgs) + img_ids = list(img_ids) + eval_imgs = list(eval_imgs.flatten()) + + coco_eval.evalImgs = eval_imgs + coco_eval.params.imgIds = img_ids + coco_eval._paramsEval = copy.deepcopy(coco_eval.params) + + +################################################################# +# From pycocotools, just removed the prints and fixed +# a Python3 bug about unicode not defined +################################################################# + + +def evaluate(self): + """ + Run per image evaluation on given images and store results (a list of dict) in self.evalImgs + :return: None + """ + # tic = time.time() + # print('Running per image evaluation...') + p = self.params + # add backward compatibility if useSegm is specified in params + if p.useSegm is not None: + p.iouType = "segm" if p.useSegm == 1 else "bbox" + print("useSegm (deprecated) is not None. Running {} evaluation".format(p.iouType)) + # print('Evaluate annotation type *{}*'.format(p.iouType)) + p.imgIds = list(np.unique(p.imgIds)) + if p.useCats: + p.catIds = list(np.unique(p.catIds)) + p.maxDets = sorted(p.maxDets) + self.params = p + + self._prepare() + # loop through images, area range, max detection number + catIds = p.catIds if p.useCats else [-1] + + if p.iouType == "segm" or p.iouType == "bbox": + computeIoU = self.computeIoU + elif p.iouType == "keypoints": + computeIoU = self.computeOks + self.ious = { + (imgId, catId): computeIoU(imgId, catId) + for imgId in p.imgIds + for catId in catIds} + + evaluateImg = self.evaluateImg + maxDet = p.maxDets[-1] + evalImgs = [ + evaluateImg(imgId, catId, areaRng, maxDet) + for catId in catIds + for areaRng in p.areaRng + for imgId in p.imgIds + ] + # this is NOT in the pycocotools code, but could be done outside + evalImgs = np.asarray(evalImgs).reshape(len(catIds), len(p.areaRng), len(p.imgIds)) + self._paramsEval = copy.deepcopy(self.params) + # toc = time.time() + # print('DONE (t={:0.2f}s).'.format(toc-tic)) + return p.imgIds, evalImgs + + +################################################################# +# end of straight copy from pycocotools, just removing the prints +################################################################# diff --git a/GroundingDINO/groundingdino/datasets/transforms.py b/GroundingDINO/groundingdino/datasets/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..91cf9269e4b31008a3ddca34a19b038a9b399991 --- /dev/null +++ b/GroundingDINO/groundingdino/datasets/transforms.py @@ -0,0 +1,311 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +Transforms and data augmentation for both image + bbox. +""" +import os +import random + +import PIL +import torch +import torchvision.transforms as T +import torchvision.transforms.functional as F + +from groundingdino.util.box_ops import box_xyxy_to_cxcywh +from groundingdino.util.misc import interpolate + + +def crop(image, target, region): + cropped_image = F.crop(image, *region) + + target = target.copy() + i, j, h, w = region + + # should we do something wrt the original size? + target["size"] = torch.tensor([h, w]) + + fields = ["labels", "area", "iscrowd", "positive_map"] + + if "boxes" in target: + boxes = target["boxes"] + max_size = torch.as_tensor([w, h], dtype=torch.float32) + cropped_boxes = boxes - torch.as_tensor([j, i, j, i]) + cropped_boxes = torch.min(cropped_boxes.reshape(-1, 2, 2), max_size) + cropped_boxes = cropped_boxes.clamp(min=0) + area = (cropped_boxes[:, 1, :] - cropped_boxes[:, 0, :]).prod(dim=1) + target["boxes"] = cropped_boxes.reshape(-1, 4) + target["area"] = area + fields.append("boxes") + + if "masks" in target: + # FIXME should we update the area here if there are no boxes? + target["masks"] = target["masks"][:, i : i + h, j : j + w] + fields.append("masks") + + # remove elements for which the boxes or masks that have zero area + if "boxes" in target or "masks" in target: + # favor boxes selection when defining which elements to keep + # this is compatible with previous implementation + if "boxes" in target: + cropped_boxes = target["boxes"].reshape(-1, 2, 2) + keep = torch.all(cropped_boxes[:, 1, :] > cropped_boxes[:, 0, :], dim=1) + else: + keep = target["masks"].flatten(1).any(1) + + for field in fields: + if field in target: + target[field] = target[field][keep] + + if os.environ.get("IPDB_SHILONG_DEBUG", None) == "INFO": + # for debug and visualization only. + if "strings_positive" in target: + target["strings_positive"] = [ + _i for _i, _j in zip(target["strings_positive"], keep) if _j + ] + + return cropped_image, target + + +def hflip(image, target): + flipped_image = F.hflip(image) + + w, h = image.size + + target = target.copy() + if "boxes" in target: + boxes = target["boxes"] + boxes = boxes[:, [2, 1, 0, 3]] * torch.as_tensor([-1, 1, -1, 1]) + torch.as_tensor( + [w, 0, w, 0] + ) + target["boxes"] = boxes + + if "masks" in target: + target["masks"] = target["masks"].flip(-1) + + return flipped_image, target + + +def resize(image, target, size, max_size=None): + # size can be min_size (scalar) or (w, h) tuple + + def get_size_with_aspect_ratio(image_size, size, max_size=None): + w, h = image_size + if max_size is not None: + min_original_size = float(min((w, h))) + max_original_size = float(max((w, h))) + if max_original_size / min_original_size * size > max_size: + size = int(round(max_size * min_original_size / max_original_size)) + + if (w <= h and w == size) or (h <= w and h == size): + return (h, w) + + if w < h: + ow = size + oh = int(size * h / w) + else: + oh = size + ow = int(size * w / h) + + return (oh, ow) + + def get_size(image_size, size, max_size=None): + if isinstance(size, (list, tuple)): + return size[::-1] + else: + return get_size_with_aspect_ratio(image_size, size, max_size) + + size = get_size(image.size, size, max_size) + rescaled_image = F.resize(image, size) + + if target is None: + return rescaled_image, None + + ratios = tuple(float(s) / float(s_orig) for s, s_orig in zip(rescaled_image.size, image.size)) + ratio_width, ratio_height = ratios + + target = target.copy() + if "boxes" in target: + boxes = target["boxes"] + scaled_boxes = boxes * torch.as_tensor( + [ratio_width, ratio_height, ratio_width, ratio_height] + ) + target["boxes"] = scaled_boxes + + if "area" in target: + area = target["area"] + scaled_area = area * (ratio_width * ratio_height) + target["area"] = scaled_area + + h, w = size + target["size"] = torch.tensor([h, w]) + + if "masks" in target: + target["masks"] = ( + interpolate(target["masks"][:, None].float(), size, mode="nearest")[:, 0] > 0.5 + ) + + return rescaled_image, target + + +def pad(image, target, padding): + # assumes that we only pad on the bottom right corners + padded_image = F.pad(image, (0, 0, padding[0], padding[1])) + if target is None: + return padded_image, None + target = target.copy() + # should we do something wrt the original size? + target["size"] = torch.tensor(padded_image.size[::-1]) + if "masks" in target: + target["masks"] = torch.nn.functional.pad(target["masks"], (0, padding[0], 0, padding[1])) + return padded_image, target + + +class ResizeDebug(object): + def __init__(self, size): + self.size = size + + def __call__(self, img, target): + return resize(img, target, self.size) + + +class RandomCrop(object): + def __init__(self, size): + self.size = size + + def __call__(self, img, target): + region = T.RandomCrop.get_params(img, self.size) + return crop(img, target, region) + + +class RandomSizeCrop(object): + def __init__(self, min_size: int, max_size: int, respect_boxes: bool = False): + # respect_boxes: True to keep all boxes + # False to tolerence box filter + self.min_size = min_size + self.max_size = max_size + self.respect_boxes = respect_boxes + + def __call__(self, img: PIL.Image.Image, target: dict): + init_boxes = len(target["boxes"]) + max_patience = 10 + for i in range(max_patience): + w = random.randint(self.min_size, min(img.width, self.max_size)) + h = random.randint(self.min_size, min(img.height, self.max_size)) + region = T.RandomCrop.get_params(img, [h, w]) + result_img, result_target = crop(img, target, region) + if ( + not self.respect_boxes + or len(result_target["boxes"]) == init_boxes + or i == max_patience - 1 + ): + return result_img, result_target + return result_img, result_target + + +class CenterCrop(object): + def __init__(self, size): + self.size = size + + def __call__(self, img, target): + image_width, image_height = img.size + crop_height, crop_width = self.size + crop_top = int(round((image_height - crop_height) / 2.0)) + crop_left = int(round((image_width - crop_width) / 2.0)) + return crop(img, target, (crop_top, crop_left, crop_height, crop_width)) + + +class RandomHorizontalFlip(object): + def __init__(self, p=0.5): + self.p = p + + def __call__(self, img, target): + if random.random() < self.p: + return hflip(img, target) + return img, target + + +class RandomResize(object): + def __init__(self, sizes, max_size=None): + assert isinstance(sizes, (list, tuple)) + self.sizes = sizes + self.max_size = max_size + + def __call__(self, img, target=None): + size = random.choice(self.sizes) + return resize(img, target, size, self.max_size) + + +class RandomPad(object): + def __init__(self, max_pad): + self.max_pad = max_pad + + def __call__(self, img, target): + pad_x = random.randint(0, self.max_pad) + pad_y = random.randint(0, self.max_pad) + return pad(img, target, (pad_x, pad_y)) + + +class RandomSelect(object): + """ + Randomly selects between transforms1 and transforms2, + with probability p for transforms1 and (1 - p) for transforms2 + """ + + def __init__(self, transforms1, transforms2, p=0.5): + self.transforms1 = transforms1 + self.transforms2 = transforms2 + self.p = p + + def __call__(self, img, target): + if random.random() < self.p: + return self.transforms1(img, target) + return self.transforms2(img, target) + + +class ToTensor(object): + def __call__(self, img, target): + return F.to_tensor(img), target + + +class RandomErasing(object): + def __init__(self, *args, **kwargs): + self.eraser = T.RandomErasing(*args, **kwargs) + + def __call__(self, img, target): + return self.eraser(img), target + + +class Normalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, image, target=None): + image = F.normalize(image, mean=self.mean, std=self.std) + if target is None: + return image, None + target = target.copy() + h, w = image.shape[-2:] + if "boxes" in target: + boxes = target["boxes"] + boxes = box_xyxy_to_cxcywh(boxes) + boxes = boxes / torch.tensor([w, h, w, h], dtype=torch.float32) + target["boxes"] = boxes + return image, target + + +class Compose(object): + def __init__(self, transforms): + self.transforms = transforms + + def __call__(self, image, target): + for t in self.transforms: + image, target = t(image, target) + return image, target + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + for t in self.transforms: + format_string += "\n" + format_string += " {0}".format(t) + format_string += "\n)" + return format_string diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/__init__.py b/GroundingDINO/groundingdino/models/GroundingDINO/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af819d61d589cfec2e0ca46612a7456f42b831a --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/__init__.py @@ -0,0 +1,15 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Conditional DETR +# Copyright (c) 2021 Microsoft. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Copied from DETR (https://github.com/facebookresearch/detr) +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# ------------------------------------------------------------------------ + +from .groundingdino import build_groundingdino diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/backbone/__init__.py b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..76e4b272b479a26c63d120c818c140870cd8c287 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/__init__.py @@ -0,0 +1 @@ +from .backbone import build_backbone diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/backbone/backbone.py b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/backbone.py new file mode 100644 index 0000000000000000000000000000000000000000..c8340c723fad8e07e2fc62daaa3912487498814b --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/backbone.py @@ -0,0 +1,221 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Conditional DETR +# Copyright (c) 2021 Microsoft. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Copied from DETR (https://github.com/facebookresearch/detr) +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# ------------------------------------------------------------------------ + +""" +Backbone modules. +""" + +from typing import Dict, List + +import torch +import torch.nn.functional as F +import torchvision +from torch import nn +from torchvision.models._utils import IntermediateLayerGetter + +from groundingdino.util.misc import NestedTensor, clean_state_dict, is_main_process + +from .position_encoding import build_position_encoding +from .swin_transformer import build_swin_transformer + + +class FrozenBatchNorm2d(torch.nn.Module): + """ + BatchNorm2d where the batch statistics and the affine parameters are fixed. + + Copy-paste from torchvision.misc.ops with added eps before rqsrt, + without which any other models than torchvision.models.resnet[18,34,50,101] + produce nans. + """ + + def __init__(self, n): + super(FrozenBatchNorm2d, self).__init__() + self.register_buffer("weight", torch.ones(n)) + self.register_buffer("bias", torch.zeros(n)) + self.register_buffer("running_mean", torch.zeros(n)) + self.register_buffer("running_var", torch.ones(n)) + + def _load_from_state_dict( + self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs + ): + num_batches_tracked_key = prefix + "num_batches_tracked" + if num_batches_tracked_key in state_dict: + del state_dict[num_batches_tracked_key] + + super(FrozenBatchNorm2d, self)._load_from_state_dict( + state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs + ) + + def forward(self, x): + # move reshapes to the beginning + # to make it fuser-friendly + w = self.weight.reshape(1, -1, 1, 1) + b = self.bias.reshape(1, -1, 1, 1) + rv = self.running_var.reshape(1, -1, 1, 1) + rm = self.running_mean.reshape(1, -1, 1, 1) + eps = 1e-5 + scale = w * (rv + eps).rsqrt() + bias = b - rm * scale + return x * scale + bias + + +class BackboneBase(nn.Module): + def __init__( + self, + backbone: nn.Module, + train_backbone: bool, + num_channels: int, + return_interm_indices: list, + ): + super().__init__() + for name, parameter in backbone.named_parameters(): + if ( + not train_backbone + or "layer2" not in name + and "layer3" not in name + and "layer4" not in name + ): + parameter.requires_grad_(False) + + return_layers = {} + for idx, layer_index in enumerate(return_interm_indices): + return_layers.update( + {"layer{}".format(5 - len(return_interm_indices) + idx): "{}".format(layer_index)} + ) + + # if len: + # if use_stage1_feature: + # return_layers = {"layer1": "0", "layer2": "1", "layer3": "2", "layer4": "3"} + # else: + # return_layers = {"layer2": "0", "layer3": "1", "layer4": "2"} + # else: + # return_layers = {'layer4': "0"} + self.body = IntermediateLayerGetter(backbone, return_layers=return_layers) + self.num_channels = num_channels + + def forward(self, tensor_list: NestedTensor): + xs = self.body(tensor_list.tensors) + out: Dict[str, NestedTensor] = {} + for name, x in xs.items(): + m = tensor_list.mask + assert m is not None + mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0] + out[name] = NestedTensor(x, mask) + # import ipdb; ipdb.set_trace() + return out + + +class Backbone(BackboneBase): + """ResNet backbone with frozen BatchNorm.""" + + def __init__( + self, + name: str, + train_backbone: bool, + dilation: bool, + return_interm_indices: list, + batch_norm=FrozenBatchNorm2d, + ): + if name in ["resnet18", "resnet34", "resnet50", "resnet101"]: + backbone = getattr(torchvision.models, name)( + replace_stride_with_dilation=[False, False, dilation], + pretrained=is_main_process(), + norm_layer=batch_norm, + ) + else: + raise NotImplementedError("Why you can get here with name {}".format(name)) + # num_channels = 512 if name in ('resnet18', 'resnet34') else 2048 + assert name not in ("resnet18", "resnet34"), "Only resnet50 and resnet101 are available." + assert return_interm_indices in [[0, 1, 2, 3], [1, 2, 3], [3]] + num_channels_all = [256, 512, 1024, 2048] + num_channels = num_channels_all[4 - len(return_interm_indices) :] + super().__init__(backbone, train_backbone, num_channels, return_interm_indices) + + +class Joiner(nn.Sequential): + def __init__(self, backbone, position_embedding): + super().__init__(backbone, position_embedding) + + def forward(self, tensor_list: NestedTensor): + xs = self[0](tensor_list) + out: List[NestedTensor] = [] + pos = [] + for name, x in xs.items(): + out.append(x) + # position encoding + pos.append(self[1](x).to(x.tensors.dtype)) + + return out, pos + + +def build_backbone(args): + """ + Useful args: + - backbone: backbone name + - lr_backbone: + - dilation + - return_interm_indices: available: [0,1,2,3], [1,2,3], [3] + - backbone_freeze_keywords: + - use_checkpoint: for swin only for now + + """ + position_embedding = build_position_encoding(args) + train_backbone = True + if not train_backbone: + raise ValueError("Please set lr_backbone > 0") + return_interm_indices = args.return_interm_indices + assert return_interm_indices in [[0, 1, 2, 3], [1, 2, 3], [3]] + args.backbone_freeze_keywords + use_checkpoint = getattr(args, "use_checkpoint", False) + + if args.backbone in ["resnet50", "resnet101"]: + backbone = Backbone( + args.backbone, + train_backbone, + args.dilation, + return_interm_indices, + batch_norm=FrozenBatchNorm2d, + ) + bb_num_channels = backbone.num_channels + elif args.backbone in [ + "swin_T_224_1k", + "swin_B_224_22k", + "swin_B_384_22k", + "swin_L_224_22k", + "swin_L_384_22k", + ]: + pretrain_img_size = int(args.backbone.split("_")[-2]) + backbone = build_swin_transformer( + args.backbone, + pretrain_img_size=pretrain_img_size, + out_indices=tuple(return_interm_indices), + dilation=False, + use_checkpoint=use_checkpoint, + ) + + bb_num_channels = backbone.num_features[4 - len(return_interm_indices) :] + else: + raise NotImplementedError("Unknown backbone {}".format(args.backbone)) + + assert len(bb_num_channels) == len( + return_interm_indices + ), f"len(bb_num_channels) {len(bb_num_channels)} != len(return_interm_indices) {len(return_interm_indices)}" + + model = Joiner(backbone, position_embedding) + model.num_channels = bb_num_channels + assert isinstance( + bb_num_channels, List + ), "bb_num_channels is expected to be a List but {}".format(type(bb_num_channels)) + # import ipdb; ipdb.set_trace() + return model diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..eac7e896bbe85a670824bfe8ef487d0535d5bd99 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py @@ -0,0 +1,186 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# DINO +# Copyright (c) 2022 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Conditional DETR +# Copyright (c) 2021 Microsoft. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Copied from DETR (https://github.com/facebookresearch/detr) +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# ------------------------------------------------------------------------ + +""" +Various positional encodings for the transformer. +""" +import math + +import torch +from torch import nn + +from groundingdino.util.misc import NestedTensor + + +class PositionEmbeddingSine(nn.Module): + """ + This is a more standard version of the position embedding, very similar to the one + used by the Attention is all you need paper, generalized to work on images. + """ + + def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None): + super().__init__() + self.num_pos_feats = num_pos_feats + self.temperature = temperature + self.normalize = normalize + if scale is not None and normalize is False: + raise ValueError("normalize should be True if scale is passed") + if scale is None: + scale = 2 * math.pi + self.scale = scale + + def forward(self, tensor_list: NestedTensor): + x = tensor_list.tensors + mask = tensor_list.mask + assert mask is not None + not_mask = ~mask + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + if self.normalize: + eps = 1e-6 + # if os.environ.get("SHILONG_AMP", None) == '1': + # eps = 1e-4 + # else: + # eps = 1e-6 + y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale + x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale + + dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats) + + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + pos_x = torch.stack( + (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos_y = torch.stack( + (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + return pos + + +class PositionEmbeddingSineHW(nn.Module): + """ + This is a more standard version of the position embedding, very similar to the one + used by the Attention is all you need paper, generalized to work on images. + """ + + def __init__( + self, num_pos_feats=64, temperatureH=10000, temperatureW=10000, normalize=False, scale=None + ): + super().__init__() + self.num_pos_feats = num_pos_feats + self.temperatureH = temperatureH + self.temperatureW = temperatureW + self.normalize = normalize + if scale is not None and normalize is False: + raise ValueError("normalize should be True if scale is passed") + if scale is None: + scale = 2 * math.pi + self.scale = scale + + def forward(self, tensor_list: NestedTensor): + x = tensor_list.tensors + mask = tensor_list.mask + assert mask is not None + not_mask = ~mask + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + + # import ipdb; ipdb.set_trace() + + if self.normalize: + eps = 1e-6 + y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale + x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale + + dim_tx = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_tx = self.temperatureW ** (2 * (torch.div(dim_tx, 2, rounding_mode='floor')) / self.num_pos_feats) + pos_x = x_embed[:, :, :, None] / dim_tx + + dim_ty = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_ty = self.temperatureH ** (2 * (torch.div(dim_ty, 2, rounding_mode='floor')) / self.num_pos_feats) + pos_y = y_embed[:, :, :, None] / dim_ty + + pos_x = torch.stack( + (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos_y = torch.stack( + (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + + # import ipdb; ipdb.set_trace() + + return pos + + +class PositionEmbeddingLearned(nn.Module): + """ + Absolute pos embedding, learned. + """ + + def __init__(self, num_pos_feats=256): + super().__init__() + self.row_embed = nn.Embedding(50, num_pos_feats) + self.col_embed = nn.Embedding(50, num_pos_feats) + self.reset_parameters() + + def reset_parameters(self): + nn.init.uniform_(self.row_embed.weight) + nn.init.uniform_(self.col_embed.weight) + + def forward(self, tensor_list: NestedTensor): + x = tensor_list.tensors + h, w = x.shape[-2:] + i = torch.arange(w, device=x.device) + j = torch.arange(h, device=x.device) + x_emb = self.col_embed(i) + y_emb = self.row_embed(j) + pos = ( + torch.cat( + [ + x_emb.unsqueeze(0).repeat(h, 1, 1), + y_emb.unsqueeze(1).repeat(1, w, 1), + ], + dim=-1, + ) + .permute(2, 0, 1) + .unsqueeze(0) + .repeat(x.shape[0], 1, 1, 1) + ) + return pos + + +def build_position_encoding(args): + N_steps = args.hidden_dim // 2 + if args.position_embedding in ("v2", "sine"): + # TODO find a better way of exposing other arguments + position_embedding = PositionEmbeddingSineHW( + N_steps, + temperatureH=args.pe_temperatureH, + temperatureW=args.pe_temperatureW, + normalize=True, + ) + elif args.position_embedding in ("v3", "learned"): + position_embedding = PositionEmbeddingLearned(N_steps) + else: + raise ValueError(f"not supported {args.position_embedding}") + + return position_embedding diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/backbone/swin_transformer.py b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/swin_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..1c66194deb5dd370e797e57e2712f44303e568cc --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/backbone/swin_transformer.py @@ -0,0 +1,802 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# DINO +# Copyright (c) 2022 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# -------------------------------------------------------- +# modified from https://github.com/SwinTransformer/Swin-Transformer-Object-Detection/blob/master/mmdet/models/backbones/swin_transformer.py +# -------------------------------------------------------- + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as checkpoint +from timm.models.layers import DropPath, to_2tuple, trunc_normal_ + +from groundingdino.util.misc import NestedTensor + + +class Mlp(nn.Module): + """Multilayer perceptron.""" + + 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.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.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 WindowAttention(nn.Module): + """Window based multi-head self attention (W-MSA) module with relative position bias. + It supports both of shifted and non-shifted window. + Args: + dim (int): Number of input channels. + window_size (tuple[int]): The height and width of the window. + num_heads (int): Number of attention heads. + qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set + attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0 + proj_drop (float, optional): Dropout ratio of output. Default: 0.0 + """ + + def __init__( + self, + dim, + window_size, + num_heads, + qkv_bias=True, + qk_scale=None, + attn_drop=0.0, + proj_drop=0.0, + ): + + super().__init__() + self.dim = dim + self.window_size = window_size # Wh, Ww + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = qk_scale or head_dim**-0.5 + + # define a parameter table of relative position bias + self.relative_position_bias_table = nn.Parameter( + torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads) + ) # 2*Wh-1 * 2*Ww-1, nH + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(self.window_size[0]) + coords_w = torch.arange(self.window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += self.window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1 + relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + self.register_buffer("relative_position_index", relative_position_index) + + 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) + + trunc_normal_(self.relative_position_bias_table, std=0.02) + self.softmax = nn.Softmax(dim=-1) + + def forward(self, x, mask=None): + """Forward function. + Args: + x: input features with shape of (num_windows*B, N, C) + mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None + """ + 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[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = q @ k.transpose(-2, -1) + + relative_position_bias = self.relative_position_bias_table[ + self.relative_position_index.view(-1) + ].view( + self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1 + ) # Wh*Ww,Wh*Ww,nH + relative_position_bias = relative_position_bias.permute( + 2, 0, 1 + ).contiguous() # nH, Wh*Ww, Wh*Ww + attn = attn + relative_position_bias.unsqueeze(0) + + if mask is not None: + nW = mask.shape[0] + attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0) + attn = attn.view(-1, self.num_heads, N, N) + attn = self.softmax(attn) + else: + attn = self.softmax(attn) + + 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 SwinTransformerBlock(nn.Module): + """Swin Transformer Block. + Args: + dim (int): Number of input channels. + num_heads (int): Number of attention heads. + window_size (int): Window size. + shift_size (int): Shift size for SW-MSA. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. + qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set. + drop (float, optional): Dropout rate. Default: 0.0 + attn_drop (float, optional): Attention dropout rate. Default: 0.0 + drop_path (float, optional): Stochastic depth rate. Default: 0.0 + act_layer (nn.Module, optional): Activation layer. Default: nn.GELU + norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm + """ + + def __init__( + self, + dim, + num_heads, + window_size=7, + shift_size=0, + mlp_ratio=4.0, + qkv_bias=True, + qk_scale=None, + drop=0.0, + attn_drop=0.0, + drop_path=0.0, + act_layer=nn.GELU, + norm_layer=nn.LayerNorm, + ): + super().__init__() + self.dim = dim + self.num_heads = num_heads + self.window_size = window_size + self.shift_size = shift_size + self.mlp_ratio = mlp_ratio + assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size" + + self.norm1 = norm_layer(dim) + self.attn = WindowAttention( + dim, + window_size=to_2tuple(self.window_size), + num_heads=num_heads, + qkv_bias=qkv_bias, + qk_scale=qk_scale, + attn_drop=attn_drop, + proj_drop=drop, + ) + + 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 = Mlp( + in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop + ) + + self.H = None + self.W = None + + def forward(self, x, mask_matrix): + """Forward function. + Args: + x: Input feature, tensor size (B, H*W, C). + H, W: Spatial resolution of the input feature. + mask_matrix: Attention mask for cyclic shift. + """ + B, L, C = x.shape + H, W = self.H, self.W + assert L == H * W, "input feature has wrong size" + + shortcut = x + x = self.norm1(x) + x = x.view(B, H, W, C) + + # pad feature maps to multiples of window size + pad_l = pad_t = 0 + pad_r = (self.window_size - W % self.window_size) % self.window_size + pad_b = (self.window_size - H % self.window_size) % self.window_size + x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b)) + _, Hp, Wp, _ = x.shape + + # cyclic shift + if self.shift_size > 0: + shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2)) + attn_mask = mask_matrix + else: + shifted_x = x + attn_mask = None + + # partition windows + x_windows = window_partition( + shifted_x, self.window_size + ) # nW*B, window_size, window_size, C + x_windows = x_windows.view( + -1, self.window_size * self.window_size, C + ) # nW*B, window_size*window_size, C + + # W-MSA/SW-MSA + attn_windows = self.attn(x_windows, mask=attn_mask) # nW*B, window_size*window_size, C + + # merge windows + attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C) + shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp) # B H' W' C + + # reverse cyclic shift + if self.shift_size > 0: + x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2)) + else: + x = shifted_x + + if pad_r > 0 or pad_b > 0: + x = x[:, :H, :W, :].contiguous() + + x = x.view(B, H * W, C) + + # FFN + x = shortcut + self.drop_path(x) + x = x + self.drop_path(self.mlp(self.norm2(x))) + + return x + + +class PatchMerging(nn.Module): + """Patch Merging Layer + Args: + dim (int): Number of input channels. + norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm + """ + + def __init__(self, dim, norm_layer=nn.LayerNorm): + super().__init__() + self.dim = dim + self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False) + self.norm = norm_layer(4 * dim) + + def forward(self, x, H, W): + """Forward function. + Args: + x: Input feature, tensor size (B, H*W, C). + H, W: Spatial resolution of the input feature. + """ + B, L, C = x.shape + assert L == H * W, "input feature has wrong size" + + x = x.view(B, H, W, C) + + # padding + pad_input = (H % 2 == 1) or (W % 2 == 1) + if pad_input: + x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2)) + + x0 = x[:, 0::2, 0::2, :] # B H/2 W/2 C + x1 = x[:, 1::2, 0::2, :] # B H/2 W/2 C + x2 = x[:, 0::2, 1::2, :] # B H/2 W/2 C + x3 = x[:, 1::2, 1::2, :] # B H/2 W/2 C + x = torch.cat([x0, x1, x2, x3], -1) # B H/2 W/2 4*C + x = x.view(B, -1, 4 * C) # B H/2*W/2 4*C + + x = self.norm(x) + x = self.reduction(x) + + return x + + +class BasicLayer(nn.Module): + """A basic Swin Transformer layer for one stage. + Args: + dim (int): Number of feature channels + depth (int): Depths of this stage. + num_heads (int): Number of attention head. + window_size (int): Local window size. Default: 7. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4. + qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set. + drop (float, optional): Dropout rate. Default: 0.0 + attn_drop (float, optional): Attention dropout rate. Default: 0.0 + drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0 + norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm + downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None + use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False. + """ + + def __init__( + self, + dim, + depth, + num_heads, + window_size=7, + mlp_ratio=4.0, + qkv_bias=True, + qk_scale=None, + drop=0.0, + attn_drop=0.0, + drop_path=0.0, + norm_layer=nn.LayerNorm, + downsample=None, + use_checkpoint=False, + ): + super().__init__() + self.window_size = window_size + self.shift_size = window_size // 2 + self.depth = depth + self.use_checkpoint = use_checkpoint + + # build blocks + self.blocks = nn.ModuleList( + [ + SwinTransformerBlock( + dim=dim, + num_heads=num_heads, + window_size=window_size, + shift_size=0 if (i % 2 == 0) else window_size // 2, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + qk_scale=qk_scale, + drop=drop, + attn_drop=attn_drop, + drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path, + norm_layer=norm_layer, + ) + for i in range(depth) + ] + ) + + # patch merging layer + if downsample is not None: + self.downsample = downsample(dim=dim, norm_layer=norm_layer) + else: + self.downsample = None + + def forward(self, x, H, W): + """Forward function. + Args: + x: Input feature, tensor size (B, H*W, C). + H, W: Spatial resolution of the input feature. + """ + + # calculate attention mask for SW-MSA + Hp = int(np.ceil(H / self.window_size)) * self.window_size + Wp = int(np.ceil(W / self.window_size)) * self.window_size + img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device) # 1 Hp Wp 1 + h_slices = ( + slice(0, -self.window_size), + slice(-self.window_size, -self.shift_size), + slice(-self.shift_size, None), + ) + w_slices = ( + slice(0, -self.window_size), + slice(-self.window_size, -self.shift_size), + slice(-self.shift_size, None), + ) + cnt = 0 + for h in h_slices: + for w in w_slices: + img_mask[:, h, w, :] = cnt + cnt += 1 + + mask_windows = window_partition( + img_mask, self.window_size + ) # nW, window_size, window_size, 1 + mask_windows = mask_windows.view(-1, self.window_size * self.window_size) + attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2) + attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill( + attn_mask == 0, float(0.0) + ) + + for blk in self.blocks: + blk.H, blk.W = H, W + if self.use_checkpoint: + x = checkpoint.checkpoint(blk, x, attn_mask) + else: + x = blk(x, attn_mask) + if self.downsample is not None: + x_down = self.downsample(x, H, W) + Wh, Ww = (H + 1) // 2, (W + 1) // 2 + return x, H, W, x_down, Wh, Ww + else: + return x, H, W, x, H, W + + +class PatchEmbed(nn.Module): + """Image to Patch Embedding + Args: + patch_size (int): Patch token size. Default: 4. + in_chans (int): Number of input image channels. Default: 3. + embed_dim (int): Number of linear projection output channels. Default: 96. + norm_layer (nn.Module, optional): Normalization layer. Default: None + """ + + def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None): + super().__init__() + patch_size = to_2tuple(patch_size) + self.patch_size = patch_size + + self.in_chans = in_chans + self.embed_dim = embed_dim + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + if norm_layer is not None: + self.norm = norm_layer(embed_dim) + else: + self.norm = None + + def forward(self, x): + """Forward function.""" + # padding + _, _, H, W = x.size() + if W % self.patch_size[1] != 0: + x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1])) + if H % self.patch_size[0] != 0: + x = F.pad(x, (0, 0, 0, self.patch_size[0] - H % self.patch_size[0])) + + x = self.proj(x) # B C Wh Ww + if self.norm is not None: + Wh, Ww = x.size(2), x.size(3) + x = x.flatten(2).transpose(1, 2) + x = self.norm(x) + x = x.transpose(1, 2).view(-1, self.embed_dim, Wh, Ww) + + return x + + +class SwinTransformer(nn.Module): + """Swin Transformer backbone. + A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` - + https://arxiv.org/pdf/2103.14030 + Args: + pretrain_img_size (int): Input image size for training the pretrained model, + used in absolute postion embedding. Default 224. + patch_size (int | tuple(int)): Patch size. Default: 4. + in_chans (int): Number of input image channels. Default: 3. + embed_dim (int): Number of linear projection output channels. Default: 96. + depths (tuple[int]): Depths of each Swin Transformer stage. + num_heads (tuple[int]): Number of attention head of each stage. + window_size (int): Window size. Default: 7. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4. + qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. + drop_rate (float): Dropout rate. + attn_drop_rate (float): Attention dropout rate. Default: 0. + drop_path_rate (float): Stochastic depth rate. Default: 0.2. + norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm. + ape (bool): If True, add absolute position embedding to the patch embedding. Default: False. + patch_norm (bool): If True, add normalization after patch embedding. Default: True. + out_indices (Sequence[int]): Output from which stages. + frozen_stages (int): Stages to be frozen (stop grad and set eval mode). + -1 means not freezing any parameters. + use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False. + dilation (bool): if True, the output size if 16x downsample, ow 32x downsample. + """ + + def __init__( + self, + pretrain_img_size=224, + patch_size=4, + in_chans=3, + embed_dim=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4.0, + qkv_bias=True, + qk_scale=None, + drop_rate=0.0, + attn_drop_rate=0.0, + drop_path_rate=0.2, + norm_layer=nn.LayerNorm, + ape=False, + patch_norm=True, + out_indices=(0, 1, 2, 3), + frozen_stages=-1, + dilation=False, + use_checkpoint=False, + ): + super().__init__() + + self.pretrain_img_size = pretrain_img_size + self.num_layers = len(depths) + self.embed_dim = embed_dim + self.ape = ape + self.patch_norm = patch_norm + self.out_indices = out_indices + self.frozen_stages = frozen_stages + self.dilation = dilation + + # if use_checkpoint: + # print("use_checkpoint!!!!!!!!!!!!!!!!!!!!!!!!") + + # split image into non-overlapping patches + self.patch_embed = PatchEmbed( + patch_size=patch_size, + in_chans=in_chans, + embed_dim=embed_dim, + norm_layer=norm_layer if self.patch_norm else None, + ) + + # absolute position embedding + if self.ape: + pretrain_img_size = to_2tuple(pretrain_img_size) + patch_size = to_2tuple(patch_size) + patches_resolution = [ + pretrain_img_size[0] // patch_size[0], + pretrain_img_size[1] // patch_size[1], + ] + + self.absolute_pos_embed = nn.Parameter( + torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1]) + ) + trunc_normal_(self.absolute_pos_embed, std=0.02) + + self.pos_drop = nn.Dropout(p=drop_rate) + + # stochastic depth + dpr = [ + x.item() for x in torch.linspace(0, drop_path_rate, sum(depths)) + ] # stochastic depth decay rule + + # build layers + self.layers = nn.ModuleList() + # prepare downsample list + downsamplelist = [PatchMerging for i in range(self.num_layers)] + downsamplelist[-1] = None + num_features = [int(embed_dim * 2**i) for i in range(self.num_layers)] + if self.dilation: + downsamplelist[-2] = None + num_features[-1] = int(embed_dim * 2 ** (self.num_layers - 1)) // 2 + for i_layer in range(self.num_layers): + layer = BasicLayer( + # dim=int(embed_dim * 2 ** i_layer), + dim=num_features[i_layer], + depth=depths[i_layer], + num_heads=num_heads[i_layer], + window_size=window_size, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + qk_scale=qk_scale, + drop=drop_rate, + attn_drop=attn_drop_rate, + drop_path=dpr[sum(depths[:i_layer]) : sum(depths[: i_layer + 1])], + norm_layer=norm_layer, + # downsample=PatchMerging if (i_layer < self.num_layers - 1) else None, + downsample=downsamplelist[i_layer], + use_checkpoint=use_checkpoint, + ) + self.layers.append(layer) + + # num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)] + self.num_features = num_features + + # add a norm layer for each output + for i_layer in out_indices: + layer = norm_layer(num_features[i_layer]) + layer_name = f"norm{i_layer}" + self.add_module(layer_name, layer) + + self._freeze_stages() + + def _freeze_stages(self): + if self.frozen_stages >= 0: + self.patch_embed.eval() + for param in self.patch_embed.parameters(): + param.requires_grad = False + + if self.frozen_stages >= 1 and self.ape: + self.absolute_pos_embed.requires_grad = False + + if self.frozen_stages >= 2: + self.pos_drop.eval() + for i in range(0, self.frozen_stages - 1): + m = self.layers[i] + m.eval() + for param in m.parameters(): + param.requires_grad = False + + # def init_weights(self, pretrained=None): + # """Initialize the weights in backbone. + # Args: + # pretrained (str, optional): Path to pre-trained weights. + # Defaults to None. + # """ + + # def _init_weights(m): + # if isinstance(m, nn.Linear): + # trunc_normal_(m.weight, std=.02) + # if isinstance(m, nn.Linear) and m.bias is not None: + # nn.init.constant_(m.bias, 0) + # elif isinstance(m, nn.LayerNorm): + # nn.init.constant_(m.bias, 0) + # nn.init.constant_(m.weight, 1.0) + + # if isinstance(pretrained, str): + # self.apply(_init_weights) + # logger = get_root_logger() + # load_checkpoint(self, pretrained, strict=False, logger=logger) + # elif pretrained is None: + # self.apply(_init_weights) + # else: + # raise TypeError('pretrained must be a str or None') + + def forward_raw(self, x): + """Forward function.""" + x = self.patch_embed(x) + + Wh, Ww = x.size(2), x.size(3) + if self.ape: + # interpolate the position embedding to the corresponding size + absolute_pos_embed = F.interpolate( + self.absolute_pos_embed, size=(Wh, Ww), mode="bicubic" + ) + x = (x + absolute_pos_embed).flatten(2).transpose(1, 2) # B Wh*Ww C + else: + x = x.flatten(2).transpose(1, 2) + x = self.pos_drop(x) + + outs = [] + for i in range(self.num_layers): + layer = self.layers[i] + x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww) + # import ipdb; ipdb.set_trace() + + if i in self.out_indices: + norm_layer = getattr(self, f"norm{i}") + x_out = norm_layer(x_out) + + out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous() + outs.append(out) + # in: + # torch.Size([2, 3, 1024, 1024]) + # outs: + # [torch.Size([2, 192, 256, 256]), torch.Size([2, 384, 128, 128]), \ + # torch.Size([2, 768, 64, 64]), torch.Size([2, 1536, 32, 32])] + return tuple(outs) + + def forward(self, tensor_list: NestedTensor): + x = tensor_list.tensors + + """Forward function.""" + x = self.patch_embed(x) + + Wh, Ww = x.size(2), x.size(3) + if self.ape: + # interpolate the position embedding to the corresponding size + absolute_pos_embed = F.interpolate( + self.absolute_pos_embed, size=(Wh, Ww), mode="bicubic" + ) + x = (x + absolute_pos_embed).flatten(2).transpose(1, 2) # B Wh*Ww C + else: + x = x.flatten(2).transpose(1, 2) + x = self.pos_drop(x) + + outs = [] + for i in range(self.num_layers): + layer = self.layers[i] + x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww) + + if i in self.out_indices: + norm_layer = getattr(self, f"norm{i}") + x_out = norm_layer(x_out) + + out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous() + outs.append(out) + # in: + # torch.Size([2, 3, 1024, 1024]) + # out: + # [torch.Size([2, 192, 256, 256]), torch.Size([2, 384, 128, 128]), \ + # torch.Size([2, 768, 64, 64]), torch.Size([2, 1536, 32, 32])] + + # collect for nesttensors + outs_dict = {} + for idx, out_i in enumerate(outs): + m = tensor_list.mask + assert m is not None + mask = F.interpolate(m[None].float(), size=out_i.shape[-2:]).to(torch.bool)[0] + outs_dict[idx] = NestedTensor(out_i, mask) + + return outs_dict + + def train(self, mode=True): + """Convert the model into training mode while keep layers freezed.""" + super(SwinTransformer, self).train(mode) + self._freeze_stages() + + +def build_swin_transformer(modelname, pretrain_img_size, **kw): + assert modelname in [ + "swin_T_224_1k", + "swin_B_224_22k", + "swin_B_384_22k", + "swin_L_224_22k", + "swin_L_384_22k", + ] + + model_para_dict = { + "swin_T_224_1k": dict( + embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24], window_size=7 + ), + "swin_B_224_22k": dict( + embed_dim=128, depths=[2, 2, 18, 2], num_heads=[4, 8, 16, 32], window_size=7 + ), + "swin_B_384_22k": dict( + embed_dim=128, depths=[2, 2, 18, 2], num_heads=[4, 8, 16, 32], window_size=12 + ), + "swin_L_224_22k": dict( + embed_dim=192, depths=[2, 2, 18, 2], num_heads=[6, 12, 24, 48], window_size=7 + ), + "swin_L_384_22k": dict( + embed_dim=192, depths=[2, 2, 18, 2], num_heads=[6, 12, 24, 48], window_size=12 + ), + } + kw_cgf = model_para_dict[modelname] + kw_cgf.update(kw) + model = SwinTransformer(pretrain_img_size=pretrain_img_size, **kw_cgf) + return model + + +if __name__ == "__main__": + model = build_swin_transformer("swin_L_384_22k", 384, dilation=True) + x = torch.rand(2, 3, 1024, 1024) + y = model.forward_raw(x) + import ipdb + + ipdb.set_trace() + x = torch.rand(2, 3, 384, 384) + y = model.forward_raw(x) diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/bertwarper.py b/GroundingDINO/groundingdino/models/GroundingDINO/bertwarper.py new file mode 100644 index 0000000000000000000000000000000000000000..f0cf9779b270e1aead32845006f8b881fcba37ad --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/bertwarper.py @@ -0,0 +1,273 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ + +import torch +import torch.nn.functional as F +import torch.utils.checkpoint as checkpoint +from torch import Tensor, nn +from torchvision.ops.boxes import nms +from transformers import BertConfig, BertModel, BertPreTrainedModel +from transformers.modeling_outputs import BaseModelOutputWithPoolingAndCrossAttentions + + +class BertModelWarper(nn.Module): + def __init__(self, bert_model): + super().__init__() + # self.bert = bert_modelc + + self.config = bert_model.config + self.embeddings = bert_model.embeddings + self.encoder = bert_model.encoder + self.pooler = bert_model.pooler + + self.get_extended_attention_mask = bert_model.get_extended_attention_mask + self.invert_attention_mask = bert_model.invert_attention_mask + self.get_head_mask = bert_model.get_head_mask + + def forward( + self, + input_ids=None, + attention_mask=None, + token_type_ids=None, + position_ids=None, + head_mask=None, + inputs_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + """ + output_attentions = ( + output_attentions if output_attentions is not None else self.config.output_attentions + ) + output_hidden_states = ( + output_hidden_states + if output_hidden_states is not None + else self.config.output_hidden_states + ) + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + if self.config.is_decoder: + use_cache = use_cache if use_cache is not None else self.config.use_cache + else: + use_cache = False + + if input_ids is not None and inputs_embeds is not None: + raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time") + elif input_ids is not None: + input_shape = input_ids.size() + batch_size, seq_length = input_shape + elif inputs_embeds is not None: + input_shape = inputs_embeds.size()[:-1] + batch_size, seq_length = input_shape + else: + raise ValueError("You have to specify either input_ids or inputs_embeds") + + device = input_ids.device if input_ids is not None else inputs_embeds.device + + # past_key_values_length + past_key_values_length = ( + past_key_values[0][0].shape[2] if past_key_values is not None else 0 + ) + + if attention_mask is None: + attention_mask = torch.ones( + ((batch_size, seq_length + past_key_values_length)), device=device + ) + if token_type_ids is None: + token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device) + + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + extended_attention_mask: torch.Tensor = self.get_extended_attention_mask( + attention_mask, input_shape, device + ) + + # If a 2D or 3D attention mask is provided for the cross-attention + # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] + if self.config.is_decoder and encoder_hidden_states is not None: + encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size() + encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length) + if encoder_attention_mask is None: + encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device) + encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask) + else: + encoder_extended_attention_mask = None + # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO': + # import ipdb; ipdb.set_trace() + + # Prepare head mask if needed + # 1.0 in head_mask indicate we keep the head + # attention_probs has shape bsz x n_heads x N x N + # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] + # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] + head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers) + + embedding_output = self.embeddings( + input_ids=input_ids, + position_ids=position_ids, + token_type_ids=token_type_ids, + inputs_embeds=inputs_embeds, + past_key_values_length=past_key_values_length, + ) + + encoder_outputs = self.encoder( + embedding_output, + attention_mask=extended_attention_mask, + head_mask=head_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_extended_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + sequence_output = encoder_outputs[0] + pooled_output = self.pooler(sequence_output) if self.pooler is not None else None + + if not return_dict: + return (sequence_output, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPoolingAndCrossAttentions( + last_hidden_state=sequence_output, + pooler_output=pooled_output, + past_key_values=encoder_outputs.past_key_values, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + cross_attentions=encoder_outputs.cross_attentions, + ) + + +class TextEncoderShell(nn.Module): + def __init__(self, text_encoder): + super().__init__() + self.text_encoder = text_encoder + self.config = self.text_encoder.config + + def forward(self, **kw): + # feed into text encoder + return self.text_encoder(**kw) + + +def generate_masks_with_special_tokens(tokenized, special_tokens_list, tokenizer): + """Generate attention mask between each pair of special tokens + Args: + input_ids (torch.Tensor): input ids. Shape: [bs, num_token] + special_tokens_mask (list): special tokens mask. + Returns: + torch.Tensor: attention mask between each special tokens. + """ + input_ids = tokenized["input_ids"] + bs, num_token = input_ids.shape + # special_tokens_mask: bs, num_token. 1 for special tokens. 0 for normal tokens + special_tokens_mask = torch.zeros((bs, num_token), device=input_ids.device).bool() + for special_token in special_tokens_list: + special_tokens_mask |= input_ids == special_token + + # idxs: each row is a list of indices of special tokens + idxs = torch.nonzero(special_tokens_mask) + + # generate attention mask and positional ids + attention_mask = ( + torch.eye(num_token, device=input_ids.device).bool().unsqueeze(0).repeat(bs, 1, 1) + ) + position_ids = torch.zeros((bs, num_token), device=input_ids.device) + previous_col = 0 + for i in range(idxs.shape[0]): + row, col = idxs[i] + if (col == 0) or (col == num_token - 1): + attention_mask[row, col, col] = True + position_ids[row, col] = 0 + else: + attention_mask[row, previous_col + 1 : col + 1, previous_col + 1 : col + 1] = True + position_ids[row, previous_col + 1 : col + 1] = torch.arange( + 0, col - previous_col, device=input_ids.device + ) + + previous_col = col + + # # padding mask + # padding_mask = tokenized['attention_mask'] + # attention_mask = attention_mask & padding_mask.unsqueeze(1).bool() & padding_mask.unsqueeze(2).bool() + + return attention_mask, position_ids.to(torch.long) + + +def generate_masks_with_special_tokens_and_transfer_map(tokenized, special_tokens_list, tokenizer): + """Generate attention mask between each pair of special tokens + Args: + input_ids (torch.Tensor): input ids. Shape: [bs, num_token] + special_tokens_mask (list): special tokens mask. + Returns: + torch.Tensor: attention mask between each special tokens. + """ + input_ids = tokenized["input_ids"] + bs, num_token = input_ids.shape + # special_tokens_mask: bs, num_token. 1 for special tokens. 0 for normal tokens + special_tokens_mask = torch.zeros((bs, num_token), device=input_ids.device).bool() + for special_token in special_tokens_list: + special_tokens_mask |= input_ids == special_token + + # idxs: each row is a list of indices of special tokens + idxs = torch.nonzero(special_tokens_mask) + + # generate attention mask and positional ids + attention_mask = ( + torch.eye(num_token, device=input_ids.device).bool().unsqueeze(0).repeat(bs, 1, 1) + ) + position_ids = torch.zeros((bs, num_token), device=input_ids.device) + cate_to_token_mask_list = [[] for _ in range(bs)] + previous_col = 0 + for i in range(idxs.shape[0]): + row, col = idxs[i] + if (col == 0) or (col == num_token - 1): + attention_mask[row, col, col] = True + position_ids[row, col] = 0 + else: + attention_mask[row, previous_col + 1 : col + 1, previous_col + 1 : col + 1] = True + position_ids[row, previous_col + 1 : col + 1] = torch.arange( + 0, col - previous_col, device=input_ids.device + ) + c2t_maski = torch.zeros((num_token), device=input_ids.device).bool() + c2t_maski[previous_col + 1 : col] = True + cate_to_token_mask_list[row].append(c2t_maski) + previous_col = col + + cate_to_token_mask_list = [ + torch.stack(cate_to_token_mask_listi, dim=0) + for cate_to_token_mask_listi in cate_to_token_mask_list + ] + + # # padding mask + # padding_mask = tokenized['attention_mask'] + # attention_mask = attention_mask & padding_mask.unsqueeze(1).bool() & padding_mask.unsqueeze(2).bool() + + return attention_mask, position_ids.to(torch.long), cate_to_token_mask_list diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn.h b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn.h new file mode 100644 index 0000000000000000000000000000000000000000..c7408eba007b424194618baa63726657e36875e3 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn.h @@ -0,0 +1,64 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +#pragma once + +#include "ms_deform_attn_cpu.h" + +#ifdef WITH_CUDA +#include "ms_deform_attn_cuda.h" +#endif + +namespace groundingdino { + +at::Tensor +ms_deform_attn_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step) +{ + if (value.type().is_cuda()) + { +#ifdef WITH_CUDA + return ms_deform_attn_cuda_forward( + value, spatial_shapes, level_start_index, sampling_loc, attn_weight, im2col_step); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + +std::vector +ms_deform_attn_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step) +{ + if (value.type().is_cuda()) + { +#ifdef WITH_CUDA + return ms_deform_attn_cuda_backward( + value, spatial_shapes, level_start_index, sampling_loc, attn_weight, grad_output, im2col_step); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + +} // namespace groundingdino \ No newline at end of file diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cpu.cpp b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cpu.cpp new file mode 100644 index 0000000000000000000000000000000000000000..551243fdadfd1682b5dc6628623b67a79b3f6c74 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cpu.cpp @@ -0,0 +1,43 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +#include + +#include +#include + +namespace groundingdino { + +at::Tensor +ms_deform_attn_cpu_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step) +{ + AT_ERROR("Not implement on cpu"); +} + +std::vector +ms_deform_attn_cpu_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step) +{ + AT_ERROR("Not implement on cpu"); +} + +} // namespace groundingdino diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cpu.h b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cpu.h new file mode 100644 index 0000000000000000000000000000000000000000..b2b88e8c46f19b6db0933163e57ccdb51180f517 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cpu.h @@ -0,0 +1,35 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +#pragma once +#include + +namespace groundingdino { + +at::Tensor +ms_deform_attn_cpu_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step); + +std::vector +ms_deform_attn_cpu_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step); + +} // namespace groundingdino diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cuda.cu b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cuda.cu new file mode 100644 index 0000000000000000000000000000000000000000..d04fae8a9a45c11e4e74f3035e94762796da4096 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cuda.cu @@ -0,0 +1,156 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +#include +#include "ms_deform_im2col_cuda.cuh" + +#include +#include +#include +#include + +namespace groundingdino { + +at::Tensor ms_deform_attn_cuda_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step) +{ + AT_ASSERTM(value.is_contiguous(), "value tensor has to be contiguous"); + AT_ASSERTM(spatial_shapes.is_contiguous(), "spatial_shapes tensor has to be contiguous"); + AT_ASSERTM(level_start_index.is_contiguous(), "level_start_index tensor has to be contiguous"); + AT_ASSERTM(sampling_loc.is_contiguous(), "sampling_loc tensor has to be contiguous"); + AT_ASSERTM(attn_weight.is_contiguous(), "attn_weight tensor has to be contiguous"); + + AT_ASSERTM(value.type().is_cuda(), "value must be a CUDA tensor"); + AT_ASSERTM(spatial_shapes.type().is_cuda(), "spatial_shapes must be a CUDA tensor"); + AT_ASSERTM(level_start_index.type().is_cuda(), "level_start_index must be a CUDA tensor"); + AT_ASSERTM(sampling_loc.type().is_cuda(), "sampling_loc must be a CUDA tensor"); + AT_ASSERTM(attn_weight.type().is_cuda(), "attn_weight must be a CUDA tensor"); + + const int batch = value.size(0); + const int spatial_size = value.size(1); + const int num_heads = value.size(2); + const int channels = value.size(3); + + const int num_levels = spatial_shapes.size(0); + + const int num_query = sampling_loc.size(1); + const int num_point = sampling_loc.size(4); + + const int im2col_step_ = std::min(batch, im2col_step); + + AT_ASSERTM(batch % im2col_step_ == 0, "batch(%d) must divide im2col_step(%d)", batch, im2col_step_); + + auto output = at::zeros({batch, num_query, num_heads, channels}, value.options()); + + const int batch_n = im2col_step_; + auto output_n = output.view({batch/im2col_step_, batch_n, num_query, num_heads, channels}); + auto per_value_size = spatial_size * num_heads * channels; + auto per_sample_loc_size = num_query * num_heads * num_levels * num_point * 2; + auto per_attn_weight_size = num_query * num_heads * num_levels * num_point; + for (int n = 0; n < batch/im2col_step_; ++n) + { + auto columns = output_n.select(0, n); + AT_DISPATCH_FLOATING_TYPES(value.type(), "ms_deform_attn_forward_cuda", ([&] { + ms_deformable_im2col_cuda(at::cuda::getCurrentCUDAStream(), + value.data() + n * im2col_step_ * per_value_size, + spatial_shapes.data(), + level_start_index.data(), + sampling_loc.data() + n * im2col_step_ * per_sample_loc_size, + attn_weight.data() + n * im2col_step_ * per_attn_weight_size, + batch_n, spatial_size, num_heads, channels, num_levels, num_query, num_point, + columns.data()); + + })); + } + + output = output.view({batch, num_query, num_heads*channels}); + + return output; +} + + +std::vector ms_deform_attn_cuda_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step) +{ + + AT_ASSERTM(value.is_contiguous(), "value tensor has to be contiguous"); + AT_ASSERTM(spatial_shapes.is_contiguous(), "spatial_shapes tensor has to be contiguous"); + AT_ASSERTM(level_start_index.is_contiguous(), "level_start_index tensor has to be contiguous"); + AT_ASSERTM(sampling_loc.is_contiguous(), "sampling_loc tensor has to be contiguous"); + AT_ASSERTM(attn_weight.is_contiguous(), "attn_weight tensor has to be contiguous"); + AT_ASSERTM(grad_output.is_contiguous(), "grad_output tensor has to be contiguous"); + + AT_ASSERTM(value.type().is_cuda(), "value must be a CUDA tensor"); + AT_ASSERTM(spatial_shapes.type().is_cuda(), "spatial_shapes must be a CUDA tensor"); + AT_ASSERTM(level_start_index.type().is_cuda(), "level_start_index must be a CUDA tensor"); + AT_ASSERTM(sampling_loc.type().is_cuda(), "sampling_loc must be a CUDA tensor"); + AT_ASSERTM(attn_weight.type().is_cuda(), "attn_weight must be a CUDA tensor"); + AT_ASSERTM(grad_output.type().is_cuda(), "grad_output must be a CUDA tensor"); + + const int batch = value.size(0); + const int spatial_size = value.size(1); + const int num_heads = value.size(2); + const int channels = value.size(3); + + const int num_levels = spatial_shapes.size(0); + + const int num_query = sampling_loc.size(1); + const int num_point = sampling_loc.size(4); + + const int im2col_step_ = std::min(batch, im2col_step); + + AT_ASSERTM(batch % im2col_step_ == 0, "batch(%d) must divide im2col_step(%d)", batch, im2col_step_); + + auto grad_value = at::zeros_like(value); + auto grad_sampling_loc = at::zeros_like(sampling_loc); + auto grad_attn_weight = at::zeros_like(attn_weight); + + const int batch_n = im2col_step_; + auto per_value_size = spatial_size * num_heads * channels; + auto per_sample_loc_size = num_query * num_heads * num_levels * num_point * 2; + auto per_attn_weight_size = num_query * num_heads * num_levels * num_point; + auto grad_output_n = grad_output.view({batch/im2col_step_, batch_n, num_query, num_heads, channels}); + + for (int n = 0; n < batch/im2col_step_; ++n) + { + auto grad_output_g = grad_output_n.select(0, n); + AT_DISPATCH_FLOATING_TYPES(value.type(), "ms_deform_attn_backward_cuda", ([&] { + ms_deformable_col2im_cuda(at::cuda::getCurrentCUDAStream(), + grad_output_g.data(), + value.data() + n * im2col_step_ * per_value_size, + spatial_shapes.data(), + level_start_index.data(), + sampling_loc.data() + n * im2col_step_ * per_sample_loc_size, + attn_weight.data() + n * im2col_step_ * per_attn_weight_size, + batch_n, spatial_size, num_heads, channels, num_levels, num_query, num_point, + grad_value.data() + n * im2col_step_ * per_value_size, + grad_sampling_loc.data() + n * im2col_step_ * per_sample_loc_size, + grad_attn_weight.data() + n * im2col_step_ * per_attn_weight_size); + + })); + } + + return { + grad_value, grad_sampling_loc, grad_attn_weight + }; +} + +} // namespace groundingdino \ No newline at end of file diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cuda.h b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cuda.h new file mode 100644 index 0000000000000000000000000000000000000000..ad1311a78f61303616504eb991aaa9c4a93d9948 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn_cuda.h @@ -0,0 +1,33 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +#pragma once +#include + +namespace groundingdino { + +at::Tensor ms_deform_attn_cuda_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step); + +std::vector ms_deform_attn_cuda_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step); + +} // namespace groundingdino \ No newline at end of file diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_im2col_cuda.cuh b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_im2col_cuda.cuh new file mode 100644 index 0000000000000000000000000000000000000000..6bc2acb7aea0eab2e9e91e769a16861e1652c284 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_im2col_cuda.cuh @@ -0,0 +1,1327 @@ +/*! +************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************** +* Modified from DCN (https://github.com/msracver/Deformable-ConvNets) +* Copyright (c) 2018 Microsoft +************************************************************************** +*/ + +#include +#include +#include + +#include +#include + +#include + +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ + i < (n); \ + i += blockDim.x * gridDim.x) + +const int CUDA_NUM_THREADS = 1024; +inline int GET_BLOCKS(const int N, const int num_threads) +{ + return (N + num_threads - 1) / num_threads; +} + + +template +__device__ scalar_t ms_deform_attn_im2col_bilinear(const scalar_t* &bottom_data, + const int &height, const int &width, const int &nheads, const int &channels, + const scalar_t &h, const scalar_t &w, const int &m, const int &c) +{ + const int h_low = floor(h); + const int w_low = floor(w); + const int h_high = h_low + 1; + const int w_high = w_low + 1; + + const scalar_t lh = h - h_low; + const scalar_t lw = w - w_low; + const scalar_t hh = 1 - lh, hw = 1 - lw; + + const int w_stride = nheads * channels; + const int h_stride = width * w_stride; + const int h_low_ptr_offset = h_low * h_stride; + const int h_high_ptr_offset = h_low_ptr_offset + h_stride; + const int w_low_ptr_offset = w_low * w_stride; + const int w_high_ptr_offset = w_low_ptr_offset + w_stride; + const int base_ptr = m * channels + c; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + { + const int ptr1 = h_low_ptr_offset + w_low_ptr_offset + base_ptr; + v1 = bottom_data[ptr1]; + } + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + { + const int ptr2 = h_low_ptr_offset + w_high_ptr_offset + base_ptr; + v2 = bottom_data[ptr2]; + } + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + { + const int ptr3 = h_high_ptr_offset + w_low_ptr_offset + base_ptr; + v3 = bottom_data[ptr3]; + } + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + { + const int ptr4 = h_high_ptr_offset + w_high_ptr_offset + base_ptr; + v4 = bottom_data[ptr4]; + } + + const scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + + const scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + return val; +} + + +template +__device__ void ms_deform_attn_col2im_bilinear(const scalar_t* &bottom_data, + const int &height, const int &width, const int &nheads, const int &channels, + const scalar_t &h, const scalar_t &w, const int &m, const int &c, + const scalar_t &top_grad, + const scalar_t &attn_weight, + scalar_t* &grad_value, + scalar_t* grad_sampling_loc, + scalar_t* grad_attn_weight) +{ + const int h_low = floor(h); + const int w_low = floor(w); + const int h_high = h_low + 1; + const int w_high = w_low + 1; + + const scalar_t lh = h - h_low; + const scalar_t lw = w - w_low; + const scalar_t hh = 1 - lh, hw = 1 - lw; + + const int w_stride = nheads * channels; + const int h_stride = width * w_stride; + const int h_low_ptr_offset = h_low * h_stride; + const int h_high_ptr_offset = h_low_ptr_offset + h_stride; + const int w_low_ptr_offset = w_low * w_stride; + const int w_high_ptr_offset = w_low_ptr_offset + w_stride; + const int base_ptr = m * channels + c; + + const scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + const scalar_t top_grad_value = top_grad * attn_weight; + scalar_t grad_h_weight = 0, grad_w_weight = 0; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + { + const int ptr1 = h_low_ptr_offset + w_low_ptr_offset + base_ptr; + v1 = bottom_data[ptr1]; + grad_h_weight -= hw * v1; + grad_w_weight -= hh * v1; + atomicAdd(grad_value+ptr1, w1*top_grad_value); + } + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + { + const int ptr2 = h_low_ptr_offset + w_high_ptr_offset + base_ptr; + v2 = bottom_data[ptr2]; + grad_h_weight -= lw * v2; + grad_w_weight += hh * v2; + atomicAdd(grad_value+ptr2, w2*top_grad_value); + } + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + { + const int ptr3 = h_high_ptr_offset + w_low_ptr_offset + base_ptr; + v3 = bottom_data[ptr3]; + grad_h_weight += hw * v3; + grad_w_weight -= lh * v3; + atomicAdd(grad_value+ptr3, w3*top_grad_value); + } + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + { + const int ptr4 = h_high_ptr_offset + w_high_ptr_offset + base_ptr; + v4 = bottom_data[ptr4]; + grad_h_weight += lw * v4; + grad_w_weight += lh * v4; + atomicAdd(grad_value+ptr4, w4*top_grad_value); + } + + const scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + *grad_attn_weight = top_grad * val; + *grad_sampling_loc = width * grad_w_weight * top_grad_value; + *(grad_sampling_loc + 1) = height * grad_h_weight * top_grad_value; +} + + +template +__device__ void ms_deform_attn_col2im_bilinear_gm(const scalar_t* &bottom_data, + const int &height, const int &width, const int &nheads, const int &channels, + const scalar_t &h, const scalar_t &w, const int &m, const int &c, + const scalar_t &top_grad, + const scalar_t &attn_weight, + scalar_t* &grad_value, + scalar_t* grad_sampling_loc, + scalar_t* grad_attn_weight) +{ + const int h_low = floor(h); + const int w_low = floor(w); + const int h_high = h_low + 1; + const int w_high = w_low + 1; + + const scalar_t lh = h - h_low; + const scalar_t lw = w - w_low; + const scalar_t hh = 1 - lh, hw = 1 - lw; + + const int w_stride = nheads * channels; + const int h_stride = width * w_stride; + const int h_low_ptr_offset = h_low * h_stride; + const int h_high_ptr_offset = h_low_ptr_offset + h_stride; + const int w_low_ptr_offset = w_low * w_stride; + const int w_high_ptr_offset = w_low_ptr_offset + w_stride; + const int base_ptr = m * channels + c; + + const scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + const scalar_t top_grad_value = top_grad * attn_weight; + scalar_t grad_h_weight = 0, grad_w_weight = 0; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + { + const int ptr1 = h_low_ptr_offset + w_low_ptr_offset + base_ptr; + v1 = bottom_data[ptr1]; + grad_h_weight -= hw * v1; + grad_w_weight -= hh * v1; + atomicAdd(grad_value+ptr1, w1*top_grad_value); + } + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + { + const int ptr2 = h_low_ptr_offset + w_high_ptr_offset + base_ptr; + v2 = bottom_data[ptr2]; + grad_h_weight -= lw * v2; + grad_w_weight += hh * v2; + atomicAdd(grad_value+ptr2, w2*top_grad_value); + } + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + { + const int ptr3 = h_high_ptr_offset + w_low_ptr_offset + base_ptr; + v3 = bottom_data[ptr3]; + grad_h_weight += hw * v3; + grad_w_weight -= lh * v3; + atomicAdd(grad_value+ptr3, w3*top_grad_value); + } + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + { + const int ptr4 = h_high_ptr_offset + w_high_ptr_offset + base_ptr; + v4 = bottom_data[ptr4]; + grad_h_weight += lw * v4; + grad_w_weight += lh * v4; + atomicAdd(grad_value+ptr4, w4*top_grad_value); + } + + const scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + atomicAdd(grad_attn_weight, top_grad * val); + atomicAdd(grad_sampling_loc, width * grad_w_weight * top_grad_value); + atomicAdd(grad_sampling_loc + 1, height * grad_h_weight * top_grad_value); +} + + +template +__global__ void ms_deformable_im2col_gpu_kernel(const int n, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *data_col) +{ + CUDA_KERNEL_LOOP(index, n) + { + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + scalar_t *data_col_ptr = data_col + index; + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + scalar_t col = 0; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const scalar_t *data_value_ptr = data_value + (data_value_ptr_init_offset + level_start_id * qid_stride); + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + col += ms_deform_attn_im2col_bilinear(data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col) * weight; + } + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + } + } + *data_col_ptr = col; + } +} + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + __shared__ scalar_t cache_grad_sampling_loc[blockSize * 2]; + __shared__ scalar_t cache_grad_attn_weight[blockSize]; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + if (tid == 0) + { + scalar_t _grad_w=cache_grad_sampling_loc[0], _grad_h=cache_grad_sampling_loc[1], _grad_a=cache_grad_attn_weight[0]; + int sid=2; + for (unsigned int tid = 1; tid < blockSize; ++tid) + { + _grad_w += cache_grad_sampling_loc[sid]; + _grad_h += cache_grad_sampling_loc[sid + 1]; + _grad_a += cache_grad_attn_weight[tid]; + sid += 2; + } + + + *grad_sampling_loc = _grad_w; + *(grad_sampling_loc + 1) = _grad_h; + *grad_attn_weight = _grad_a; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + __shared__ scalar_t cache_grad_sampling_loc[blockSize * 2]; + __shared__ scalar_t cache_grad_attn_weight[blockSize]; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + + for (unsigned int s=blockSize/2; s>0; s>>=1) + { + if (tid < s) { + const unsigned int xid1 = tid << 1; + const unsigned int xid2 = (tid + s) << 1; + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + s]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1]; + } + __syncthreads(); + } + + if (tid == 0) + { + *grad_sampling_loc = cache_grad_sampling_loc[0]; + *(grad_sampling_loc + 1) = cache_grad_sampling_loc[1]; + *grad_attn_weight = cache_grad_attn_weight[0]; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_reduce_v1(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + extern __shared__ int _s[]; + scalar_t* cache_grad_sampling_loc = (scalar_t*)_s; + scalar_t* cache_grad_attn_weight = cache_grad_sampling_loc + 2 * blockDim.x; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + if (tid == 0) + { + scalar_t _grad_w=cache_grad_sampling_loc[0], _grad_h=cache_grad_sampling_loc[1], _grad_a=cache_grad_attn_weight[0]; + int sid=2; + for (unsigned int tid = 1; tid < blockDim.x; ++tid) + { + _grad_w += cache_grad_sampling_loc[sid]; + _grad_h += cache_grad_sampling_loc[sid + 1]; + _grad_a += cache_grad_attn_weight[tid]; + sid += 2; + } + + + *grad_sampling_loc = _grad_w; + *(grad_sampling_loc + 1) = _grad_h; + *grad_attn_weight = _grad_a; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_reduce_v2(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + extern __shared__ int _s[]; + scalar_t* cache_grad_sampling_loc = (scalar_t*)_s; + scalar_t* cache_grad_attn_weight = cache_grad_sampling_loc + 2 * blockDim.x; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + + for (unsigned int s=blockDim.x/2, spre=blockDim.x; s>0; s>>=1, spre>>=1) + { + if (tid < s) { + const unsigned int xid1 = tid << 1; + const unsigned int xid2 = (tid + s) << 1; + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + s]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1]; + if (tid + (s << 1) < spre) + { + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + (s << 1)]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2 + (s << 1)]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1 + (s << 1)]; + } + } + __syncthreads(); + } + + if (tid == 0) + { + *grad_sampling_loc = cache_grad_sampling_loc[0]; + *(grad_sampling_loc + 1) = cache_grad_sampling_loc[1]; + *grad_attn_weight = cache_grad_attn_weight[0]; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_reduce_v2_multi_blocks(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + extern __shared__ int _s[]; + scalar_t* cache_grad_sampling_loc = (scalar_t*)_s; + scalar_t* cache_grad_attn_weight = cache_grad_sampling_loc + 2 * blockDim.x; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + + for (unsigned int s=blockDim.x/2, spre=blockDim.x; s>0; s>>=1, spre>>=1) + { + if (tid < s) { + const unsigned int xid1 = tid << 1; + const unsigned int xid2 = (tid + s) << 1; + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + s]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1]; + if (tid + (s << 1) < spre) + { + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + (s << 1)]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2 + (s << 1)]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1 + (s << 1)]; + } + } + __syncthreads(); + } + + if (tid == 0) + { + atomicAdd(grad_sampling_loc, cache_grad_sampling_loc[0]); + atomicAdd(grad_sampling_loc + 1, cache_grad_sampling_loc[1]); + atomicAdd(grad_attn_weight, cache_grad_attn_weight[0]); + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +__global__ void ms_deformable_col2im_gpu_kernel_gm(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear_gm( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + grad_sampling_loc, grad_attn_weight); + } + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +void ms_deformable_im2col_cuda(cudaStream_t stream, + const scalar_t* data_value, + const int64_t* data_spatial_shapes, + const int64_t* data_level_start_index, + const scalar_t* data_sampling_loc, + const scalar_t* data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t* data_col) +{ + const int num_kernels = batch_size * num_query * num_heads * channels; + const int num_actual_kernels = batch_size * num_query * num_heads * channels; + const int num_threads = CUDA_NUM_THREADS; + ms_deformable_im2col_gpu_kernel + <<>>( + num_kernels, data_value, data_spatial_shapes, data_level_start_index, data_sampling_loc, data_attn_weight, + batch_size, spatial_size, num_heads, channels, num_levels, num_query, num_point, data_col); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in ms_deformable_im2col_cuda: %s\n", cudaGetErrorString(err)); + } + +} + +template +void ms_deformable_col2im_cuda(cudaStream_t stream, + const scalar_t* grad_col, + const scalar_t* data_value, + const int64_t * data_spatial_shapes, + const int64_t * data_level_start_index, + const scalar_t * data_sampling_loc, + const scalar_t * data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t* grad_value, + scalar_t* grad_sampling_loc, + scalar_t* grad_attn_weight) +{ + const int num_threads = (channels > CUDA_NUM_THREADS)?CUDA_NUM_THREADS:channels; + const int num_kernels = batch_size * num_query * num_heads * channels; + const int num_actual_kernels = batch_size * num_query * num_heads * channels; + if (channels > 1024) + { + if ((channels & 1023) == 0) + { + ms_deformable_col2im_gpu_kernel_shm_reduce_v2_multi_blocks + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + else + { + ms_deformable_col2im_gpu_kernel_gm + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + } + else{ + switch(channels) + { + case 1: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 2: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 4: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 8: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 16: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 32: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 64: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 128: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 256: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 512: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 1024: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + default: + if (channels < 64) + { + ms_deformable_col2im_gpu_kernel_shm_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + else + { + ms_deformable_col2im_gpu_kernel_shm_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + } + } + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in ms_deformable_col2im_cuda: %s\n", cudaGetErrorString(err)); + } + +} \ No newline at end of file diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/cuda_version.cu b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/cuda_version.cu new file mode 100644 index 0000000000000000000000000000000000000000..64569e34ffb250964de27e33e7a53f3822270b9e --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/cuda_version.cu @@ -0,0 +1,7 @@ +#include + +namespace groundingdino { +int get_cudart_version() { + return CUDART_VERSION; +} +} // namespace groundingdino diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/csrc/vision.cpp b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/vision.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c1f2c50c82909bbd5492c163d634af77a3ba1781 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/csrc/vision.cpp @@ -0,0 +1,58 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + +#include "MsDeformAttn/ms_deform_attn.h" + +namespace groundingdino { + +#ifdef WITH_CUDA +extern int get_cudart_version(); +#endif + +std::string get_cuda_version() { +#ifdef WITH_CUDA + std::ostringstream oss; + + // copied from + // https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/cuda/detail/CUDAHooks.cpp#L231 + auto printCudaStyleVersion = [&](int v) { + oss << (v / 1000) << "." << (v / 10 % 100); + if (v % 10 != 0) { + oss << "." << (v % 10); + } + }; + printCudaStyleVersion(get_cudart_version()); + return oss.str(); +#else + return std::string("not available"); +#endif +} + +// similar to +// https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/Version.cpp +std::string get_compiler_version() { + std::ostringstream ss; +#if defined(__GNUC__) +#ifndef __clang__ + { ss << "GCC " << __GNUC__ << "." << __GNUC_MINOR__; } +#endif +#endif + +#if defined(__clang_major__) + { + ss << "clang " << __clang_major__ << "." << __clang_minor__ << "." + << __clang_patchlevel__; + } +#endif + +#if defined(_MSC_VER) + { ss << "MSVC " << _MSC_FULL_VER; } +#endif + return ss.str(); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("ms_deform_attn_forward", &ms_deform_attn_forward, "ms_deform_attn_forward"); + m.def("ms_deform_attn_backward", &ms_deform_attn_backward, "ms_deform_attn_backward"); +} + +} // namespace groundingdino \ No newline at end of file diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/fuse_modules.py b/GroundingDINO/groundingdino/models/GroundingDINO/fuse_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..2753b3ddee43c7a9fe28d1824db5d786e7e1ad59 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/fuse_modules.py @@ -0,0 +1,297 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ + +import torch +import torch.nn as nn +import torch.nn.functional as F +from timm.models.layers import DropPath + + +class FeatureResizer(nn.Module): + """ + This class takes as input a set of embeddings of dimension C1 and outputs a set of + embedding of dimension C2, after a linear transformation, dropout and normalization (LN). + """ + + def __init__(self, input_feat_size, output_feat_size, dropout, do_ln=True): + super().__init__() + self.do_ln = do_ln + # Object feature encoding + self.fc = nn.Linear(input_feat_size, output_feat_size, bias=True) + self.layer_norm = nn.LayerNorm(output_feat_size, eps=1e-12) + self.dropout = nn.Dropout(dropout) + + def forward(self, encoder_features): + x = self.fc(encoder_features) + if self.do_ln: + x = self.layer_norm(x) + output = self.dropout(x) + return output + + +def l1norm(X, dim, eps=1e-8): + """L1-normalize columns of X""" + norm = torch.abs(X).sum(dim=dim, keepdim=True) + eps + X = torch.div(X, norm) + return X + + +def l2norm(X, dim, eps=1e-8): + """L2-normalize columns of X""" + norm = torch.pow(X, 2).sum(dim=dim, keepdim=True).sqrt() + eps + X = torch.div(X, norm) + return X + + +def func_attention(query, context, smooth=1, raw_feature_norm="softmax", eps=1e-8): + """ + query: (n_context, queryL, d) + context: (n_context, sourceL, d) + """ + batch_size_q, queryL = query.size(0), query.size(1) + batch_size, sourceL = context.size(0), context.size(1) + + # Get attention + # --> (batch, d, queryL) + queryT = torch.transpose(query, 1, 2) + + # (batch, sourceL, d)(batch, d, queryL) + # --> (batch, sourceL, queryL) + attn = torch.bmm(context, queryT) + if raw_feature_norm == "softmax": + # --> (batch*sourceL, queryL) + attn = attn.view(batch_size * sourceL, queryL) + attn = nn.Softmax()(attn) + # --> (batch, sourceL, queryL) + attn = attn.view(batch_size, sourceL, queryL) + elif raw_feature_norm == "l2norm": + attn = l2norm(attn, 2) + elif raw_feature_norm == "clipped_l2norm": + attn = nn.LeakyReLU(0.1)(attn) + attn = l2norm(attn, 2) + else: + raise ValueError("unknown first norm type:", raw_feature_norm) + # --> (batch, queryL, sourceL) + attn = torch.transpose(attn, 1, 2).contiguous() + # --> (batch*queryL, sourceL) + attn = attn.view(batch_size * queryL, sourceL) + attn = nn.Softmax()(attn * smooth) + # --> (batch, queryL, sourceL) + attn = attn.view(batch_size, queryL, sourceL) + # --> (batch, sourceL, queryL) + attnT = torch.transpose(attn, 1, 2).contiguous() + + # --> (batch, d, sourceL) + contextT = torch.transpose(context, 1, 2) + # (batch x d x sourceL)(batch x sourceL x queryL) + # --> (batch, d, queryL) + weightedContext = torch.bmm(contextT, attnT) + # --> (batch, queryL, d) + weightedContext = torch.transpose(weightedContext, 1, 2) + + return weightedContext, attnT + + +class BiMultiHeadAttention(nn.Module): + def __init__(self, v_dim, l_dim, embed_dim, num_heads, dropout=0.1, cfg=None): + super(BiMultiHeadAttention, self).__init__() + + self.embed_dim = embed_dim + self.num_heads = num_heads + self.head_dim = embed_dim // num_heads + self.v_dim = v_dim + self.l_dim = l_dim + + assert ( + self.head_dim * self.num_heads == self.embed_dim + ), f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`: {self.num_heads})." + self.scale = self.head_dim ** (-0.5) + self.dropout = dropout + + self.v_proj = nn.Linear(self.v_dim, self.embed_dim) + self.l_proj = nn.Linear(self.l_dim, self.embed_dim) + self.values_v_proj = nn.Linear(self.v_dim, self.embed_dim) + self.values_l_proj = nn.Linear(self.l_dim, self.embed_dim) + + self.out_v_proj = nn.Linear(self.embed_dim, self.v_dim) + self.out_l_proj = nn.Linear(self.embed_dim, self.l_dim) + + self.stable_softmax_2d = True + self.clamp_min_for_underflow = True + self.clamp_max_for_overflow = True + + self._reset_parameters() + + def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int): + return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous() + + def _reset_parameters(self): + nn.init.xavier_uniform_(self.v_proj.weight) + self.v_proj.bias.data.fill_(0) + nn.init.xavier_uniform_(self.l_proj.weight) + self.l_proj.bias.data.fill_(0) + nn.init.xavier_uniform_(self.values_v_proj.weight) + self.values_v_proj.bias.data.fill_(0) + nn.init.xavier_uniform_(self.values_l_proj.weight) + self.values_l_proj.bias.data.fill_(0) + nn.init.xavier_uniform_(self.out_v_proj.weight) + self.out_v_proj.bias.data.fill_(0) + nn.init.xavier_uniform_(self.out_l_proj.weight) + self.out_l_proj.bias.data.fill_(0) + + def forward(self, v, l, attention_mask_v=None, attention_mask_l=None): + """_summary_ + + Args: + v (_type_): bs, n_img, dim + l (_type_): bs, n_text, dim + attention_mask_v (_type_, optional): _description_. bs, n_img + attention_mask_l (_type_, optional): _description_. bs, n_text + + Returns: + _type_: _description_ + """ + # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO': + # import ipdb; ipdb.set_trace() + bsz, tgt_len, _ = v.size() + + query_states = self.v_proj(v) * self.scale + key_states = self._shape(self.l_proj(l), -1, bsz) + value_v_states = self._shape(self.values_v_proj(v), -1, bsz) + value_l_states = self._shape(self.values_l_proj(l), -1, bsz) + + proj_shape = (bsz * self.num_heads, -1, self.head_dim) + query_states = self._shape(query_states, tgt_len, bsz).view(*proj_shape) + key_states = key_states.view(*proj_shape) + value_v_states = value_v_states.view(*proj_shape) + value_l_states = value_l_states.view(*proj_shape) + + src_len = key_states.size(1) + attn_weights = torch.bmm(query_states, key_states.transpose(1, 2)) # bs*nhead, nimg, ntxt + + if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len): + raise ValueError( + f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {attn_weights.size()}" + ) + + if self.stable_softmax_2d: + attn_weights = attn_weights - attn_weights.max() + + if self.clamp_min_for_underflow: + attn_weights = torch.clamp( + attn_weights, min=-50000 + ) # Do not increase -50000, data type half has quite limited range + if self.clamp_max_for_overflow: + attn_weights = torch.clamp( + attn_weights, max=50000 + ) # Do not increase 50000, data type half has quite limited range + + attn_weights_T = attn_weights.transpose(1, 2) + attn_weights_l = attn_weights_T - torch.max(attn_weights_T, dim=-1, keepdim=True)[0] + if self.clamp_min_for_underflow: + attn_weights_l = torch.clamp( + attn_weights_l, min=-50000 + ) # Do not increase -50000, data type half has quite limited range + if self.clamp_max_for_overflow: + attn_weights_l = torch.clamp( + attn_weights_l, max=50000 + ) # Do not increase 50000, data type half has quite limited range + + # mask vison for language + if attention_mask_v is not None: + attention_mask_v = ( + attention_mask_v[:, None, None, :].repeat(1, self.num_heads, 1, 1).flatten(0, 1) + ) + attn_weights_l.masked_fill_(attention_mask_v, float("-inf")) + + attn_weights_l = attn_weights_l.softmax(dim=-1) + + # mask language for vision + if attention_mask_l is not None: + attention_mask_l = ( + attention_mask_l[:, None, None, :].repeat(1, self.num_heads, 1, 1).flatten(0, 1) + ) + attn_weights.masked_fill_(attention_mask_l, float("-inf")) + attn_weights_v = attn_weights.softmax(dim=-1) + + attn_probs_v = F.dropout(attn_weights_v, p=self.dropout, training=self.training) + attn_probs_l = F.dropout(attn_weights_l, p=self.dropout, training=self.training) + + attn_output_v = torch.bmm(attn_probs_v, value_l_states) + attn_output_l = torch.bmm(attn_probs_l, value_v_states) + + if attn_output_v.size() != (bsz * self.num_heads, tgt_len, self.head_dim): + raise ValueError( + f"`attn_output_v` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {attn_output_v.size()}" + ) + + if attn_output_l.size() != (bsz * self.num_heads, src_len, self.head_dim): + raise ValueError( + f"`attn_output_l` should be of size {(bsz, self.num_heads, src_len, self.head_dim)}, but is {attn_output_l.size()}" + ) + + attn_output_v = attn_output_v.view(bsz, self.num_heads, tgt_len, self.head_dim) + attn_output_v = attn_output_v.transpose(1, 2) + attn_output_v = attn_output_v.reshape(bsz, tgt_len, self.embed_dim) + + attn_output_l = attn_output_l.view(bsz, self.num_heads, src_len, self.head_dim) + attn_output_l = attn_output_l.transpose(1, 2) + attn_output_l = attn_output_l.reshape(bsz, src_len, self.embed_dim) + + attn_output_v = self.out_v_proj(attn_output_v) + attn_output_l = self.out_l_proj(attn_output_l) + + return attn_output_v, attn_output_l + + +# Bi-Direction MHA (text->image, image->text) +class BiAttentionBlock(nn.Module): + def __init__( + self, + v_dim, + l_dim, + embed_dim, + num_heads, + dropout=0.1, + drop_path=0.0, + init_values=1e-4, + cfg=None, + ): + """ + Inputs: + embed_dim - Dimensionality of input and attention feature vectors + hidden_dim - Dimensionality of hidden layer in feed-forward network + (usually 2-4x larger than embed_dim) + num_heads - Number of heads to use in the Multi-Head Attention block + dropout - Amount of dropout to apply in the feed-forward network + """ + super(BiAttentionBlock, self).__init__() + + # pre layer norm + self.layer_norm_v = nn.LayerNorm(v_dim) + self.layer_norm_l = nn.LayerNorm(l_dim) + self.attn = BiMultiHeadAttention( + v_dim=v_dim, l_dim=l_dim, embed_dim=embed_dim, num_heads=num_heads, dropout=dropout + ) + + # add layer scale for training stability + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + self.gamma_v = nn.Parameter(init_values * torch.ones((v_dim)), requires_grad=True) + self.gamma_l = nn.Parameter(init_values * torch.ones((l_dim)), requires_grad=True) + + def forward(self, v, l, attention_mask_v=None, attention_mask_l=None): + v = self.layer_norm_v(v) + l = self.layer_norm_l(l) + delta_v, delta_l = self.attn( + v, l, attention_mask_v=attention_mask_v, attention_mask_l=attention_mask_l + ) + # v, l = v + delta_v, l + delta_l + v = v + self.drop_path(self.gamma_v * delta_v) + l = l + self.drop_path(self.gamma_l * delta_l) + return v, l + + # def forward(self, v:List[torch.Tensor], l, attention_mask_v=None, attention_mask_l=None) diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/groundingdino.py b/GroundingDINO/groundingdino/models/GroundingDINO/groundingdino.py new file mode 100644 index 0000000000000000000000000000000000000000..cd97028df679f89e5e7518e27ab620f2d6b1861d --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/groundingdino.py @@ -0,0 +1,412 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Conditional DETR model and criterion classes. +# Copyright (c) 2021 Microsoft. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Modified from DETR (https://github.com/facebookresearch/detr) +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# ------------------------------------------------------------------------ +# Modified from Deformable DETR (https://github.com/fundamentalvision/Deformable-DETR) +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# ------------------------------------------------------------------------ +import copy +from typing import List + +import torch +import torch.nn.functional as F +from torch import nn +from torchvision.ops.boxes import nms +from transformers import AutoTokenizer, BertModel, BertTokenizer, RobertaModel, RobertaTokenizerFast + +from groundingdino.util import box_ops, get_tokenlizer +from groundingdino.util.misc import ( + NestedTensor, + accuracy, + get_world_size, + interpolate, + inverse_sigmoid, + is_dist_avail_and_initialized, + nested_tensor_from_tensor_list, +) +from groundingdino.util.utils import get_phrases_from_posmap +from groundingdino.util.visualizer import COCOVisualizer +from groundingdino.util.vl_utils import create_positive_map_from_span + +from ..registry import MODULE_BUILD_FUNCS +from .backbone import build_backbone +from .bertwarper import ( + BertModelWarper, + generate_masks_with_special_tokens, + generate_masks_with_special_tokens_and_transfer_map, +) +from .transformer import build_transformer +from .utils import MLP, ContrastiveEmbed, sigmoid_focal_loss + + +class GroundingDINO(nn.Module): + """This is the Cross-Attention Detector module that performs object detection""" + + def __init__( + self, + backbone, + transformer, + num_queries, + aux_loss=False, + iter_update=False, + query_dim=2, + num_feature_levels=1, + nheads=8, + # two stage + two_stage_type="no", # ['no', 'standard'] + dec_pred_bbox_embed_share=True, + two_stage_class_embed_share=True, + two_stage_bbox_embed_share=True, + num_patterns=0, + dn_number=100, + dn_box_noise_scale=0.4, + dn_label_noise_ratio=0.5, + dn_labelbook_size=100, + text_encoder_type="bert-base-uncased", + sub_sentence_present=True, + max_text_len=256, + ): + """Initializes the model. + Parameters: + backbone: torch module of the backbone to be used. See backbone.py + transformer: torch module of the transformer architecture. See transformer.py + num_queries: number of object queries, ie detection slot. This is the maximal number of objects + Conditional DETR can detect in a single image. For COCO, we recommend 100 queries. + aux_loss: True if auxiliary decoding losses (loss at each decoder layer) are to be used. + """ + super().__init__() + self.num_queries = num_queries + self.transformer = transformer + self.hidden_dim = hidden_dim = transformer.d_model + self.num_feature_levels = num_feature_levels + self.nheads = nheads + self.max_text_len = 256 + self.sub_sentence_present = sub_sentence_present + + # setting query dim + self.query_dim = query_dim + assert query_dim == 4 + + # for dn training + self.num_patterns = num_patterns + self.dn_number = dn_number + self.dn_box_noise_scale = dn_box_noise_scale + self.dn_label_noise_ratio = dn_label_noise_ratio + self.dn_labelbook_size = dn_labelbook_size + + # bert + self.tokenizer = get_tokenlizer.get_tokenlizer(text_encoder_type) + self.bert = get_tokenlizer.get_pretrained_language_model(text_encoder_type) + self.bert.pooler.dense.weight.requires_grad_(False) + self.bert.pooler.dense.bias.requires_grad_(False) + self.bert = BertModelWarper(bert_model=self.bert) + + self.feat_map = nn.Linear(self.bert.config.hidden_size, self.hidden_dim, bias=True) + nn.init.constant_(self.feat_map.bias.data, 0) + nn.init.xavier_uniform_(self.feat_map.weight.data) + # freeze + + # special tokens + self.specical_tokens = self.tokenizer.convert_tokens_to_ids(["[CLS]", "[SEP]", ".", "?"]) + + # prepare input projection layers + if num_feature_levels > 1: + num_backbone_outs = len(backbone.num_channels) + input_proj_list = [] + for _ in range(num_backbone_outs): + in_channels = backbone.num_channels[_] + input_proj_list.append( + nn.Sequential( + nn.Conv2d(in_channels, hidden_dim, kernel_size=1), + nn.GroupNorm(32, hidden_dim), + ) + ) + for _ in range(num_feature_levels - num_backbone_outs): + input_proj_list.append( + nn.Sequential( + nn.Conv2d(in_channels, hidden_dim, kernel_size=3, stride=2, padding=1), + nn.GroupNorm(32, hidden_dim), + ) + ) + in_channels = hidden_dim + self.input_proj = nn.ModuleList(input_proj_list) + else: + assert two_stage_type == "no", "two_stage_type should be no if num_feature_levels=1 !!!" + self.input_proj = nn.ModuleList( + [ + nn.Sequential( + nn.Conv2d(backbone.num_channels[-1], hidden_dim, kernel_size=1), + nn.GroupNorm(32, hidden_dim), + ) + ] + ) + + self.backbone = backbone + self.aux_loss = aux_loss + self.box_pred_damping = box_pred_damping = None + + self.iter_update = iter_update + assert iter_update, "Why not iter_update?" + + # prepare pred layers + self.dec_pred_bbox_embed_share = dec_pred_bbox_embed_share + # prepare class & box embed + _class_embed = ContrastiveEmbed() + + _bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3) + nn.init.constant_(_bbox_embed.layers[-1].weight.data, 0) + nn.init.constant_(_bbox_embed.layers[-1].bias.data, 0) + + if dec_pred_bbox_embed_share: + box_embed_layerlist = [_bbox_embed for i in range(transformer.num_decoder_layers)] + else: + box_embed_layerlist = [ + copy.deepcopy(_bbox_embed) for i in range(transformer.num_decoder_layers) + ] + class_embed_layerlist = [_class_embed for i in range(transformer.num_decoder_layers)] + self.bbox_embed = nn.ModuleList(box_embed_layerlist) + self.class_embed = nn.ModuleList(class_embed_layerlist) + self.transformer.decoder.bbox_embed = self.bbox_embed + self.transformer.decoder.class_embed = self.class_embed + + # two stage + self.two_stage_type = two_stage_type + assert two_stage_type in ["no", "standard"], "unknown param {} of two_stage_type".format( + two_stage_type + ) + if two_stage_type != "no": + if two_stage_bbox_embed_share: + assert dec_pred_bbox_embed_share + self.transformer.enc_out_bbox_embed = _bbox_embed + else: + self.transformer.enc_out_bbox_embed = copy.deepcopy(_bbox_embed) + + if two_stage_class_embed_share: + assert dec_pred_bbox_embed_share + self.transformer.enc_out_class_embed = _class_embed + else: + self.transformer.enc_out_class_embed = copy.deepcopy(_class_embed) + + self.refpoint_embed = None + + self._reset_parameters() + + def _reset_parameters(self): + # init input_proj + for proj in self.input_proj: + nn.init.xavier_uniform_(proj[0].weight, gain=1) + nn.init.constant_(proj[0].bias, 0) + + def set_image_tensor(self, samples: NestedTensor): + if isinstance(samples, (list, torch.Tensor)): + samples = nested_tensor_from_tensor_list(samples) + self.features, self.poss = self.backbone(samples) + + def unset_image_tensor(self): + if hasattr(self, 'features'): + del self.features + if hasattr(self,'poss'): + del self.poss + + def set_image_features(self, features , poss): + self.features = features + self.poss = poss + + def init_ref_points(self, use_num_queries): + self.refpoint_embed = nn.Embedding(use_num_queries, self.query_dim) + + def forward(self, samples: NestedTensor, targets: List = None, **kw): + """The forward expects a NestedTensor, which consists of: + - samples.tensor: batched images, of shape [batch_size x 3 x H x W] + - samples.mask: a binary mask of shape [batch_size x H x W], containing 1 on padded pixels + + It returns a dict with the following elements: + - "pred_logits": the classification logits (including no-object) for all queries. + Shape= [batch_size x num_queries x num_classes] + - "pred_boxes": The normalized boxes coordinates for all queries, represented as + (center_x, center_y, width, height). These values are normalized in [0, 1], + relative to the size of each individual image (disregarding possible padding). + See PostProcess for information on how to retrieve the unnormalized bounding box. + - "aux_outputs": Optional, only returned when auxilary losses are activated. It is a list of + dictionnaries containing the two above keys for each decoder layer. + """ + if targets is None: + captions = kw["captions"] + else: + captions = [t["caption"] for t in targets] + + # encoder texts + tokenized = self.tokenizer(captions, padding="longest", return_tensors="pt").to( + samples.device + ) + ( + text_self_attention_masks, + position_ids, + cate_to_token_mask_list, + ) = generate_masks_with_special_tokens_and_transfer_map( + tokenized, self.specical_tokens, self.tokenizer + ) + + if text_self_attention_masks.shape[1] > self.max_text_len: + text_self_attention_masks = text_self_attention_masks[ + :, : self.max_text_len, : self.max_text_len + ] + position_ids = position_ids[:, : self.max_text_len] + tokenized["input_ids"] = tokenized["input_ids"][:, : self.max_text_len] + tokenized["attention_mask"] = tokenized["attention_mask"][:, : self.max_text_len] + tokenized["token_type_ids"] = tokenized["token_type_ids"][:, : self.max_text_len] + + # extract text embeddings + if self.sub_sentence_present: + tokenized_for_encoder = {k: v for k, v in tokenized.items() if k != "attention_mask"} + tokenized_for_encoder["attention_mask"] = text_self_attention_masks + tokenized_for_encoder["position_ids"] = position_ids + else: + # import ipdb; ipdb.set_trace() + tokenized_for_encoder = tokenized + + bert_output = self.bert(**tokenized_for_encoder) # bs, 195, 768 + + encoded_text = self.feat_map(bert_output["last_hidden_state"]) # bs, 195, d_model + text_token_mask = tokenized.attention_mask.bool() # bs, 195 + # text_token_mask: True for nomask, False for mask + # text_self_attention_masks: True for nomask, False for mask + + if encoded_text.shape[1] > self.max_text_len: + encoded_text = encoded_text[:, : self.max_text_len, :] + text_token_mask = text_token_mask[:, : self.max_text_len] + position_ids = position_ids[:, : self.max_text_len] + text_self_attention_masks = text_self_attention_masks[ + :, : self.max_text_len, : self.max_text_len + ] + + text_dict = { + "encoded_text": encoded_text, # bs, 195, d_model + "text_token_mask": text_token_mask, # bs, 195 + "position_ids": position_ids, # bs, 195 + "text_self_attention_masks": text_self_attention_masks, # bs, 195,195 + } + + # import ipdb; ipdb.set_trace() + if isinstance(samples, (list, torch.Tensor)): + samples = nested_tensor_from_tensor_list(samples) + if not hasattr(self, 'features') or not hasattr(self, 'poss'): + self.set_image_tensor(samples) + + srcs = [] + masks = [] + for l, feat in enumerate(self.features): + src, mask = feat.decompose() + srcs.append(self.input_proj[l](src)) + masks.append(mask) + assert mask is not None + if self.num_feature_levels > len(srcs): + _len_srcs = len(srcs) + for l in range(_len_srcs, self.num_feature_levels): + if l == _len_srcs: + src = self.input_proj[l](self.features[-1].tensors) + else: + src = self.input_proj[l](srcs[-1]) + m = samples.mask + mask = F.interpolate(m[None].float(), size=src.shape[-2:]).to(torch.bool)[0] + pos_l = self.backbone[1](NestedTensor(src, mask)).to(src.dtype) + srcs.append(src) + masks.append(mask) + self.poss.append(pos_l) + + input_query_bbox = input_query_label = attn_mask = dn_meta = None + hs, reference, hs_enc, ref_enc, init_box_proposal = self.transformer( + srcs, masks, input_query_bbox, self.poss, input_query_label, attn_mask, text_dict + ) + + # deformable-detr-like anchor update + outputs_coord_list = [] + for dec_lid, (layer_ref_sig, layer_bbox_embed, layer_hs) in enumerate( + zip(reference[:-1], self.bbox_embed, hs) + ): + layer_delta_unsig = layer_bbox_embed(layer_hs) + layer_outputs_unsig = layer_delta_unsig + inverse_sigmoid(layer_ref_sig) + layer_outputs_unsig = layer_outputs_unsig.sigmoid() + outputs_coord_list.append(layer_outputs_unsig) + outputs_coord_list = torch.stack(outputs_coord_list) + + # output + outputs_class = torch.stack( + [ + layer_cls_embed(layer_hs, text_dict) + for layer_cls_embed, layer_hs in zip(self.class_embed, hs) + ] + ) + out = {"pred_logits": outputs_class[-1], "pred_boxes": outputs_coord_list[-1]} + + # # for intermediate outputs + # if self.aux_loss: + # out['aux_outputs'] = self._set_aux_loss(outputs_class, outputs_coord_list) + + # # for encoder output + # if hs_enc is not None: + # # prepare intermediate outputs + # interm_coord = ref_enc[-1] + # interm_class = self.transformer.enc_out_class_embed(hs_enc[-1], text_dict) + # out['interm_outputs'] = {'pred_logits': interm_class, 'pred_boxes': interm_coord} + # out['interm_outputs_for_matching_pre'] = {'pred_logits': interm_class, 'pred_boxes': init_box_proposal} + unset_image_tensor = kw.get('unset_image_tensor', True) + if unset_image_tensor: + self.unset_image_tensor() ## If necessary + return out + + @torch.jit.unused + def _set_aux_loss(self, outputs_class, outputs_coord): + # this is a workaround to make torchscript happy, as torchscript + # doesn't support dictionary with non-homogeneous values, such + # as a dict having both a Tensor and a list. + return [ + {"pred_logits": a, "pred_boxes": b} + for a, b in zip(outputs_class[:-1], outputs_coord[:-1]) + ] + + +@MODULE_BUILD_FUNCS.registe_with_name(module_name="groundingdino") +def build_groundingdino(args): + + backbone = build_backbone(args) + transformer = build_transformer(args) + + dn_labelbook_size = args.dn_labelbook_size + dec_pred_bbox_embed_share = args.dec_pred_bbox_embed_share + sub_sentence_present = args.sub_sentence_present + + model = GroundingDINO( + backbone, + transformer, + num_queries=args.num_queries, + aux_loss=True, + iter_update=True, + query_dim=4, + num_feature_levels=args.num_feature_levels, + nheads=args.nheads, + dec_pred_bbox_embed_share=dec_pred_bbox_embed_share, + two_stage_type=args.two_stage_type, + two_stage_bbox_embed_share=args.two_stage_bbox_embed_share, + two_stage_class_embed_share=args.two_stage_class_embed_share, + num_patterns=args.num_patterns, + dn_number=0, + dn_box_noise_scale=args.dn_box_noise_scale, + dn_label_noise_ratio=args.dn_label_noise_ratio, + dn_labelbook_size=dn_labelbook_size, + text_encoder_type=args.text_encoder_type, + sub_sentence_present=sub_sentence_present, + max_text_len=args.max_text_len, + ) + + return model + diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/ms_deform_attn.py b/GroundingDINO/groundingdino/models/GroundingDINO/ms_deform_attn.py new file mode 100644 index 0000000000000000000000000000000000000000..489d501bef364020212306d81e9b85c8daa27491 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/ms_deform_attn.py @@ -0,0 +1,413 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from: +# https://github.com/fundamentalvision/Deformable-DETR/blob/main/models/ops/functions/ms_deform_attn_func.py +# https://github.com/fundamentalvision/Deformable-DETR/blob/main/models/ops/modules/ms_deform_attn.py +# https://github.com/open-mmlab/mmcv/blob/master/mmcv/ops/multi_scale_deform_attn.py +# ------------------------------------------------------------------------------------------------ + +import math +import warnings +from typing import Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.init import constant_, xavier_uniform_ + +try: + from groundingdino import _C +except: + warnings.warn("Failed to load custom C++ ops. Running on CPU mode Only!") + + +# helpers +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 MultiScaleDeformableAttnFunction(Function): + @staticmethod + def forward( + ctx, + value, + value_spatial_shapes, + value_level_start_index, + sampling_locations, + attention_weights, + im2col_step, + ): + ctx.im2col_step = im2col_step + output = _C.ms_deform_attn_forward( + value, + value_spatial_shapes, + value_level_start_index, + sampling_locations, + attention_weights, + ctx.im2col_step, + ) + ctx.save_for_backward( + value, + value_spatial_shapes, + value_level_start_index, + sampling_locations, + attention_weights, + ) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + ( + value, + value_spatial_shapes, + value_level_start_index, + sampling_locations, + attention_weights, + ) = ctx.saved_tensors + grad_value, grad_sampling_loc, grad_attn_weight = _C.ms_deform_attn_backward( + value, + value_spatial_shapes, + value_level_start_index, + sampling_locations, + attention_weights, + grad_output, + ctx.im2col_step, + ) + + return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None + + +def multi_scale_deformable_attn_pytorch( + value: torch.Tensor, + value_spatial_shapes: torch.Tensor, + sampling_locations: torch.Tensor, + attention_weights: torch.Tensor, +) -> torch.Tensor: + + bs, _, num_heads, embed_dims = value.shape + _, num_queries, num_heads, num_levels, num_points, _ = 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 level, (H_, W_) in enumerate(value_spatial_shapes): + # bs, H_*W_, num_heads, embed_dims -> + # bs, H_*W_, num_heads*embed_dims -> + # bs, num_heads*embed_dims, H_*W_ -> + # bs*num_heads, embed_dims, H_, W_ + value_l_ = ( + value_list[level].flatten(2).transpose(1, 2).reshape(bs * num_heads, embed_dims, H_, W_) + ) + # bs, num_queries, num_heads, num_points, 2 -> + # bs, num_heads, num_queries, num_points, 2 -> + # bs*num_heads, num_queries, num_points, 2 + sampling_grid_l_ = sampling_grids[:, :, :, level].transpose(1, 2).flatten(0, 1) + # bs*num_heads, embed_dims, num_queries, num_points + 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_) + # (bs, num_queries, num_heads, num_levels, num_points) -> + # (bs, num_heads, num_queries, num_levels, num_points) -> + # (bs, num_heads, 1, num_queries, num_levels*num_points) + attention_weights = attention_weights.transpose(1, 2).reshape( + bs * num_heads, 1, num_queries, num_levels * num_points + ) + output = ( + (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights) + .sum(-1) + .view(bs, num_heads * embed_dims, num_queries) + ) + return output.transpose(1, 2).contiguous() + + +class MultiScaleDeformableAttention(nn.Module): + """Multi-Scale Deformable Attention Module used in Deformable-DETR + + `Deformable DETR: Deformable Transformers for End-to-End Object Detection. + `_. + + Args: + embed_dim (int): The embedding dimension of Attention. Default: 256. + num_heads (int): The number of attention heads. Default: 8. + num_levels (int): The number of feature map used in Attention. Default: 4. + num_points (int): The number of sampling points for each query + in each head. Default: 4. + img2col_steps (int): The step used in image_to_column. Defualt: 64. + dropout (float): Dropout layer used in output. Default: 0.1. + batch_first (bool): if ``True``, then the input and output tensor will be + provided as `(bs, n, embed_dim)`. Default: False. `(n, bs, embed_dim)` + """ + + def __init__( + self, + embed_dim: int = 256, + num_heads: int = 8, + num_levels: int = 4, + num_points: int = 4, + img2col_step: int = 64, + batch_first: bool = False, + ): + super().__init__() + if embed_dim % num_heads != 0: + raise ValueError( + "embed_dim must be divisible by num_heads, but got {} and {}".format( + embed_dim, num_heads + ) + ) + head_dim = embed_dim // num_heads + + self.batch_first = batch_first + + if not _is_power_of_2(head_dim): + warnings.warn( + """ + You'd better set d_model in MSDeformAttn to make sure that + each dim of the attention head a power of 2, which is more efficient. + """ + ) + + self.im2col_step = img2col_step + self.embed_dim = embed_dim + self.num_heads = num_heads + self.num_levels = num_levels + self.num_points = num_points + self.sampling_offsets = nn.Linear(embed_dim, num_heads * num_levels * num_points * 2) + self.attention_weights = nn.Linear(embed_dim, num_heads * num_levels * num_points) + self.value_proj = nn.Linear(embed_dim, embed_dim) + self.output_proj = nn.Linear(embed_dim, embed_dim) + + self.init_weights() + + def _reset_parameters(self): + return self.init_weights() + + def init_weights(self): + """ + Default initialization for Parameters of Module. + """ + constant_(self.sampling_offsets.weight.data, 0.0) + thetas = torch.arange(self.num_heads, dtype=torch.float32) * ( + 2.0 * math.pi / self.num_heads + ) + grid_init = torch.stack([thetas.cos(), thetas.sin()], -1) + grid_init = ( + (grid_init / grid_init.abs().max(-1, keepdim=True)[0]) + .view(self.num_heads, 1, 1, 2) + .repeat(1, self.num_levels, self.num_points, 1) + ) + for i in range(self.num_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 freeze_sampling_offsets(self): + print("Freeze sampling offsets") + self.sampling_offsets.weight.requires_grad = False + self.sampling_offsets.bias.requires_grad = False + + def freeze_attention_weights(self): + print("Freeze attention weights") + self.attention_weights.weight.requires_grad = False + self.attention_weights.bias.requires_grad = False + + def forward( + self, + query: torch.Tensor, + key: Optional[torch.Tensor] = None, + value: Optional[torch.Tensor] = None, + query_pos: Optional[torch.Tensor] = None, + key_padding_mask: Optional[torch.Tensor] = None, + reference_points: Optional[torch.Tensor] = None, + spatial_shapes: Optional[torch.Tensor] = None, + level_start_index: Optional[torch.Tensor] = None, + **kwargs + ) -> torch.Tensor: + + """Forward Function of MultiScaleDeformableAttention + + Args: + query (torch.Tensor): Query embeddings with shape + `(num_query, bs, embed_dim)` + key (torch.Tensor): Key embeddings with shape + `(num_key, bs, embed_dim)` + value (torch.Tensor): Value embeddings with shape + `(num_key, bs, embed_dim)` + query_pos (torch.Tensor): The position embedding for `query`. Default: None. + key_padding_mask (torch.Tensor): ByteTensor for `query`, with shape `(bs, num_key)`, + indicating which elements within `key` to be ignored in attention. + reference_points (torch.Tensor): The normalized reference points + with shape `(bs, num_query, num_levels, 2)`, + all elements is range in [0, 1], top-left (0, 0), + bottom-right (1, 1), including padding are. + or `(N, Length_{query}, num_levels, 4)`, add additional + two dimensions `(h, w)` to form reference boxes. + spatial_shapes (torch.Tensor): Spatial shape of features in different levels. + With shape `(num_levels, 2)`, last dimension represents `(h, w)`. + level_start_index (torch.Tensor): The start index of each level. A tensor with + shape `(num_levels, )` which can be represented as + `[0, h_0 * w_0, h_0 * w_0 + h_1 * w_1, ...]`. + + Returns: + torch.Tensor: forward results with shape `(num_query, bs, embed_dim)` + """ + + if value is None: + value = query + + if query_pos is not None: + query = query + query_pos + + if not self.batch_first: + # change to (bs, num_query ,embed_dims) + query = query.permute(1, 0, 2) + value = value.permute(1, 0, 2) + + bs, num_query, _ = query.shape + bs, num_value, _ = value.shape + + assert (spatial_shapes[:, 0] * spatial_shapes[:, 1]).sum() == num_value + + value = self.value_proj(value) + if key_padding_mask is not None: + value = value.masked_fill(key_padding_mask[..., None], float(0)) + value = value.view(bs, num_value, self.num_heads, -1) + sampling_offsets = self.sampling_offsets(query).view( + bs, num_query, self.num_heads, self.num_levels, self.num_points, 2 + ) + attention_weights = self.attention_weights(query).view( + bs, num_query, self.num_heads, self.num_levels * self.num_points + ) + attention_weights = attention_weights.softmax(-1) + attention_weights = attention_weights.view( + bs, + num_query, + self.num_heads, + self.num_levels, + self.num_points, + ) + + # bs, num_query, num_heads, num_levels, num_points, 2 + if reference_points.shape[-1] == 2: + offset_normalizer = torch.stack([spatial_shapes[..., 1], 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.num_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] + ) + ) + + if torch.cuda.is_available() and value.is_cuda: + halffloat = False + if value.dtype == torch.float16: + halffloat = True + value = value.float() + sampling_locations = sampling_locations.float() + attention_weights = attention_weights.float() + + output = MultiScaleDeformableAttnFunction.apply( + value, + spatial_shapes, + level_start_index, + sampling_locations, + attention_weights, + self.im2col_step, + ) + + if halffloat: + output = output.half() + else: + output = multi_scale_deformable_attn_pytorch( + value, spatial_shapes, sampling_locations, attention_weights + ) + + output = self.output_proj(output) + + if not self.batch_first: + output = output.permute(1, 0, 2) + + return output + + +def create_dummy_class(klass, dependency, message=""): + """ + When a dependency of a class is not available, create a dummy class which throws ImportError + when used. + + Args: + klass (str): name of the class. + dependency (str): name of the dependency. + message: extra message to print + Returns: + class: a class object + """ + err = "Cannot import '{}', therefore '{}' is not available.".format(dependency, klass) + if message: + err = err + " " + message + + class _DummyMetaClass(type): + # throw error on class attribute access + def __getattr__(_, __): # noqa: B902 + raise ImportError(err) + + class _Dummy(object, metaclass=_DummyMetaClass): + # throw error on constructor + def __init__(self, *args, **kwargs): + raise ImportError(err) + + return _Dummy + + +def create_dummy_func(func, dependency, message=""): + """ + When a dependency of a function is not available, create a dummy function which throws + ImportError when used. + + Args: + func (str): name of the function. + dependency (str or list[str]): name(s) of the dependency. + message: extra message to print + Returns: + function: a function object + """ + err = "Cannot import '{}', therefore '{}' is not available.".format(dependency, func) + if message: + err = err + " " + message + + if isinstance(dependency, (list, tuple)): + dependency = ",".join(dependency) + + def _dummy(*args, **kwargs): + raise ImportError(err) + + return _dummy diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/transformer.py b/GroundingDINO/groundingdino/models/GroundingDINO/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..fcb8742dbdde6e80fd38b11d064211f6935aae76 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/transformer.py @@ -0,0 +1,959 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# DINO +# Copyright (c) 2022 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Conditional DETR Transformer class. +# Copyright (c) 2021 Microsoft. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Modified from DETR (https://github.com/facebookresearch/detr) +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# ------------------------------------------------------------------------ + +from typing import Optional + +import torch +import torch.utils.checkpoint as checkpoint +from torch import Tensor, nn + +from groundingdino.util.misc import inverse_sigmoid + +from .fuse_modules import BiAttentionBlock +from .ms_deform_attn import MultiScaleDeformableAttention as MSDeformAttn +from .transformer_vanilla import TransformerEncoderLayer +from .utils import ( + MLP, + _get_activation_fn, + _get_clones, + gen_encoder_output_proposals, + gen_sineembed_for_position, + get_sine_pos_embed, +) + + +class Transformer(nn.Module): + def __init__( + self, + d_model=256, + nhead=8, + num_queries=300, + num_encoder_layers=6, + num_unicoder_layers=0, + num_decoder_layers=6, + dim_feedforward=2048, + dropout=0.0, + activation="relu", + normalize_before=False, + return_intermediate_dec=False, + query_dim=4, + num_patterns=0, + # for deformable encoder + num_feature_levels=1, + enc_n_points=4, + dec_n_points=4, + # init query + learnable_tgt_init=False, + # two stage + two_stage_type="no", # ['no', 'standard', 'early', 'combine', 'enceachlayer', 'enclayer1'] + embed_init_tgt=False, + # for text + use_text_enhancer=False, + use_fusion_layer=False, + use_checkpoint=False, + use_transformer_ckpt=False, + use_text_cross_attention=False, + text_dropout=0.1, + fusion_dropout=0.1, + fusion_droppath=0.0, + ): + super().__init__() + self.num_feature_levels = num_feature_levels + self.num_encoder_layers = num_encoder_layers + self.num_unicoder_layers = num_unicoder_layers + self.num_decoder_layers = num_decoder_layers + self.num_queries = num_queries + assert query_dim == 4 + + # choose encoder layer type + encoder_layer = DeformableTransformerEncoderLayer( + d_model, dim_feedforward, dropout, activation, num_feature_levels, nhead, enc_n_points + ) + + if use_text_enhancer: + text_enhance_layer = TransformerEncoderLayer( + d_model=d_model, + nhead=nhead // 2, + dim_feedforward=dim_feedforward // 2, + dropout=text_dropout, + ) + else: + text_enhance_layer = None + + if use_fusion_layer: + feature_fusion_layer = BiAttentionBlock( + v_dim=d_model, + l_dim=d_model, + embed_dim=dim_feedforward // 2, + num_heads=nhead // 2, + dropout=fusion_dropout, + drop_path=fusion_droppath, + ) + else: + feature_fusion_layer = None + + encoder_norm = nn.LayerNorm(d_model) if normalize_before else None + assert encoder_norm is None + self.encoder = TransformerEncoder( + encoder_layer, + num_encoder_layers, + d_model=d_model, + num_queries=num_queries, + text_enhance_layer=text_enhance_layer, + feature_fusion_layer=feature_fusion_layer, + use_checkpoint=use_checkpoint, + use_transformer_ckpt=use_transformer_ckpt, + ) + + # choose decoder layer type + decoder_layer = DeformableTransformerDecoderLayer( + d_model, + dim_feedforward, + dropout, + activation, + num_feature_levels, + nhead, + dec_n_points, + use_text_cross_attention=use_text_cross_attention, + ) + + decoder_norm = nn.LayerNorm(d_model) + self.decoder = TransformerDecoder( + decoder_layer, + num_decoder_layers, + decoder_norm, + return_intermediate=return_intermediate_dec, + d_model=d_model, + query_dim=query_dim, + num_feature_levels=num_feature_levels, + ) + + self.d_model = d_model + self.nhead = nhead + self.dec_layers = num_decoder_layers + self.num_queries = num_queries # useful for single stage model only + self.num_patterns = num_patterns + if not isinstance(num_patterns, int): + Warning("num_patterns should be int but {}".format(type(num_patterns))) + self.num_patterns = 0 + + if num_feature_levels > 1: + if self.num_encoder_layers > 0: + self.level_embed = nn.Parameter(torch.Tensor(num_feature_levels, d_model)) + else: + self.level_embed = None + + self.learnable_tgt_init = learnable_tgt_init + assert learnable_tgt_init, "why not learnable_tgt_init" + self.embed_init_tgt = embed_init_tgt + if (two_stage_type != "no" and embed_init_tgt) or (two_stage_type == "no"): + self.tgt_embed = nn.Embedding(self.num_queries, d_model) + nn.init.normal_(self.tgt_embed.weight.data) + else: + self.tgt_embed = None + + # for two stage + self.two_stage_type = two_stage_type + assert two_stage_type in ["no", "standard"], "unknown param {} of two_stage_type".format( + two_stage_type + ) + if two_stage_type == "standard": + # anchor selection at the output of encoder + self.enc_output = nn.Linear(d_model, d_model) + self.enc_output_norm = nn.LayerNorm(d_model) + self.two_stage_wh_embedding = None + + if two_stage_type == "no": + self.init_ref_points(num_queries) # init self.refpoint_embed + + self.enc_out_class_embed = None + self.enc_out_bbox_embed = None + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + for m in self.modules(): + if isinstance(m, MSDeformAttn): + m._reset_parameters() + if self.num_feature_levels > 1 and self.level_embed is not None: + nn.init.normal_(self.level_embed) + + def get_valid_ratio(self, mask): + _, 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 init_ref_points(self, use_num_queries): + self.refpoint_embed = nn.Embedding(use_num_queries, 4) + + def forward(self, srcs, masks, refpoint_embed, pos_embeds, tgt, attn_mask=None, text_dict=None): + """ + Input: + - srcs: List of multi features [bs, ci, hi, wi] + - masks: List of multi masks [bs, hi, wi] + - refpoint_embed: [bs, num_dn, 4]. None in infer + - pos_embeds: List of multi pos embeds [bs, ci, hi, wi] + - tgt: [bs, num_dn, d_model]. None in infer + + """ + # prepare input for encoder + src_flatten = [] + mask_flatten = [] + lvl_pos_embed_flatten = [] + spatial_shapes = [] + for lvl, (src, mask, pos_embed) in enumerate(zip(srcs, masks, pos_embeds)): + bs, c, h, w = src.shape + spatial_shape = (h, w) + spatial_shapes.append(spatial_shape) + + src = src.flatten(2).transpose(1, 2) # bs, hw, c + mask = mask.flatten(1) # bs, hw + pos_embed = pos_embed.flatten(2).transpose(1, 2) # bs, hw, c + if self.num_feature_levels > 1 and self.level_embed is not None: + lvl_pos_embed = pos_embed + self.level_embed[lvl].view(1, 1, -1) + else: + lvl_pos_embed = pos_embed + lvl_pos_embed_flatten.append(lvl_pos_embed) + src_flatten.append(src) + mask_flatten.append(mask) + src_flatten = torch.cat(src_flatten, 1) # bs, \sum{hxw}, c + mask_flatten = torch.cat(mask_flatten, 1) # bs, \sum{hxw} + lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1) # bs, \sum{hxw}, c + spatial_shapes = torch.as_tensor( + spatial_shapes, dtype=torch.long, device=src_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 masks], 1) + + # two stage + enc_topk_proposals = enc_refpoint_embed = None + + ######################################################### + # Begin Encoder + ######################################################### + memory, memory_text = self.encoder( + src_flatten, + pos=lvl_pos_embed_flatten, + level_start_index=level_start_index, + spatial_shapes=spatial_shapes, + valid_ratios=valid_ratios, + key_padding_mask=mask_flatten, + memory_text=text_dict["encoded_text"], + text_attention_mask=~text_dict["text_token_mask"], + # we ~ the mask . False means use the token; True means pad the token + position_ids=text_dict["position_ids"], + text_self_attention_masks=text_dict["text_self_attention_masks"], + ) + ######################################################### + # End Encoder + # - memory: bs, \sum{hw}, c + # - mask_flatten: bs, \sum{hw} + # - lvl_pos_embed_flatten: bs, \sum{hw}, c + # - enc_intermediate_output: None or (nenc+1, bs, nq, c) or (nenc, bs, nq, c) + # - enc_intermediate_refpoints: None or (nenc+1, bs, nq, c) or (nenc, bs, nq, c) + ######################################################### + text_dict["encoded_text"] = memory_text + # if os.environ.get("SHILONG_AMP_INFNAN_DEBUG") == '1': + # if memory.isnan().any() | memory.isinf().any(): + # import ipdb; ipdb.set_trace() + + if self.two_stage_type == "standard": + output_memory, output_proposals = gen_encoder_output_proposals( + memory, mask_flatten, spatial_shapes + ) + output_memory = self.enc_output_norm(self.enc_output(output_memory)) + + if text_dict is not None: + enc_outputs_class_unselected = self.enc_out_class_embed(output_memory, text_dict) + else: + enc_outputs_class_unselected = self.enc_out_class_embed(output_memory) + + topk_logits = enc_outputs_class_unselected.max(-1)[0] + enc_outputs_coord_unselected = ( + self.enc_out_bbox_embed(output_memory) + output_proposals + ) # (bs, \sum{hw}, 4) unsigmoid + topk = self.num_queries + + topk_proposals = torch.topk(topk_logits, topk, dim=1)[1] # bs, nq + + # gather boxes + refpoint_embed_undetach = torch.gather( + enc_outputs_coord_unselected, 1, topk_proposals.unsqueeze(-1).repeat(1, 1, 4) + ) # unsigmoid + refpoint_embed_ = refpoint_embed_undetach.detach() + init_box_proposal = torch.gather( + output_proposals, 1, topk_proposals.unsqueeze(-1).repeat(1, 1, 4) + ).sigmoid() # sigmoid + + # gather tgt + tgt_undetach = torch.gather( + output_memory, 1, topk_proposals.unsqueeze(-1).repeat(1, 1, self.d_model) + ) + if self.embed_init_tgt: + tgt_ = ( + self.tgt_embed.weight[:, None, :].repeat(1, bs, 1).transpose(0, 1) + ) # nq, bs, d_model + else: + tgt_ = tgt_undetach.detach() + + if refpoint_embed is not None: + refpoint_embed = torch.cat([refpoint_embed, refpoint_embed_], dim=1) + tgt = torch.cat([tgt, tgt_], dim=1) + else: + refpoint_embed, tgt = refpoint_embed_, tgt_ + + elif self.two_stage_type == "no": + tgt_ = ( + self.tgt_embed.weight[:, None, :].repeat(1, bs, 1).transpose(0, 1) + ) # nq, bs, d_model + refpoint_embed_ = ( + self.refpoint_embed.weight[:, None, :].repeat(1, bs, 1).transpose(0, 1) + ) # nq, bs, 4 + + if refpoint_embed is not None: + refpoint_embed = torch.cat([refpoint_embed, refpoint_embed_], dim=1) + tgt = torch.cat([tgt, tgt_], dim=1) + else: + refpoint_embed, tgt = refpoint_embed_, tgt_ + + if self.num_patterns > 0: + tgt_embed = tgt.repeat(1, self.num_patterns, 1) + refpoint_embed = refpoint_embed.repeat(1, self.num_patterns, 1) + tgt_pat = self.patterns.weight[None, :, :].repeat_interleave( + self.num_queries, 1 + ) # 1, n_q*n_pat, d_model + tgt = tgt_embed + tgt_pat + + init_box_proposal = refpoint_embed_.sigmoid() + + else: + raise NotImplementedError("unknown two_stage_type {}".format(self.two_stage_type)) + ######################################################### + # End preparing tgt + # - tgt: bs, NQ, d_model + # - refpoint_embed(unsigmoid): bs, NQ, d_model + ######################################################### + + ######################################################### + # Begin Decoder + ######################################################### + hs, references = self.decoder( + tgt=tgt.transpose(0, 1), + memory=memory.transpose(0, 1), + memory_key_padding_mask=mask_flatten, + pos=lvl_pos_embed_flatten.transpose(0, 1), + refpoints_unsigmoid=refpoint_embed.transpose(0, 1), + level_start_index=level_start_index, + spatial_shapes=spatial_shapes, + valid_ratios=valid_ratios, + tgt_mask=attn_mask, + memory_text=text_dict["encoded_text"], + text_attention_mask=~text_dict["text_token_mask"], + # we ~ the mask . False means use the token; True means pad the token + ) + ######################################################### + # End Decoder + # hs: n_dec, bs, nq, d_model + # references: n_dec+1, bs, nq, query_dim + ######################################################### + + ######################################################### + # Begin postprocess + ######################################################### + if self.two_stage_type == "standard": + hs_enc = tgt_undetach.unsqueeze(0) + ref_enc = refpoint_embed_undetach.sigmoid().unsqueeze(0) + else: + hs_enc = ref_enc = None + ######################################################### + # End postprocess + # hs_enc: (n_enc+1, bs, nq, d_model) or (1, bs, nq, d_model) or (n_enc, bs, nq, d_model) or None + # ref_enc: (n_enc+1, bs, nq, query_dim) or (1, bs, nq, query_dim) or (n_enc, bs, nq, d_model) or None + ######################################################### + + return hs, references, hs_enc, ref_enc, init_box_proposal + # hs: (n_dec, bs, nq, d_model) + # references: sigmoid coordinates. (n_dec+1, bs, bq, 4) + # hs_enc: (n_enc+1, bs, nq, d_model) or (1, bs, nq, d_model) or None + # ref_enc: sigmoid coordinates. \ + # (n_enc+1, bs, nq, query_dim) or (1, bs, nq, query_dim) or None + + +class TransformerEncoder(nn.Module): + def __init__( + self, + encoder_layer, + num_layers, + d_model=256, + num_queries=300, + enc_layer_share=False, + text_enhance_layer=None, + feature_fusion_layer=None, + use_checkpoint=False, + use_transformer_ckpt=False, + ): + """_summary_ + + Args: + encoder_layer (_type_): _description_ + num_layers (_type_): _description_ + norm (_type_, optional): _description_. Defaults to None. + d_model (int, optional): _description_. Defaults to 256. + num_queries (int, optional): _description_. Defaults to 300. + enc_layer_share (bool, optional): _description_. Defaults to False. + + """ + super().__init__() + # prepare layers + self.layers = [] + self.text_layers = [] + self.fusion_layers = [] + if num_layers > 0: + self.layers = _get_clones(encoder_layer, num_layers, layer_share=enc_layer_share) + + if text_enhance_layer is not None: + self.text_layers = _get_clones( + text_enhance_layer, num_layers, layer_share=enc_layer_share + ) + if feature_fusion_layer is not None: + self.fusion_layers = _get_clones( + feature_fusion_layer, num_layers, layer_share=enc_layer_share + ) + else: + self.layers = [] + del encoder_layer + + if text_enhance_layer is not None: + self.text_layers = [] + del text_enhance_layer + if feature_fusion_layer is not None: + self.fusion_layers = [] + del feature_fusion_layer + + self.query_scale = None + self.num_queries = num_queries + self.num_layers = num_layers + self.d_model = d_model + + self.use_checkpoint = use_checkpoint + self.use_transformer_ckpt = use_transformer_ckpt + + @staticmethod + def get_reference_points(spatial_shapes, valid_ratios, 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] / (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 forward( + self, + # for images + src: Tensor, + pos: Tensor, + spatial_shapes: Tensor, + level_start_index: Tensor, + valid_ratios: Tensor, + key_padding_mask: Tensor, + # for texts + memory_text: Tensor = None, + text_attention_mask: Tensor = None, + pos_text: Tensor = None, + text_self_attention_masks: Tensor = None, + position_ids: Tensor = None, + ): + """ + Input: + - src: [bs, sum(hi*wi), 256] + - pos: pos embed for src. [bs, sum(hi*wi), 256] + - spatial_shapes: h,w of each level [num_level, 2] + - level_start_index: [num_level] start point of level in sum(hi*wi). + - valid_ratios: [bs, num_level, 2] + - key_padding_mask: [bs, sum(hi*wi)] + + - memory_text: bs, n_text, 256 + - text_attention_mask: bs, n_text + False for no padding; True for padding + - pos_text: bs, n_text, 256 + + - position_ids: bs, n_text + Intermedia: + - reference_points: [bs, sum(hi*wi), num_level, 2] + Outpus: + - output: [bs, sum(hi*wi), 256] + """ + + output = src + + # preparation and reshape + if self.num_layers > 0: + reference_points = self.get_reference_points( + spatial_shapes, valid_ratios, device=src.device + ) + + if self.text_layers: + # generate pos_text + bs, n_text, text_dim = memory_text.shape + if pos_text is None and position_ids is None: + pos_text = ( + torch.arange(n_text, device=memory_text.device) + .float() + .unsqueeze(0) + .unsqueeze(-1) + .repeat(bs, 1, 1) + ) + pos_text = get_sine_pos_embed(pos_text, num_pos_feats=256, exchange_xy=False) + if position_ids is not None: + pos_text = get_sine_pos_embed( + position_ids[..., None], num_pos_feats=256, exchange_xy=False + ) + + # main process + for layer_id, layer in enumerate(self.layers): + # if output.isnan().any() or memory_text.isnan().any(): + # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO': + # import ipdb; ipdb.set_trace() + if self.fusion_layers: + if self.use_checkpoint: + output, memory_text = checkpoint.checkpoint( + self.fusion_layers[layer_id], + output, + memory_text, + key_padding_mask, + text_attention_mask, + ) + else: + output, memory_text = self.fusion_layers[layer_id]( + v=output, + l=memory_text, + attention_mask_v=key_padding_mask, + attention_mask_l=text_attention_mask, + ) + + if self.text_layers: + memory_text = self.text_layers[layer_id]( + src=memory_text.transpose(0, 1), + src_mask=~text_self_attention_masks, # note we use ~ for mask here + src_key_padding_mask=text_attention_mask, + pos=(pos_text.transpose(0, 1) if pos_text is not None else None), + ).transpose(0, 1) + + # main process + if self.use_transformer_ckpt: + output = checkpoint.checkpoint( + layer, + output, + pos, + reference_points, + spatial_shapes, + level_start_index, + key_padding_mask, + ) + else: + output = layer( + src=output, + pos=pos, + reference_points=reference_points, + spatial_shapes=spatial_shapes, + level_start_index=level_start_index, + key_padding_mask=key_padding_mask, + ) + + return output, memory_text + + +class TransformerDecoder(nn.Module): + def __init__( + self, + decoder_layer, + num_layers, + norm=None, + return_intermediate=False, + d_model=256, + query_dim=4, + num_feature_levels=1, + ): + super().__init__() + if num_layers > 0: + self.layers = _get_clones(decoder_layer, num_layers) + else: + self.layers = [] + self.num_layers = num_layers + self.norm = norm + self.return_intermediate = return_intermediate + assert return_intermediate, "support return_intermediate only" + self.query_dim = query_dim + assert query_dim in [2, 4], "query_dim should be 2/4 but {}".format(query_dim) + self.num_feature_levels = num_feature_levels + + self.ref_point_head = MLP(query_dim // 2 * d_model, d_model, d_model, 2) + self.query_pos_sine_scale = None + + self.query_scale = None + self.bbox_embed = None + self.class_embed = None + + self.d_model = d_model + + self.ref_anchor_head = None + + def forward( + self, + tgt, + memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + refpoints_unsigmoid: Optional[Tensor] = None, # num_queries, bs, 2 + # for memory + level_start_index: Optional[Tensor] = None, # num_levels + spatial_shapes: Optional[Tensor] = None, # bs, num_levels, 2 + valid_ratios: Optional[Tensor] = None, + # for text + memory_text: Optional[Tensor] = None, + text_attention_mask: Optional[Tensor] = None, + ): + """ + Input: + - tgt: nq, bs, d_model + - memory: hw, bs, d_model + - pos: hw, bs, d_model + - refpoints_unsigmoid: nq, bs, 2/4 + - valid_ratios/spatial_shapes: bs, nlevel, 2 + """ + output = tgt + + intermediate = [] + reference_points = refpoints_unsigmoid.sigmoid() + ref_points = [reference_points] + + for layer_id, 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, :] + ) # nq, bs, nlevel, 4 + else: + assert reference_points.shape[-1] == 2 + reference_points_input = reference_points[:, :, None] * valid_ratios[None, :] + query_sine_embed = gen_sineembed_for_position( + reference_points_input[:, :, 0, :] + ) # nq, bs, 256*2 + + # conditional query + raw_query_pos = self.ref_point_head(query_sine_embed) # nq, bs, 256 + pos_scale = self.query_scale(output) if self.query_scale is not None else 1 + query_pos = pos_scale * raw_query_pos + # if os.environ.get("SHILONG_AMP_INFNAN_DEBUG") == '1': + # if query_pos.isnan().any() | query_pos.isinf().any(): + # import ipdb; ipdb.set_trace() + + # main process + output = layer( + tgt=output, + tgt_query_pos=query_pos, + tgt_query_sine_embed=query_sine_embed, + tgt_key_padding_mask=tgt_key_padding_mask, + tgt_reference_points=reference_points_input, + memory_text=memory_text, + text_attention_mask=text_attention_mask, + memory=memory, + memory_key_padding_mask=memory_key_padding_mask, + memory_level_start_index=level_start_index, + memory_spatial_shapes=spatial_shapes, + memory_pos=pos, + self_attn_mask=tgt_mask, + cross_attn_mask=memory_mask, + ) + if output.isnan().any() | output.isinf().any(): + print(f"output layer_id {layer_id} is nan") + try: + num_nan = output.isnan().sum().item() + num_inf = output.isinf().sum().item() + print(f"num_nan {num_nan}, num_inf {num_inf}") + except Exception as e: + print(e) + # if os.environ.get("SHILONG_AMP_INFNAN_DEBUG") == '1': + # import ipdb; ipdb.set_trace() + + # iter update + if self.bbox_embed is not None: + # box_holder = self.bbox_embed(output) + # box_holder[..., :self.query_dim] += inverse_sigmoid(reference_points) + # new_reference_points = box_holder[..., :self.query_dim].sigmoid() + + reference_before_sigmoid = inverse_sigmoid(reference_points) + delta_unsig = self.bbox_embed[layer_id](output) + outputs_unsig = delta_unsig + reference_before_sigmoid + new_reference_points = outputs_unsig.sigmoid() + + reference_points = new_reference_points.detach() + # if layer_id != self.num_layers - 1: + ref_points.append(new_reference_points) + + intermediate.append(self.norm(output)) + + return [ + [itm_out.transpose(0, 1) for itm_out in intermediate], + [itm_refpoint.transpose(0, 1) for itm_refpoint in ref_points], + ] + + +class DeformableTransformerEncoderLayer(nn.Module): + def __init__( + self, + d_model=256, + d_ffn=1024, + dropout=0.1, + activation="relu", + n_levels=4, + n_heads=8, + n_points=4, + ): + super().__init__() + + # self attention + self.self_attn = MSDeformAttn( + embed_dim=d_model, + num_levels=n_levels, + num_heads=n_heads, + num_points=n_points, + batch_first=True, + ) + self.dropout1 = nn.Dropout(dropout) + self.norm1 = nn.LayerNorm(d_model) + + # ffn + self.linear1 = nn.Linear(d_model, d_ffn) + self.activation = _get_activation_fn(activation, d_model=d_ffn) + self.dropout2 = nn.Dropout(dropout) + self.linear2 = nn.Linear(d_ffn, d_model) + self.dropout3 = nn.Dropout(dropout) + self.norm2 = nn.LayerNorm(d_model) + + @staticmethod + def with_pos_embed(tensor, pos): + return tensor if pos is None else tensor + pos + + def forward_ffn(self, src): + src2 = self.linear2(self.dropout2(self.activation(self.linear1(src)))) + src = src + self.dropout3(src2) + src = self.norm2(src) + return src + + def forward( + self, src, pos, reference_points, spatial_shapes, level_start_index, key_padding_mask=None + ): + # self attention + # import ipdb; ipdb.set_trace() + src2 = self.self_attn( + query=self.with_pos_embed(src, pos), + reference_points=reference_points, + value=src, + spatial_shapes=spatial_shapes, + level_start_index=level_start_index, + key_padding_mask=key_padding_mask, + ) + src = src + self.dropout1(src2) + src = self.norm1(src) + + # ffn + src = self.forward_ffn(src) + + return src + + +class DeformableTransformerDecoderLayer(nn.Module): + def __init__( + self, + d_model=256, + d_ffn=1024, + dropout=0.1, + activation="relu", + n_levels=4, + n_heads=8, + n_points=4, + use_text_feat_guide=False, + use_text_cross_attention=False, + ): + super().__init__() + + # cross attention + self.cross_attn = MSDeformAttn( + embed_dim=d_model, + num_levels=n_levels, + num_heads=n_heads, + num_points=n_points, + batch_first=True, + ) + self.dropout1 = nn.Dropout(dropout) if dropout > 0 else nn.Identity() + self.norm1 = nn.LayerNorm(d_model) + + # cross attention text + if use_text_cross_attention: + self.ca_text = nn.MultiheadAttention(d_model, n_heads, dropout=dropout) + self.catext_dropout = nn.Dropout(dropout) if dropout > 0 else nn.Identity() + self.catext_norm = nn.LayerNorm(d_model) + + # self attention + self.self_attn = nn.MultiheadAttention(d_model, n_heads, dropout=dropout) + self.dropout2 = nn.Dropout(dropout) if dropout > 0 else nn.Identity() + self.norm2 = nn.LayerNorm(d_model) + + # ffn + self.linear1 = nn.Linear(d_model, d_ffn) + self.activation = _get_activation_fn(activation, d_model=d_ffn, batch_dim=1) + self.dropout3 = nn.Dropout(dropout) if dropout > 0 else nn.Identity() + self.linear2 = nn.Linear(d_ffn, d_model) + self.dropout4 = nn.Dropout(dropout) if dropout > 0 else nn.Identity() + self.norm3 = nn.LayerNorm(d_model) + + self.key_aware_proj = None + self.use_text_feat_guide = use_text_feat_guide + assert not use_text_feat_guide + self.use_text_cross_attention = use_text_cross_attention + + def rm_self_attn_modules(self): + self.self_attn = None + self.dropout2 = None + self.norm2 = None + + @staticmethod + def with_pos_embed(tensor, pos): + return tensor if pos is None else tensor + pos + + def forward_ffn(self, tgt): + with torch.cuda.amp.autocast(enabled=False): + tgt2 = self.linear2(self.dropout3(self.activation(self.linear1(tgt)))) + tgt = tgt + self.dropout4(tgt2) + tgt = self.norm3(tgt) + return tgt + + def forward( + self, + # for tgt + tgt: Optional[Tensor], # nq, bs, d_model + tgt_query_pos: Optional[Tensor] = None, # pos for query. MLP(Sine(pos)) + tgt_query_sine_embed: Optional[Tensor] = None, # pos for query. Sine(pos) + tgt_key_padding_mask: Optional[Tensor] = None, + tgt_reference_points: Optional[Tensor] = None, # nq, bs, 4 + memory_text: Optional[Tensor] = None, # bs, num_token, d_model + text_attention_mask: Optional[Tensor] = None, # bs, num_token + # for memory + memory: Optional[Tensor] = None, # hw, bs, d_model + memory_key_padding_mask: Optional[Tensor] = None, + memory_level_start_index: Optional[Tensor] = None, # num_levels + memory_spatial_shapes: Optional[Tensor] = None, # bs, num_levels, 2 + memory_pos: Optional[Tensor] = None, # pos for memory + # sa + self_attn_mask: Optional[Tensor] = None, # mask used for self-attention + cross_attn_mask: Optional[Tensor] = None, # mask used for cross-attention + ): + """ + Input: + - tgt/tgt_query_pos: nq, bs, d_model + - + """ + assert cross_attn_mask is None + + # self attention + if self.self_attn is not None: + # import ipdb; ipdb.set_trace() + q = k = self.with_pos_embed(tgt, tgt_query_pos) + tgt2 = self.self_attn(q, k, tgt, attn_mask=self_attn_mask)[0] + tgt = tgt + self.dropout2(tgt2) + tgt = self.norm2(tgt) + + if self.use_text_cross_attention: + tgt2 = self.ca_text( + self.with_pos_embed(tgt, tgt_query_pos), + memory_text.transpose(0, 1), + memory_text.transpose(0, 1), + key_padding_mask=text_attention_mask, + )[0] + tgt = tgt + self.catext_dropout(tgt2) + tgt = self.catext_norm(tgt) + + tgt2 = self.cross_attn( + query=self.with_pos_embed(tgt, tgt_query_pos).transpose(0, 1), + reference_points=tgt_reference_points.transpose(0, 1).contiguous(), + value=memory.transpose(0, 1), + spatial_shapes=memory_spatial_shapes, + level_start_index=memory_level_start_index, + key_padding_mask=memory_key_padding_mask, + ).transpose(0, 1) + tgt = tgt + self.dropout1(tgt2) + tgt = self.norm1(tgt) + + # ffn + tgt = self.forward_ffn(tgt) + + return tgt + + +def build_transformer(args): + return Transformer( + d_model=args.hidden_dim, + dropout=args.dropout, + nhead=args.nheads, + num_queries=args.num_queries, + dim_feedforward=args.dim_feedforward, + num_encoder_layers=args.enc_layers, + num_decoder_layers=args.dec_layers, + normalize_before=args.pre_norm, + return_intermediate_dec=True, + query_dim=args.query_dim, + activation=args.transformer_activation, + num_patterns=args.num_patterns, + num_feature_levels=args.num_feature_levels, + enc_n_points=args.enc_n_points, + dec_n_points=args.dec_n_points, + learnable_tgt_init=True, + # two stage + two_stage_type=args.two_stage_type, # ['no', 'standard', 'early'] + embed_init_tgt=args.embed_init_tgt, + use_text_enhancer=args.use_text_enhancer, + use_fusion_layer=args.use_fusion_layer, + use_checkpoint=args.use_checkpoint, + use_transformer_ckpt=args.use_transformer_ckpt, + use_text_cross_attention=args.use_text_cross_attention, + text_dropout=args.text_dropout, + fusion_dropout=args.fusion_dropout, + fusion_droppath=args.fusion_droppath, + ) diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/transformer_vanilla.py b/GroundingDINO/groundingdino/models/GroundingDINO/transformer_vanilla.py new file mode 100644 index 0000000000000000000000000000000000000000..10c0920c1a217af5bb3e1b13077568035ab3b7b5 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/transformer_vanilla.py @@ -0,0 +1,123 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Copyright (c) Aishwarya Kamath & Nicolas Carion. Licensed under the Apache License 2.0. All Rights Reserved +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +DETR Transformer class. + +Copy-paste from torch.nn.Transformer with modifications: + * positional encodings are passed in MHattention + * extra LN at the end of encoder is removed + * decoder returns a stack of activations from all decoding layers +""" +from typing import Optional + +import torch +import torch.nn.functional as F +from torch import Tensor, nn + +from .utils import ( + MLP, + _get_activation_fn, + _get_clones, + gen_encoder_output_proposals, + gen_sineembed_for_position, + sigmoid_focal_loss, +) + + +class TextTransformer(nn.Module): + def __init__(self, num_layers, d_model=256, nheads=8, dim_feedforward=2048, dropout=0.1): + super().__init__() + self.num_layers = num_layers + self.d_model = d_model + self.nheads = nheads + self.dim_feedforward = dim_feedforward + self.norm = None + + single_encoder_layer = TransformerEncoderLayer( + d_model=d_model, nhead=nheads, dim_feedforward=dim_feedforward, dropout=dropout + ) + self.layers = _get_clones(single_encoder_layer, num_layers) + + def forward(self, memory_text: torch.Tensor, text_attention_mask: torch.Tensor): + """ + + Args: + text_attention_mask: bs, num_token + memory_text: bs, num_token, d_model + + Raises: + RuntimeError: _description_ + + Returns: + output: bs, num_token, d_model + """ + + output = memory_text.transpose(0, 1) + + for layer in self.layers: + output = layer(output, src_key_padding_mask=text_attention_mask) + + if self.norm is not None: + output = self.norm(output) + + return output.transpose(0, 1) + + +class TransformerEncoderLayer(nn.Module): + def __init__( + self, + d_model, + nhead, + dim_feedforward=2048, + dropout=0.1, + activation="relu", + normalize_before=False, + ): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm1 = nn.LayerNorm(d_model) + self.norm2 = nn.LayerNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + self.nhead = nhead + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward( + self, + src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + ): + # repeat attn mask + if src_mask.dim() == 3 and src_mask.shape[0] == src.shape[1]: + # bs, num_q, num_k + src_mask = src_mask.repeat(self.nhead, 1, 1) + + q = k = self.with_pos_embed(src, pos) + + src2 = self.self_attn(q, k, value=src, attn_mask=src_mask)[0] + + # src2 = self.self_attn(q, k, value=src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0] + src = src + self.dropout1(src2) + src = self.norm1(src) + src2 = self.linear2(self.dropout(self.activation(self.linear1(src)))) + src = src + self.dropout2(src2) + src = self.norm2(src) + return src diff --git a/GroundingDINO/groundingdino/models/GroundingDINO/utils.py b/GroundingDINO/groundingdino/models/GroundingDINO/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5bd18f70225e12b2e27fdb4eabcde91d959f8e31 --- /dev/null +++ b/GroundingDINO/groundingdino/models/GroundingDINO/utils.py @@ -0,0 +1,268 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ + +import copy +import math + +import torch +import torch.nn.functional as F +from torch import Tensor, nn + + +def _get_clones(module, N, layer_share=False): + # import ipdb; ipdb.set_trace() + if layer_share: + return nn.ModuleList([module for i in range(N)]) + else: + return nn.ModuleList([copy.deepcopy(module) for i in range(N)]) + + +def get_sine_pos_embed( + pos_tensor: torch.Tensor, + num_pos_feats: int = 128, + temperature: int = 10000, + exchange_xy: bool = True, +): + """generate sine position embedding from a position tensor + Args: + pos_tensor (torch.Tensor): shape: [..., n]. + num_pos_feats (int): projected shape for each float in the tensor. + temperature (int): temperature in the sine/cosine function. + exchange_xy (bool, optional): exchange pos x and pos y. \ + For example, input tensor is [x,y], the results will be [pos(y), pos(x)]. Defaults to True. + Returns: + pos_embed (torch.Tensor): shape: [..., n*num_pos_feats]. + """ + scale = 2 * math.pi + dim_t = torch.arange(num_pos_feats, dtype=torch.float32, device=pos_tensor.device) + dim_t = temperature ** (2 * torch.div(dim_t, 2, rounding_mode="floor") / num_pos_feats) + + def sine_func(x: torch.Tensor): + sin_x = x * scale / dim_t + sin_x = torch.stack((sin_x[..., 0::2].sin(), sin_x[..., 1::2].cos()), dim=3).flatten(2) + return sin_x + + pos_res = [sine_func(x) for x in pos_tensor.split([1] * pos_tensor.shape[-1], dim=-1)] + if exchange_xy: + pos_res[0], pos_res[1] = pos_res[1], pos_res[0] + pos_res = torch.cat(pos_res, dim=-1) + return pos_res + + +def gen_encoder_output_proposals( + memory: Tensor, memory_padding_mask: Tensor, spatial_shapes: Tensor, learnedwh=None +): + """ + Input: + - memory: bs, \sum{hw}, d_model + - memory_padding_mask: bs, \sum{hw} + - spatial_shapes: nlevel, 2 + - learnedwh: 2 + Output: + - output_memory: bs, \sum{hw}, d_model + - output_proposals: bs, \sum{hw}, 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) + + # import ipdb; ipdb.set_trace() + + 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) # H_, W_, 2 + + 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 + + if learnedwh is not None: + # import ipdb; ipdb.set_trace() + wh = torch.ones_like(grid) * learnedwh.sigmoid() * (2.0**lvl) + else: + wh = torch.ones_like(grid) * 0.05 * (2.0**lvl) + + # scale = torch.cat([W_[None].unsqueeze(-1), H_[None].unsqueeze(-1)], 1).view(1, 1, 1, 2).repeat(N_, 1, 1, 1) + # grid = (grid.unsqueeze(0).expand(N_, -1, -1, -1) + 0.5) / scale + # wh = torch.ones_like(grid) / scale + proposal = torch.cat((grid, wh), -1).view(N_, -1, 4) + proposals.append(proposal) + _cur += H_ * W_ + # import ipdb; ipdb.set_trace() + 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)) # unsigmoid + 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 = output_memory.masked_fill(memory_padding_mask.unsqueeze(-1), float('inf')) + # output_memory = output_memory.masked_fill(~output_proposals_valid, float('inf')) + + return output_memory, output_proposals + + +class RandomBoxPerturber: + def __init__( + self, x_noise_scale=0.2, y_noise_scale=0.2, w_noise_scale=0.2, h_noise_scale=0.2 + ) -> None: + self.noise_scale = torch.Tensor( + [x_noise_scale, y_noise_scale, w_noise_scale, h_noise_scale] + ) + + def __call__(self, refanchors: Tensor) -> Tensor: + nq, bs, query_dim = refanchors.shape + device = refanchors.device + + noise_raw = torch.rand_like(refanchors) + noise_scale = self.noise_scale.to(device)[:query_dim] + + new_refanchors = refanchors * (1 + (noise_raw - 0.5) * noise_scale) + return new_refanchors.clamp_(0, 1) + + +def sigmoid_focal_loss( + inputs, targets, num_boxes, alpha: float = 0.25, gamma: float = 2, no_reduction=False +): + """ + Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002. + Args: + inputs: A float tensor of arbitrary shape. + The predictions for each example. + targets: A float tensor with the same shape as inputs. Stores the binary + classification label for each element in inputs + (0 for the negative class and 1 for the positive class). + alpha: (optional) Weighting factor in range (0,1) to balance + positive vs negative examples. Default = -1 (no weighting). + gamma: Exponent of the modulating factor (1 - p_t) to + balance easy vs hard examples. + Returns: + Loss tensor + """ + prob = inputs.sigmoid() + ce_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none") + p_t = prob * targets + (1 - prob) * (1 - targets) + loss = ce_loss * ((1 - p_t) ** gamma) + + if alpha >= 0: + alpha_t = alpha * targets + (1 - alpha) * (1 - targets) + loss = alpha_t * loss + + if no_reduction: + return loss + + return loss.mean(1).sum() / num_boxes + + +class MLP(nn.Module): + """Very simple multi-layer perceptron (also called FFN)""" + + def __init__(self, input_dim, hidden_dim, output_dim, num_layers): + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = nn.ModuleList( + nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]) + ) + + def forward(self, x): + for i, layer in enumerate(self.layers): + x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) + return x + + +def _get_activation_fn(activation, d_model=256, batch_dim=0): + """Return an activation function given a string""" + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + if activation == "glu": + return F.glu + if activation == "prelu": + return nn.PReLU() + if activation == "selu": + return F.selu + + raise RuntimeError(f"activation should be relu/gelu, not {activation}.") + + +def gen_sineembed_for_position(pos_tensor): + # n_query, bs, _ = pos_tensor.size() + # sineembed_tensor = torch.zeros(n_query, bs, 256) + scale = 2 * math.pi + dim_t = torch.arange(128, dtype=torch.float32, device=pos_tensor.device) + dim_t = 10000 ** (2 * (torch.div(dim_t, 2, rounding_mode='floor')) / 128) + x_embed = pos_tensor[:, :, 0] * scale + y_embed = pos_tensor[:, :, 1] * scale + pos_x = x_embed[:, :, None] / dim_t + pos_y = y_embed[:, :, None] / dim_t + pos_x = torch.stack((pos_x[:, :, 0::2].sin(), pos_x[:, :, 1::2].cos()), dim=3).flatten(2) + pos_y = torch.stack((pos_y[:, :, 0::2].sin(), pos_y[:, :, 1::2].cos()), dim=3).flatten(2) + if pos_tensor.size(-1) == 2: + pos = torch.cat((pos_y, pos_x), dim=2) + elif pos_tensor.size(-1) == 4: + w_embed = pos_tensor[:, :, 2] * scale + pos_w = w_embed[:, :, None] / dim_t + pos_w = torch.stack((pos_w[:, :, 0::2].sin(), pos_w[:, :, 1::2].cos()), dim=3).flatten(2) + + h_embed = pos_tensor[:, :, 3] * scale + pos_h = h_embed[:, :, None] / dim_t + pos_h = torch.stack((pos_h[:, :, 0::2].sin(), pos_h[:, :, 1::2].cos()), dim=3).flatten(2) + + pos = torch.cat((pos_y, pos_x, pos_w, pos_h), dim=2) + else: + raise ValueError("Unknown pos_tensor shape(-1):{}".format(pos_tensor.size(-1))) + return pos + + +class ContrastiveEmbed(nn.Module): + def __init__(self, max_text_len=256): + """ + Args: + max_text_len: max length of text. + """ + super().__init__() + self.max_text_len = max_text_len + + def forward(self, x, text_dict): + """_summary_ + + Args: + x (_type_): _description_ + text_dict (_type_): _description_ + { + 'encoded_text': encoded_text, # bs, 195, d_model + 'text_token_mask': text_token_mask, # bs, 195 + # True for used tokens. False for padding tokens + } + Returns: + _type_: _description_ + """ + assert isinstance(text_dict, dict) + + y = text_dict["encoded_text"] + text_token_mask = text_dict["text_token_mask"] + + res = x @ y.transpose(-1, -2) + res.masked_fill_(~text_token_mask[:, None, :], float("-inf")) + + # padding to max_text_len + new_res = torch.full((*res.shape[:-1], self.max_text_len), float("-inf"), device=res.device) + new_res[..., : res.shape[-1]] = res + + return new_res diff --git a/GroundingDINO/groundingdino/models/__init__.py b/GroundingDINO/groundingdino/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e3413961d1d184b99835eb1e919b052d70298bc6 --- /dev/null +++ b/GroundingDINO/groundingdino/models/__init__.py @@ -0,0 +1,18 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +from .GroundingDINO import build_groundingdino + + +def build_model(args): + # we use register to maintain models from catdet6 on. + from .registry import MODULE_BUILD_FUNCS + + assert args.modelname in MODULE_BUILD_FUNCS._module_dict + build_func = MODULE_BUILD_FUNCS.get(args.modelname) + model = build_func(args) + return model diff --git a/GroundingDINO/groundingdino/models/registry.py b/GroundingDINO/groundingdino/models/registry.py new file mode 100644 index 0000000000000000000000000000000000000000..2d22a59eec79a2a19b83fa1779f2adaf5753aec6 --- /dev/null +++ b/GroundingDINO/groundingdino/models/registry.py @@ -0,0 +1,66 @@ +# ------------------------------------------------------------------------ +# Grounding DINO +# url: https://github.com/IDEA-Research/GroundingDINO +# Copyright (c) 2023 IDEA. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------ +# -*- coding: utf-8 -*- +# @Author: Yihao Chen +# @Date: 2021-08-16 16:03:17 +# @Last Modified by: Shilong Liu +# @Last Modified time: 2022-01-23 15:26 +# modified from mmcv + +import inspect +from functools import partial + + +class Registry(object): + def __init__(self, name): + self._name = name + self._module_dict = dict() + + def __repr__(self): + format_str = self.__class__.__name__ + "(name={}, items={})".format( + self._name, list(self._module_dict.keys()) + ) + return format_str + + def __len__(self): + return len(self._module_dict) + + @property + def name(self): + return self._name + + @property + def module_dict(self): + return self._module_dict + + def get(self, key): + return self._module_dict.get(key, None) + + def registe_with_name(self, module_name=None, force=False): + return partial(self.register, module_name=module_name, force=force) + + def register(self, module_build_function, module_name=None, force=False): + """Register a module build function. + Args: + module (:obj:`nn.Module`): Module to be registered. + """ + if not inspect.isfunction(module_build_function): + raise TypeError( + "module_build_function must be a function, but got {}".format( + type(module_build_function) + ) + ) + if module_name is None: + module_name = module_build_function.__name__ + if not force and module_name in self._module_dict: + raise KeyError("{} is already registered in {}".format(module_name, self.name)) + self._module_dict[module_name] = module_build_function + + return module_build_function + + +MODULE_BUILD_FUNCS = Registry("model build functions") diff --git a/GroundingDINO/groundingdino/util/__init__.py b/GroundingDINO/groundingdino/util/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..168f9979a4623806934b0ff1102ac166704e7dec --- /dev/null +++ b/GroundingDINO/groundingdino/util/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved diff --git a/GroundingDINO/groundingdino/util/box_ops.py b/GroundingDINO/groundingdino/util/box_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..781068d294e576954edb4bd07b6e0f30e4e1bcd9 --- /dev/null +++ b/GroundingDINO/groundingdino/util/box_ops.py @@ -0,0 +1,140 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +Utilities for bounding box manipulation and GIoU. +""" +import torch +from torchvision.ops.boxes import box_area + + +def box_cxcywh_to_xyxy(x): + x_c, y_c, w, h = x.unbind(-1) + b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)] + return torch.stack(b, dim=-1) + + +def box_xyxy_to_cxcywh(x): + x0, y0, x1, y1 = x.unbind(-1) + b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)] + return torch.stack(b, dim=-1) + + +# modified from torchvision to also return the union +def box_iou(boxes1, boxes2): + area1 = box_area(boxes1) + area2 = box_area(boxes2) + + # import ipdb; ipdb.set_trace() + lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2] + rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2] + + wh = (rb - lt).clamp(min=0) # [N,M,2] + inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] + + union = area1[:, None] + area2 - inter + + iou = inter / (union + 1e-6) + return iou, union + + +def generalized_box_iou(boxes1, boxes2): + """ + Generalized IoU from https://giou.stanford.edu/ + + The boxes should be in [x0, y0, x1, y1] format + + Returns a [N, M] pairwise matrix, where N = len(boxes1) + and M = len(boxes2) + """ + # degenerate boxes gives inf / nan results + # so do an early check + assert (boxes1[:, 2:] >= boxes1[:, :2]).all() + assert (boxes2[:, 2:] >= boxes2[:, :2]).all() + # except: + # import ipdb; ipdb.set_trace() + iou, union = box_iou(boxes1, boxes2) + + lt = torch.min(boxes1[:, None, :2], boxes2[:, :2]) + rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:]) + + wh = (rb - lt).clamp(min=0) # [N,M,2] + area = wh[:, :, 0] * wh[:, :, 1] + + return iou - (area - union) / (area + 1e-6) + + +# modified from torchvision to also return the union +def box_iou_pairwise(boxes1, boxes2): + area1 = box_area(boxes1) + area2 = box_area(boxes2) + + lt = torch.max(boxes1[:, :2], boxes2[:, :2]) # [N,2] + rb = torch.min(boxes1[:, 2:], boxes2[:, 2:]) # [N,2] + + wh = (rb - lt).clamp(min=0) # [N,2] + inter = wh[:, 0] * wh[:, 1] # [N] + + union = area1 + area2 - inter + + iou = inter / union + return iou, union + + +def generalized_box_iou_pairwise(boxes1, boxes2): + """ + Generalized IoU from https://giou.stanford.edu/ + + Input: + - boxes1, boxes2: N,4 + Output: + - giou: N, 4 + """ + # degenerate boxes gives inf / nan results + # so do an early check + assert (boxes1[:, 2:] >= boxes1[:, :2]).all() + assert (boxes2[:, 2:] >= boxes2[:, :2]).all() + assert boxes1.shape == boxes2.shape + iou, union = box_iou_pairwise(boxes1, boxes2) # N, 4 + + lt = torch.min(boxes1[:, :2], boxes2[:, :2]) + rb = torch.max(boxes1[:, 2:], boxes2[:, 2:]) + + wh = (rb - lt).clamp(min=0) # [N,2] + area = wh[:, 0] * wh[:, 1] + + return iou - (area - union) / area + + +def masks_to_boxes(masks): + """Compute the bounding boxes around the provided masks + + The masks should be in format [N, H, W] where N is the number of masks, (H, W) are the spatial dimensions. + + Returns a [N, 4] tensors, with the boxes in xyxy format + """ + if masks.numel() == 0: + return torch.zeros((0, 4), device=masks.device) + + h, w = masks.shape[-2:] + + y = torch.arange(0, h, dtype=torch.float) + x = torch.arange(0, w, dtype=torch.float) + y, x = torch.meshgrid(y, x) + + x_mask = masks * x.unsqueeze(0) + x_max = x_mask.flatten(1).max(-1)[0] + x_min = x_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0] + + y_mask = masks * y.unsqueeze(0) + y_max = y_mask.flatten(1).max(-1)[0] + y_min = y_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0] + + return torch.stack([x_min, y_min, x_max, y_max], 1) + + +if __name__ == "__main__": + x = torch.rand(5, 4) + y = torch.rand(3, 4) + iou, union = box_iou(x, y) + import ipdb + + ipdb.set_trace() diff --git a/GroundingDINO/groundingdino/util/get_tokenlizer.py b/GroundingDINO/groundingdino/util/get_tokenlizer.py new file mode 100644 index 0000000000000000000000000000000000000000..dd2d972b4278e04a1ebef7d5e77aecd4eaf4205b --- /dev/null +++ b/GroundingDINO/groundingdino/util/get_tokenlizer.py @@ -0,0 +1,29 @@ +from transformers import AutoTokenizer, BertModel, BertTokenizer, RobertaModel, RobertaTokenizerFast +import os + +def get_tokenlizer(text_encoder_type): + if not isinstance(text_encoder_type, str): + # print("text_encoder_type is not a str") + if hasattr(text_encoder_type, "text_encoder_type"): + text_encoder_type = text_encoder_type.text_encoder_type + elif text_encoder_type.get("text_encoder_type", False): + text_encoder_type = text_encoder_type.get("text_encoder_type") + elif os.path.isdir(text_encoder_type) and os.path.exists(text_encoder_type): + pass + else: + raise ValueError( + "Unknown type of text_encoder_type: {}".format(type(text_encoder_type)) + ) + print("final text_encoder_type: {}".format(text_encoder_type)) + + tokenizer = AutoTokenizer.from_pretrained(text_encoder_type) + return tokenizer + + +def get_pretrained_language_model(text_encoder_type): + if text_encoder_type == "bert-base-uncased" or (os.path.isdir(text_encoder_type) and os.path.exists(text_encoder_type)): + return BertModel.from_pretrained(text_encoder_type) + if text_encoder_type == "roberta-base": + return RobertaModel.from_pretrained(text_encoder_type) + + raise ValueError("Unknown text_encoder_type {}".format(text_encoder_type)) diff --git a/GroundingDINO/groundingdino/util/inference.py b/GroundingDINO/groundingdino/util/inference.py new file mode 100644 index 0000000000000000000000000000000000000000..9497d9902561915b0d42dc0c4d64cae07ad9ae7d --- /dev/null +++ b/GroundingDINO/groundingdino/util/inference.py @@ -0,0 +1,262 @@ +from typing import Tuple, List + +import cv2 +import numpy as np +import supervision as sv +import torch +from PIL import Image +from torchvision.ops import box_convert +import bisect +import sys + +sys.path.append("../../") +import groundingdino.datasets.transforms as T +from groundingdino.models import build_model +from groundingdino.util.misc import clean_state_dict +from groundingdino.util.slconfig import SLConfig +from groundingdino.util.utils import get_phrases_from_posmap + +# ---------------------------------------------------------------------------------------------------------------------- +# OLD API +# ---------------------------------------------------------------------------------------------------------------------- + + +def preprocess_caption(caption: str) -> str: + result = caption.lower().strip() + if result.endswith("."): + return result + return result + "." + + +def load_model(model_config_path: str, model_checkpoint_path: str, device: str = "cuda"): + args = SLConfig.fromfile(model_config_path) + args.device = device + model = build_model(args) + checkpoint = torch.load(model_checkpoint_path, map_location="cpu") + model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False) + model.eval() + return model + + +def load_image(image_path: str) -> Tuple[np.array, torch.Tensor]: + transform = T.Compose( + [ + T.RandomResize([800], max_size=1333), + T.ToTensor(), + T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), + ] + ) + image_source = Image.open(image_path).convert("RGB") + image = np.asarray(image_source) + image_transformed, _ = transform(image_source, None) + image_transformed = image_transformed.cuda() + return image, image_transformed + + +def predict( + model, + image: torch.Tensor, + caption: str, + box_threshold: float, + text_threshold: float, + device: str = "cuda", + remove_combined: bool = False +) -> Tuple[torch.Tensor, torch.Tensor, List[str]]: + caption = preprocess_caption(caption=caption) + + model = model.to(device) + image = image.to(device) + + with torch.no_grad(): + outputs = model(image[None], captions=[caption]) + + prediction_logits = outputs["pred_logits"].cpu().sigmoid()[0] # prediction_logits.shape = (nq, 256) + prediction_boxes = outputs["pred_boxes"].cpu()[0] # prediction_boxes.shape = (nq, 4) + + mask = prediction_logits.max(dim=1)[0] > box_threshold + logits = prediction_logits[mask] # logits.shape = (n, 256) + boxes = prediction_boxes[mask] # boxes.shape = (n, 4) + + tokenizer = model.tokenizer + tokenized = tokenizer(caption) + + if remove_combined: + sep_idx = [i for i in range(len(tokenized['input_ids'])) if tokenized['input_ids'][i] in [101, 102, 1012]] + + phrases = [] + for logit in logits: + max_idx = logit.argmax() + insert_idx = bisect.bisect_left(sep_idx, max_idx) + right_idx = sep_idx[insert_idx] + left_idx = sep_idx[insert_idx - 1] + phrases.append(get_phrases_from_posmap(logit > text_threshold, tokenized, tokenizer, left_idx, right_idx).replace('.', '')) + else: + phrases = [ + get_phrases_from_posmap(logit > text_threshold, tokenized, tokenizer).replace('.', '') + for logit + in logits + ] + + return boxes, logits.max(dim=1)[0], phrases + + +def annotate(image_source: np.ndarray, boxes: torch.Tensor, logits: torch.Tensor, phrases: List[str]) -> np.ndarray: + h, w, _ = image_source.shape + boxes = boxes * torch.Tensor([w, h, w, h]) + xyxy = box_convert(boxes=boxes, in_fmt="cxcywh", out_fmt="xyxy").numpy() + detections = sv.Detections(xyxy=xyxy) + + labels = [ + f"{phrase} {logit:.2f}" + for phrase, logit + in zip(phrases, logits) + ] + + box_annotator = sv.BoxAnnotator() + annotated_frame = cv2.cvtColor(image_source, cv2.COLOR_RGB2BGR) + annotated_frame = box_annotator.annotate(scene=annotated_frame, detections=detections, labels=labels) + return annotated_frame + + +# ---------------------------------------------------------------------------------------------------------------------- +# NEW API +# ---------------------------------------------------------------------------------------------------------------------- + + +class Model: + + def __init__( + self, + model_config_path: str, + model_checkpoint_path: str, + device: str = "cuda" + ): + self.model = load_model( + model_config_path=model_config_path, + model_checkpoint_path=model_checkpoint_path, + device=device + ).to(device) + self.device = device + + def predict_with_caption( + self, + image: np.ndarray, + caption: str, + box_threshold: float = 0.35, + text_threshold: float = 0.25 + ) -> Tuple[sv.Detections, List[str]]: + """ + import cv2 + + image = cv2.imread(IMAGE_PATH) + + model = Model(model_config_path=CONFIG_PATH, model_checkpoint_path=WEIGHTS_PATH) + detections, labels = model.predict_with_caption( + image=image, + caption=caption, + box_threshold=BOX_THRESHOLD, + text_threshold=TEXT_THRESHOLD + ) + + import supervision as sv + + box_annotator = sv.BoxAnnotator() + annotated_image = box_annotator.annotate(scene=image, detections=detections, labels=labels) + """ + processed_image = Model.preprocess_image(image_bgr=image).to(self.device) + boxes, logits, phrases = predict( + model=self.model, + image=processed_image, + caption=caption, + box_threshold=box_threshold, + text_threshold=text_threshold, + device=self.device) + source_h, source_w, _ = image.shape + detections = Model.post_process_result( + source_h=source_h, + source_w=source_w, + boxes=boxes, + logits=logits) + return detections, phrases + + def predict_with_classes( + self, + image: np.ndarray, + classes: List[str], + box_threshold: float, + text_threshold: float + ) -> sv.Detections: + """ + import cv2 + + image = cv2.imread(IMAGE_PATH) + + model = Model(model_config_path=CONFIG_PATH, model_checkpoint_path=WEIGHTS_PATH) + detections = model.predict_with_classes( + image=image, + classes=CLASSES, + box_threshold=BOX_THRESHOLD, + text_threshold=TEXT_THRESHOLD + ) + + + import supervision as sv + + box_annotator = sv.BoxAnnotator() + annotated_image = box_annotator.annotate(scene=image, detections=detections) + """ + caption = ". ".join(classes) + processed_image = Model.preprocess_image(image_bgr=image).to(self.device) + boxes, logits, phrases = predict( + model=self.model, + image=processed_image, + caption=caption, + box_threshold=box_threshold, + text_threshold=text_threshold, + device=self.device) + source_h, source_w, _ = image.shape + detections = Model.post_process_result( + source_h=source_h, + source_w=source_w, + boxes=boxes, + logits=logits) + class_id = Model.phrases2classes(phrases=phrases, classes=classes) + detections.class_id = class_id + return detections + + @staticmethod + def preprocess_image(image_bgr: np.ndarray) -> torch.Tensor: + transform = T.Compose( + [ + T.RandomResize([800], max_size=1333), + T.ToTensor(), + T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), + ] + ) + image_pillow = Image.fromarray(cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)) + image_transformed, _ = transform(image_pillow, None) + return image_transformed + + @staticmethod + def post_process_result( + source_h: int, + source_w: int, + boxes: torch.Tensor, + logits: torch.Tensor + ) -> sv.Detections: + boxes = boxes * torch.Tensor([source_w, source_h, source_w, source_h]) + xyxy = box_convert(boxes=boxes, in_fmt="cxcywh", out_fmt="xyxy").numpy() + confidence = logits.numpy() + return sv.Detections(xyxy=xyxy, confidence=confidence) + + @staticmethod + def phrases2classes(phrases: List[str], classes: List[str]) -> np.ndarray: + class_ids = [] + for phrase in phrases: + for class_ in classes: + if class_ in phrase: + class_ids.append(classes.index(class_)) + break + else: + class_ids.append(None) + return np.array(class_ids) diff --git a/GroundingDINO/groundingdino/util/logger.py b/GroundingDINO/groundingdino/util/logger.py new file mode 100644 index 0000000000000000000000000000000000000000..18145f54c927abd59b95f3fa6e6da8002bc2ce97 --- /dev/null +++ b/GroundingDINO/groundingdino/util/logger.py @@ -0,0 +1,93 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import functools +import logging +import os +import sys + +from termcolor import colored + + +class _ColorfulFormatter(logging.Formatter): + def __init__(self, *args, **kwargs): + self._root_name = kwargs.pop("root_name") + "." + self._abbrev_name = kwargs.pop("abbrev_name", "") + if len(self._abbrev_name): + self._abbrev_name = self._abbrev_name + "." + super(_ColorfulFormatter, self).__init__(*args, **kwargs) + + def formatMessage(self, record): + record.name = record.name.replace(self._root_name, self._abbrev_name) + log = super(_ColorfulFormatter, self).formatMessage(record) + if record.levelno == logging.WARNING: + prefix = colored("WARNING", "red", attrs=["blink"]) + elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL: + prefix = colored("ERROR", "red", attrs=["blink", "underline"]) + else: + return log + return prefix + " " + log + + +# so that calling setup_logger multiple times won't add many handlers +@functools.lru_cache() +def setup_logger(output=None, distributed_rank=0, *, color=True, name="imagenet", abbrev_name=None): + """ + Initialize the detectron2 logger and set its verbosity level to "INFO". + + Args: + output (str): 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`. + name (str): the root module name of this logger + + Returns: + logging.Logger: a logger + """ + logger = logging.getLogger(name) + logger.setLevel(logging.DEBUG) + logger.propagate = False + + if abbrev_name is None: + abbrev_name = name + + plain_formatter = logging.Formatter( + "[%(asctime)s.%(msecs)03d]: %(message)s", datefmt="%m/%d %H:%M:%S" + ) + # stdout logging: master only + if distributed_rank == 0: + ch = logging.StreamHandler(stream=sys.stdout) + ch.setLevel(logging.DEBUG) + if color: + formatter = _ColorfulFormatter( + colored("[%(asctime)s.%(msecs)03d]: ", "green") + "%(message)s", + datefmt="%m/%d %H:%M:%S", + root_name=name, + abbrev_name=str(abbrev_name), + ) + else: + formatter = plain_formatter + ch.setFormatter(formatter) + logger.addHandler(ch) + + # file logging: all workers + if output is not None: + if output.endswith(".txt") or output.endswith(".log"): + filename = output + else: + filename = os.path.join(output, "log.txt") + if distributed_rank > 0: + filename = filename + f".rank{distributed_rank}" + os.makedirs(os.path.dirname(filename), exist_ok=True) + + fh = logging.StreamHandler(_cached_log_stream(filename)) + fh.setLevel(logging.DEBUG) + fh.setFormatter(plain_formatter) + logger.addHandler(fh) + + return logger + + +# cache the opened file object, so that different calls to `setup_logger` +# with the same file name can safely write to the same file. +@functools.lru_cache(maxsize=None) +def _cached_log_stream(filename): + return open(filename, "a") diff --git a/GroundingDINO/groundingdino/util/misc.py b/GroundingDINO/groundingdino/util/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..d64b84ef24bea0c98e76824feb1903f6bfebe7a5 --- /dev/null +++ b/GroundingDINO/groundingdino/util/misc.py @@ -0,0 +1,717 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +Misc functions, including distributed helpers. + +Mostly copy-paste from torchvision references. +""" +import colorsys +import datetime +import functools +import io +import json +import os +import pickle +import subprocess +import time +from collections import OrderedDict, defaultdict, deque +from typing import List, Optional + +import numpy as np +import torch +import torch.distributed as dist + +# needed due to empty tensor bug in pytorch and torchvision 0.5 +import torchvision +from torch import Tensor + +__torchvision_need_compat_flag = float(torchvision.__version__.split(".")[1]) < 7 +if __torchvision_need_compat_flag: + from torchvision.ops import _new_empty_tensor + from torchvision.ops.misc import _output_size + + +class SmoothedValue(object): + """Track a series of values and provide access to smoothed values over a + window or the global series average. + """ + + def __init__(self, window_size=20, fmt=None): + 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, n=1): + self.deque.append(value) + self.count += n + self.total += value * n + + def synchronize_between_processes(self): + """ + Warning: does not synchronize the deque! + """ + if not is_dist_avail_and_initialized(): + return + t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda") + dist.barrier() + dist.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)) + if d.shape[0] == 0: + return 0 + 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): + if os.environ.get("SHILONG_AMP", None) == "1": + eps = 1e-4 + else: + eps = 1e-6 + return self.total / (self.count + eps) + + @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, + ) + + +@functools.lru_cache() +def _get_global_gloo_group(): + """ + Return a process group based on gloo backend, containing all the ranks + The result is cached. + """ + + if dist.get_backend() == "nccl": + return dist.new_group(backend="gloo") + + return dist.group.WORLD + + +def all_gather_cpu(data): + """ + Run all_gather on arbitrary picklable data (not necessarily tensors) + Args: + data: any picklable object + Returns: + list[data]: list of data gathered from each rank + """ + + world_size = get_world_size() + if world_size == 1: + return [data] + + cpu_group = _get_global_gloo_group() + + buffer = io.BytesIO() + torch.save(data, buffer) + data_view = buffer.getbuffer() + device = "cuda" if cpu_group is None else "cpu" + tensor = torch.ByteTensor(data_view).to(device) + + # obtain Tensor size of each rank + local_size = torch.tensor([tensor.numel()], device=device, dtype=torch.long) + size_list = [torch.tensor([0], device=device, dtype=torch.long) for _ in range(world_size)] + if cpu_group is None: + dist.all_gather(size_list, local_size) + else: + print("gathering on cpu") + dist.all_gather(size_list, local_size, group=cpu_group) + size_list = [int(size.item()) for size in size_list] + max_size = max(size_list) + assert isinstance(local_size.item(), int) + local_size = int(local_size.item()) + + # receiving Tensor from all ranks + # we pad the tensor because torch all_gather does not support + # gathering tensors of different shapes + tensor_list = [] + for _ in size_list: + tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device=device)) + if local_size != max_size: + padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device=device) + tensor = torch.cat((tensor, padding), dim=0) + if cpu_group is None: + dist.all_gather(tensor_list, tensor) + else: + dist.all_gather(tensor_list, tensor, group=cpu_group) + + data_list = [] + for size, tensor in zip(size_list, tensor_list): + tensor = torch.split(tensor, [size, max_size - size], dim=0)[0] + buffer = io.BytesIO(tensor.cpu().numpy()) + obj = torch.load(buffer) + data_list.append(obj) + + return data_list + + +def all_gather(data): + """ + Run all_gather on arbitrary picklable data (not necessarily tensors) + Args: + data: any picklable object + Returns: + list[data]: list of data gathered from each rank + """ + + if os.getenv("CPU_REDUCE") == "1": + return all_gather_cpu(data) + + world_size = get_world_size() + if world_size == 1: + return [data] + + # serialized to a Tensor + buffer = pickle.dumps(data) + storage = torch.ByteStorage.from_buffer(buffer) + tensor = torch.ByteTensor(storage).to("cuda") + + # obtain Tensor size of each rank + local_size = torch.tensor([tensor.numel()], device="cuda") + size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)] + dist.all_gather(size_list, local_size) + size_list = [int(size.item()) for size in size_list] + max_size = max(size_list) + + # receiving Tensor from all ranks + # we pad the tensor because torch all_gather does not support + # gathering tensors of different shapes + tensor_list = [] + for _ in size_list: + tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda")) + if local_size != max_size: + padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda") + tensor = torch.cat((tensor, padding), dim=0) + dist.all_gather(tensor_list, tensor) + + data_list = [] + for size, tensor in zip(size_list, tensor_list): + buffer = tensor.cpu().numpy().tobytes()[:size] + data_list.append(pickle.loads(buffer)) + + return data_list + + +def reduce_dict(input_dict, average=True): + """ + Args: + input_dict (dict): all the values will be reduced + average (bool): whether to do average or sum + Reduce the values in the dictionary from all processes so that all processes + have the averaged results. Returns a dict with the same fields as + input_dict, after reduction. + """ + world_size = get_world_size() + if world_size < 2: + return input_dict + with torch.no_grad(): + names = [] + values = [] + # sort the keys so that they are consistent across processes + for k in sorted(input_dict.keys()): + names.append(k) + values.append(input_dict[k]) + values = torch.stack(values, dim=0) + dist.all_reduce(values) + if average: + values /= world_size + reduced_dict = {k: v for k, v in zip(names, values)} + return reduced_dict + + +class MetricLogger(object): + def __init__(self, delimiter="\t"): + self.meters = defaultdict(SmoothedValue) + self.delimiter = delimiter + + 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(): + # print(name, str(meter)) + # import ipdb;ipdb.set_trace() + if meter.count > 0: + 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 log_every(self, iterable, print_freq, header=None, logger=None): + if logger is None: + print_func = print + else: + print_func = logger.info + + i = 0 + if not header: + header = "" + start_time = time.time() + end = time.time() + iter_time = SmoothedValue(fmt="{avg:.4f}") + data_time = SmoothedValue(fmt="{avg:.4f}") + space_fmt = ":" + str(len(str(len(iterable)))) + "d" + if torch.cuda.is_available(): + log_msg = self.delimiter.join( + [ + header, + "[{0" + space_fmt + "}/{1}]", + "eta: {eta}", + "{meters}", + "time: {time}", + "data: {data}", + "max mem: {memory:.0f}", + ] + ) + else: + log_msg = self.delimiter.join( + [ + header, + "[{0" + space_fmt + "}/{1}]", + "eta: {eta}", + "{meters}", + "time: {time}", + "data: {data}", + ] + ) + MB = 1024.0 * 1024.0 + for obj in iterable: + data_time.update(time.time() - end) + yield obj + # import ipdb; ipdb.set_trace() + iter_time.update(time.time() - end) + if i % print_freq == 0 or i == len(iterable) - 1: + eta_seconds = iter_time.global_avg * (len(iterable) - i) + eta_string = str(datetime.timedelta(seconds=int(eta_seconds))) + if torch.cuda.is_available(): + print_func( + log_msg.format( + i, + len(iterable), + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + memory=torch.cuda.max_memory_allocated() / MB, + ) + ) + else: + print_func( + log_msg.format( + i, + len(iterable), + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + ) + ) + i += 1 + end = time.time() + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + print_func( + "{} Total time: {} ({:.4f} s / it)".format( + header, total_time_str, total_time / len(iterable) + ) + ) + + +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 uncommited 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 + + +def collate_fn(batch): + # import ipdb; ipdb.set_trace() + batch = list(zip(*batch)) + batch[0] = nested_tensor_from_tensor_list(batch[0]) + return tuple(batch) + + +def _max_by_axis(the_list): + # type: (List[List[int]]) -> List[int] + maxes = the_list[0] + for sublist in the_list[1:]: + for index, item in enumerate(sublist): + maxes[index] = max(maxes[index], item) + return maxes + + +class NestedTensor(object): + def __init__(self, tensors, mask: Optional[Tensor]): + self.tensors = tensors + self.mask = mask + if mask == "auto": + self.mask = torch.zeros_like(tensors).to(tensors.device) + if self.mask.dim() == 3: + self.mask = self.mask.sum(0).to(bool) + elif self.mask.dim() == 4: + self.mask = self.mask.sum(1).to(bool) + else: + raise ValueError( + "tensors dim must be 3 or 4 but {}({})".format( + self.tensors.dim(), self.tensors.shape + ) + ) + + def imgsize(self): + res = [] + for i in range(self.tensors.shape[0]): + mask = self.mask[i] + maxH = (~mask).sum(0).max() + maxW = (~mask).sum(1).max() + res.append(torch.Tensor([maxH, maxW])) + return res + + def to(self, device): + # type: (Device) -> NestedTensor # noqa + cast_tensor = self.tensors.to(device) + mask = self.mask + if mask is not None: + assert mask is not None + cast_mask = mask.to(device) + else: + cast_mask = None + return NestedTensor(cast_tensor, cast_mask) + + def to_img_list_single(self, tensor, mask): + assert tensor.dim() == 3, "dim of tensor should be 3 but {}".format(tensor.dim()) + maxH = (~mask).sum(0).max() + maxW = (~mask).sum(1).max() + img = tensor[:, :maxH, :maxW] + return img + + def to_img_list(self): + """remove the padding and convert to img list + + Returns: + [type]: [description] + """ + if self.tensors.dim() == 3: + return self.to_img_list_single(self.tensors, self.mask) + else: + res = [] + for i in range(self.tensors.shape[0]): + tensor_i = self.tensors[i] + mask_i = self.mask[i] + res.append(self.to_img_list_single(tensor_i, mask_i)) + return res + + @property + def device(self): + return self.tensors.device + + def decompose(self): + return self.tensors, self.mask + + def __repr__(self): + return str(self.tensors) + + @property + def shape(self): + return {"tensors.shape": self.tensors.shape, "mask.shape": self.mask.shape} + + +def nested_tensor_from_tensor_list(tensor_list: List[Tensor]): + # TODO make this more general + if tensor_list[0].ndim == 3: + if torchvision._is_tracing(): + # nested_tensor_from_tensor_list() does not export well to ONNX + # call _onnx_nested_tensor_from_tensor_list() instead + return _onnx_nested_tensor_from_tensor_list(tensor_list) + + # TODO make it support different-sized images + max_size = _max_by_axis([list(img.shape) for img in tensor_list]) + # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list])) + batch_shape = [len(tensor_list)] + max_size + b, c, h, w = batch_shape + dtype = tensor_list[0].dtype + device = tensor_list[0].device + tensor = torch.zeros(batch_shape, dtype=dtype, device=device) + mask = torch.ones((b, h, w), dtype=torch.bool, device=device) + for img, pad_img, m in zip(tensor_list, tensor, mask): + pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img) + m[: img.shape[1], : img.shape[2]] = False + else: + raise ValueError("not supported") + return NestedTensor(tensor, mask) + + +# _onnx_nested_tensor_from_tensor_list() is an implementation of +# nested_tensor_from_tensor_list() that is supported by ONNX tracing. +@torch.jit.unused +def _onnx_nested_tensor_from_tensor_list(tensor_list: List[Tensor]) -> NestedTensor: + max_size = [] + for i in range(tensor_list[0].dim()): + max_size_i = torch.max( + torch.stack([img.shape[i] for img in tensor_list]).to(torch.float32) + ).to(torch.int64) + max_size.append(max_size_i) + max_size = tuple(max_size) + + # work around for + # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img) + # m[: img.shape[1], :img.shape[2]] = False + # which is not yet supported in onnx + padded_imgs = [] + padded_masks = [] + for img in tensor_list: + padding = [(s1 - s2) for s1, s2 in zip(max_size, tuple(img.shape))] + padded_img = torch.nn.functional.pad(img, (0, padding[2], 0, padding[1], 0, padding[0])) + padded_imgs.append(padded_img) + + m = torch.zeros_like(img[0], dtype=torch.int, device=img.device) + padded_mask = torch.nn.functional.pad(m, (0, padding[2], 0, padding[1]), "constant", 1) + padded_masks.append(padded_mask.to(torch.bool)) + + tensor = torch.stack(padded_imgs) + mask = torch.stack(padded_masks) + + return NestedTensor(tensor, mask=mask) + + +def setup_for_distributed(is_master): + """ + This function disables printing when not in master process + """ + import builtins as __builtin__ + + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop("force", False) + if is_master or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print + + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def get_world_size(): + if not is_dist_avail_and_initialized(): + return 1 + return dist.get_world_size() + + +def get_rank(): + if not is_dist_avail_and_initialized(): + return 0 + return dist.get_rank() + + +def is_main_process(): + return get_rank() == 0 + + +def save_on_master(*args, **kwargs): + if is_main_process(): + torch.save(*args, **kwargs) + + +def init_distributed_mode(args): + if "WORLD_SIZE" in os.environ and os.environ["WORLD_SIZE"] != "": # 'RANK' in os.environ and + args.rank = int(os.environ["RANK"]) + args.world_size = int(os.environ["WORLD_SIZE"]) + args.gpu = args.local_rank = int(os.environ["LOCAL_RANK"]) + + # launch by torch.distributed.launch + # Single node + # python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 1 --rank 0 ... + # Multi nodes + # python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 0 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ... + # python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 1 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ... + # args.rank = int(os.environ.get('OMPI_COMM_WORLD_RANK')) + # local_world_size = int(os.environ['GPU_PER_NODE_COUNT']) + # args.world_size = args.world_size * local_world_size + # args.gpu = args.local_rank = int(os.environ['LOCAL_RANK']) + # args.rank = args.rank * local_world_size + args.local_rank + print( + "world size: {}, rank: {}, local rank: {}".format( + args.world_size, args.rank, args.local_rank + ) + ) + print(json.dumps(dict(os.environ), indent=2)) + elif "SLURM_PROCID" in os.environ: + args.rank = int(os.environ["SLURM_PROCID"]) + args.gpu = args.local_rank = int(os.environ["SLURM_LOCALID"]) + args.world_size = int(os.environ["SLURM_NPROCS"]) + + print( + "world size: {}, world rank: {}, local rank: {}, device_count: {}".format( + args.world_size, args.rank, args.local_rank, torch.cuda.device_count() + ) + ) + else: + print("Not using distributed mode") + args.distributed = False + args.world_size = 1 + args.rank = 0 + args.local_rank = 0 + return + + print("world_size:{} rank:{} local_rank:{}".format(args.world_size, args.rank, args.local_rank)) + args.distributed = True + torch.cuda.set_device(args.local_rank) + args.dist_backend = "nccl" + print("| distributed init (rank {}): {}".format(args.rank, args.dist_url), flush=True) + + torch.distributed.init_process_group( + backend=args.dist_backend, + world_size=args.world_size, + rank=args.rank, + init_method=args.dist_url, + ) + + print("Before torch.distributed.barrier()") + torch.distributed.barrier() + print("End torch.distributed.barrier()") + setup_for_distributed(args.rank == 0) + + +@torch.no_grad() +def accuracy(output, target, topk=(1,)): + """Computes the precision@k for the specified values of k""" + if target.numel() == 0: + return [torch.zeros([], device=output.device)] + maxk = max(topk) + batch_size = target.size(0) + + _, pred = output.topk(maxk, 1, True, True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + + res = [] + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0) + res.append(correct_k.mul_(100.0 / batch_size)) + return res + + +@torch.no_grad() +def accuracy_onehot(pred, gt): + """_summary_ + + Args: + pred (_type_): n, c + gt (_type_): n, c + """ + tp = ((pred - gt).abs().sum(-1) < 1e-4).float().sum() + acc = tp / gt.shape[0] * 100 + return acc + + +def interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None): + # type: (Tensor, Optional[List[int]], Optional[float], str, Optional[bool]) -> Tensor + """ + Equivalent to nn.functional.interpolate, but with support for empty batch sizes. + This will eventually be supported natively by PyTorch, and this + class can go away. + """ + if __torchvision_need_compat_flag < 0.7: + if input.numel() > 0: + return torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners) + + output_shape = _output_size(2, input, size, scale_factor) + output_shape = list(input.shape[:-2]) + list(output_shape) + return _new_empty_tensor(input, output_shape) + else: + return torchvision.ops.misc.interpolate(input, size, scale_factor, mode, align_corners) + + +class color_sys: + def __init__(self, num_colors) -> None: + self.num_colors = num_colors + colors = [] + for i in np.arange(0.0, 360.0, 360.0 / num_colors): + hue = i / 360.0 + lightness = (50 + np.random.rand() * 10) / 100.0 + saturation = (90 + np.random.rand() * 10) / 100.0 + colors.append( + tuple([int(j * 255) for j in colorsys.hls_to_rgb(hue, lightness, saturation)]) + ) + self.colors = colors + + def __call__(self, idx): + return self.colors[idx] + + +def inverse_sigmoid(x, eps=1e-3): + x = x.clamp(min=0, max=1) + x1 = x.clamp(min=eps) + x2 = (1 - x).clamp(min=eps) + return torch.log(x1 / x2) + + +def clean_state_dict(state_dict): + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + if k[:7] == "module.": + k = k[7:] # remove `module.` + new_state_dict[k] = v + return new_state_dict diff --git a/GroundingDINO/groundingdino/util/slconfig.py b/GroundingDINO/groundingdino/util/slconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..672e72ed0b68a54c13ade66c9f146d2d542e97c6 --- /dev/null +++ b/GroundingDINO/groundingdino/util/slconfig.py @@ -0,0 +1,427 @@ +# ========================================================== +# Modified from mmcv +# ========================================================== +import ast +import os +import os.path as osp +import shutil +import sys +import tempfile +from argparse import Action +from importlib import import_module + +from addict import Dict +from yapf.yapflib.yapf_api import FormatCode + +BASE_KEY = "_base_" +DELETE_KEY = "_delete_" +RESERVED_KEYS = ["filename", "text", "pretty_text", "get", "dump", "merge_from_dict"] + + +def check_file_exist(filename, msg_tmpl='file "{}" does not exist'): + if not osp.isfile(filename): + raise FileNotFoundError(msg_tmpl.format(filename)) + + +class ConfigDict(Dict): + def __missing__(self, name): + raise KeyError(name) + + def __getattr__(self, name): + try: + value = super(ConfigDict, self).__getattr__(name) + except KeyError: + ex = AttributeError(f"'{self.__class__.__name__}' object has no " f"attribute '{name}'") + except Exception as e: + ex = e + else: + return value + raise ex + + +class SLConfig(object): + """ + config files. + only support .py file as config now. + + ref: mmcv.utils.config + + Example: + >>> cfg = Config(dict(a=1, b=dict(b1=[0, 1]))) + >>> cfg.a + 1 + >>> cfg.b + {'b1': [0, 1]} + >>> cfg.b.b1 + [0, 1] + >>> cfg = Config.fromfile('tests/data/config/a.py') + >>> cfg.filename + "/home/kchen/projects/mmcv/tests/data/config/a.py" + >>> cfg.item4 + 'test' + >>> cfg + "Config [path: /home/kchen/projects/mmcv/tests/data/config/a.py]: " + "{'item1': [1, 2], 'item2': {'a': 0}, 'item3': True, 'item4': 'test'}" + """ + + @staticmethod + def _validate_py_syntax(filename): + with open(filename) as f: + content = f.read() + try: + ast.parse(content) + except SyntaxError: + raise SyntaxError("There are syntax errors in config " f"file {filename}") + + @staticmethod + def _file2dict(filename): + filename = osp.abspath(osp.expanduser(filename)) + check_file_exist(filename) + if filename.lower().endswith(".py"): + with tempfile.TemporaryDirectory() as temp_config_dir: + temp_config_file = tempfile.NamedTemporaryFile(dir=temp_config_dir, suffix=".py") + temp_config_name = osp.basename(temp_config_file.name) + if os.name == 'nt': + temp_config_file.close() + shutil.copyfile(filename, osp.join(temp_config_dir, temp_config_name)) + temp_module_name = osp.splitext(temp_config_name)[0] + sys.path.insert(0, temp_config_dir) + SLConfig._validate_py_syntax(filename) + mod = import_module(temp_module_name) + sys.path.pop(0) + cfg_dict = { + name: value for name, value in mod.__dict__.items() if not name.startswith("__") + } + # delete imported module + del sys.modules[temp_module_name] + # close temp file + temp_config_file.close() + elif filename.lower().endswith((".yml", ".yaml", ".json")): + from .slio import slload + + cfg_dict = slload(filename) + else: + raise IOError("Only py/yml/yaml/json type are supported now!") + + cfg_text = filename + "\n" + with open(filename, "r") as f: + cfg_text += f.read() + + # parse the base file + if BASE_KEY in cfg_dict: + cfg_dir = osp.dirname(filename) + base_filename = cfg_dict.pop(BASE_KEY) + base_filename = base_filename if isinstance(base_filename, list) else [base_filename] + + cfg_dict_list = list() + cfg_text_list = list() + for f in base_filename: + _cfg_dict, _cfg_text = SLConfig._file2dict(osp.join(cfg_dir, f)) + cfg_dict_list.append(_cfg_dict) + cfg_text_list.append(_cfg_text) + + base_cfg_dict = dict() + for c in cfg_dict_list: + if len(base_cfg_dict.keys() & c.keys()) > 0: + raise KeyError("Duplicate key is not allowed among bases") + # TODO Allow the duplicate key while warnning user + base_cfg_dict.update(c) + + base_cfg_dict = SLConfig._merge_a_into_b(cfg_dict, base_cfg_dict) + cfg_dict = base_cfg_dict + + # merge cfg_text + cfg_text_list.append(cfg_text) + cfg_text = "\n".join(cfg_text_list) + + return cfg_dict, cfg_text + + @staticmethod + def _merge_a_into_b(a, b): + """merge dict `a` into dict `b` (non-inplace). + values in `a` will overwrite `b`. + copy first to avoid inplace modification + + Args: + a ([type]): [description] + b ([type]): [description] + + Returns: + [dict]: [description] + """ + # import ipdb; ipdb.set_trace() + if not isinstance(a, dict): + return a + + b = b.copy() + for k, v in a.items(): + if isinstance(v, dict) and k in b and not v.pop(DELETE_KEY, False): + + if not isinstance(b[k], dict) and not isinstance(b[k], list): + # if : + # import ipdb; ipdb.set_trace() + raise TypeError( + f"{k}={v} in child config cannot inherit from base " + f"because {k} is a dict in the child config but is of " + f"type {type(b[k])} in base config. You may set " + f"`{DELETE_KEY}=True` to ignore the base config" + ) + b[k] = SLConfig._merge_a_into_b(v, b[k]) + elif isinstance(b, list): + try: + _ = int(k) + except: + raise TypeError( + f"b is a list, " f"index {k} should be an int when input but {type(k)}" + ) + b[int(k)] = SLConfig._merge_a_into_b(v, b[int(k)]) + else: + b[k] = v + + return b + + @staticmethod + def fromfile(filename): + cfg_dict, cfg_text = SLConfig._file2dict(filename) + return SLConfig(cfg_dict, cfg_text=cfg_text, filename=filename) + + def __init__(self, cfg_dict=None, cfg_text=None, filename=None): + if cfg_dict is None: + cfg_dict = dict() + elif not isinstance(cfg_dict, dict): + raise TypeError("cfg_dict must be a dict, but " f"got {type(cfg_dict)}") + for key in cfg_dict: + if key in RESERVED_KEYS: + raise KeyError(f"{key} is reserved for config file") + + super(SLConfig, self).__setattr__("_cfg_dict", ConfigDict(cfg_dict)) + super(SLConfig, self).__setattr__("_filename", filename) + if cfg_text: + text = cfg_text + elif filename: + with open(filename, "r") as f: + text = f.read() + else: + text = "" + super(SLConfig, self).__setattr__("_text", text) + + @property + def filename(self): + return self._filename + + @property + def text(self): + return self._text + + @property + def pretty_text(self): + + indent = 4 + + def _indent(s_, num_spaces): + s = s_.split("\n") + if len(s) == 1: + return s_ + first = s.pop(0) + s = [(num_spaces * " ") + line for line in s] + s = "\n".join(s) + s = first + "\n" + s + return s + + def _format_basic_types(k, v, use_mapping=False): + if isinstance(v, str): + v_str = f"'{v}'" + else: + v_str = str(v) + + if use_mapping: + k_str = f"'{k}'" if isinstance(k, str) else str(k) + attr_str = f"{k_str}: {v_str}" + else: + attr_str = f"{str(k)}={v_str}" + attr_str = _indent(attr_str, indent) + + return attr_str + + def _format_list(k, v, use_mapping=False): + # check if all items in the list are dict + if all(isinstance(_, dict) for _ in v): + v_str = "[\n" + v_str += "\n".join( + f"dict({_indent(_format_dict(v_), indent)})," for v_ in v + ).rstrip(",") + if use_mapping: + k_str = f"'{k}'" if isinstance(k, str) else str(k) + attr_str = f"{k_str}: {v_str}" + else: + attr_str = f"{str(k)}={v_str}" + attr_str = _indent(attr_str, indent) + "]" + else: + attr_str = _format_basic_types(k, v, use_mapping) + return attr_str + + def _contain_invalid_identifier(dict_str): + contain_invalid_identifier = False + for key_name in dict_str: + contain_invalid_identifier |= not str(key_name).isidentifier() + return contain_invalid_identifier + + def _format_dict(input_dict, outest_level=False): + r = "" + s = [] + + use_mapping = _contain_invalid_identifier(input_dict) + if use_mapping: + r += "{" + for idx, (k, v) in enumerate(input_dict.items()): + is_last = idx >= len(input_dict) - 1 + end = "" if outest_level or is_last else "," + if isinstance(v, dict): + v_str = "\n" + _format_dict(v) + if use_mapping: + k_str = f"'{k}'" if isinstance(k, str) else str(k) + attr_str = f"{k_str}: dict({v_str}" + else: + attr_str = f"{str(k)}=dict({v_str}" + attr_str = _indent(attr_str, indent) + ")" + end + elif isinstance(v, list): + attr_str = _format_list(k, v, use_mapping) + end + else: + attr_str = _format_basic_types(k, v, use_mapping) + end + + s.append(attr_str) + r += "\n".join(s) + if use_mapping: + r += "}" + return r + + cfg_dict = self._cfg_dict.to_dict() + text = _format_dict(cfg_dict, outest_level=True) + # copied from setup.cfg + yapf_style = dict( + based_on_style="pep8", + blank_line_before_nested_class_or_def=True, + split_before_expression_after_opening_paren=True, + ) + text, _ = FormatCode(text, style_config=yapf_style, verify=True) + + return text + + def __repr__(self): + return f"Config (path: {self.filename}): {self._cfg_dict.__repr__()}" + + def __len__(self): + return len(self._cfg_dict) + + def __getattr__(self, name): + # # debug + # print('+'*15) + # print('name=%s' % name) + # print("addr:", id(self)) + # # print('type(self):', type(self)) + # print(self.__dict__) + # print('+'*15) + # if self.__dict__ == {}: + # raise ValueError + + return getattr(self._cfg_dict, name) + + def __getitem__(self, name): + return self._cfg_dict.__getitem__(name) + + def __setattr__(self, name, value): + if isinstance(value, dict): + value = ConfigDict(value) + self._cfg_dict.__setattr__(name, value) + + def __setitem__(self, name, value): + if isinstance(value, dict): + value = ConfigDict(value) + self._cfg_dict.__setitem__(name, value) + + def __iter__(self): + return iter(self._cfg_dict) + + def dump(self, file=None): + # import ipdb; ipdb.set_trace() + if file is None: + return self.pretty_text + else: + with open(file, "w") as f: + f.write(self.pretty_text) + + def merge_from_dict(self, options): + """Merge list into cfg_dict + + Merge the dict parsed by MultipleKVAction into this cfg. + + Examples: + >>> options = {'model.backbone.depth': 50, + ... 'model.backbone.with_cp':True} + >>> cfg = Config(dict(model=dict(backbone=dict(type='ResNet')))) + >>> cfg.merge_from_dict(options) + >>> cfg_dict = super(Config, self).__getattribute__('_cfg_dict') + >>> assert cfg_dict == dict( + ... model=dict(backbone=dict(depth=50, with_cp=True))) + + Args: + options (dict): dict of configs to merge from. + """ + option_cfg_dict = {} + for full_key, v in options.items(): + d = option_cfg_dict + key_list = full_key.split(".") + for subkey in key_list[:-1]: + d.setdefault(subkey, ConfigDict()) + d = d[subkey] + subkey = key_list[-1] + d[subkey] = v + + cfg_dict = super(SLConfig, self).__getattribute__("_cfg_dict") + super(SLConfig, self).__setattr__( + "_cfg_dict", SLConfig._merge_a_into_b(option_cfg_dict, cfg_dict) + ) + + # for multiprocess + def __setstate__(self, state): + self.__init__(state) + + def copy(self): + return SLConfig(self._cfg_dict.copy()) + + def deepcopy(self): + return SLConfig(self._cfg_dict.deepcopy()) + + +class DictAction(Action): + """ + argparse action to split an argument into KEY=VALUE form + on the first = and append to a dictionary. List options should + be passed as comma separated values, i.e KEY=V1,V2,V3 + """ + + @staticmethod + def _parse_int_float_bool(val): + try: + return int(val) + except ValueError: + pass + try: + return float(val) + except ValueError: + pass + if val.lower() in ["true", "false"]: + return True if val.lower() == "true" else False + if val.lower() in ["none", "null"]: + return None + return val + + def __call__(self, parser, namespace, values, option_string=None): + options = {} + for kv in values: + key, val = kv.split("=", maxsplit=1) + val = [self._parse_int_float_bool(v) for v in val.split(",")] + if len(val) == 1: + val = val[0] + options[key] = val + setattr(namespace, self.dest, options) diff --git a/GroundingDINO/groundingdino/util/slio.py b/GroundingDINO/groundingdino/util/slio.py new file mode 100644 index 0000000000000000000000000000000000000000..72c1f0f7b82cdc931d381feef64fe15815ba657e --- /dev/null +++ b/GroundingDINO/groundingdino/util/slio.py @@ -0,0 +1,177 @@ +# ========================================================== +# Modified from mmcv +# ========================================================== + +import json +import pickle +from abc import ABCMeta, abstractmethod +from pathlib import Path + +import yaml + +try: + from yaml import CLoader as Loader, CDumper as Dumper +except ImportError: + from yaml import Loader, Dumper + + +# =========================== +# Rigister handler +# =========================== + + +class BaseFileHandler(metaclass=ABCMeta): + @abstractmethod + def load_from_fileobj(self, file, **kwargs): + pass + + @abstractmethod + def dump_to_fileobj(self, obj, file, **kwargs): + pass + + @abstractmethod + def dump_to_str(self, obj, **kwargs): + pass + + def load_from_path(self, filepath, mode="r", **kwargs): + with open(filepath, mode) as f: + return self.load_from_fileobj(f, **kwargs) + + def dump_to_path(self, obj, filepath, mode="w", **kwargs): + with open(filepath, mode) as f: + self.dump_to_fileobj(obj, f, **kwargs) + + +class JsonHandler(BaseFileHandler): + def load_from_fileobj(self, file): + return json.load(file) + + def dump_to_fileobj(self, obj, file, **kwargs): + json.dump(obj, file, **kwargs) + + def dump_to_str(self, obj, **kwargs): + return json.dumps(obj, **kwargs) + + +class PickleHandler(BaseFileHandler): + def load_from_fileobj(self, file, **kwargs): + return pickle.load(file, **kwargs) + + def load_from_path(self, filepath, **kwargs): + return super(PickleHandler, self).load_from_path(filepath, mode="rb", **kwargs) + + def dump_to_str(self, obj, **kwargs): + kwargs.setdefault("protocol", 2) + return pickle.dumps(obj, **kwargs) + + def dump_to_fileobj(self, obj, file, **kwargs): + kwargs.setdefault("protocol", 2) + pickle.dump(obj, file, **kwargs) + + def dump_to_path(self, obj, filepath, **kwargs): + super(PickleHandler, self).dump_to_path(obj, filepath, mode="wb", **kwargs) + + +class YamlHandler(BaseFileHandler): + def load_from_fileobj(self, file, **kwargs): + kwargs.setdefault("Loader", Loader) + return yaml.load(file, **kwargs) + + def dump_to_fileobj(self, obj, file, **kwargs): + kwargs.setdefault("Dumper", Dumper) + yaml.dump(obj, file, **kwargs) + + def dump_to_str(self, obj, **kwargs): + kwargs.setdefault("Dumper", Dumper) + return yaml.dump(obj, **kwargs) + + +file_handlers = { + "json": JsonHandler(), + "yaml": YamlHandler(), + "yml": YamlHandler(), + "pickle": PickleHandler(), + "pkl": PickleHandler(), +} + +# =========================== +# load and dump +# =========================== + + +def is_str(x): + """Whether the input is an string instance. + + Note: This method is deprecated since python 2 is no longer supported. + """ + return isinstance(x, str) + + +def slload(file, file_format=None, **kwargs): + """Load data from json/yaml/pickle files. + + This method provides a unified api for loading data from serialized files. + + Args: + file (str or :obj:`Path` or file-like object): Filename or a file-like + object. + file_format (str, optional): If not specified, the file format will be + inferred from the file extension, otherwise use the specified one. + Currently supported formats include "json", "yaml/yml" and + "pickle/pkl". + + Returns: + The content from the file. + """ + if isinstance(file, Path): + file = str(file) + if file_format is None and is_str(file): + file_format = file.split(".")[-1] + if file_format not in file_handlers: + raise TypeError(f"Unsupported format: {file_format}") + + handler = file_handlers[file_format] + if is_str(file): + obj = handler.load_from_path(file, **kwargs) + elif hasattr(file, "read"): + obj = handler.load_from_fileobj(file, **kwargs) + else: + raise TypeError('"file" must be a filepath str or a file-object') + return obj + + +def sldump(obj, file=None, file_format=None, **kwargs): + """Dump data to json/yaml/pickle strings or files. + + This method provides a unified api for dumping data as strings or to files, + and also supports custom arguments for each file format. + + Args: + obj (any): The python object to be dumped. + file (str or :obj:`Path` or file-like object, optional): If not + specified, then the object is dump to a str, otherwise to a file + specified by the filename or file-like object. + file_format (str, optional): Same as :func:`load`. + + Returns: + bool: True for success, False otherwise. + """ + if isinstance(file, Path): + file = str(file) + if file_format is None: + if is_str(file): + file_format = file.split(".")[-1] + elif file is None: + raise ValueError("file_format must be specified since file is None") + if file_format not in file_handlers: + raise TypeError(f"Unsupported format: {file_format}") + + handler = file_handlers[file_format] + if file is None: + return handler.dump_to_str(obj, **kwargs) + elif is_str(file): + handler.dump_to_path(obj, file, **kwargs) + elif hasattr(file, "write"): + handler.dump_to_fileobj(obj, file, **kwargs) + else: + raise TypeError('"file" must be a filename str or a file-object') diff --git a/GroundingDINO/groundingdino/util/time_counter.py b/GroundingDINO/groundingdino/util/time_counter.py new file mode 100644 index 0000000000000000000000000000000000000000..0aedb2e4d61bfbe7571dca9d50053f0fedaa1359 --- /dev/null +++ b/GroundingDINO/groundingdino/util/time_counter.py @@ -0,0 +1,62 @@ +import json +import time + + +class TimeCounter: + def __init__(self) -> None: + pass + + def clear(self): + self.timedict = {} + self.basetime = time.perf_counter() + + def timeit(self, name): + nowtime = time.perf_counter() - self.basetime + self.timedict[name] = nowtime + self.basetime = time.perf_counter() + + +class TimeHolder: + def __init__(self) -> None: + self.timedict = {} + + def update(self, _timedict: dict): + for k, v in _timedict.items(): + if k not in self.timedict: + self.timedict[k] = AverageMeter(name=k, val_only=True) + self.timedict[k].update(val=v) + + def final_res(self): + return {k: v.avg for k, v in self.timedict.items()} + + def __str__(self): + return json.dumps(self.final_res(), indent=2) + + +class AverageMeter(object): + """Computes and stores the average and current value""" + + def __init__(self, name, fmt=":f", val_only=False): + self.name = name + self.fmt = fmt + self.val_only = val_only + self.reset() + + def reset(self): + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + def __str__(self): + if self.val_only: + fmtstr = "{name} {val" + self.fmt + "}" + else: + fmtstr = "{name} {val" + self.fmt + "} ({avg" + self.fmt + "})" + return fmtstr.format(**self.__dict__) diff --git a/GroundingDINO/groundingdino/util/utils.py b/GroundingDINO/groundingdino/util/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8cf83ae03a7865bc48493be16e8b1b2d53a1b09f --- /dev/null +++ b/GroundingDINO/groundingdino/util/utils.py @@ -0,0 +1,610 @@ +import argparse +import json +import warnings +from collections import OrderedDict +from copy import deepcopy +from typing import Any, Dict, List + +import numpy as np +import torch +from transformers import AutoTokenizer + +from groundingdino.util.slconfig import SLConfig + + +def slprint(x, name="x"): + if isinstance(x, (torch.Tensor, np.ndarray)): + print(f"{name}.shape:", x.shape) + elif isinstance(x, (tuple, list)): + print("type x:", type(x)) + for i in range(min(10, len(x))): + slprint(x[i], f"{name}[{i}]") + elif isinstance(x, dict): + for k, v in x.items(): + slprint(v, f"{name}[{k}]") + else: + print(f"{name}.type:", type(x)) + + +def clean_state_dict(state_dict): + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + if k[:7] == "module.": + k = k[7:] # remove `module.` + new_state_dict[k] = v + return new_state_dict + + +def renorm( + img: torch.FloatTensor, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] +) -> torch.FloatTensor: + # img: tensor(3,H,W) or tensor(B,3,H,W) + # return: same as img + assert img.dim() == 3 or img.dim() == 4, "img.dim() should be 3 or 4 but %d" % img.dim() + if img.dim() == 3: + assert img.size(0) == 3, 'img.size(0) shoule be 3 but "%d". (%s)' % ( + img.size(0), + str(img.size()), + ) + img_perm = img.permute(1, 2, 0) + mean = torch.Tensor(mean) + std = torch.Tensor(std) + img_res = img_perm * std + mean + return img_res.permute(2, 0, 1) + else: # img.dim() == 4 + assert img.size(1) == 3, 'img.size(1) shoule be 3 but "%d". (%s)' % ( + img.size(1), + str(img.size()), + ) + img_perm = img.permute(0, 2, 3, 1) + mean = torch.Tensor(mean) + std = torch.Tensor(std) + img_res = img_perm * std + mean + return img_res.permute(0, 3, 1, 2) + + +class CocoClassMapper: + def __init__(self) -> None: + self.category_map_str = { + "1": 1, + "2": 2, + "3": 3, + "4": 4, + "5": 5, + "6": 6, + "7": 7, + "8": 8, + "9": 9, + "10": 10, + "11": 11, + "13": 12, + "14": 13, + "15": 14, + "16": 15, + "17": 16, + "18": 17, + "19": 18, + "20": 19, + "21": 20, + "22": 21, + "23": 22, + "24": 23, + "25": 24, + "27": 25, + "28": 26, + "31": 27, + "32": 28, + "33": 29, + "34": 30, + "35": 31, + "36": 32, + "37": 33, + "38": 34, + "39": 35, + "40": 36, + "41": 37, + "42": 38, + "43": 39, + "44": 40, + "46": 41, + "47": 42, + "48": 43, + "49": 44, + "50": 45, + "51": 46, + "52": 47, + "53": 48, + "54": 49, + "55": 50, + "56": 51, + "57": 52, + "58": 53, + "59": 54, + "60": 55, + "61": 56, + "62": 57, + "63": 58, + "64": 59, + "65": 60, + "67": 61, + "70": 62, + "72": 63, + "73": 64, + "74": 65, + "75": 66, + "76": 67, + "77": 68, + "78": 69, + "79": 70, + "80": 71, + "81": 72, + "82": 73, + "84": 74, + "85": 75, + "86": 76, + "87": 77, + "88": 78, + "89": 79, + "90": 80, + } + self.origin2compact_mapper = {int(k): v - 1 for k, v in self.category_map_str.items()} + self.compact2origin_mapper = {int(v - 1): int(k) for k, v in self.category_map_str.items()} + + def origin2compact(self, idx): + return self.origin2compact_mapper[int(idx)] + + def compact2origin(self, idx): + return self.compact2origin_mapper[int(idx)] + + +def to_device(item, device): + if isinstance(item, torch.Tensor): + return item.to(device) + elif isinstance(item, list): + return [to_device(i, device) for i in item] + elif isinstance(item, dict): + return {k: to_device(v, device) for k, v in item.items()} + else: + raise NotImplementedError( + "Call Shilong if you use other containers! type: {}".format(type(item)) + ) + + +# +def get_gaussian_mean(x, axis, other_axis, softmax=True): + """ + + Args: + x (float): Input images(BxCxHxW) + axis (int): The index for weighted mean + other_axis (int): The other index + + Returns: weighted index for axis, BxC + + """ + mat2line = torch.sum(x, axis=other_axis) + # mat2line = mat2line / mat2line.mean() * 10 + if softmax: + u = torch.softmax(mat2line, axis=2) + else: + u = mat2line / (mat2line.sum(2, keepdim=True) + 1e-6) + size = x.shape[axis] + ind = torch.linspace(0, 1, size).to(x.device) + batch = x.shape[0] + channel = x.shape[1] + index = ind.repeat([batch, channel, 1]) + mean_position = torch.sum(index * u, dim=2) + return mean_position + + +def get_expected_points_from_map(hm, softmax=True): + """get_gaussian_map_from_points + B,C,H,W -> B,N,2 float(0, 1) float(0, 1) + softargmax function + + Args: + hm (float): Input images(BxCxHxW) + + Returns: + weighted index for axis, BxCx2. float between 0 and 1. + + """ + # hm = 10*hm + B, C, H, W = hm.shape + y_mean = get_gaussian_mean(hm, 2, 3, softmax=softmax) # B,C + x_mean = get_gaussian_mean(hm, 3, 2, softmax=softmax) # B,C + # return torch.cat((x_mean.unsqueeze(-1), y_mean.unsqueeze(-1)), 2) + return torch.stack([x_mean, y_mean], dim=2) + + +# Positional encoding (section 5.1) +# borrow from nerf +class Embedder: + def __init__(self, **kwargs): + self.kwargs = kwargs + self.create_embedding_fn() + + def create_embedding_fn(self): + embed_fns = [] + d = self.kwargs["input_dims"] + out_dim = 0 + if self.kwargs["include_input"]: + embed_fns.append(lambda x: x) + out_dim += d + + max_freq = self.kwargs["max_freq_log2"] + N_freqs = self.kwargs["num_freqs"] + + if self.kwargs["log_sampling"]: + freq_bands = 2.0 ** torch.linspace(0.0, max_freq, steps=N_freqs) + else: + freq_bands = torch.linspace(2.0**0.0, 2.0**max_freq, steps=N_freqs) + + for freq in freq_bands: + for p_fn in self.kwargs["periodic_fns"]: + embed_fns.append(lambda x, p_fn=p_fn, freq=freq: p_fn(x * freq)) + out_dim += d + + self.embed_fns = embed_fns + self.out_dim = out_dim + + def embed(self, inputs): + return torch.cat([fn(inputs) for fn in self.embed_fns], -1) + + +def get_embedder(multires, i=0): + import torch.nn as nn + + if i == -1: + return nn.Identity(), 3 + + embed_kwargs = { + "include_input": True, + "input_dims": 3, + "max_freq_log2": multires - 1, + "num_freqs": multires, + "log_sampling": True, + "periodic_fns": [torch.sin, torch.cos], + } + + embedder_obj = Embedder(**embed_kwargs) + embed = lambda x, eo=embedder_obj: eo.embed(x) + return embed, embedder_obj.out_dim + + +class APOPMeter: + def __init__(self) -> None: + self.tp = 0 + self.fp = 0 + self.tn = 0 + self.fn = 0 + + def update(self, pred, gt): + """ + Input: + pred, gt: Tensor() + """ + assert pred.shape == gt.shape + self.tp += torch.logical_and(pred == 1, gt == 1).sum().item() + self.fp += torch.logical_and(pred == 1, gt == 0).sum().item() + self.tn += torch.logical_and(pred == 0, gt == 0).sum().item() + self.tn += torch.logical_and(pred == 1, gt == 0).sum().item() + + def update_cm(self, tp, fp, tn, fn): + self.tp += tp + self.fp += fp + self.tn += tn + self.tn += fn + + +def inverse_sigmoid(x, eps=1e-5): + x = x.clamp(min=0, max=1) + x1 = x.clamp(min=eps) + x2 = (1 - x).clamp(min=eps) + return torch.log(x1 / x2) + + +def get_raw_dict(args): + """ + return the dicf contained in args. + + e.g: + >>> with open(path, 'w') as f: + json.dump(get_raw_dict(args), f, indent=2) + """ + if isinstance(args, argparse.Namespace): + return vars(args) + elif isinstance(args, dict): + return args + elif isinstance(args, SLConfig): + return args._cfg_dict + else: + raise NotImplementedError("Unknown type {}".format(type(args))) + + +def stat_tensors(tensor): + assert tensor.dim() == 1 + tensor_sm = tensor.softmax(0) + entropy = (tensor_sm * torch.log(tensor_sm + 1e-9)).sum() + + return { + "max": tensor.max(), + "min": tensor.min(), + "mean": tensor.mean(), + "var": tensor.var(), + "std": tensor.var() ** 0.5, + "entropy": entropy, + } + + +class NiceRepr: + """Inherit from this class and define ``__nice__`` to "nicely" print your + objects. + + Defines ``__str__`` and ``__repr__`` in terms of ``__nice__`` function + Classes that inherit from :class:`NiceRepr` should redefine ``__nice__``. + If the inheriting class has a ``__len__``, method then the default + ``__nice__`` method will return its length. + + Example: + >>> class Foo(NiceRepr): + ... def __nice__(self): + ... return 'info' + >>> foo = Foo() + >>> assert str(foo) == '' + >>> assert repr(foo).startswith('>> class Bar(NiceRepr): + ... pass + >>> bar = Bar() + >>> import pytest + >>> with pytest.warns(None) as record: + >>> assert 'object at' in str(bar) + >>> assert 'object at' in repr(bar) + + Example: + >>> class Baz(NiceRepr): + ... def __len__(self): + ... return 5 + >>> baz = Baz() + >>> assert str(baz) == '' + """ + + def __nice__(self): + """str: a "nice" summary string describing this module""" + if hasattr(self, "__len__"): + # It is a common pattern for objects to use __len__ in __nice__ + # As a convenience we define a default __nice__ for these objects + return str(len(self)) + else: + # In all other cases force the subclass to overload __nice__ + raise NotImplementedError(f"Define the __nice__ method for {self.__class__!r}") + + def __repr__(self): + """str: the string of the module""" + try: + nice = self.__nice__() + classname = self.__class__.__name__ + return f"<{classname}({nice}) at {hex(id(self))}>" + except NotImplementedError as ex: + warnings.warn(str(ex), category=RuntimeWarning) + return object.__repr__(self) + + def __str__(self): + """str: the string of the module""" + try: + classname = self.__class__.__name__ + nice = self.__nice__() + return f"<{classname}({nice})>" + except NotImplementedError as ex: + warnings.warn(str(ex), category=RuntimeWarning) + return object.__repr__(self) + + +def ensure_rng(rng=None): + """Coerces input into a random number generator. + + If the input is None, then a global random state is returned. + + If the input is a numeric value, then that is used as a seed to construct a + random state. Otherwise the input is returned as-is. + + Adapted from [1]_. + + Args: + rng (int | numpy.random.RandomState | None): + if None, then defaults to the global rng. Otherwise this can be an + integer or a RandomState class + Returns: + (numpy.random.RandomState) : rng - + a numpy random number generator + + References: + .. [1] https://gitlab.kitware.com/computer-vision/kwarray/blob/master/kwarray/util_random.py#L270 # noqa: E501 + """ + + if rng is None: + rng = np.random.mtrand._rand + elif isinstance(rng, int): + rng = np.random.RandomState(rng) + else: + rng = rng + return rng + + +def random_boxes(num=1, scale=1, rng=None): + """Simple version of ``kwimage.Boxes.random`` + + Returns: + Tensor: shape (n, 4) in x1, y1, x2, y2 format. + + References: + https://gitlab.kitware.com/computer-vision/kwimage/blob/master/kwimage/structs/boxes.py#L1390 + + Example: + >>> num = 3 + >>> scale = 512 + >>> rng = 0 + >>> boxes = random_boxes(num, scale, rng) + >>> print(boxes) + tensor([[280.9925, 278.9802, 308.6148, 366.1769], + [216.9113, 330.6978, 224.0446, 456.5878], + [405.3632, 196.3221, 493.3953, 270.7942]]) + """ + rng = ensure_rng(rng) + + tlbr = rng.rand(num, 4).astype(np.float32) + + tl_x = np.minimum(tlbr[:, 0], tlbr[:, 2]) + tl_y = np.minimum(tlbr[:, 1], tlbr[:, 3]) + br_x = np.maximum(tlbr[:, 0], tlbr[:, 2]) + br_y = np.maximum(tlbr[:, 1], tlbr[:, 3]) + + tlbr[:, 0] = tl_x * scale + tlbr[:, 1] = tl_y * scale + tlbr[:, 2] = br_x * scale + tlbr[:, 3] = br_y * scale + + boxes = torch.from_numpy(tlbr) + return boxes + + +class ModelEma(torch.nn.Module): + def __init__(self, model, decay=0.9997, device=None): + super(ModelEma, self).__init__() + # make a copy of the model for accumulating moving average of weights + self.module = deepcopy(model) + self.module.eval() + + # import ipdb; ipdb.set_trace() + + self.decay = decay + self.device = device # perform ema on different device from model if set + if self.device is not None: + self.module.to(device=device) + + def _update(self, model, update_fn): + with torch.no_grad(): + for ema_v, model_v in zip( + self.module.state_dict().values(), model.state_dict().values() + ): + if self.device is not None: + model_v = model_v.to(device=self.device) + ema_v.copy_(update_fn(ema_v, model_v)) + + def update(self, model): + self._update(model, update_fn=lambda e, m: self.decay * e + (1.0 - self.decay) * m) + + def set(self, model): + self._update(model, update_fn=lambda e, m: m) + + +class BestMetricSingle: + def __init__(self, init_res=0.0, better="large") -> None: + self.init_res = init_res + self.best_res = init_res + self.best_ep = -1 + + self.better = better + assert better in ["large", "small"] + + def isbetter(self, new_res, old_res): + if self.better == "large": + return new_res > old_res + if self.better == "small": + return new_res < old_res + + def update(self, new_res, ep): + if self.isbetter(new_res, self.best_res): + self.best_res = new_res + self.best_ep = ep + return True + return False + + def __str__(self) -> str: + return "best_res: {}\t best_ep: {}".format(self.best_res, self.best_ep) + + def __repr__(self) -> str: + return self.__str__() + + def summary(self) -> dict: + return { + "best_res": self.best_res, + "best_ep": self.best_ep, + } + + +class BestMetricHolder: + def __init__(self, init_res=0.0, better="large", use_ema=False) -> None: + self.best_all = BestMetricSingle(init_res, better) + self.use_ema = use_ema + if use_ema: + self.best_ema = BestMetricSingle(init_res, better) + self.best_regular = BestMetricSingle(init_res, better) + + def update(self, new_res, epoch, is_ema=False): + """ + return if the results is the best. + """ + if not self.use_ema: + return self.best_all.update(new_res, epoch) + else: + if is_ema: + self.best_ema.update(new_res, epoch) + return self.best_all.update(new_res, epoch) + else: + self.best_regular.update(new_res, epoch) + return self.best_all.update(new_res, epoch) + + def summary(self): + if not self.use_ema: + return self.best_all.summary() + + res = {} + res.update({f"all_{k}": v for k, v in self.best_all.summary().items()}) + res.update({f"regular_{k}": v for k, v in self.best_regular.summary().items()}) + res.update({f"ema_{k}": v for k, v in self.best_ema.summary().items()}) + return res + + def __repr__(self) -> str: + return json.dumps(self.summary(), indent=2) + + def __str__(self) -> str: + return self.__repr__() + + +def targets_to(targets: List[Dict[str, Any]], device): + """Moves the target dicts to the given device.""" + excluded_keys = [ + "questionId", + "tokens_positive", + "strings_positive", + "tokens", + "dataset_name", + "sentence_id", + "original_img_id", + "nb_eval", + "task_id", + "original_id", + "token_span", + "caption", + "dataset_type", + ] + return [ + {k: v.to(device) if k not in excluded_keys else v for k, v in t.items()} for t in targets + ] + + +def get_phrases_from_posmap( + posmap: torch.BoolTensor, tokenized: Dict, tokenizer: AutoTokenizer, left_idx: int = 0, right_idx: int = 255 +): + assert isinstance(posmap, torch.Tensor), "posmap must be torch.Tensor" + if posmap.dim() == 1: + posmap[0: left_idx + 1] = False + posmap[right_idx:] = False + non_zero_idx = posmap.nonzero(as_tuple=True)[0].tolist() + token_ids = [tokenized["input_ids"][i] for i in non_zero_idx] + return tokenizer.decode(token_ids) + else: + raise NotImplementedError("posmap must be 1-dim") diff --git a/GroundingDINO/groundingdino/util/visualizer.py b/GroundingDINO/groundingdino/util/visualizer.py new file mode 100644 index 0000000000000000000000000000000000000000..7a1b7b101e9b73f75f9136bc67f2063c7c1cf1c1 --- /dev/null +++ b/GroundingDINO/groundingdino/util/visualizer.py @@ -0,0 +1,318 @@ +# -*- coding: utf-8 -*- +""" +@File : visualizer.py +@Time : 2022/04/05 11:39:33 +@Author : Shilong Liu +@Contact : slongliu86@gmail.com +""" + +import datetime +import os + +import cv2 +import matplotlib.pyplot as plt +import numpy as np +import torch +from matplotlib import transforms +from matplotlib.collections import PatchCollection +from matplotlib.patches import Polygon +from pycocotools import mask as maskUtils + + +def renorm( + img: torch.FloatTensor, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] +) -> torch.FloatTensor: + # img: tensor(3,H,W) or tensor(B,3,H,W) + # return: same as img + assert img.dim() == 3 or img.dim() == 4, "img.dim() should be 3 or 4 but %d" % img.dim() + if img.dim() == 3: + assert img.size(0) == 3, 'img.size(0) shoule be 3 but "%d". (%s)' % ( + img.size(0), + str(img.size()), + ) + img_perm = img.permute(1, 2, 0) + mean = torch.Tensor(mean) + std = torch.Tensor(std) + img_res = img_perm * std + mean + return img_res.permute(2, 0, 1) + else: # img.dim() == 4 + assert img.size(1) == 3, 'img.size(1) shoule be 3 but "%d". (%s)' % ( + img.size(1), + str(img.size()), + ) + img_perm = img.permute(0, 2, 3, 1) + mean = torch.Tensor(mean) + std = torch.Tensor(std) + img_res = img_perm * std + mean + return img_res.permute(0, 3, 1, 2) + + +class ColorMap: + def __init__(self, basergb=[255, 255, 0]): + self.basergb = np.array(basergb) + + def __call__(self, attnmap): + # attnmap: h, w. np.uint8. + # return: h, w, 4. np.uint8. + assert attnmap.dtype == np.uint8 + h, w = attnmap.shape + res = self.basergb.copy() + res = res[None][None].repeat(h, 0).repeat(w, 1) # h, w, 3 + attn1 = attnmap.copy()[..., None] # h, w, 1 + res = np.concatenate((res, attn1), axis=-1).astype(np.uint8) + return res + + +def rainbow_text(x, y, ls, lc, **kw): + """ + Take a list of strings ``ls`` and colors ``lc`` and place them next to each + other, with text ls[i] being shown in color lc[i]. + + This example shows how to do both vertical and horizontal text, and will + pass all keyword arguments to plt.text, so you can set the font size, + family, etc. + """ + t = plt.gca().transData + fig = plt.gcf() + plt.show() + + # horizontal version + for s, c in zip(ls, lc): + text = plt.text(x, y, " " + s + " ", color=c, transform=t, **kw) + text.draw(fig.canvas.get_renderer()) + ex = text.get_window_extent() + t = transforms.offset_copy(text._transform, x=ex.width, units="dots") + + # #vertical version + # for s,c in zip(ls,lc): + # text = plt.text(x,y," "+s+" ",color=c, transform=t, + # rotation=90,va='bottom',ha='center',**kw) + # text.draw(fig.canvas.get_renderer()) + # ex = text.get_window_extent() + # t = transforms.offset_copy(text._transform, y=ex.height, units='dots') + + +class COCOVisualizer: + def __init__(self, coco=None, tokenlizer=None) -> None: + self.coco = coco + + def visualize(self, img, tgt, caption=None, dpi=180, savedir="vis"): + """ + img: tensor(3, H, W) + tgt: make sure they are all on cpu. + must have items: 'image_id', 'boxes', 'size' + """ + plt.figure(dpi=dpi) + plt.rcParams["font.size"] = "5" + ax = plt.gca() + img = renorm(img).permute(1, 2, 0) + # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO': + # import ipdb; ipdb.set_trace() + ax.imshow(img) + + self.addtgt(tgt) + + if tgt is None: + image_id = 0 + elif "image_id" not in tgt: + image_id = 0 + else: + image_id = tgt["image_id"] + + if caption is None: + savename = "{}/{}-{}.png".format( + savedir, int(image_id), str(datetime.datetime.now()).replace(" ", "-") + ) + else: + savename = "{}/{}-{}-{}.png".format( + savedir, caption, int(image_id), str(datetime.datetime.now()).replace(" ", "-") + ) + print("savename: {}".format(savename)) + os.makedirs(os.path.dirname(savename), exist_ok=True) + plt.savefig(savename) + plt.close() + + def addtgt(self, tgt): + """ """ + if tgt is None or not "boxes" in tgt: + ax = plt.gca() + + if "caption" in tgt: + ax.set_title(tgt["caption"], wrap=True) + + ax.set_axis_off() + return + + ax = plt.gca() + H, W = tgt["size"] + numbox = tgt["boxes"].shape[0] + + color = [] + polygons = [] + boxes = [] + for box in tgt["boxes"].cpu(): + unnormbbox = box * torch.Tensor([W, H, W, H]) + unnormbbox[:2] -= unnormbbox[2:] / 2 + [bbox_x, bbox_y, bbox_w, bbox_h] = unnormbbox.tolist() + boxes.append([bbox_x, bbox_y, bbox_w, bbox_h]) + poly = [ + [bbox_x, bbox_y], + [bbox_x, bbox_y + bbox_h], + [bbox_x + bbox_w, bbox_y + bbox_h], + [bbox_x + bbox_w, bbox_y], + ] + np_poly = np.array(poly).reshape((4, 2)) + polygons.append(Polygon(np_poly)) + c = (np.random.random((1, 3)) * 0.6 + 0.4).tolist()[0] + color.append(c) + + p = PatchCollection(polygons, facecolor=color, linewidths=0, alpha=0.1) + ax.add_collection(p) + p = PatchCollection(polygons, facecolor="none", edgecolors=color, linewidths=2) + ax.add_collection(p) + + if "strings_positive" in tgt and len(tgt["strings_positive"]) > 0: + assert ( + len(tgt["strings_positive"]) == numbox + ), f"{len(tgt['strings_positive'])} = {numbox}, " + for idx, strlist in enumerate(tgt["strings_positive"]): + cate_id = int(tgt["labels"][idx]) + _string = str(cate_id) + ":" + " ".join(strlist) + bbox_x, bbox_y, bbox_w, bbox_h = boxes[idx] + # ax.text(bbox_x, bbox_y, _string, color='black', bbox={'facecolor': 'yellow', 'alpha': 1.0, 'pad': 1}) + ax.text( + bbox_x, + bbox_y, + _string, + color="black", + bbox={"facecolor": color[idx], "alpha": 0.6, "pad": 1}, + ) + + if "box_label" in tgt: + assert len(tgt["box_label"]) == numbox, f"{len(tgt['box_label'])} = {numbox}, " + for idx, bl in enumerate(tgt["box_label"]): + _string = str(bl) + bbox_x, bbox_y, bbox_w, bbox_h = boxes[idx] + # ax.text(bbox_x, bbox_y, _string, color='black', bbox={'facecolor': 'yellow', 'alpha': 1.0, 'pad': 1}) + ax.text( + bbox_x, + bbox_y, + _string, + color="black", + bbox={"facecolor": color[idx], "alpha": 0.6, "pad": 1}, + ) + + if "caption" in tgt: + ax.set_title(tgt["caption"], wrap=True) + # plt.figure() + # rainbow_text(0.0,0.0,"all unicorns poop rainbows ! ! !".split(), + # ['red', 'orange', 'brown', 'green', 'blue', 'purple', 'black']) + + if "attn" in tgt: + # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO': + # import ipdb; ipdb.set_trace() + if isinstance(tgt["attn"], tuple): + tgt["attn"] = [tgt["attn"]] + for item in tgt["attn"]: + attn_map, basergb = item + attn_map = (attn_map - attn_map.min()) / (attn_map.max() - attn_map.min() + 1e-3) + attn_map = (attn_map * 255).astype(np.uint8) + cm = ColorMap(basergb) + heatmap = cm(attn_map) + ax.imshow(heatmap) + ax.set_axis_off() + + def showAnns(self, anns, draw_bbox=False): + """ + Display the specified annotations. + :param anns (array of object): annotations to display + :return: None + """ + if len(anns) == 0: + return 0 + if "segmentation" in anns[0] or "keypoints" in anns[0]: + datasetType = "instances" + elif "caption" in anns[0]: + datasetType = "captions" + else: + raise Exception("datasetType not supported") + if datasetType == "instances": + ax = plt.gca() + ax.set_autoscale_on(False) + polygons = [] + color = [] + for ann in anns: + c = (np.random.random((1, 3)) * 0.6 + 0.4).tolist()[0] + if "segmentation" in ann: + if type(ann["segmentation"]) == list: + # polygon + for seg in ann["segmentation"]: + poly = np.array(seg).reshape((int(len(seg) / 2), 2)) + polygons.append(Polygon(poly)) + color.append(c) + else: + # mask + t = self.imgs[ann["image_id"]] + if type(ann["segmentation"]["counts"]) == list: + rle = maskUtils.frPyObjects( + [ann["segmentation"]], t["height"], t["width"] + ) + else: + rle = [ann["segmentation"]] + m = maskUtils.decode(rle) + img = np.ones((m.shape[0], m.shape[1], 3)) + if ann["iscrowd"] == 1: + color_mask = np.array([2.0, 166.0, 101.0]) / 255 + if ann["iscrowd"] == 0: + color_mask = np.random.random((1, 3)).tolist()[0] + for i in range(3): + img[:, :, i] = color_mask[i] + ax.imshow(np.dstack((img, m * 0.5))) + if "keypoints" in ann and type(ann["keypoints"]) == list: + # turn skeleton into zero-based index + sks = np.array(self.loadCats(ann["category_id"])[0]["skeleton"]) - 1 + kp = np.array(ann["keypoints"]) + x = kp[0::3] + y = kp[1::3] + v = kp[2::3] + for sk in sks: + if np.all(v[sk] > 0): + plt.plot(x[sk], y[sk], linewidth=3, color=c) + plt.plot( + x[v > 0], + y[v > 0], + "o", + markersize=8, + markerfacecolor=c, + markeredgecolor="k", + markeredgewidth=2, + ) + plt.plot( + x[v > 1], + y[v > 1], + "o", + markersize=8, + markerfacecolor=c, + markeredgecolor=c, + markeredgewidth=2, + ) + + if draw_bbox: + [bbox_x, bbox_y, bbox_w, bbox_h] = ann["bbox"] + poly = [ + [bbox_x, bbox_y], + [bbox_x, bbox_y + bbox_h], + [bbox_x + bbox_w, bbox_y + bbox_h], + [bbox_x + bbox_w, bbox_y], + ] + np_poly = np.array(poly).reshape((4, 2)) + polygons.append(Polygon(np_poly)) + color.append(c) + + # p = PatchCollection(polygons, facecolor=color, linewidths=0, alpha=0.4) + # ax.add_collection(p) + p = PatchCollection(polygons, facecolor="none", edgecolors=color, linewidths=2) + ax.add_collection(p) + elif datasetType == "captions": + for ann in anns: + print(ann["caption"]) diff --git a/GroundingDINO/groundingdino/util/vl_utils.py b/GroundingDINO/groundingdino/util/vl_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c91bb02f584398f08a28e6b7719e2b99f6e28616 --- /dev/null +++ b/GroundingDINO/groundingdino/util/vl_utils.py @@ -0,0 +1,100 @@ +import os +import random +from typing import List + +import torch + + +def create_positive_map_from_span(tokenized, token_span, max_text_len=256): + """construct a map such that positive_map[i,j] = True iff box i is associated to token j + Input: + - tokenized: + - input_ids: Tensor[1, ntokens] + - attention_mask: Tensor[1, ntokens] + - token_span: list with length num_boxes. + - each item: [start_idx, end_idx] + """ + positive_map = torch.zeros((len(token_span), max_text_len), dtype=torch.float) + for j, tok_list in enumerate(token_span): + for (beg, end) in tok_list: + beg_pos = tokenized.char_to_token(beg) + end_pos = tokenized.char_to_token(end - 1) + if beg_pos is None: + try: + beg_pos = tokenized.char_to_token(beg + 1) + if beg_pos is None: + beg_pos = tokenized.char_to_token(beg + 2) + except: + beg_pos = None + if end_pos is None: + try: + end_pos = tokenized.char_to_token(end - 2) + if end_pos is None: + end_pos = tokenized.char_to_token(end - 3) + except: + end_pos = None + if beg_pos is None or end_pos is None: + continue + + assert beg_pos is not None and end_pos is not None + if os.environ.get("SHILONG_DEBUG_ONLY_ONE_POS", None) == "TRUE": + positive_map[j, beg_pos] = 1 + break + else: + positive_map[j, beg_pos : end_pos + 1].fill_(1) + + return positive_map / (positive_map.sum(-1)[:, None] + 1e-6) + + +def build_captions_and_token_span(cat_list, force_lowercase): + """ + Return: + captions: str + cat2tokenspan: dict + { + 'dog': [[0, 2]], + ... + } + """ + + cat2tokenspan = {} + captions = "" + for catname in cat_list: + class_name = catname + if force_lowercase: + class_name = class_name.lower() + if "/" in class_name: + class_name_list: List = class_name.strip().split("/") + class_name_list.append(class_name) + class_name: str = random.choice(class_name_list) + + tokens_positive_i = [] + subnamelist = [i.strip() for i in class_name.strip().split(" ")] + for subname in subnamelist: + if len(subname) == 0: + continue + if len(captions) > 0: + captions = captions + " " + strat_idx = len(captions) + end_idx = strat_idx + len(subname) + tokens_positive_i.append([strat_idx, end_idx]) + captions = captions + subname + + if len(tokens_positive_i) > 0: + captions = captions + " ." + cat2tokenspan[class_name] = tokens_positive_i + + return captions, cat2tokenspan + + +def build_id2posspan_and_caption(category_dict: dict): + """Build id2pos_span and caption from category_dict + + Args: + category_dict (dict): category_dict + """ + cat_list = [item["name"].lower() for item in category_dict] + id2catname = {item["id"]: item["name"].lower() for item in category_dict} + caption, cat2posspan = build_captions_and_token_span(cat_list, force_lowercase=True) + id2posspan = {catid: cat2posspan[catname] for catid, catname in id2catname.items()} + return id2posspan, caption diff --git a/GroundingDINO/groundingdino/version.py b/GroundingDINO/groundingdino/version.py new file mode 100644 index 0000000000000000000000000000000000000000..b794fd409a5e3b3b65ad76a43d6a01a318877640 --- /dev/null +++ b/GroundingDINO/groundingdino/version.py @@ -0,0 +1 @@ +__version__ = '0.1.0' diff --git a/GroundingDINO/requirements.txt b/GroundingDINO/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..9282de3d8e3655f2e78238a276ff6d367c37d75b --- /dev/null +++ b/GroundingDINO/requirements.txt @@ -0,0 +1,10 @@ +torch +torchvision +transformers +addict +yapf +timm +numpy +opencv-python +supervision +pycocotools diff --git a/GroundingDINO/setup.py b/GroundingDINO/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..275b6fc323713cda8074b2b538a427c46f1c74db --- /dev/null +++ b/GroundingDINO/setup.py @@ -0,0 +1,220 @@ +# coding=utf-8 +# Copyright 2022 The IDEA Authors. All rights reserved. +# +# 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. +# ------------------------------------------------------------------------------------------------ +# Modified from +# https://github.com/fundamentalvision/Deformable-DETR/blob/main/models/ops/setup.py +# https://github.com/facebookresearch/detectron2/blob/main/setup.py +# https://github.com/open-mmlab/mmdetection/blob/master/setup.py +# https://github.com/Oneflow-Inc/libai/blob/main/setup.py +# ------------------------------------------------------------------------------------------------ + +import glob +import os +import subprocess + +import subprocess +import sys + +def install_torch(): + try: + import torch + except ImportError: + subprocess.check_call([sys.executable, "-m", "pip", "install", "torch"]) + +# Call the function to ensure torch is installed +install_torch() + +import torch +from setuptools import find_packages, setup +from torch.utils.cpp_extension import CUDA_HOME, CppExtension, CUDAExtension + +# groundingdino version info +version = "0.1.0" +package_name = "groundingdino" +cwd = os.path.dirname(os.path.abspath(__file__)) + + +sha = "Unknown" +try: + sha = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=cwd).decode("ascii").strip() +except Exception: + pass + + +def write_version_file(): + version_path = os.path.join(cwd, "groundingdino", "version.py") + with open(version_path, "w") as f: + f.write(f"__version__ = '{version}'\n") + # f.write(f"git_version = {repr(sha)}\n") + + +requirements = ["torch", "torchvision"] + +torch_ver = [int(x) for x in torch.__version__.split(".")[:2]] + + +def get_extensions(): + this_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_dir = os.path.join(this_dir, "groundingdino", "models", "GroundingDINO", "csrc") + + main_source = os.path.join(extensions_dir, "vision.cpp") + sources = glob.glob(os.path.join(extensions_dir, "**", "*.cpp")) + source_cuda = glob.glob(os.path.join(extensions_dir, "**", "*.cu")) + glob.glob( + os.path.join(extensions_dir, "*.cu") + ) + + sources = [main_source] + sources + + extension = CppExtension + + extra_compile_args = {"cxx": []} + define_macros = [] + + if CUDA_HOME is not None and (torch.cuda.is_available() or "TORCH_CUDA_ARCH_LIST" in os.environ): + print("Compiling with CUDA") + extension = CUDAExtension + sources += source_cuda + define_macros += [("WITH_CUDA", None)] + extra_compile_args["nvcc"] = [ + "-DCUDA_HAS_FP16=1", + "-D__CUDA_NO_HALF_OPERATORS__", + "-D__CUDA_NO_HALF_CONVERSIONS__", + "-D__CUDA_NO_HALF2_OPERATORS__", + ] + else: + print("Compiling without CUDA") + define_macros += [("WITH_HIP", None)] + extra_compile_args["nvcc"] = [] + return None + + sources = [os.path.join(extensions_dir, s) for s in sources] + include_dirs = [extensions_dir] + + ext_modules = [ + extension( + "groundingdino._C", + sources, + include_dirs=include_dirs, + define_macros=define_macros, + extra_compile_args=extra_compile_args, + ) + ] + + return ext_modules + + +def parse_requirements(fname="requirements.txt", with_version=True): + """Parse the package dependencies listed in a requirements file but strips + specific versioning information. + + Args: + fname (str): path to requirements file + with_version (bool, default=False): if True include version specs + + Returns: + List[str]: list of requirements items + + CommandLine: + python -c "import setup; print(setup.parse_requirements())" + """ + import re + import sys + from os.path import exists + + require_fpath = fname + + def parse_line(line): + """Parse information from a line in a requirements text file.""" + if line.startswith("-r "): + # Allow specifying requirements in other files + target = line.split(" ")[1] + for info in parse_require_file(target): + yield info + else: + info = {"line": line} + if line.startswith("-e "): + info["package"] = line.split("#egg=")[1] + elif "@git+" in line: + info["package"] = line + else: + # Remove versioning from the package + pat = "(" + "|".join([">=", "==", ">"]) + ")" + parts = re.split(pat, line, maxsplit=1) + parts = [p.strip() for p in parts] + + info["package"] = parts[0] + if len(parts) > 1: + op, rest = parts[1:] + if ";" in rest: + # Handle platform specific dependencies + # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies + version, platform_deps = map(str.strip, rest.split(";")) + info["platform_deps"] = platform_deps + else: + version = rest # NOQA + info["version"] = (op, version) + yield info + + def parse_require_file(fpath): + with open(fpath, "r") as f: + for line in f.readlines(): + line = line.strip() + if line and not line.startswith("#"): + for info in parse_line(line): + yield info + + def gen_packages_items(): + if exists(require_fpath): + for info in parse_require_file(require_fpath): + parts = [info["package"]] + if with_version and "version" in info: + parts.extend(info["version"]) + if not sys.version.startswith("3.4"): + # apparently package_deps are broken in 3.4 + platform_deps = info.get("platform_deps") + if platform_deps is not None: + parts.append(";" + platform_deps) + item = "".join(parts) + yield item + + packages = list(gen_packages_items()) + return packages + + +if __name__ == "__main__": + print(f"Building wheel {package_name}-{version}") + + with open("LICENSE", "r", encoding="utf-8") as f: + license = f.read() + + write_version_file() + + setup( + name="groundingdino", + version="0.1.0", + author="International Digital Economy Academy, Shilong Liu", + url="https://github.com/IDEA-Research/GroundingDINO", + description="open-set object detector", + license=license, + install_requires=parse_requirements("requirements.txt"), + packages=find_packages( + exclude=( + "configs", + "tests", + ) + ), + ext_modules=get_extensions(), + cmdclass={"build_ext": torch.utils.cpp_extension.BuildExtension}, + ) diff --git a/GroundingDINO/test.ipynb b/GroundingDINO/test.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..9138092afbddd18f6680e232a5d713eab19e6f45 --- /dev/null +++ b/GroundingDINO/test.ipynb @@ -0,0 +1,114 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "final text_encoder_type: bert-base-uncased\n" + ] + }, + { + "data": { + "application/json": { + "ascii": false, + "bar_format": null, + "colour": null, + "elapsed": 0.014210224151611328, + "initial": 0, + "n": 0, + "ncols": null, + "nrows": null, + "postfix": null, + "prefix": "Downloading model.safetensors", + "rate": null, + "total": 440449768, + "unit": "B", + "unit_divisor": 1000, + "unit_scale": true + }, + "application/vnd.jupyter.widget-view+json": { + "model_id": "5922f34578364d36afa13de9f01254bd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading model.safetensors: 0%| | 0.00/440M [00:00🦍 Primate Detection + """ + ) + + gr.HTML( + """ + + The csv contains frame numbers and timestamps, bounding box coordinates, and number of detections per frame.

+ """ + ) + with gr.Row(): + with gr.Column(): + input = gr.Video(label="Input Video", interactive=True) + grounding_caption = gr.Textbox(label="What do you want to detect?") + with gr.Accordion("Advanced Options", open=False): + box_threshold = gr.Slider( + label="Box Threshold", + info="Adjust the threshold to change the sensitivity of the model, lower thresholds being more sensitive.", + minimum=0.0, + maximum=1.0, + value=0.25, + step=0.01 + ) + text_threshold = gr.Slider( + label="Text Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.01 + ) + fps_processed = gr.Slider( + label="Frame Detection Rate", + info="Adjust the frame detection rate. I.e. a value of 120 will run detection every 120 frames, a value of 1 will run detection on every frame. Note: the lower the number the slower the processing time.", + minimum=1, + maximum=120, + value=3, + step=1) + video_options = gr.CheckboxGroup(choices=["Bounding boxes", "Masks"], + label="Video Output Options", + info="Select the options to display in the output video.", + value=["Bounding boxes"], + interactive=True) + + # TODO: Make button visible only after a file has been uploaded + run_btn = gr.Button(value="Run Detection", visible=True) + with gr.Column(): + vid = gr.Video(label="Output Video", height=350, interactive=False, visible=True) + # download_btn = gr.Button(value="Generate Download", visible=True) + download_file = gr.Files(label="CSV, Video Output", interactive=False) + + run_btn.click(fn=run_sam_dino, inputs=[input, grounding_caption, box_threshold, text_threshold, fps_processed, video_options], outputs=[vid]) + vid.change(fn=vid_download, outputs=download_file) + + gr.Examples( + [["baboon_15s.mp4", "baboon", 0.25, 0.25, 1, ["Bounding boxes", "Masks"]]], + inputs = [input, grounding_caption, box_threshold, text_threshold, fps_processed, video_options], + outputs = [vid], + fn=run_sam_dino, + cache_examples=True, + label='Example' + ) + +demo.launch(share=False) \ No newline at end of file diff --git a/baboon_15s.mp4 b/baboon_15s.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..50d8300a0841a057248a4e022b00aa2f588fc0c8 --- /dev/null +++ b/baboon_15s.mp4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60b6845667e7a62685ee91a0cbea5e9d624c8637d564bde2690ac8f86bf77729 +size 19019436 diff --git a/dino_sam.py b/dino_sam.py new file mode 100644 index 0000000000000000000000000000000000000000..4ee78b62727ad4b0fc081a75a014f4d78fb788fd --- /dev/null +++ b/dino_sam.py @@ -0,0 +1,220 @@ +import datetime +import cv2 +import os +import numpy as np +import torch +import io +import cProfile +import csv +import pstats +import warnings +from memory_profiler import profile +from pstats import SortKey +from tqdm import tqdm +from torchvision.ops import box_convert +from typing import Tuple +from GroundingDINO.groundingdino.util.inference import load_model, load_image, annotate, preprocess_caption +from GroundingDINO.groundingdino.util.utils import get_phrases_from_posmap +from segment_anything import sam_model_registry +from segment_anything.utils.transforms import ResizeLongestSide +from video_utils import mp4_to_png, frame_to_timestamp, vid_stitcher + +warnings.filterwarnings("ignore") + +def prepare_image(image, transform, device): + image = transform.apply_image(image) + image = torch.as_tensor(image, device=device.device) + return image.permute(2, 0, 1).contiguous() + +def sam_dino_vid( + vid_path: str, + text_prompt: str, + box_threshold: float = 0.35, + text_threshold: float = 0.25, + fps_processed: int = 1, + video_options: list[str] = ["Bounding boxes"], + config_path: str = "GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py", + weights_path: str = "groundingdino_swint_ogc.pth", + device: str = 'cuda', + batch_size: int = 10 + ) -> (str, str): + """ Args: + Returns: + """ + + masks_needed = False + boxes_needed = True + # if masks are selected, load SAM model + if "Bounding boxes" not in video_options: + boxes_needed = False + if "Masks" in video_options: + masks_needed = True + checkpoint = "sam_vit_h_4b8939.pth" + model_type = "vit_h" + sam = sam_model_registry[model_type](checkpoint=checkpoint) + sam.to(device=device) + resize_transform = ResizeLongestSide(sam.image_encoder.img_size) + + # create new dirs and paths for results + filename = os.path.splitext(os.path.basename(vid_path))[0] + results_dir = "../processed/" + filename + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + os.mkdir(results_dir) + frames_dir = os.path.join(results_dir, "frames") + os.mkdir(frames_dir) + csv_path = os.path.join(results_dir, "detections.csv") + + # load the groundingDINO model + gd_model = load_model(config_path, weights_path, device=device) + + # process video and create a directory of video frames + fps = mp4_to_png(vid_path, frames_dir) + + # get the frame paths for the images to process + frame_filenames = os.listdir(frames_dir) + + frame_paths = [] # list of frame paths to process based on fps_processed + other_paths = [] # list of every frame path in the dir + for i, frame in enumerate(frame_filenames): + if i % fps_processed == 0: + frame_paths.append(os.path.join(frames_dir, frame)) + else: + other_paths.append(os.path.join(frames_dir, frame)) + + # TODO: rename vars to be more clear + # run dino_predict_batch and sam_predict_batch in batches of frames + # write the results to a csv + with open(csv_path, 'w', newline='') as csvfile: + writer = csv.writer(csvfile) + writer.writerow(["Frame", "Timestamp (hh:mm:ss)", "Boxes (cxcywh)", "# Boxes"]) + # run groundingDINO in batches + for i in tqdm(range(0, len(frame_paths), batch_size), desc="Running batches"): + batch_paths = frame_paths[i:i+batch_size] # paths for this batch + images_orig = [load_image(img)[0] for img in batch_paths] + image_stack = torch.stack([load_image(img)[1] for img in batch_paths]) + boxes_i, logits_i, phrases_i = dino_predict_batch( + model=gd_model, + images=image_stack, + caption=text_prompt, + box_threshold=box_threshold, + text_threshold=text_threshold + ) + + annotated_frame_paths = [os.path.join(frames_dir, os.path.basename(frame_path)) for frame_path in batch_paths] + # convert images_orig to rgb from bgr + images_orig = [cv2.cvtColor(image, cv2.COLOR_BGR2RGB) for image in images_orig] + + if masks_needed: + # run SAM in batches on boxes from dino + batched_input = [] + sam_boxes = [] + for image, box in zip(images_orig, boxes_i): + height, width = image.shape[:2] + # convert the boxes from groundingDINO format to SAM format + box = box * torch.Tensor([width, height, width, height]) + box = box_convert(box, in_fmt="cxcywh", out_fmt="xyxy").cuda() + sam_boxes.append(box) + batched_input.append({ + "image": prepare_image(image, resize_transform, sam), + "boxes": resize_transform.apply_boxes_torch(box, image.shape[:2]), + "original_size": image.shape[:2] + }) + batched_output = sam(batched_input, multimask_output=False) + for i, prediction in enumerate(batched_output): + # write to annotated_frames_dir for stitching + mask = prediction["masks"].cpu().numpy() + box = sam_boxes[i].cpu().numpy() + annotated_frame = plot_sam(images_orig[i], mask, box, boxes_shown=boxes_needed) + cv2.imwrite(annotated_frame_paths[i], annotated_frame) + + elif boxes_needed and not masks_needed: + # get groundingDINO annotated frames + for i, (image, box, logit, phrase) in enumerate(zip(images_orig, boxes_i, logits_i, phrases_i)): + annotated_frame = annotate(image_source=image, boxes=box, logits=logit, phrases=phrase) + cv2.imwrite(annotated_frame_paths[i], annotated_frame) + + # write results to csv + # TODO: convert boxes to SAM format for clearer understanding + frame_names = [os.path.basename(frame_path).split(".")[0] for frame_path in batch_paths] + for i, frame in enumerate(frame_names): + writer.writerow([frame, frame_to_timestamp(int(frame[-8:]), fps), boxes_i[i], len(boxes_i[i])]) + csvfile.close() + + # stitch the frames + save_path = vid_stitcher(frames_dir, output_path=os.path.join(results_dir, "output.mp4"), fps=fps) + print("Results saved to: " + save_path) + return csv_path, save_path + + +def dino_predict_batch( + model, + images: torch.Tensor, + caption: str, + box_threshold: float, + text_threshold: float, + device: str = "cuda" +) -> Tuple[list[torch.Tensor], list[torch.Tensor], list[list[str]]]: + ''' + return: + bboxes_batch: list of tensors of shape (n, 4) + predicts_batch: list of tensors of shape (n,) + phrases_batch: list of list of strings of shape (n,) + ''' + caption = preprocess_caption(caption=caption) + model = model.to(device) + image = images.to(device) + with torch.no_grad(): + outputs = model(image, captions=[caption for _ in range(len(images))]) + prediction_logits = outputs["pred_logits"].cpu().sigmoid() # prediction_logits.shape = (num_batch, nq, 256) + prediction_boxes = outputs["pred_boxes"].cpu() # prediction_boxes.shape = (num_batch, nq, 4) + + mask = prediction_logits.max(dim=2)[0] > box_threshold # mask: torch.Size([num_batch, 256]) + + bboxes_batch = [] + predicts_batch = [] + phrases_batch = [] # list of lists + tokenizer = model.tokenizer + tokenized = tokenizer(caption) + for i in range(prediction_logits.shape[0]): + logits = prediction_logits[i][mask[i]] # logits.shape = (n, 256) + phrases = [ + get_phrases_from_posmap(logit > text_threshold, tokenized, tokenizer).replace('.', '') + for logit # logit is a tensor of shape (256,) torch.Size([256]) + in logits # torch.Size([7, 256]) + ] + boxes = prediction_boxes[i][mask[i]] # boxes.shape = (n, 4) + phrases_batch.append(phrases) + bboxes_batch.append(boxes) + predicts_batch.append(logits.max(dim=1)[0]) + + return bboxes_batch, predicts_batch, phrases_batch + +def plot_sam( + image: np.ndarray, + masks: list[np.ndarray], + boxes: np.ndarray, + boxes_shown: bool = True, + masks_shown: bool = True, +) -> np.ndarray: + """ + Plot image with masks and/or boxes. + """ + # Use cv2 to plot the boxes and masks if they exist + if boxes_shown: + for box in boxes: + # red bbox + cv2.rectangle(image, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), (0, 0, 255), 2) + if masks_shown: + # blue mask + color = np.array([255, 144, 30]) + color = color.astype(np.uint8) + for mask in masks: + # turn the mask into a colored mask + h, w = mask.shape[-2:] + mask = mask.reshape(h, w, 1) * color.reshape(1, 1, -1) + image = cv2.addWeighted(image, 1, mask, 0.5, 0) + return image + +if __name__ == '__main__': + start_time = datetime.datetime.now() + sam_dino_vid("baboon_15s.mp4", "baboon", box_threshold=0.3, text_threshold=0.3, fps_processed=30, video_options=['Bounding boxes', 'Masks']) + print("elapsed: " + str(datetime.datetime.now() - start_time)) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..9022d95a75af1b9fc68cf038619db9cd48704386 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,24 @@ +addict==2.4.0 +fiftyone==0.23.7 +gradio==4.23.0 +huggingface_hub==0.20.2 +ipdb==0.13.13 +matplotlib==3.8.2 +memory_profiler==0.61.0 +numpy==1.26.4 +opencv_python==4.9.0.80 +opencv_python_headless==4.8.1.78 +Pillow==10.2.0 +pycocotools==2.0.7 +PyYAML==6.0.1 +Requests==2.31.0 +setuptools==60.2.0 +supervision==0.6.0 +termcolor==2.4.0 +timm==0.9.12 +torch==2.0.0 +torchvision==0.15.1 +tqdm==4.65.2 +transformers==4.36.2 +typer==0.10.0 +yapf==0.40.2 \ No newline at end of file diff --git a/segment_anything/__init__.py b/segment_anything/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34383d83f5e76bc801f31b20e5651e383be348b6 --- /dev/null +++ b/segment_anything/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +from .build_sam import ( + build_sam, + build_sam_vit_h, + build_sam_vit_l, + build_sam_vit_b, + sam_model_registry, +) +from .predictor import SamPredictor +from .automatic_mask_generator import SamAutomaticMaskGenerator diff --git a/segment_anything/automatic_mask_generator.py b/segment_anything/automatic_mask_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..d5a8c969207f119feff7087f94e044403acdff00 --- /dev/null +++ b/segment_anything/automatic_mask_generator.py @@ -0,0 +1,372 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from torchvision.ops.boxes import batched_nms, box_area # type: ignore + +from typing import Any, Dict, List, Optional, Tuple + +from .modeling import Sam +from .predictor import SamPredictor +from .utils.amg import ( + MaskData, + area_from_rle, + batch_iterator, + batched_mask_to_box, + box_xyxy_to_xywh, + build_all_layer_point_grids, + calculate_stability_score, + coco_encode_rle, + generate_crop_boxes, + is_box_near_crop_edge, + mask_to_rle_pytorch, + remove_small_regions, + rle_to_mask, + uncrop_boxes_xyxy, + uncrop_masks, + uncrop_points, +) + + +class SamAutomaticMaskGenerator: + def __init__( + self, + model: Sam, + points_per_side: Optional[int] = 32, + points_per_batch: int = 64, + pred_iou_thresh: float = 0.88, + stability_score_thresh: float = 0.95, + stability_score_offset: float = 1.0, + box_nms_thresh: float = 0.7, + crop_n_layers: int = 0, + crop_nms_thresh: float = 0.7, + crop_overlap_ratio: float = 512 / 1500, + crop_n_points_downscale_factor: int = 1, + point_grids: Optional[List[np.ndarray]] = None, + min_mask_region_area: int = 0, + output_mode: str = "binary_mask", + ) -> None: + """ + Using a SAM model, generates masks for the entire image. + Generates a grid of point prompts over the image, then filters + low quality and duplicate masks. The default settings are chosen + for SAM with a ViT-H backbone. + + Arguments: + model (Sam): The SAM model to use for mask prediction. + points_per_side (int or None): The number of points to be sampled + along one side of the image. The total number of points is + points_per_side**2. If None, 'point_grids' must provide explicit + point sampling. + points_per_batch (int): Sets the number of points run simultaneously + by the model. Higher numbers may be faster but use more GPU memory. + pred_iou_thresh (float): A filtering threshold in [0,1], using the + model's predicted mask quality. + stability_score_thresh (float): A filtering threshold in [0,1], using + the stability of the mask under changes to the cutoff used to binarize + the model's mask predictions. + stability_score_offset (float): The amount to shift the cutoff when + calculated the stability score. + box_nms_thresh (float): The box IoU cutoff used by non-maximal + suppression to filter duplicate masks. + crop_n_layers (int): If >0, mask prediction will be run again on + crops of the image. Sets the number of layers to run, where each + layer has 2**i_layer number of image crops. + crop_nms_thresh (float): The box IoU cutoff used by non-maximal + suppression to filter duplicate masks between different crops. + crop_overlap_ratio (float): Sets the degree to which crops overlap. + In the first crop layer, crops will overlap by this fraction of + the image length. Later layers with more crops scale down this overlap. + crop_n_points_downscale_factor (int): The number of points-per-side + sampled in layer n is scaled down by crop_n_points_downscale_factor**n. + point_grids (list(np.ndarray) or None): A list over explicit grids + of points used for sampling, normalized to [0,1]. The nth grid in the + list is used in the nth crop layer. Exclusive with points_per_side. + min_mask_region_area (int): If >0, postprocessing will be applied + to remove disconnected regions and holes in masks with area smaller + than min_mask_region_area. Requires opencv. + output_mode (str): The form masks are returned in. Can be 'binary_mask', + 'uncompressed_rle', or 'coco_rle'. 'coco_rle' requires pycocotools. + For large resolutions, 'binary_mask' may consume large amounts of + memory. + """ + + assert (points_per_side is None) != ( + point_grids is None + ), "Exactly one of points_per_side or point_grid must be provided." + if points_per_side is not None: + self.point_grids = build_all_layer_point_grids( + points_per_side, + crop_n_layers, + crop_n_points_downscale_factor, + ) + elif point_grids is not None: + self.point_grids = point_grids + else: + raise ValueError("Can't have both points_per_side and point_grid be None.") + + assert output_mode in [ + "binary_mask", + "uncompressed_rle", + "coco_rle", + ], f"Unknown output_mode {output_mode}." + if output_mode == "coco_rle": + from pycocotools import mask as mask_utils # type: ignore # noqa: F401 + + if min_mask_region_area > 0: + import cv2 # type: ignore # noqa: F401 + + self.predictor = SamPredictor(model) + self.points_per_batch = points_per_batch + self.pred_iou_thresh = pred_iou_thresh + self.stability_score_thresh = stability_score_thresh + self.stability_score_offset = stability_score_offset + self.box_nms_thresh = box_nms_thresh + self.crop_n_layers = crop_n_layers + self.crop_nms_thresh = crop_nms_thresh + self.crop_overlap_ratio = crop_overlap_ratio + self.crop_n_points_downscale_factor = crop_n_points_downscale_factor + self.min_mask_region_area = min_mask_region_area + self.output_mode = output_mode + + @torch.no_grad() + def generate(self, image: np.ndarray) -> List[Dict[str, Any]]: + """ + Generates masks for the given image. + + Arguments: + image (np.ndarray): The image to generate masks for, in HWC uint8 format. + + Returns: + list(dict(str, any)): A list over records for masks. Each record is + a dict containing the following keys: + segmentation (dict(str, any) or np.ndarray): The mask. If + output_mode='binary_mask', is an array of shape HW. Otherwise, + is a dictionary containing the RLE. + bbox (list(float)): The box around the mask, in XYWH format. + area (int): The area in pixels of the mask. + predicted_iou (float): The model's own prediction of the mask's + quality. This is filtered by the pred_iou_thresh parameter. + point_coords (list(list(float))): The point coordinates input + to the model to generate this mask. + stability_score (float): A measure of the mask's quality. This + is filtered on using the stability_score_thresh parameter. + crop_box (list(float)): The crop of the image used to generate + the mask, given in XYWH format. + """ + + # Generate masks + mask_data = self._generate_masks(image) + + # Filter small disconnected regions and holes in masks + if self.min_mask_region_area > 0: + mask_data = self.postprocess_small_regions( + mask_data, + self.min_mask_region_area, + max(self.box_nms_thresh, self.crop_nms_thresh), + ) + + # Encode masks + if self.output_mode == "coco_rle": + mask_data["segmentations"] = [coco_encode_rle(rle) for rle in mask_data["rles"]] + elif self.output_mode == "binary_mask": + mask_data["segmentations"] = [rle_to_mask(rle) for rle in mask_data["rles"]] + else: + mask_data["segmentations"] = mask_data["rles"] + + # Write mask records + curr_anns = [] + for idx in range(len(mask_data["segmentations"])): + ann = { + "segmentation": mask_data["segmentations"][idx], + "area": area_from_rle(mask_data["rles"][idx]), + "bbox": box_xyxy_to_xywh(mask_data["boxes"][idx]).tolist(), + "predicted_iou": mask_data["iou_preds"][idx].item(), + "point_coords": [mask_data["points"][idx].tolist()], + "stability_score": mask_data["stability_score"][idx].item(), + "crop_box": box_xyxy_to_xywh(mask_data["crop_boxes"][idx]).tolist(), + } + curr_anns.append(ann) + + return curr_anns + + def _generate_masks(self, image: np.ndarray) -> MaskData: + orig_size = image.shape[:2] + crop_boxes, layer_idxs = generate_crop_boxes( + orig_size, self.crop_n_layers, self.crop_overlap_ratio + ) + + # Iterate over image crops + data = MaskData() + for crop_box, layer_idx in zip(crop_boxes, layer_idxs): + crop_data = self._process_crop(image, crop_box, layer_idx, orig_size) + data.cat(crop_data) + + # Remove duplicate masks between crops + if len(crop_boxes) > 1: + # Prefer masks from smaller crops + scores = 1 / box_area(data["crop_boxes"]) + scores = scores.to(data["boxes"].device) + keep_by_nms = batched_nms( + data["boxes"].float(), + scores, + torch.zeros_like(data["boxes"][:, 0]), # categories + iou_threshold=self.crop_nms_thresh, + ) + data.filter(keep_by_nms) + + data.to_numpy() + return data + + def _process_crop( + self, + image: np.ndarray, + crop_box: List[int], + crop_layer_idx: int, + orig_size: Tuple[int, ...], + ) -> MaskData: + # Crop the image and calculate embeddings + x0, y0, x1, y1 = crop_box + cropped_im = image[y0:y1, x0:x1, :] + cropped_im_size = cropped_im.shape[:2] + self.predictor.set_image(cropped_im) + + # Get points for this crop + points_scale = np.array(cropped_im_size)[None, ::-1] + points_for_image = self.point_grids[crop_layer_idx] * points_scale + + # Generate masks for this crop in batches + data = MaskData() + for (points,) in batch_iterator(self.points_per_batch, points_for_image): + batch_data = self._process_batch(points, cropped_im_size, crop_box, orig_size) + data.cat(batch_data) + del batch_data + self.predictor.reset_image() + + # Remove duplicates within this crop. + keep_by_nms = batched_nms( + data["boxes"].float(), + data["iou_preds"], + torch.zeros_like(data["boxes"][:, 0]), # categories + iou_threshold=self.box_nms_thresh, + ) + data.filter(keep_by_nms) + + # Return to the original image frame + data["boxes"] = uncrop_boxes_xyxy(data["boxes"], crop_box) + data["points"] = uncrop_points(data["points"], crop_box) + data["crop_boxes"] = torch.tensor([crop_box for _ in range(len(data["rles"]))]) + + return data + + def _process_batch( + self, + points: np.ndarray, + im_size: Tuple[int, ...], + crop_box: List[int], + orig_size: Tuple[int, ...], + ) -> MaskData: + orig_h, orig_w = orig_size + + # Run model on this batch + transformed_points = self.predictor.transform.apply_coords(points, im_size) + in_points = torch.as_tensor(transformed_points, device=self.predictor.device) + in_labels = torch.ones(in_points.shape[0], dtype=torch.int, device=in_points.device) + masks, iou_preds, _ = self.predictor.predict_torch( + in_points[:, None, :], + in_labels[:, None], + multimask_output=True, + return_logits=True, + ) + + # Serialize predictions and store in MaskData + data = MaskData( + masks=masks.flatten(0, 1), + iou_preds=iou_preds.flatten(0, 1), + points=torch.as_tensor(points.repeat(masks.shape[1], axis=0)), + ) + del masks + + # Filter by predicted IoU + if self.pred_iou_thresh > 0.0: + keep_mask = data["iou_preds"] > self.pred_iou_thresh + data.filter(keep_mask) + + # Calculate stability score + data["stability_score"] = calculate_stability_score( + data["masks"], self.predictor.model.mask_threshold, self.stability_score_offset + ) + if self.stability_score_thresh > 0.0: + keep_mask = data["stability_score"] >= self.stability_score_thresh + data.filter(keep_mask) + + # Threshold masks and calculate boxes + data["masks"] = data["masks"] > self.predictor.model.mask_threshold + data["boxes"] = batched_mask_to_box(data["masks"]) + + # Filter boxes that touch crop boundaries + keep_mask = ~is_box_near_crop_edge(data["boxes"], crop_box, [0, 0, orig_w, orig_h]) + if not torch.all(keep_mask): + data.filter(keep_mask) + + # Compress to RLE + data["masks"] = uncrop_masks(data["masks"], crop_box, orig_h, orig_w) + data["rles"] = mask_to_rle_pytorch(data["masks"]) + del data["masks"] + + return data + + @staticmethod + def postprocess_small_regions( + mask_data: MaskData, min_area: int, nms_thresh: float + ) -> MaskData: + """ + Removes small disconnected regions and holes in masks, then reruns + box NMS to remove any new duplicates. + + Edits mask_data in place. + + Requires open-cv as a dependency. + """ + if len(mask_data["rles"]) == 0: + return mask_data + + # Filter small disconnected regions and holes + new_masks = [] + scores = [] + for rle in mask_data["rles"]: + mask = rle_to_mask(rle) + + mask, changed = remove_small_regions(mask, min_area, mode="holes") + unchanged = not changed + mask, changed = remove_small_regions(mask, min_area, mode="islands") + unchanged = unchanged and not changed + + new_masks.append(torch.as_tensor(mask).unsqueeze(0)) + # Give score=0 to changed masks and score=1 to unchanged masks + # so NMS will prefer ones that didn't need postprocessing + scores.append(float(unchanged)) + + # Recalculate boxes and remove any new duplicates + masks = torch.cat(new_masks, dim=0) + boxes = batched_mask_to_box(masks) + keep_by_nms = batched_nms( + boxes.float(), + torch.as_tensor(scores), + torch.zeros_like(boxes[:, 0]), # categories + iou_threshold=nms_thresh, + ) + + # Only recalculate RLEs for masks that have changed + for i_mask in keep_by_nms: + if scores[i_mask] == 0.0: + mask_torch = masks[i_mask].unsqueeze(0) + mask_data["rles"][i_mask] = mask_to_rle_pytorch(mask_torch)[0] + mask_data["boxes"][i_mask] = boxes[i_mask] # update res directly + mask_data.filter(keep_by_nms) + + return mask_data diff --git a/segment_anything/build_sam.py b/segment_anything/build_sam.py new file mode 100644 index 0000000000000000000000000000000000000000..37cd245124079e7cdd0d047ef9dde077db99efcc --- /dev/null +++ b/segment_anything/build_sam.py @@ -0,0 +1,107 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from functools import partial + +from .modeling import ImageEncoderViT, MaskDecoder, PromptEncoder, Sam, TwoWayTransformer + + +def build_sam_vit_h(checkpoint=None): + return _build_sam( + encoder_embed_dim=1280, + encoder_depth=32, + encoder_num_heads=16, + encoder_global_attn_indexes=[7, 15, 23, 31], + checkpoint=checkpoint, + ) + + +build_sam = build_sam_vit_h + + +def build_sam_vit_l(checkpoint=None): + return _build_sam( + encoder_embed_dim=1024, + encoder_depth=24, + encoder_num_heads=16, + encoder_global_attn_indexes=[5, 11, 17, 23], + checkpoint=checkpoint, + ) + + +def build_sam_vit_b(checkpoint=None): + return _build_sam( + encoder_embed_dim=768, + encoder_depth=12, + encoder_num_heads=12, + encoder_global_attn_indexes=[2, 5, 8, 11], + checkpoint=checkpoint, + ) + + +sam_model_registry = { + "default": build_sam_vit_h, + "vit_h": build_sam_vit_h, + "vit_l": build_sam_vit_l, + "vit_b": build_sam_vit_b, +} + + +def _build_sam( + encoder_embed_dim, + encoder_depth, + encoder_num_heads, + encoder_global_attn_indexes, + checkpoint=None, +): + prompt_embed_dim = 256 + image_size = 1024 + vit_patch_size = 16 + image_embedding_size = image_size // vit_patch_size + sam = Sam( + image_encoder=ImageEncoderViT( + depth=encoder_depth, + embed_dim=encoder_embed_dim, + img_size=image_size, + mlp_ratio=4, + norm_layer=partial(torch.nn.LayerNorm, eps=1e-6), + num_heads=encoder_num_heads, + patch_size=vit_patch_size, + qkv_bias=True, + use_rel_pos=True, + global_attn_indexes=encoder_global_attn_indexes, + window_size=14, + out_chans=prompt_embed_dim, + ), + prompt_encoder=PromptEncoder( + embed_dim=prompt_embed_dim, + image_embedding_size=(image_embedding_size, image_embedding_size), + input_image_size=(image_size, image_size), + mask_in_chans=16, + ), + mask_decoder=MaskDecoder( + num_multimask_outputs=3, + transformer=TwoWayTransformer( + depth=2, + embedding_dim=prompt_embed_dim, + mlp_dim=2048, + num_heads=8, + ), + transformer_dim=prompt_embed_dim, + iou_head_depth=3, + iou_head_hidden_dim=256, + ), + pixel_mean=[123.675, 116.28, 103.53], + pixel_std=[58.395, 57.12, 57.375], + ) + sam.eval() + if checkpoint is not None: + with open(checkpoint, "rb") as f: + state_dict = torch.load(f) + sam.load_state_dict(state_dict) + return sam diff --git a/segment_anything/modeling/__init__.py b/segment_anything/modeling/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..38e906243d898d7fc071c0fe218338c5cace3ea1 --- /dev/null +++ b/segment_anything/modeling/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +from .sam import Sam +from .image_encoder import ImageEncoderViT +from .mask_decoder import MaskDecoder +from .prompt_encoder import PromptEncoder +from .transformer import TwoWayTransformer diff --git a/segment_anything/modeling/common.py b/segment_anything/modeling/common.py new file mode 100644 index 0000000000000000000000000000000000000000..2bf15236a3eb24d8526073bc4fa2b274cccb3f96 --- /dev/null +++ b/segment_anything/modeling/common.py @@ -0,0 +1,43 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from typing import Type + + +class MLPBlock(nn.Module): + def __init__( + self, + embedding_dim: int, + mlp_dim: int, + act: Type[nn.Module] = nn.GELU, + ) -> None: + super().__init__() + self.lin1 = nn.Linear(embedding_dim, mlp_dim) + self.lin2 = nn.Linear(mlp_dim, embedding_dim) + self.act = act() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.lin2(self.act(self.lin1(x))) + + +# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py # noqa +# Itself from https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119 # noqa +class LayerNorm2d(nn.Module): + def __init__(self, num_channels: int, eps: float = 1e-6) -> None: + super().__init__() + self.weight = nn.Parameter(torch.ones(num_channels)) + self.bias = nn.Parameter(torch.zeros(num_channels)) + self.eps = eps + + def forward(self, x: torch.Tensor) -> torch.Tensor: + u = x.mean(1, keepdim=True) + s = (x - u).pow(2).mean(1, keepdim=True) + x = (x - u) / torch.sqrt(s + self.eps) + x = self.weight[:, None, None] * x + self.bias[:, None, None] + return x diff --git a/segment_anything/modeling/image_encoder.py b/segment_anything/modeling/image_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..66351d9d7c589be693f4b3485901d3bdfed54d4a --- /dev/null +++ b/segment_anything/modeling/image_encoder.py @@ -0,0 +1,395 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license 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 typing import Optional, Tuple, Type + +from .common import LayerNorm2d, MLPBlock + + +# This class and its supporting functions below lightly adapted from the ViTDet backbone available at: https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/backbone/vit.py # noqa +class ImageEncoderViT(nn.Module): + def __init__( + self, + img_size: int = 1024, + patch_size: int = 16, + in_chans: int = 3, + embed_dim: int = 768, + depth: int = 12, + num_heads: int = 12, + mlp_ratio: float = 4.0, + out_chans: int = 256, + qkv_bias: bool = True, + norm_layer: Type[nn.Module] = nn.LayerNorm, + act_layer: Type[nn.Module] = nn.GELU, + use_abs_pos: bool = True, + use_rel_pos: bool = False, + rel_pos_zero_init: bool = True, + window_size: int = 0, + global_attn_indexes: Tuple[int, ...] = (), + ) -> None: + """ + Args: + img_size (int): Input image size. + patch_size (int): Patch size. + in_chans (int): Number of input image channels. + embed_dim (int): Patch embedding dimension. + depth (int): Depth of ViT. + num_heads (int): Number of attention heads in each ViT block. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. + qkv_bias (bool): If True, add a learnable bias to query, key, value. + norm_layer (nn.Module): Normalization layer. + act_layer (nn.Module): Activation layer. + use_abs_pos (bool): If True, use absolute positional embeddings. + use_rel_pos (bool): If True, add relative positional embeddings to the attention map. + rel_pos_zero_init (bool): If True, zero initialize relative positional parameters. + window_size (int): Window size for window attention blocks. + global_attn_indexes (list): Indexes for blocks using global attention. + """ + super().__init__() + self.img_size = img_size + + self.patch_embed = PatchEmbed( + kernel_size=(patch_size, patch_size), + stride=(patch_size, patch_size), + in_chans=in_chans, + embed_dim=embed_dim, + ) + + self.pos_embed: Optional[nn.Parameter] = None + if use_abs_pos: + # Initialize absolute positional embedding with pretrain image size. + self.pos_embed = nn.Parameter( + torch.zeros(1, img_size // patch_size, img_size // patch_size, embed_dim) + ) + + self.blocks = nn.ModuleList() + for i in range(depth): + block = Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + norm_layer=norm_layer, + act_layer=act_layer, + use_rel_pos=use_rel_pos, + rel_pos_zero_init=rel_pos_zero_init, + window_size=window_size if i not in global_attn_indexes else 0, + input_size=(img_size // patch_size, img_size // patch_size), + ) + self.blocks.append(block) + + self.neck = nn.Sequential( + nn.Conv2d( + embed_dim, + out_chans, + kernel_size=1, + bias=False, + ), + LayerNorm2d(out_chans), + nn.Conv2d( + out_chans, + out_chans, + kernel_size=3, + padding=1, + bias=False, + ), + LayerNorm2d(out_chans), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.patch_embed(x) + if self.pos_embed is not None: + x = x + self.pos_embed + + for blk in self.blocks: + x = blk(x) + + x = self.neck(x.permute(0, 3, 1, 2)) + + return x + + +class Block(nn.Module): + """Transformer blocks with support of window attention and residual propagation blocks""" + + def __init__( + self, + dim: int, + num_heads: int, + mlp_ratio: float = 4.0, + qkv_bias: bool = True, + norm_layer: Type[nn.Module] = nn.LayerNorm, + act_layer: Type[nn.Module] = nn.GELU, + use_rel_pos: bool = False, + rel_pos_zero_init: bool = True, + window_size: int = 0, + input_size: Optional[Tuple[int, int]] = None, + ) -> None: + """ + Args: + dim (int): Number of input channels. + num_heads (int): Number of attention heads in each ViT block. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. + qkv_bias (bool): If True, add a learnable bias to query, key, value. + norm_layer (nn.Module): Normalization layer. + act_layer (nn.Module): Activation layer. + use_rel_pos (bool): If True, add relative positional embeddings to the attention map. + rel_pos_zero_init (bool): If True, zero initialize relative positional parameters. + window_size (int): Window size for window attention blocks. If it equals 0, then + use global attention. + input_size (tuple(int, int) or None): Input resolution for calculating the relative + positional parameter size. + """ + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + use_rel_pos=use_rel_pos, + rel_pos_zero_init=rel_pos_zero_init, + input_size=input_size if window_size == 0 else (window_size, window_size), + ) + + self.norm2 = norm_layer(dim) + self.mlp = MLPBlock(embedding_dim=dim, mlp_dim=int(dim * mlp_ratio), act=act_layer) + + self.window_size = window_size + + def forward(self, x: torch.Tensor) -> torch.Tensor: + shortcut = x + x = self.norm1(x) + # Window partition + if self.window_size > 0: + H, W = x.shape[1], x.shape[2] + x, pad_hw = window_partition(x, self.window_size) + + x = self.attn(x) + # Reverse window partition + if self.window_size > 0: + x = window_unpartition(x, self.window_size, pad_hw, (H, W)) + + x = shortcut + x + x = x + self.mlp(self.norm2(x)) + + return x + + +class Attention(nn.Module): + """Multi-head Attention block with relative position embeddings.""" + + def __init__( + self, + dim: int, + num_heads: int = 8, + qkv_bias: bool = True, + use_rel_pos: bool = False, + rel_pos_zero_init: bool = True, + input_size: Optional[Tuple[int, int]] = None, + ) -> None: + """ + Args: + dim (int): Number of input channels. + num_heads (int): Number of attention heads. + qkv_bias (bool): If True, add a learnable bias to query, key, value. + rel_pos (bool): If True, add relative positional embeddings to the attention map. + rel_pos_zero_init (bool): If True, zero initialize relative positional parameters. + input_size (tuple(int, int) or None): Input resolution for calculating the relative + positional parameter size. + """ + 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.proj = nn.Linear(dim, dim) + + self.use_rel_pos = use_rel_pos + if self.use_rel_pos: + assert ( + input_size is not None + ), "Input size must be provided if using relative positional encoding." + # initialize relative positional embeddings + self.rel_pos_h = nn.Parameter(torch.zeros(2 * input_size[0] - 1, head_dim)) + self.rel_pos_w = nn.Parameter(torch.zeros(2 * input_size[1] - 1, head_dim)) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + B, H, W, _ = x.shape + # qkv with shape (3, B, nHead, H * W, C) + qkv = self.qkv(x).reshape(B, H * W, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + # q, k, v with shape (B * nHead, H * W, C) + q, k, v = qkv.reshape(3, B * self.num_heads, H * W, -1).unbind(0) + + attn = (q * self.scale) @ k.transpose(-2, -1) + + if self.use_rel_pos: + attn = add_decomposed_rel_pos(attn, q, self.rel_pos_h, self.rel_pos_w, (H, W), (H, W)) + + attn = attn.softmax(dim=-1) + x = (attn @ v).view(B, self.num_heads, H, W, -1).permute(0, 2, 3, 1, 4).reshape(B, H, W, -1) + x = self.proj(x) + + return x + + +def window_partition(x: torch.Tensor, window_size: int) -> Tuple[torch.Tensor, Tuple[int, int]]: + """ + Partition into non-overlapping windows with padding if needed. + Args: + x (tensor): input tokens with [B, H, W, C]. + window_size (int): window size. + + Returns: + windows: windows after partition with [B * num_windows, window_size, window_size, C]. + (Hp, Wp): padded height and width before partition + """ + B, H, W, C = x.shape + + pad_h = (window_size - H % window_size) % window_size + pad_w = (window_size - W % window_size) % window_size + if pad_h > 0 or pad_w > 0: + x = F.pad(x, (0, 0, 0, pad_w, 0, pad_h)) + Hp, Wp = H + pad_h, W + pad_w + + x = x.view(B, Hp // window_size, window_size, Wp // window_size, window_size, C) + windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C) + return windows, (Hp, Wp) + + +def window_unpartition( + windows: torch.Tensor, window_size: int, pad_hw: Tuple[int, int], hw: Tuple[int, int] +) -> torch.Tensor: + """ + Window unpartition into original sequences and removing padding. + Args: + windows (tensor): input tokens with [B * num_windows, window_size, window_size, C]. + window_size (int): window size. + pad_hw (Tuple): padded height and width (Hp, Wp). + hw (Tuple): original height and width (H, W) before padding. + + Returns: + x: unpartitioned sequences with [B, H, W, C]. + """ + Hp, Wp = pad_hw + H, W = hw + B = windows.shape[0] // (Hp * Wp // window_size // window_size) + x = windows.view(B, Hp // window_size, Wp // window_size, window_size, window_size, -1) + x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, Hp, Wp, -1) + + if Hp > H or Wp > W: + x = x[:, :H, :W, :].contiguous() + return x + + +def get_rel_pos(q_size: int, k_size: int, rel_pos: torch.Tensor) -> torch.Tensor: + """ + Get relative positional embeddings according to the relative positions of + query and key sizes. + Args: + q_size (int): size of query q. + k_size (int): size of key k. + rel_pos (Tensor): relative position embeddings (L, C). + + Returns: + Extracted positional embeddings according to relative positions. + """ + max_rel_dist = int(2 * max(q_size, k_size) - 1) + # Interpolate rel pos if needed. + if rel_pos.shape[0] != max_rel_dist: + # Interpolate rel pos. + rel_pos_resized = F.interpolate( + rel_pos.reshape(1, rel_pos.shape[0], -1).permute(0, 2, 1), + size=max_rel_dist, + mode="linear", + ) + rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0) + else: + rel_pos_resized = rel_pos + + # Scale the coords with short length if shapes for q and k are different. + q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0) + k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0) + relative_coords = (q_coords - k_coords) + (k_size - 1) * max(q_size / k_size, 1.0) + + return rel_pos_resized[relative_coords.long()] + + +def add_decomposed_rel_pos( + attn: torch.Tensor, + q: torch.Tensor, + rel_pos_h: torch.Tensor, + rel_pos_w: torch.Tensor, + q_size: Tuple[int, int], + k_size: Tuple[int, int], +) -> torch.Tensor: + """ + Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`. + https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py # noqa B950 + Args: + attn (Tensor): attention map. + q (Tensor): query q in the attention layer with shape (B, q_h * q_w, C). + rel_pos_h (Tensor): relative position embeddings (Lh, C) for height axis. + rel_pos_w (Tensor): relative position embeddings (Lw, C) for width axis. + q_size (Tuple): spatial sequence size of query q with (q_h, q_w). + k_size (Tuple): spatial sequence size of key k with (k_h, k_w). + + Returns: + attn (Tensor): attention map with added relative positional embeddings. + """ + q_h, q_w = q_size + k_h, k_w = k_size + Rh = get_rel_pos(q_h, k_h, rel_pos_h) + Rw = get_rel_pos(q_w, k_w, rel_pos_w) + + B, _, dim = q.shape + r_q = q.reshape(B, q_h, q_w, dim) + rel_h = torch.einsum("bhwc,hkc->bhwk", r_q, Rh) + rel_w = torch.einsum("bhwc,wkc->bhwk", r_q, Rw) + + attn = ( + attn.view(B, q_h, q_w, k_h, k_w) + rel_h[:, :, :, :, None] + rel_w[:, :, :, None, :] + ).view(B, q_h * q_w, k_h * k_w) + + return attn + + +class PatchEmbed(nn.Module): + """ + Image to Patch Embedding. + """ + + def __init__( + self, + kernel_size: Tuple[int, int] = (16, 16), + stride: Tuple[int, int] = (16, 16), + padding: Tuple[int, int] = (0, 0), + in_chans: int = 3, + embed_dim: int = 768, + ) -> None: + """ + Args: + kernel_size (Tuple): kernel size of the projection layer. + stride (Tuple): stride of the projection layer. + padding (Tuple): padding size of the projection layer. + in_chans (int): Number of input image channels. + embed_dim (int): Patch embedding dimension. + """ + super().__init__() + + self.proj = nn.Conv2d( + in_chans, embed_dim, kernel_size=kernel_size, stride=stride, padding=padding + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.proj(x) + # B C H W -> B H W C + x = x.permute(0, 2, 3, 1) + return x diff --git a/segment_anything/modeling/mask_decoder.py b/segment_anything/modeling/mask_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..5d2fdb03d535a91fa725d1ec4e92a7a1f217dfe0 --- /dev/null +++ b/segment_anything/modeling/mask_decoder.py @@ -0,0 +1,176 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from torch import nn +from torch.nn import functional as F + +from typing import List, Tuple, Type + +from .common import LayerNorm2d + + +class MaskDecoder(nn.Module): + def __init__( + self, + *, + transformer_dim: int, + transformer: nn.Module, + num_multimask_outputs: int = 3, + activation: Type[nn.Module] = nn.GELU, + iou_head_depth: int = 3, + iou_head_hidden_dim: int = 256, + ) -> None: + """ + Predicts masks given an image and prompt embeddings, using a + transformer architecture. + + Arguments: + transformer_dim (int): the channel dimension of the transformer + transformer (nn.Module): the transformer used to predict masks + num_multimask_outputs (int): the number of masks to predict + when disambiguating masks + activation (nn.Module): the type of activation to use when + upscaling masks + iou_head_depth (int): the depth of the MLP used to predict + mask quality + iou_head_hidden_dim (int): the hidden dimension of the MLP + used to predict mask quality + """ + super().__init__() + self.transformer_dim = transformer_dim + self.transformer = transformer + + self.num_multimask_outputs = num_multimask_outputs + + self.iou_token = nn.Embedding(1, transformer_dim) + self.num_mask_tokens = num_multimask_outputs + 1 + self.mask_tokens = nn.Embedding(self.num_mask_tokens, transformer_dim) + + self.output_upscaling = nn.Sequential( + nn.ConvTranspose2d(transformer_dim, transformer_dim // 4, kernel_size=2, stride=2), + LayerNorm2d(transformer_dim // 4), + activation(), + nn.ConvTranspose2d(transformer_dim // 4, transformer_dim // 8, kernel_size=2, stride=2), + activation(), + ) + self.output_hypernetworks_mlps = nn.ModuleList( + [ + MLP(transformer_dim, transformer_dim, transformer_dim // 8, 3) + for i in range(self.num_mask_tokens) + ] + ) + + self.iou_prediction_head = MLP( + transformer_dim, iou_head_hidden_dim, self.num_mask_tokens, iou_head_depth + ) + + def forward( + self, + image_embeddings: torch.Tensor, + image_pe: torch.Tensor, + sparse_prompt_embeddings: torch.Tensor, + dense_prompt_embeddings: torch.Tensor, + multimask_output: bool, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Predict masks given image and prompt embeddings. + + Arguments: + image_embeddings (torch.Tensor): the embeddings from the image encoder + image_pe (torch.Tensor): positional encoding with the shape of image_embeddings + sparse_prompt_embeddings (torch.Tensor): the embeddings of the points and boxes + dense_prompt_embeddings (torch.Tensor): the embeddings of the mask inputs + multimask_output (bool): Whether to return multiple masks or a single + mask. + + Returns: + torch.Tensor: batched predicted masks + torch.Tensor: batched predictions of mask quality + """ + masks, iou_pred = self.predict_masks( + image_embeddings=image_embeddings, + image_pe=image_pe, + sparse_prompt_embeddings=sparse_prompt_embeddings, + dense_prompt_embeddings=dense_prompt_embeddings, + ) + + # Select the correct mask or masks for output + if multimask_output: + mask_slice = slice(1, None) + else: + mask_slice = slice(0, 1) + masks = masks[:, mask_slice, :, :] + iou_pred = iou_pred[:, mask_slice] + + # Prepare output + return masks, iou_pred + + def predict_masks( + self, + image_embeddings: torch.Tensor, + image_pe: torch.Tensor, + sparse_prompt_embeddings: torch.Tensor, + dense_prompt_embeddings: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """Predicts masks. See 'forward' for more details.""" + # Concatenate output tokens + output_tokens = torch.cat([self.iou_token.weight, self.mask_tokens.weight], dim=0) + output_tokens = output_tokens.unsqueeze(0).expand(sparse_prompt_embeddings.size(0), -1, -1) + tokens = torch.cat((output_tokens, sparse_prompt_embeddings), dim=1) + + # Expand per-image data in batch direction to be per-mask + src = torch.repeat_interleave(image_embeddings, tokens.shape[0], dim=0) + src = src + dense_prompt_embeddings + pos_src = torch.repeat_interleave(image_pe, tokens.shape[0], dim=0) + b, c, h, w = src.shape + + # Run the transformer + hs, src = self.transformer(src, pos_src, tokens) + iou_token_out = hs[:, 0, :] + mask_tokens_out = hs[:, 1 : (1 + self.num_mask_tokens), :] + + # Upscale mask embeddings and predict masks using the mask tokens + src = src.transpose(1, 2).view(b, c, h, w) + upscaled_embedding = self.output_upscaling(src) + hyper_in_list: List[torch.Tensor] = [] + for i in range(self.num_mask_tokens): + hyper_in_list.append(self.output_hypernetworks_mlps[i](mask_tokens_out[:, i, :])) + hyper_in = torch.stack(hyper_in_list, dim=1) + b, c, h, w = upscaled_embedding.shape + masks = (hyper_in @ upscaled_embedding.view(b, c, h * w)).view(b, -1, h, w) + + # Generate mask quality predictions + iou_pred = self.iou_prediction_head(iou_token_out) + + return masks, iou_pred + + +# Lightly adapted from +# https://github.com/facebookresearch/MaskFormer/blob/main/mask_former/modeling/transformer/transformer_predictor.py # noqa +class MLP(nn.Module): + def __init__( + self, + input_dim: int, + hidden_dim: int, + output_dim: int, + num_layers: int, + sigmoid_output: bool = False, + ) -> None: + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = nn.ModuleList( + nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]) + ) + self.sigmoid_output = sigmoid_output + + def forward(self, x): + for i, layer in enumerate(self.layers): + x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) + if self.sigmoid_output: + x = F.sigmoid(x) + return x diff --git a/segment_anything/modeling/prompt_encoder.py b/segment_anything/modeling/prompt_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..c3143f4f8e02ddd7ca8587b40ff5d47c3a6b7ef3 --- /dev/null +++ b/segment_anything/modeling/prompt_encoder.py @@ -0,0 +1,214 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from torch import nn + +from typing import Any, Optional, Tuple, Type + +from .common import LayerNorm2d + + +class PromptEncoder(nn.Module): + def __init__( + self, + embed_dim: int, + image_embedding_size: Tuple[int, int], + input_image_size: Tuple[int, int], + mask_in_chans: int, + activation: Type[nn.Module] = nn.GELU, + ) -> None: + """ + Encodes prompts for input to SAM's mask decoder. + + Arguments: + embed_dim (int): The prompts' embedding dimension + image_embedding_size (tuple(int, int)): The spatial size of the + image embedding, as (H, W). + input_image_size (int): The padded size of the image as input + to the image encoder, as (H, W). + mask_in_chans (int): The number of hidden channels used for + encoding input masks. + activation (nn.Module): The activation to use when encoding + input masks. + """ + super().__init__() + self.embed_dim = embed_dim + self.input_image_size = input_image_size + self.image_embedding_size = image_embedding_size + self.pe_layer = PositionEmbeddingRandom(embed_dim // 2) + + self.num_point_embeddings: int = 4 # pos/neg point + 2 box corners + point_embeddings = [nn.Embedding(1, embed_dim) for i in range(self.num_point_embeddings)] + self.point_embeddings = nn.ModuleList(point_embeddings) + self.not_a_point_embed = nn.Embedding(1, embed_dim) + + self.mask_input_size = (4 * image_embedding_size[0], 4 * image_embedding_size[1]) + self.mask_downscaling = nn.Sequential( + nn.Conv2d(1, mask_in_chans // 4, kernel_size=2, stride=2), + LayerNorm2d(mask_in_chans // 4), + activation(), + nn.Conv2d(mask_in_chans // 4, mask_in_chans, kernel_size=2, stride=2), + LayerNorm2d(mask_in_chans), + activation(), + nn.Conv2d(mask_in_chans, embed_dim, kernel_size=1), + ) + self.no_mask_embed = nn.Embedding(1, embed_dim) + + def get_dense_pe(self) -> torch.Tensor: + """ + Returns the positional encoding used to encode point prompts, + applied to a dense set of points the shape of the image encoding. + + Returns: + torch.Tensor: Positional encoding with shape + 1x(embed_dim)x(embedding_h)x(embedding_w) + """ + return self.pe_layer(self.image_embedding_size).unsqueeze(0) + + def _embed_points( + self, + points: torch.Tensor, + labels: torch.Tensor, + pad: bool, + ) -> torch.Tensor: + """Embeds point prompts.""" + points = points + 0.5 # Shift to center of pixel + if pad: + padding_point = torch.zeros((points.shape[0], 1, 2), device=points.device) + padding_label = -torch.ones((labels.shape[0], 1), device=labels.device) + points = torch.cat([points, padding_point], dim=1) + labels = torch.cat([labels, padding_label], dim=1) + point_embedding = self.pe_layer.forward_with_coords(points, self.input_image_size) + point_embedding[labels == -1] = 0.0 + point_embedding[labels == -1] += self.not_a_point_embed.weight + point_embedding[labels == 0] += self.point_embeddings[0].weight + point_embedding[labels == 1] += self.point_embeddings[1].weight + return point_embedding + + def _embed_boxes(self, boxes: torch.Tensor) -> torch.Tensor: + """Embeds box prompts.""" + boxes = boxes + 0.5 # Shift to center of pixel + coords = boxes.reshape(-1, 2, 2) + corner_embedding = self.pe_layer.forward_with_coords(coords, self.input_image_size) + corner_embedding[:, 0, :] += self.point_embeddings[2].weight + corner_embedding[:, 1, :] += self.point_embeddings[3].weight + return corner_embedding + + def _embed_masks(self, masks: torch.Tensor) -> torch.Tensor: + """Embeds mask inputs.""" + mask_embedding = self.mask_downscaling(masks) + return mask_embedding + + def _get_batch_size( + self, + points: Optional[Tuple[torch.Tensor, torch.Tensor]], + boxes: Optional[torch.Tensor], + masks: Optional[torch.Tensor], + ) -> int: + """ + Gets the batch size of the output given the batch size of the input prompts. + """ + if points is not None: + return points[0].shape[0] + elif boxes is not None: + return boxes.shape[0] + elif masks is not None: + return masks.shape[0] + else: + return 1 + + def _get_device(self) -> torch.device: + return self.point_embeddings[0].weight.device + + def forward( + self, + points: Optional[Tuple[torch.Tensor, torch.Tensor]], + boxes: Optional[torch.Tensor], + masks: Optional[torch.Tensor], + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Embeds different types of prompts, returning both sparse and dense + embeddings. + + Arguments: + points (tuple(torch.Tensor, torch.Tensor) or none): point coordinates + and labels to embed. + boxes (torch.Tensor or none): boxes to embed + masks (torch.Tensor or none): masks to embed + + Returns: + torch.Tensor: sparse embeddings for the points and boxes, with shape + BxNx(embed_dim), where N is determined by the number of input points + and boxes. + torch.Tensor: dense embeddings for the masks, in the shape + Bx(embed_dim)x(embed_H)x(embed_W) + """ + bs = self._get_batch_size(points, boxes, masks) + sparse_embeddings = torch.empty((bs, 0, self.embed_dim), device=self._get_device()) + if points is not None: + coords, labels = points + point_embeddings = self._embed_points(coords, labels, pad=(boxes is None)) + sparse_embeddings = torch.cat([sparse_embeddings, point_embeddings], dim=1) + if boxes is not None: + box_embeddings = self._embed_boxes(boxes) + sparse_embeddings = torch.cat([sparse_embeddings, box_embeddings], dim=1) + + if masks is not None: + dense_embeddings = self._embed_masks(masks) + else: + dense_embeddings = self.no_mask_embed.weight.reshape(1, -1, 1, 1).expand( + bs, -1, self.image_embedding_size[0], self.image_embedding_size[1] + ) + + return sparse_embeddings, dense_embeddings + + +class PositionEmbeddingRandom(nn.Module): + """ + Positional encoding using random spatial frequencies. + """ + + def __init__(self, num_pos_feats: int = 64, scale: Optional[float] = None) -> None: + super().__init__() + if scale is None or scale <= 0.0: + scale = 1.0 + self.register_buffer( + "positional_encoding_gaussian_matrix", + scale * torch.randn((2, num_pos_feats)), + ) + + def _pe_encoding(self, coords: torch.Tensor) -> torch.Tensor: + """Positionally encode points that are normalized to [0,1].""" + # assuming coords are in [0, 1]^2 square and have d_1 x ... x d_n x 2 shape + coords = 2 * coords - 1 + coords = coords @ self.positional_encoding_gaussian_matrix + coords = 2 * np.pi * coords + # outputs d_1 x ... x d_n x C shape + return torch.cat([torch.sin(coords), torch.cos(coords)], dim=-1) + + def forward(self, size: Tuple[int, int]) -> torch.Tensor: + """Generate positional encoding for a grid of the specified size.""" + h, w = size + device: Any = self.positional_encoding_gaussian_matrix.device + grid = torch.ones((h, w), device=device, dtype=torch.float32) + y_embed = grid.cumsum(dim=0) - 0.5 + x_embed = grid.cumsum(dim=1) - 0.5 + y_embed = y_embed / h + x_embed = x_embed / w + + pe = self._pe_encoding(torch.stack([x_embed, y_embed], dim=-1)) + return pe.permute(2, 0, 1) # C x H x W + + def forward_with_coords( + self, coords_input: torch.Tensor, image_size: Tuple[int, int] + ) -> torch.Tensor: + """Positionally encode points that are not normalized to [0,1].""" + coords = coords_input.clone() + coords[:, :, 0] = coords[:, :, 0] / image_size[1] + coords[:, :, 1] = coords[:, :, 1] / image_size[0] + return self._pe_encoding(coords.to(torch.float)) # B x N x C diff --git a/segment_anything/modeling/sam.py b/segment_anything/modeling/sam.py new file mode 100644 index 0000000000000000000000000000000000000000..8074cff6b40addc6b66f7ab4962218eef20da13c --- /dev/null +++ b/segment_anything/modeling/sam.py @@ -0,0 +1,174 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from torch import nn +from torch.nn import functional as F + +from typing import Any, Dict, List, Tuple + +from .image_encoder import ImageEncoderViT +from .mask_decoder import MaskDecoder +from .prompt_encoder import PromptEncoder + + +class Sam(nn.Module): + mask_threshold: float = 0.0 + image_format: str = "RGB" + + def __init__( + self, + image_encoder: ImageEncoderViT, + prompt_encoder: PromptEncoder, + mask_decoder: MaskDecoder, + pixel_mean: List[float] = [123.675, 116.28, 103.53], + pixel_std: List[float] = [58.395, 57.12, 57.375], + ) -> None: + """ + SAM predicts object masks from an image and input prompts. + + Arguments: + image_encoder (ImageEncoderViT): The backbone used to encode the + image into image embeddings that allow for efficient mask prediction. + prompt_encoder (PromptEncoder): Encodes various types of input prompts. + mask_decoder (MaskDecoder): Predicts masks from the image embeddings + and encoded prompts. + pixel_mean (list(float)): Mean values for normalizing pixels in the input image. + pixel_std (list(float)): Std values for normalizing pixels in the input image. + """ + super().__init__() + self.image_encoder = image_encoder + self.prompt_encoder = prompt_encoder + self.mask_decoder = mask_decoder + self.register_buffer("pixel_mean", torch.Tensor(pixel_mean).view(-1, 1, 1), False) + self.register_buffer("pixel_std", torch.Tensor(pixel_std).view(-1, 1, 1), False) + + @property + def device(self) -> Any: + return self.pixel_mean.device + + @torch.no_grad() + def forward( + self, + batched_input: List[Dict[str, Any]], + multimask_output: bool, + ) -> List[Dict[str, torch.Tensor]]: + """ + Predicts masks end-to-end from provided images and prompts. + If prompts are not known in advance, using SamPredictor is + recommended over calling the model directly. + + Arguments: + batched_input (list(dict)): A list over input images, each a + dictionary with the following keys. A prompt key can be + excluded if it is not present. + 'image': The image as a torch tensor in 3xHxW format, + already transformed for input to the model. + 'original_size': (tuple(int, int)) The original size of + the image before transformation, as (H, W). + 'point_coords': (torch.Tensor) Batched point prompts for + this image, with shape BxNx2. Already transformed to the + input frame of the model. + 'point_labels': (torch.Tensor) Batched labels for point prompts, + with shape BxN. + 'boxes': (torch.Tensor) Batched box inputs, with shape Bx4. + Already transformed to the input frame of the model. + 'mask_inputs': (torch.Tensor) Batched mask inputs to the model, + in the form Bx1xHxW. + multimask_output (bool): Whether the model should predict multiple + disambiguating masks, or return a single mask. + + Returns: + (list(dict)): A list over input images, where each element is + as dictionary with the following keys. + 'masks': (torch.Tensor) Batched binary mask predictions, + with shape BxCxHxW, where B is the number of input prompts, + C is determined by multimask_output, and (H, W) is the + original size of the image. + 'iou_predictions': (torch.Tensor) The model's predictions + of mask quality, in shape BxC. + 'low_res_logits': (torch.Tensor) Low resolution logits with + shape BxCxHxW, where H=W=256. Can be passed as mask input + to subsequent iterations of prediction. + """ + input_images = torch.stack([self.preprocess(x["image"]) for x in batched_input], dim=0) + image_embeddings = self.image_encoder(input_images) + + outputs = [] + for image_record, curr_embedding in zip(batched_input, image_embeddings): + if "point_coords" in image_record: + points = (image_record["point_coords"], image_record["point_labels"]) + else: + points = None + sparse_embeddings, dense_embeddings = self.prompt_encoder( + points=points, + boxes=image_record.get("boxes", None), + masks=image_record.get("mask_inputs", None), + ) + low_res_masks, iou_predictions = self.mask_decoder( + image_embeddings=curr_embedding.unsqueeze(0), + image_pe=self.prompt_encoder.get_dense_pe(), + sparse_prompt_embeddings=sparse_embeddings, + dense_prompt_embeddings=dense_embeddings, + multimask_output=multimask_output, + ) + masks = self.postprocess_masks( + low_res_masks, + input_size=image_record["image"].shape[-2:], + original_size=image_record["original_size"], + ) + masks = masks > self.mask_threshold + outputs.append( + { + "masks": masks, + "iou_predictions": iou_predictions, + "low_res_logits": low_res_masks, + } + ) + return outputs + + def postprocess_masks( + self, + masks: torch.Tensor, + input_size: Tuple[int, ...], + original_size: Tuple[int, ...], + ) -> torch.Tensor: + """ + Remove padding and upscale masks to the original image size. + + Arguments: + masks (torch.Tensor): Batched masks from the mask_decoder, + in BxCxHxW format. + input_size (tuple(int, int)): The size of the image input to the + model, in (H, W) format. Used to remove padding. + original_size (tuple(int, int)): The original size of the image + before resizing for input to the model, in (H, W) format. + + Returns: + (torch.Tensor): Batched masks in BxCxHxW format, where (H, W) + is given by original_size. + """ + masks = F.interpolate( + masks, + (self.image_encoder.img_size, self.image_encoder.img_size), + mode="bilinear", + align_corners=False, + ) + masks = masks[..., : input_size[0], : input_size[1]] + masks = F.interpolate(masks, original_size, mode="bilinear", align_corners=False) + return masks + + def preprocess(self, x: torch.Tensor) -> torch.Tensor: + """Normalize pixel values and pad to a square input.""" + # Normalize colors + x = (x - self.pixel_mean) / self.pixel_std + + # Pad + h, w = x.shape[-2:] + padh = self.image_encoder.img_size - h + padw = self.image_encoder.img_size - w + x = F.pad(x, (0, padw, 0, padh)) + return x diff --git a/segment_anything/modeling/transformer.py b/segment_anything/modeling/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..28fafea52288603fea275f3a100790471825c34a --- /dev/null +++ b/segment_anything/modeling/transformer.py @@ -0,0 +1,240 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from torch import Tensor, nn + +import math +from typing import Tuple, Type + +from .common import MLPBlock + + +class TwoWayTransformer(nn.Module): + def __init__( + self, + depth: int, + embedding_dim: int, + num_heads: int, + mlp_dim: int, + activation: Type[nn.Module] = nn.ReLU, + attention_downsample_rate: int = 2, + ) -> None: + """ + A transformer decoder that attends to an input image using + queries whose positional embedding is supplied. + + Args: + depth (int): number of layers in the transformer + embedding_dim (int): the channel dimension for the input embeddings + num_heads (int): the number of heads for multihead attention. Must + divide embedding_dim + mlp_dim (int): the channel dimension internal to the MLP block + activation (nn.Module): the activation to use in the MLP block + """ + super().__init__() + self.depth = depth + self.embedding_dim = embedding_dim + self.num_heads = num_heads + self.mlp_dim = mlp_dim + self.layers = nn.ModuleList() + + for i in range(depth): + self.layers.append( + TwoWayAttentionBlock( + embedding_dim=embedding_dim, + num_heads=num_heads, + mlp_dim=mlp_dim, + activation=activation, + attention_downsample_rate=attention_downsample_rate, + skip_first_layer_pe=(i == 0), + ) + ) + + self.final_attn_token_to_image = Attention( + embedding_dim, num_heads, downsample_rate=attention_downsample_rate + ) + self.norm_final_attn = nn.LayerNorm(embedding_dim) + + def forward( + self, + image_embedding: Tensor, + image_pe: Tensor, + point_embedding: Tensor, + ) -> Tuple[Tensor, Tensor]: + """ + Args: + image_embedding (torch.Tensor): image to attend to. Should be shape + B x embedding_dim x h x w for any h and w. + image_pe (torch.Tensor): the positional encoding to add to the image. Must + have the same shape as image_embedding. + point_embedding (torch.Tensor): the embedding to add to the query points. + Must have shape B x N_points x embedding_dim for any N_points. + + Returns: + torch.Tensor: the processed point_embedding + torch.Tensor: the processed image_embedding + """ + # BxCxHxW -> BxHWxC == B x N_image_tokens x C + bs, c, h, w = image_embedding.shape + image_embedding = image_embedding.flatten(2).permute(0, 2, 1) + image_pe = image_pe.flatten(2).permute(0, 2, 1) + + # Prepare queries + queries = point_embedding + keys = image_embedding + + # Apply transformer blocks and final layernorm + for layer in self.layers: + queries, keys = layer( + queries=queries, + keys=keys, + query_pe=point_embedding, + key_pe=image_pe, + ) + + # Apply the final attention layer from the points to the image + q = queries + point_embedding + k = keys + image_pe + attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys) + queries = queries + attn_out + queries = self.norm_final_attn(queries) + + return queries, keys + + +class TwoWayAttentionBlock(nn.Module): + def __init__( + self, + embedding_dim: int, + num_heads: int, + mlp_dim: int = 2048, + activation: Type[nn.Module] = nn.ReLU, + attention_downsample_rate: int = 2, + skip_first_layer_pe: bool = False, + ) -> None: + """ + A transformer block with four layers: (1) self-attention of sparse + inputs, (2) cross attention of sparse inputs to dense inputs, (3) mlp + block on sparse inputs, and (4) cross attention of dense inputs to sparse + inputs. + + Arguments: + embedding_dim (int): the channel dimension of the embeddings + num_heads (int): the number of heads in the attention layers + mlp_dim (int): the hidden dimension of the mlp block + activation (nn.Module): the activation of the mlp block + skip_first_layer_pe (bool): skip the PE on the first layer + """ + super().__init__() + self.self_attn = Attention(embedding_dim, num_heads) + self.norm1 = nn.LayerNorm(embedding_dim) + + self.cross_attn_token_to_image = Attention( + embedding_dim, num_heads, downsample_rate=attention_downsample_rate + ) + self.norm2 = nn.LayerNorm(embedding_dim) + + self.mlp = MLPBlock(embedding_dim, mlp_dim, activation) + self.norm3 = nn.LayerNorm(embedding_dim) + + self.norm4 = nn.LayerNorm(embedding_dim) + self.cross_attn_image_to_token = Attention( + embedding_dim, num_heads, downsample_rate=attention_downsample_rate + ) + + self.skip_first_layer_pe = skip_first_layer_pe + + def forward( + self, queries: Tensor, keys: Tensor, query_pe: Tensor, key_pe: Tensor + ) -> Tuple[Tensor, Tensor]: + # Self attention block + if self.skip_first_layer_pe: + queries = self.self_attn(q=queries, k=queries, v=queries) + else: + q = queries + query_pe + attn_out = self.self_attn(q=q, k=q, v=queries) + queries = queries + attn_out + queries = self.norm1(queries) + + # Cross attention block, tokens attending to image embedding + q = queries + query_pe + k = keys + key_pe + attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys) + queries = queries + attn_out + queries = self.norm2(queries) + + # MLP block + mlp_out = self.mlp(queries) + queries = queries + mlp_out + queries = self.norm3(queries) + + # Cross attention block, image embedding attending to tokens + q = queries + query_pe + k = keys + key_pe + attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries) + keys = keys + attn_out + keys = self.norm4(keys) + + return queries, keys + + +class Attention(nn.Module): + """ + An attention layer that allows for downscaling the size of the embedding + after projection to queries, keys, and values. + """ + + def __init__( + self, + embedding_dim: int, + num_heads: int, + downsample_rate: int = 1, + ) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.internal_dim = embedding_dim // downsample_rate + self.num_heads = num_heads + assert self.internal_dim % num_heads == 0, "num_heads must divide embedding_dim." + + self.q_proj = nn.Linear(embedding_dim, self.internal_dim) + self.k_proj = nn.Linear(embedding_dim, self.internal_dim) + self.v_proj = nn.Linear(embedding_dim, self.internal_dim) + self.out_proj = nn.Linear(self.internal_dim, embedding_dim) + + def _separate_heads(self, x: Tensor, num_heads: int) -> Tensor: + b, n, c = x.shape + x = x.reshape(b, n, num_heads, c // num_heads) + return x.transpose(1, 2) # B x N_heads x N_tokens x C_per_head + + def _recombine_heads(self, x: Tensor) -> Tensor: + b, n_heads, n_tokens, c_per_head = x.shape + x = x.transpose(1, 2) + return x.reshape(b, n_tokens, n_heads * c_per_head) # B x N_tokens x C + + def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor: + # Input projections + q = self.q_proj(q) + k = self.k_proj(k) + v = self.v_proj(v) + + # Separate into heads + q = self._separate_heads(q, self.num_heads) + k = self._separate_heads(k, self.num_heads) + v = self._separate_heads(v, self.num_heads) + + # Attention + _, _, _, c_per_head = q.shape + attn = q @ k.permute(0, 1, 3, 2) # B x N_heads x N_tokens x N_tokens + attn = attn / math.sqrt(c_per_head) + attn = torch.softmax(attn, dim=-1) + + # Get output + out = attn @ v + out = self._recombine_heads(out) + out = self.out_proj(out) + + return out diff --git a/segment_anything/predictor.py b/segment_anything/predictor.py new file mode 100644 index 0000000000000000000000000000000000000000..8a6e6d816955b4c6097e1de6ce6e4ed3bafe327c --- /dev/null +++ b/segment_anything/predictor.py @@ -0,0 +1,269 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +from segment_anything.modeling import Sam + +from typing import Optional, Tuple + +from .utils.transforms import ResizeLongestSide + + +class SamPredictor: + def __init__( + self, + sam_model: Sam, + ) -> None: + """ + Uses SAM to calculate the image embedding for an image, and then + allow repeated, efficient mask prediction given prompts. + + Arguments: + sam_model (Sam): The model to use for mask prediction. + """ + super().__init__() + self.model = sam_model + self.transform = ResizeLongestSide(sam_model.image_encoder.img_size) + self.reset_image() + + def set_image( + self, + image: np.ndarray, + image_format: str = "RGB", + ) -> None: + """ + Calculates the image embeddings for the provided image, allowing + masks to be predicted with the 'predict' method. + + Arguments: + image (np.ndarray): The image for calculating masks. Expects an + image in HWC uint8 format, with pixel values in [0, 255]. + image_format (str): The color format of the image, in ['RGB', 'BGR']. + """ + assert image_format in [ + "RGB", + "BGR", + ], f"image_format must be in ['RGB', 'BGR'], is {image_format}." + if image_format != self.model.image_format: + image = image[..., ::-1] + + # Transform the image to the form expected by the model + input_image = self.transform.apply_image(image) + input_image_torch = torch.as_tensor(input_image, device=self.device) + input_image_torch = input_image_torch.permute(2, 0, 1).contiguous()[None, :, :, :] + + self.set_torch_image(input_image_torch, image.shape[:2]) + + @torch.no_grad() + def set_torch_image( + self, + transformed_image: torch.Tensor, + original_image_size: Tuple[int, ...], + ) -> None: + """ + Calculates the image embeddings for the provided image, allowing + masks to be predicted with the 'predict' method. Expects the input + image to be already transformed to the format expected by the model. + + Arguments: + transformed_image (torch.Tensor): The input image, with shape + 1x3xHxW, which has been transformed with ResizeLongestSide. + original_image_size (tuple(int, int)): The size of the image + before transformation, in (H, W) format. + """ + assert ( + len(transformed_image.shape) == 4 + and transformed_image.shape[1] == 3 + and max(*transformed_image.shape[2:]) == self.model.image_encoder.img_size + ), f"set_torch_image input must be BCHW with long side {self.model.image_encoder.img_size}." + self.reset_image() + + self.original_size = original_image_size + self.input_size = tuple(transformed_image.shape[-2:]) + input_image = self.model.preprocess(transformed_image) + self.features = self.model.image_encoder(input_image) + self.is_image_set = True + + def predict( + self, + point_coords: Optional[np.ndarray] = None, + point_labels: Optional[np.ndarray] = None, + box: Optional[np.ndarray] = None, + mask_input: Optional[np.ndarray] = None, + multimask_output: bool = True, + return_logits: bool = False, + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Predict masks for the given input prompts, using the currently set image. + + Arguments: + point_coords (np.ndarray or None): A Nx2 array of point prompts to the + model. Each point is in (X,Y) in pixels. + point_labels (np.ndarray or None): A length N array of labels for the + point prompts. 1 indicates a foreground point and 0 indicates a + background point. + box (np.ndarray or None): A length 4 array given a box prompt to the + model, in XYXY format. + mask_input (np.ndarray): A low resolution mask input to the model, typically + coming from a previous prediction iteration. Has form 1xHxW, where + for SAM, H=W=256. + multimask_output (bool): If true, the model will return three masks. + For ambiguous input prompts (such as a single click), this will often + produce better masks than a single prediction. If only a single + mask is needed, the model's predicted quality score can be used + to select the best mask. For non-ambiguous prompts, such as multiple + input prompts, multimask_output=False can give better results. + return_logits (bool): If true, returns un-thresholded masks logits + instead of a binary mask. + + Returns: + (np.ndarray): The output masks in CxHxW format, where C is the + number of masks, and (H, W) is the original image size. + (np.ndarray): An array of length C containing the model's + predictions for the quality of each mask. + (np.ndarray): An array of shape CxHxW, where C is the number + of masks and H=W=256. These low resolution logits can be passed to + a subsequent iteration as mask input. + """ + if not self.is_image_set: + raise RuntimeError("An image must be set with .set_image(...) before mask prediction.") + + # Transform input prompts + coords_torch, labels_torch, box_torch, mask_input_torch = None, None, None, None + if point_coords is not None: + assert ( + point_labels is not None + ), "point_labels must be supplied if point_coords is supplied." + point_coords = self.transform.apply_coords(point_coords, self.original_size) + coords_torch = torch.as_tensor(point_coords, dtype=torch.float, device=self.device) + labels_torch = torch.as_tensor(point_labels, dtype=torch.int, device=self.device) + coords_torch, labels_torch = coords_torch[None, :, :], labels_torch[None, :] + if box is not None: + box = self.transform.apply_boxes(box, self.original_size) + box_torch = torch.as_tensor(box, dtype=torch.float, device=self.device) + box_torch = box_torch[None, :] + if mask_input is not None: + mask_input_torch = torch.as_tensor(mask_input, dtype=torch.float, device=self.device) + mask_input_torch = mask_input_torch[None, :, :, :] + + masks, iou_predictions, low_res_masks = self.predict_torch( + coords_torch, + labels_torch, + box_torch, + mask_input_torch, + multimask_output, + return_logits=return_logits, + ) + + masks_np = masks[0].detach().cpu().numpy() + iou_predictions_np = iou_predictions[0].detach().cpu().numpy() + low_res_masks_np = low_res_masks[0].detach().cpu().numpy() + return masks_np, iou_predictions_np, low_res_masks_np + + @torch.no_grad() + def predict_torch( + self, + point_coords: Optional[torch.Tensor], + point_labels: Optional[torch.Tensor], + boxes: Optional[torch.Tensor] = None, + mask_input: Optional[torch.Tensor] = None, + multimask_output: bool = True, + return_logits: bool = False, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Predict masks for the given input prompts, using the currently set image. + Input prompts are batched torch tensors and are expected to already be + transformed to the input frame using ResizeLongestSide. + + Arguments: + point_coords (torch.Tensor or None): A BxNx2 array of point prompts to the + model. Each point is in (X,Y) in pixels. + point_labels (torch.Tensor or None): A BxN array of labels for the + point prompts. 1 indicates a foreground point and 0 indicates a + background point. + boxes (np.ndarray or None): A Bx4 array given a box prompt to the + model, in XYXY format. + mask_input (np.ndarray): A low resolution mask input to the model, typically + coming from a previous prediction iteration. Has form Bx1xHxW, where + for SAM, H=W=256. Masks returned by a previous iteration of the + predict method do not need further transformation. + multimask_output (bool): If true, the model will return three masks. + For ambiguous input prompts (such as a single click), this will often + produce better masks than a single prediction. If only a single + mask is needed, the model's predicted quality score can be used + to select the best mask. For non-ambiguous prompts, such as multiple + input prompts, multimask_output=False can give better results. + return_logits (bool): If true, returns un-thresholded masks logits + instead of a binary mask. + + Returns: + (torch.Tensor): The output masks in BxCxHxW format, where C is the + number of masks, and (H, W) is the original image size. + (torch.Tensor): An array of shape BxC containing the model's + predictions for the quality of each mask. + (torch.Tensor): An array of shape BxCxHxW, where C is the number + of masks and H=W=256. These low res logits can be passed to + a subsequent iteration as mask input. + """ + if not self.is_image_set: + raise RuntimeError("An image must be set with .set_image(...) before mask prediction.") + + if point_coords is not None: + points = (point_coords, point_labels) + else: + points = None + + # Embed prompts + sparse_embeddings, dense_embeddings = self.model.prompt_encoder( + points=points, + boxes=boxes, + masks=mask_input, + ) + + # Predict masks + low_res_masks, iou_predictions = self.model.mask_decoder( + image_embeddings=self.features, + image_pe=self.model.prompt_encoder.get_dense_pe(), + sparse_prompt_embeddings=sparse_embeddings, + dense_prompt_embeddings=dense_embeddings, + multimask_output=multimask_output, + ) + + # Upscale the masks to the original image resolution + masks = self.model.postprocess_masks(low_res_masks, self.input_size, self.original_size) + + if not return_logits: + masks = masks > self.model.mask_threshold + + return masks, iou_predictions, low_res_masks + + def get_image_embedding(self) -> torch.Tensor: + """ + Returns the image embeddings for the currently set image, with + shape 1xCxHxW, where C is the embedding dimension and (H,W) are + the embedding spatial dimension of SAM (typically C=256, H=W=64). + """ + if not self.is_image_set: + raise RuntimeError( + "An image must be set with .set_image(...) to generate an embedding." + ) + assert self.features is not None, "Features must exist if an image has been set." + return self.features + + @property + def device(self) -> torch.device: + return self.model.device + + def reset_image(self) -> None: + """Resets the currently set image.""" + self.is_image_set = False + self.features = None + self.orig_h = None + self.orig_w = None + self.input_h = None + self.input_w = None diff --git a/segment_anything/utils/__init__.py b/segment_anything/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5277f46157403e47fd830fc519144b97ef69d4ae --- /dev/null +++ b/segment_anything/utils/__init__.py @@ -0,0 +1,5 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. diff --git a/segment_anything/utils/amg.py b/segment_anything/utils/amg.py new file mode 100644 index 0000000000000000000000000000000000000000..be064071ef399fea96c673ad173689656c23534a --- /dev/null +++ b/segment_anything/utils/amg.py @@ -0,0 +1,346 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +import math +from copy import deepcopy +from itertools import product +from typing import Any, Dict, Generator, ItemsView, List, Tuple + + +class MaskData: + """ + A structure for storing masks and their related data in batched format. + Implements basic filtering and concatenation. + """ + + def __init__(self, **kwargs) -> None: + for v in kwargs.values(): + assert isinstance( + v, (list, np.ndarray, torch.Tensor) + ), "MaskData only supports list, numpy arrays, and torch tensors." + self._stats = dict(**kwargs) + + def __setitem__(self, key: str, item: Any) -> None: + assert isinstance( + item, (list, np.ndarray, torch.Tensor) + ), "MaskData only supports list, numpy arrays, and torch tensors." + self._stats[key] = item + + def __delitem__(self, key: str) -> None: + del self._stats[key] + + def __getitem__(self, key: str) -> Any: + return self._stats[key] + + def items(self) -> ItemsView[str, Any]: + return self._stats.items() + + def filter(self, keep: torch.Tensor) -> None: + for k, v in self._stats.items(): + if v is None: + self._stats[k] = None + elif isinstance(v, torch.Tensor): + self._stats[k] = v[torch.as_tensor(keep, device=v.device)] + elif isinstance(v, np.ndarray): + self._stats[k] = v[keep.detach().cpu().numpy()] + elif isinstance(v, list) and keep.dtype == torch.bool: + self._stats[k] = [a for i, a in enumerate(v) if keep[i]] + elif isinstance(v, list): + self._stats[k] = [v[i] for i in keep] + else: + raise TypeError(f"MaskData key {k} has an unsupported type {type(v)}.") + + def cat(self, new_stats: "MaskData") -> None: + for k, v in new_stats.items(): + if k not in self._stats or self._stats[k] is None: + self._stats[k] = deepcopy(v) + elif isinstance(v, torch.Tensor): + self._stats[k] = torch.cat([self._stats[k], v], dim=0) + elif isinstance(v, np.ndarray): + self._stats[k] = np.concatenate([self._stats[k], v], axis=0) + elif isinstance(v, list): + self._stats[k] = self._stats[k] + deepcopy(v) + else: + raise TypeError(f"MaskData key {k} has an unsupported type {type(v)}.") + + def to_numpy(self) -> None: + for k, v in self._stats.items(): + if isinstance(v, torch.Tensor): + self._stats[k] = v.detach().cpu().numpy() + + +def is_box_near_crop_edge( + boxes: torch.Tensor, crop_box: List[int], orig_box: List[int], atol: float = 20.0 +) -> torch.Tensor: + """Filter masks at the edge of a crop, but not at the edge of the original image.""" + crop_box_torch = torch.as_tensor(crop_box, dtype=torch.float, device=boxes.device) + orig_box_torch = torch.as_tensor(orig_box, dtype=torch.float, device=boxes.device) + boxes = uncrop_boxes_xyxy(boxes, crop_box).float() + near_crop_edge = torch.isclose(boxes, crop_box_torch[None, :], atol=atol, rtol=0) + near_image_edge = torch.isclose(boxes, orig_box_torch[None, :], atol=atol, rtol=0) + near_crop_edge = torch.logical_and(near_crop_edge, ~near_image_edge) + return torch.any(near_crop_edge, dim=1) + + +def box_xyxy_to_xywh(box_xyxy: torch.Tensor) -> torch.Tensor: + box_xywh = deepcopy(box_xyxy) + box_xywh[2] = box_xywh[2] - box_xywh[0] + box_xywh[3] = box_xywh[3] - box_xywh[1] + return box_xywh + + +def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]: + assert len(args) > 0 and all( + len(a) == len(args[0]) for a in args + ), "Batched iteration must have inputs of all the same size." + n_batches = len(args[0]) // batch_size + int(len(args[0]) % batch_size != 0) + for b in range(n_batches): + yield [arg[b * batch_size : (b + 1) * batch_size] for arg in args] + + +def mask_to_rle_pytorch(tensor: torch.Tensor) -> List[Dict[str, Any]]: + """ + Encodes masks to an uncompressed RLE, in the format expected by + pycoco tools. + """ + # Put in fortran order and flatten h,w + b, h, w = tensor.shape + tensor = tensor.permute(0, 2, 1).flatten(1) + + # Compute change indices + diff = tensor[:, 1:] ^ tensor[:, :-1] + change_indices = diff.nonzero() + + # Encode run length + out = [] + for i in range(b): + cur_idxs = change_indices[change_indices[:, 0] == i, 1] + cur_idxs = torch.cat( + [ + torch.tensor([0], dtype=cur_idxs.dtype, device=cur_idxs.device), + cur_idxs + 1, + torch.tensor([h * w], dtype=cur_idxs.dtype, device=cur_idxs.device), + ] + ) + btw_idxs = cur_idxs[1:] - cur_idxs[:-1] + counts = [] if tensor[i, 0] == 0 else [0] + counts.extend(btw_idxs.detach().cpu().tolist()) + out.append({"size": [h, w], "counts": counts}) + return out + + +def rle_to_mask(rle: Dict[str, Any]) -> np.ndarray: + """Compute a binary mask from an uncompressed RLE.""" + h, w = rle["size"] + mask = np.empty(h * w, dtype=bool) + idx = 0 + parity = False + for count in rle["counts"]: + mask[idx : idx + count] = parity + idx += count + parity ^= True + mask = mask.reshape(w, h) + return mask.transpose() # Put in C order + + +def area_from_rle(rle: Dict[str, Any]) -> int: + return sum(rle["counts"][1::2]) + + +def calculate_stability_score( + masks: torch.Tensor, mask_threshold: float, threshold_offset: float +) -> torch.Tensor: + """ + Computes the stability score for a batch of masks. The stability + score is the IoU between the binary masks obtained by thresholding + the predicted mask logits at high and low values. + """ + # One mask is always contained inside the other. + # Save memory by preventing unnecessary cast to torch.int64 + intersections = ( + (masks > (mask_threshold + threshold_offset)) + .sum(-1, dtype=torch.int16) + .sum(-1, dtype=torch.int32) + ) + unions = ( + (masks > (mask_threshold - threshold_offset)) + .sum(-1, dtype=torch.int16) + .sum(-1, dtype=torch.int32) + ) + return intersections / unions + + +def build_point_grid(n_per_side: int) -> np.ndarray: + """Generates a 2D grid of points evenly spaced in [0,1]x[0,1].""" + offset = 1 / (2 * n_per_side) + points_one_side = np.linspace(offset, 1 - offset, n_per_side) + points_x = np.tile(points_one_side[None, :], (n_per_side, 1)) + points_y = np.tile(points_one_side[:, None], (1, n_per_side)) + points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2) + return points + + +def build_all_layer_point_grids( + n_per_side: int, n_layers: int, scale_per_layer: int +) -> List[np.ndarray]: + """Generates point grids for all crop layers.""" + points_by_layer = [] + for i in range(n_layers + 1): + n_points = int(n_per_side / (scale_per_layer**i)) + points_by_layer.append(build_point_grid(n_points)) + return points_by_layer + + +def generate_crop_boxes( + im_size: Tuple[int, ...], n_layers: int, overlap_ratio: float +) -> Tuple[List[List[int]], List[int]]: + """ + Generates a list of crop boxes of different sizes. Each layer + has (2**i)**2 boxes for the ith layer. + """ + crop_boxes, layer_idxs = [], [] + im_h, im_w = im_size + short_side = min(im_h, im_w) + + # Original image + crop_boxes.append([0, 0, im_w, im_h]) + layer_idxs.append(0) + + def crop_len(orig_len, n_crops, overlap): + return int(math.ceil((overlap * (n_crops - 1) + orig_len) / n_crops)) + + for i_layer in range(n_layers): + n_crops_per_side = 2 ** (i_layer + 1) + overlap = int(overlap_ratio * short_side * (2 / n_crops_per_side)) + + crop_w = crop_len(im_w, n_crops_per_side, overlap) + crop_h = crop_len(im_h, n_crops_per_side, overlap) + + crop_box_x0 = [int((crop_w - overlap) * i) for i in range(n_crops_per_side)] + crop_box_y0 = [int((crop_h - overlap) * i) for i in range(n_crops_per_side)] + + # Crops in XYWH format + for x0, y0 in product(crop_box_x0, crop_box_y0): + box = [x0, y0, min(x0 + crop_w, im_w), min(y0 + crop_h, im_h)] + crop_boxes.append(box) + layer_idxs.append(i_layer + 1) + + return crop_boxes, layer_idxs + + +def uncrop_boxes_xyxy(boxes: torch.Tensor, crop_box: List[int]) -> torch.Tensor: + x0, y0, _, _ = crop_box + offset = torch.tensor([[x0, y0, x0, y0]], device=boxes.device) + # Check if boxes has a channel dimension + if len(boxes.shape) == 3: + offset = offset.unsqueeze(1) + return boxes + offset + + +def uncrop_points(points: torch.Tensor, crop_box: List[int]) -> torch.Tensor: + x0, y0, _, _ = crop_box + offset = torch.tensor([[x0, y0]], device=points.device) + # Check if points has a channel dimension + if len(points.shape) == 3: + offset = offset.unsqueeze(1) + return points + offset + + +def uncrop_masks( + masks: torch.Tensor, crop_box: List[int], orig_h: int, orig_w: int +) -> torch.Tensor: + x0, y0, x1, y1 = crop_box + if x0 == 0 and y0 == 0 and x1 == orig_w and y1 == orig_h: + return masks + # Coordinate transform masks + pad_x, pad_y = orig_w - (x1 - x0), orig_h - (y1 - y0) + pad = (x0, pad_x - x0, y0, pad_y - y0) + return torch.nn.functional.pad(masks, pad, value=0) + + +def remove_small_regions( + mask: np.ndarray, area_thresh: float, mode: str +) -> Tuple[np.ndarray, bool]: + """ + Removes small disconnected regions and holes in a mask. Returns the + mask and an indicator of if the mask has been modified. + """ + import cv2 # type: ignore + + assert mode in ["holes", "islands"] + correct_holes = mode == "holes" + working_mask = (correct_holes ^ mask).astype(np.uint8) + n_labels, regions, stats, _ = cv2.connectedComponentsWithStats(working_mask, 8) + sizes = stats[:, -1][1:] # Row 0 is background label + small_regions = [i + 1 for i, s in enumerate(sizes) if s < area_thresh] + if len(small_regions) == 0: + return mask, False + fill_labels = [0] + small_regions + if not correct_holes: + fill_labels = [i for i in range(n_labels) if i not in fill_labels] + # If every region is below threshold, keep largest + if len(fill_labels) == 0: + fill_labels = [int(np.argmax(sizes)) + 1] + mask = np.isin(regions, fill_labels) + return mask, True + + +def coco_encode_rle(uncompressed_rle: Dict[str, Any]) -> Dict[str, Any]: + from pycocotools import mask as mask_utils # type: ignore + + h, w = uncompressed_rle["size"] + rle = mask_utils.frPyObjects(uncompressed_rle, h, w) + rle["counts"] = rle["counts"].decode("utf-8") # Necessary to serialize with json + return rle + + +def batched_mask_to_box(masks: torch.Tensor) -> torch.Tensor: + """ + Calculates boxes in XYXY format around masks. Return [0,0,0,0] for + an empty mask. For input shape C1xC2x...xHxW, the output shape is C1xC2x...x4. + """ + # torch.max below raises an error on empty inputs, just skip in this case + if torch.numel(masks) == 0: + return torch.zeros(*masks.shape[:-2], 4, device=masks.device) + + # Normalize shape to CxHxW + shape = masks.shape + h, w = shape[-2:] + if len(shape) > 2: + masks = masks.flatten(0, -3) + else: + masks = masks.unsqueeze(0) + + # Get top and bottom edges + in_height, _ = torch.max(masks, dim=-1) + in_height_coords = in_height * torch.arange(h, device=in_height.device)[None, :] + bottom_edges, _ = torch.max(in_height_coords, dim=-1) + in_height_coords = in_height_coords + h * (~in_height) + top_edges, _ = torch.min(in_height_coords, dim=-1) + + # Get left and right edges + in_width, _ = torch.max(masks, dim=-2) + in_width_coords = in_width * torch.arange(w, device=in_width.device)[None, :] + right_edges, _ = torch.max(in_width_coords, dim=-1) + in_width_coords = in_width_coords + w * (~in_width) + left_edges, _ = torch.min(in_width_coords, dim=-1) + + # If the mask is empty the right edge will be to the left of the left edge. + # Replace these boxes with [0, 0, 0, 0] + empty_filter = (right_edges < left_edges) | (bottom_edges < top_edges) + out = torch.stack([left_edges, top_edges, right_edges, bottom_edges], dim=-1) + out = out * (~empty_filter).unsqueeze(-1) + + # Return to original shape + if len(shape) > 2: + out = out.reshape(*shape[:-2], 4) + else: + out = out[0] + + return out diff --git a/segment_anything/utils/onnx.py b/segment_anything/utils/onnx.py new file mode 100644 index 0000000000000000000000000000000000000000..3196bdf4b782e6eeb3da4ad66ef3c7b1741535fe --- /dev/null +++ b/segment_anything/utils/onnx.py @@ -0,0 +1,144 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +from torch.nn import functional as F + +from typing import Tuple + +from ..modeling import Sam +from .amg import calculate_stability_score + + +class SamOnnxModel(nn.Module): + """ + This model should not be called directly, but is used in ONNX export. + It combines the prompt encoder, mask decoder, and mask postprocessing of Sam, + with some functions modified to enable model tracing. Also supports extra + options controlling what information. See the ONNX export script for details. + """ + + def __init__( + self, + model: Sam, + return_single_mask: bool, + use_stability_score: bool = False, + return_extra_metrics: bool = False, + ) -> None: + super().__init__() + self.mask_decoder = model.mask_decoder + self.model = model + self.img_size = model.image_encoder.img_size + self.return_single_mask = return_single_mask + self.use_stability_score = use_stability_score + self.stability_score_offset = 1.0 + self.return_extra_metrics = return_extra_metrics + + @staticmethod + def resize_longest_image_size( + input_image_size: torch.Tensor, longest_side: int + ) -> torch.Tensor: + input_image_size = input_image_size.to(torch.float32) + scale = longest_side / torch.max(input_image_size) + transformed_size = scale * input_image_size + transformed_size = torch.floor(transformed_size + 0.5).to(torch.int64) + return transformed_size + + def _embed_points(self, point_coords: torch.Tensor, point_labels: torch.Tensor) -> torch.Tensor: + point_coords = point_coords + 0.5 + point_coords = point_coords / self.img_size + point_embedding = self.model.prompt_encoder.pe_layer._pe_encoding(point_coords) + point_labels = point_labels.unsqueeze(-1).expand_as(point_embedding) + + point_embedding = point_embedding * (point_labels != -1) + point_embedding = point_embedding + self.model.prompt_encoder.not_a_point_embed.weight * ( + point_labels == -1 + ) + + for i in range(self.model.prompt_encoder.num_point_embeddings): + point_embedding = point_embedding + self.model.prompt_encoder.point_embeddings[ + i + ].weight * (point_labels == i) + + return point_embedding + + def _embed_masks(self, input_mask: torch.Tensor, has_mask_input: torch.Tensor) -> torch.Tensor: + mask_embedding = has_mask_input * self.model.prompt_encoder.mask_downscaling(input_mask) + mask_embedding = mask_embedding + ( + 1 - has_mask_input + ) * self.model.prompt_encoder.no_mask_embed.weight.reshape(1, -1, 1, 1) + return mask_embedding + + def mask_postprocessing(self, masks: torch.Tensor, orig_im_size: torch.Tensor) -> torch.Tensor: + masks = F.interpolate( + masks, + size=(self.img_size, self.img_size), + mode="bilinear", + align_corners=False, + ) + + prepadded_size = self.resize_longest_image_size(orig_im_size, self.img_size).to(torch.int64) + masks = masks[..., : prepadded_size[0], : prepadded_size[1]] # type: ignore + + orig_im_size = orig_im_size.to(torch.int64) + h, w = orig_im_size[0], orig_im_size[1] + masks = F.interpolate(masks, size=(h, w), mode="bilinear", align_corners=False) + return masks + + def select_masks( + self, masks: torch.Tensor, iou_preds: torch.Tensor, num_points: int + ) -> Tuple[torch.Tensor, torch.Tensor]: + # Determine if we should return the multiclick mask or not from the number of points. + # The reweighting is used to avoid control flow. + score_reweight = torch.tensor( + [[1000] + [0] * (self.model.mask_decoder.num_mask_tokens - 1)] + ).to(iou_preds.device) + score = iou_preds + (num_points - 2.5) * score_reweight + best_idx = torch.argmax(score, dim=1) + masks = masks[torch.arange(masks.shape[0]), best_idx, :, :].unsqueeze(1) + iou_preds = iou_preds[torch.arange(masks.shape[0]), best_idx].unsqueeze(1) + + return masks, iou_preds + + @torch.no_grad() + def forward( + self, + image_embeddings: torch.Tensor, + point_coords: torch.Tensor, + point_labels: torch.Tensor, + mask_input: torch.Tensor, + has_mask_input: torch.Tensor, + orig_im_size: torch.Tensor, + ): + sparse_embedding = self._embed_points(point_coords, point_labels) + dense_embedding = self._embed_masks(mask_input, has_mask_input) + + masks, scores = self.model.mask_decoder.predict_masks( + image_embeddings=image_embeddings, + image_pe=self.model.prompt_encoder.get_dense_pe(), + sparse_prompt_embeddings=sparse_embedding, + dense_prompt_embeddings=dense_embedding, + ) + + if self.use_stability_score: + scores = calculate_stability_score( + masks, self.model.mask_threshold, self.stability_score_offset + ) + + if self.return_single_mask: + masks, scores = self.select_masks(masks, scores, point_coords.shape[1]) + + upscaled_masks = self.mask_postprocessing(masks, orig_im_size) + + if self.return_extra_metrics: + stability_scores = calculate_stability_score( + upscaled_masks, self.model.mask_threshold, self.stability_score_offset + ) + areas = (upscaled_masks > self.model.mask_threshold).sum(-1).sum(-1) + return upscaled_masks, scores, stability_scores, areas, masks + + return upscaled_masks, scores, masks diff --git a/segment_anything/utils/transforms.py b/segment_anything/utils/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..c08ba1e3db751f3a5483a003be38c69c2cf2df85 --- /dev/null +++ b/segment_anything/utils/transforms.py @@ -0,0 +1,102 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from torch.nn import functional as F +from torchvision.transforms.functional import resize, to_pil_image # type: ignore + +from copy import deepcopy +from typing import Tuple + + +class ResizeLongestSide: + """ + Resizes images to the longest side 'target_length', as well as provides + methods for resizing coordinates and boxes. Provides methods for + transforming both numpy array and batched torch tensors. + """ + + def __init__(self, target_length: int) -> None: + self.target_length = target_length + + def apply_image(self, image: np.ndarray) -> np.ndarray: + """ + Expects a numpy array with shape HxWxC in uint8 format. + """ + target_size = self.get_preprocess_shape(image.shape[0], image.shape[1], self.target_length) + return np.array(resize(to_pil_image(image), target_size)) + + def apply_coords(self, coords: np.ndarray, original_size: Tuple[int, ...]) -> np.ndarray: + """ + Expects a numpy array of length 2 in the final dimension. Requires the + original image size in (H, W) format. + """ + old_h, old_w = original_size + new_h, new_w = self.get_preprocess_shape( + original_size[0], original_size[1], self.target_length + ) + coords = deepcopy(coords).astype(float) + coords[..., 0] = coords[..., 0] * (new_w / old_w) + coords[..., 1] = coords[..., 1] * (new_h / old_h) + return coords + + def apply_boxes(self, boxes: np.ndarray, original_size: Tuple[int, ...]) -> np.ndarray: + """ + Expects a numpy array shape Bx4. Requires the original image size + in (H, W) format. + """ + boxes = self.apply_coords(boxes.reshape(-1, 2, 2), original_size) + return boxes.reshape(-1, 4) + + def apply_image_torch(self, image: torch.Tensor) -> torch.Tensor: + """ + Expects batched images with shape BxCxHxW and float format. This + transformation may not exactly match apply_image. apply_image is + the transformation expected by the model. + """ + # Expects an image in BCHW format. May not exactly match apply_image. + target_size = self.get_preprocess_shape(image.shape[2], image.shape[3], self.target_length) + return F.interpolate( + image, target_size, mode="bilinear", align_corners=False, antialias=True + ) + + def apply_coords_torch( + self, coords: torch.Tensor, original_size: Tuple[int, ...] + ) -> torch.Tensor: + """ + Expects a torch tensor with length 2 in the last dimension. Requires the + original image size in (H, W) format. + """ + old_h, old_w = original_size + new_h, new_w = self.get_preprocess_shape( + original_size[0], original_size[1], self.target_length + ) + coords = deepcopy(coords).to(torch.float) + coords[..., 0] = coords[..., 0] * (new_w / old_w) + coords[..., 1] = coords[..., 1] * (new_h / old_h) + return coords + + def apply_boxes_torch( + self, boxes: torch.Tensor, original_size: Tuple[int, ...] + ) -> torch.Tensor: + """ + Expects a torch tensor with shape Bx4. Requires the original image + size in (H, W) format. + """ + boxes = self.apply_coords_torch(boxes.reshape(-1, 2, 2), original_size) + return boxes.reshape(-1, 4) + + @staticmethod + def get_preprocess_shape(oldh: int, oldw: int, long_side_length: int) -> Tuple[int, int]: + """ + Compute the output size given input size and target long side length. + """ + scale = long_side_length * 1.0 / max(oldh, oldw) + newh, neww = oldh * scale, oldw * scale + neww = int(neww + 0.5) + newh = int(newh + 0.5) + return (newh, neww) diff --git a/video_utils.py b/video_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..fc6abac4f436c92b17226b76c52323b78a35e708 --- /dev/null +++ b/video_utils.py @@ -0,0 +1,53 @@ +import datetime +from glob import glob +import cv2 +import os +from tqdm import tqdm + +def mp4_to_png(input_path: str, save_path: str) -> str: + """ Converts mp4 to pngs for each frame of the video. + Args: input_path is the path to the mp4 file, save_path is the directory to save the frames. + Returns: save_path, fps the number of frames per second. + """ + # get frames per second + fps = int(cv2.VideoCapture(input_path).get(cv2.CAP_PROP_FPS)) + # run subprocess to convert mp4 to pngs + os.system(f"ffmpeg -i {input_path} -vf fps={fps} {save_path}/frame%08d.png") + return fps + +def frame_to_timestamp(frame_number: int, fps: int): + # Calculate the timestamp in seconds + timestamp_seconds = frame_number / fps + + # Convert the timestamp to hh:mm:ss + minutes, seconds = divmod(timestamp_seconds, 60) + hours, minutes = divmod(minutes, 60) + # print("Timestamp:", hours, ":", minutes, ":", seconds) + timestamp = f"{int(hours):02d}:{int(minutes):02d}:{seconds:06.3f}" + return timestamp + +def vid_stitcher(frames_dir: str, output_path: str, fps: int = 30) -> str: + """ + Takes a list of frames as numpy arrays and writes them to a video file. + """ + # Get the list of frames + frame_list = sorted(glob(os.path.join(frames_dir, 'frame*.png'))) + + # Prepare the VideoWriter + frame = cv2.imread(frame_list[0]) + height, width, _ = frame.shape + fourcc = cv2.VideoWriter_fourcc(*'mp4v') + out = cv2.VideoWriter(output_path, fourcc, fps, (width, height)) + + # Use multithreading to read frames faster + from concurrent.futures import ThreadPoolExecutor + with ThreadPoolExecutor() as executor: + frames = list(executor.map(cv2.imread, frame_list)) + + # Write frames to the video + with tqdm(total=len(frame_list), desc='Stitching frames') as pbar: + for frame in frames: + out.write(frame) + pbar.update(1) + + return output_path \ No newline at end of file