Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,78 @@ 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
+examples/videos/camel.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/car.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/figure1.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/figure2.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/figure3.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/goldfish.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/horse.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/paragliding.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/pstudio.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/stroller.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/swing.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/tennis.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/videos/tesla.mp4 filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000000.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000001.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000002.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000003.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000004.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000005.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000006.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000007.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000008.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000009.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000010.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000011.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000012.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000013.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000014.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000015.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000016.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052216_587020/images/000017.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000000.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000001.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000002.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000003.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000004.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000005.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000006.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000007.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000008.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052439_748027/images/000009.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052521_840381/images/cam00.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052521_840381/images/cam01.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052521_840381/images/cam18.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_052521_840381/images/cam19.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_053256_343581/images/cam00.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_053256_343581/images/cam01.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_053256_343581/images/cam18.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_053256_343581/images/cam19.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_053630_522657/images/cam18.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_053630_522657/images/cam19.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_161749_937508/images/000000.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_161749_937508/images/000001.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_161749_937508/images/000002.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_161749_937508/images/000003.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_162743_468054/images/000000.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_162743_468054/images/000001.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_162743_468054/images/000002.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_162743_468054/images/000003.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_163859_002158/images/000000.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_163859_002158/images/000001.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_163859_002158/images/000002.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_163859_002158/images/000003.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000000.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000001.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000002.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000003.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000004.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000005.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000006.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000007.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000008.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000009.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000010.png filter=lfs diff=lfs merge=lfs -text
+input_images_20260127_170350_777007/images/000011.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,132 @@
+data/
+checkpoints/
+
+# 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/

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Eldar Insafutdinov, Edgar Sucar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

LICENSE-VGGT

@@ -0,0 +1,115 @@
+VGGT License
+
+v1 Last Updated: July 29, 2025
+
+“Acceptable Use Policy” means the Acceptable Use Policy, applicable to Research Materials, that is incorporated into this Agreement.
+
+“Agreement” means the terms and conditions for use, reproduction, distribution and modification of the Research Materials set forth herein.
+
+
+“Documentation” means the specifications, manuals and documentation accompanying 
+Research Materials distributed by Meta.
+
+
+“Licensee” or “you” means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf.
+
+“Meta” or “we” means Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) and Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland).
+“Research Materials” means, collectively, Documentation and the models, software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code, demonstration materials and other elements of the foregoing distributed by Meta and made available under this Agreement.
+
+By clicking “I Accept” below or by using or distributing any portion or element of the Research Materials, you agree to be bound by this Agreement.
+
+
+1. License Rights and Redistribution.
+
+
+a. Grant of Rights. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the Research Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Research Materials.  
+ 
+b. Redistribution and Use.  
+
+
+i. Distribution of Research Materials, and any derivative works thereof, are subject to the terms of this Agreement. If you distribute or make the Research Materials, or any derivative works thereof, available to a third party, you may only do so under the terms of this Agreement. You shall also provide a copy of this Agreement to such third party.
+
+
+ii.  If you submit for publication the results of research you perform on, using, or otherwise in connection with Research Materials, you must acknowledge the use of Research Materials in your publication.
+
+
+iii. Your use of the Research Materials must comply with applicable laws and regulations (including Trade Control Laws) and adhere to the Acceptable Use Policy, which is hereby incorporated by reference into this Agreement.
+2. User Support. Your  use of the Research Materials is done at your own discretion; Meta does not process any information nor provide any service in relation to such use.  Meta is under no obligation to provide any support services for the Research Materials. Any support provided is “as is”, “with all faults”, and without warranty of any kind.
+
+
+3. Disclaimer of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE RESEARCH MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE RESEARCH MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE RESEARCH MATERIALS AND ANY OUTPUT AND RESULTS.
+ 
+4. Limitation of Liability. IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT OR INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
+ 
+5. Intellectual Property.
+
+
+a. Subject to Meta’s ownership of Research Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the Research Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications.
+ 
+b. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Research Materials, outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the Research Materials.
+ 
+6. Term and Termination. The term of this Agreement will commence upon your acceptance of this Agreement or access to the Research Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the Research Materials. Sections 5, 6 and 9 shall survive the termination of this Agreement. 
+ 
+7. Governing Law and Jurisdiction. This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement. 
+
+
+8. Modifications and Amendments. Meta may modify this Agreement from time to time; provided that they are similar in spirit to the current version of the Agreement, but may differ in detail to address new problems or concerns. All such changes will be effective immediately. Your continued use of the Research Materials after any modification to this Agreement constitutes your agreement to such modification. Except as provided in this Agreement, no modification or addition to any provision of this Agreement will be binding unless it is in writing and signed by an authorized representative of both you and Meta.
+
+
+Acceptable Use Policy 
+
+Meta seeks to further understanding of new and existing research domains with the mission of advancing the state-of-the-art in artificial intelligence through open research for the benefit of all. 
+
+As part of this mission, Meta makes certain research materials available for use in accordance with this Agreement (including the Acceptable Use Policy). Meta is committed to promoting the safe and responsible use of such research materials.  
+
+Prohibited Uses
+
+You agree you will not use, or allow others to use, Research Materials to:
+
+ Violate the law or others’ rights, including to:
+Engage in, promote, generate, contribute to, encourage, plan, incite, or further illegal or unlawful activity or content, such as:
+Violence or terrorism
+Exploitation or harm to children, including the solicitation, creation, acquisition, or dissemination of child exploitative content or failure to report Child Sexual Abuse Material
+Human trafficking, exploitation, and sexual violence
+The illegal distribution of information or materials to minors, including obscene materials, or failure to employ legally required age-gating in connection with such information or materials.
+Sexual solicitation
+Any other criminal activity
+
+Engage in, promote, incite, or facilitate the harassment, abuse, threatening, or bullying of individuals or groups of individuals
+
+Engage in, promote, incite, or facilitate discrimination or other unlawful or harmful conduct in the provision of employment, employment benefits, credit, housing, other economic benefits, or other essential goods and services
+
+Engage in the unauthorized or unlicensed practice of any profession including, but not limited to, financial, legal, medical/health, or related professional practices
+
+Collect, process, disclose, generate, or infer health, demographic, or other sensitive personal or private information about individuals without rights and consents required by applicable laws
+
+Engage in or facilitate any action or generate any content that infringes, misappropriates, or otherwise violates any third-party rights, including the outputs or results of any technology using Research Materials
+
+Create, generate, or facilitate the creation of malicious code, malware, computer viruses or do anything else that could disable, overburden, interfere with or impair the proper working, integrity, operation or appearance of a website or computer system
+
+2. Engage in, promote, incite, facilitate, or assist in the planning or development of activities that present a risk of death or bodily harm to individuals, including use of research artifacts related to the following:
+
+Military, warfare, nuclear industries or applications, espionage, use for materials or activities that are subject to the International Traffic Arms Regulations (ITAR) maintained by the United States Department of State
+
+Guns and illegal weapons (including weapon development)
+
+Illegal drugs and regulated/controlled substances
+Operation of critical infrastructure, transportation technologies, or heavy machinery
+
+Self-harm or harm to others, including suicide, cutting, and eating disorders
+Any content intended to incite or promote violence, abuse, or any infliction of bodily harm to an individual
+
+3. Intentionally deceive or mislead others, including use of Research Materials related to the following:
+
+ Generating, promoting, or furthering fraud or the creation or promotion of disinformation
+ Generating, promoting, or furthering defamatory content, including the creation of defamatory statements, images, or other content
+
+Generating, promoting, or further distributing spam
+
+ Impersonating another individual without consent, authorization, or legal right
+
+Representing that outputs of research materials or outputs from technology using Research Materials are human-generated
+
+Generating or facilitating false online engagement, including fake reviews and other means of fake online engagement
+
+4. Fail to appropriately disclose to end users any known dangers of your Research Materials.

README.md

@@ -1,12 +1,44 @@
 ---
-title: Vdpm
-emoji: 💻
-colorFrom: indigo
-colorTo: yellow
+title: vdpm
+app_file: gradio_demo.py
 sdk: gradio
-sdk_version: 6.4.0
-app_file: app.py
-pinned: false
+sdk_version: 5.17.1
 ---
+<div align="center">
+<h1>V-DPM: 4D Video Reconstruction with Dynamic Point Maps</h1>
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<a href="https://www.robots.ox.ac.uk/~vgg/research/vdpm/"><img src="https://img.shields.io/badge/Project_Page-green" alt="Project Page"></a>
+<a href="https://huggingface.co/spaces/edgarsucar/vdpm"><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Demo-blue'></a>
+
+**[Visual Geometry Group, University of Oxford](https://www.robots.ox.ac.uk/~vgg/)**
+
+
+[Edgar Sucar](https://edgarsucar.github.io/)\*, [Eldar Insafutdinov](https://eldar.insafutdinov.com/)\*, [Zihang Lai](https://scholar.google.com/citations?user=31eXgMYAAAAJ), [Andrea Vedaldi](https://www.robots.ox.ac.uk/~vedaldi/)
+</div>
+
+## Setup
+
+First, clone the repository and setup a virtual environment with [uv](https://github.com/astral-sh/uv):
+
+```bash
+git clone git@github.com:eldar/vdpm.git
+cd vdpm
+uv venv --python 3.12
+. .venv/bin/activate
+
+# Install PyTorch with CUDA 11.8 first
+uv pip install torch==2.5.1 torchvision==0.20.1 --index-url https://download.pytorch.org/whl/cu118
+
+# Then install remaining dependencies
+uv pip install -r requirements.txt
+```
+
+## Viser demo
+```bash
+python visualise.py ++vis.input_video=examples/videos/camel.mp4
+```
+
+## Gradio demo
+```bash
+python gradio_demo.py
+```

check_model_size.py

@@ -0,0 +1,85 @@
+import torch
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+def check_model_memory():
+    # Simple config object
+    class SimpleConfig:
+        class ModelConfig:
+            decoder_depth = 4
+        model = ModelConfig()
+    
+    cfg = SimpleConfig()
+    
+    # Import after path is set
+    from dpm.model import VDPM
+    
+    # Create model on CPU first to count parameters
+    print("Creating model...")
+    model = VDPM(cfg)
+    
+    # Count parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    
+    print(f"\n{'='*60}")
+    print(f"MODEL SIZE ANALYSIS FOR RTX 3070 Ti (8GB)")
+    print(f"{'='*60}")
+    print(f"Total parameters: {total_params:,}")
+    print(f"Trainable parameters: {trainable_params:,}")
+    print(f"\nEstimated model weights memory:")
+    print(f"  - FP32 (float32): {total_params * 4 / 1024**3:.2f} GB")
+    print(f"  - FP16 (float16): {total_params * 2 / 1024**3:.2f} GB")
+    print(f"  - BF16 (bfloat16): {total_params * 2 / 1024**3:.2f} GB")
+    print(f"  - INT8 (quantized): {total_params * 1 / 1024**3:.2f} GB  <-- RECOMMENDED for 8GB GPU")
+    
+    # Estimate activation memory for typical input
+    batch_size = 1
+    num_frames = 5  # typical video length
+    img_size = 518
+    print(f"\nEstimated activation memory (batch={batch_size}, frames={num_frames}, img_size={img_size}):")
+    
+    # Input images: [B, S, 3, H, W]
+    input_mem = batch_size * num_frames * 3 * img_size * img_size * 4 / 1024**3
+    print(f"  - Input images (FP32): {input_mem:.2f} GB")
+    
+    # Rough estimate for activations (can be 2-4x model size during forward pass)
+    activation_mem_estimate = total_params * 2 * 3 / 1024**3  # conservative estimate
+    print(f"  - Activations (estimate): {activation_mem_estimate:.2f} GB")
+    
+    # Calculate total for different precision modes
+    total_fp16 = (total_params * 2 / 1024**3) + input_mem + activation_mem_estimate
+    total_int8 = (total_params * 1 / 1024**3) + input_mem + (activation_mem_estimate * 0.6)  # INT8 reduces activations too
+    
+    print(f"\nTotal estimated GPU memory needed:")
+    print(f"  - With FP16/BF16: {total_fp16:.2f} GB")
+    print(f"  - With INT8 quantization: {total_int8:.2f} GB  <-- FITS IN 8GB!")
+    print(f"Your RTX 3070 Ti has: 8 GB VRAM")
+    
+    if total_int8 <= 8:
+        print(f"\n✓ With INT8 quantization, model will fit in GPU memory!")
+        print(f"  Set USE_QUANTIZATION = True in gradio_demo.py")
+    elif total_fp16 > 8:
+        print(f"\n⚠️  WARNING: Even with INT8 ({total_int8:.2f} GB), memory is tight")
+        print(f"    Recommendations:")
+        print(f"  1. Use INT8 quantization (USE_QUANTIZATION = True)")
+        print(f"  2. Reduce number of input frames to {num_frames} or fewer")
+        print(f"  3. Clear CUDA cache between batches")
+    else:
+        print(f"\n✓ Model should fit with FP16!")
+    
+    print(f"{'='*60}\n")
+    
+    # Check actual GPU memory if CUDA available
+    if torch.cuda.is_available():
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print(f"Total GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+        print(f"Current GPU memory allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+        print(f"Current GPU memory cached: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+if __name__ == "__main__":
+    check_model_memory()
+

configs/config.yaml

@@ -0,0 +1,50 @@
+defaults:
+  - _self_
+  - hydra: defaults
+  - model: dpm
+
+config:
+  exp_name: "debug"
+  file: "config.yaml"
+
+data_loader:
+  batch_size: 2
+  num_workers: 8
+  dynamic_batch: false
+
+train:
+  logging: true
+  num_gpus: 4
+  amp: bfloat16
+  amp_dpt: false
+  dry_run: false
+  camera_loss_lambda: 5.0
+
+optimiser:
+  lr: 0.00005 # absolute lr
+  blr: 1.5e-4 # base learning rate: absolute_lr = base_lr * total_batch_size / 256
+  start_epoch:
+  epochs: 70
+  accum_iter: 1
+  warmup_epochs: 3
+  min_lr: 1e-06
+
+run:
+  resume: false
+  dirpath: null
+  debug: false
+  random_seed: 42
+  git_hash: null
+  log_frequency: 250
+  training_progress_bar: false
+  save_freq: 5
+  eval_freq: 1
+  keep_freq: 5
+  print_freq: 20
+  num_keep_ckpts: 5
+  # Old Dust3r params
+  world_size: -1
+  local_rank: -1
+  dist_url: "env://"
+  seed: 0
+

configs/model/dpm.yaml

@@ -0,0 +1,3 @@
+name: dpm-video
+pretrained: /work/eldar/models/vggt/VGGT-1B.pt
+decoder_depth: 4

configs/visualise.yaml

@@ -0,0 +1,13 @@
+defaults:
+  - _self_
+  - model: dpm
+
+hydra:
+  output_subdir: null  # Disable saving of config files.
+  job:
+    chdir: False
+
+vis:
+  port: 8080
+  input_video:
+

dpm/aggregator.py

@@ -0,0 +1,366 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE-VGGT file in the root directory of this source tree.
+
+import logging
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+from typing import Optional, Tuple, Union, List, Dict, Any
+
+from vggt.layers import PatchEmbed
+from vggt.layers.block import Block
+from vggt.layers.rope import RotaryPositionEmbedding2D, PositionGetter
+from vggt.layers.vision_transformer import vit_small, vit_base, vit_large, vit_giant2
+
+logger = logging.getLogger(__name__)
+
+_RESNET_MEAN = [0.485, 0.456, 0.406]
+_RESNET_STD = [0.229, 0.224, 0.225]
+
+
+class Aggregator(nn.Module):
+    """
+    The Aggregator applies alternating-attention over input frames,
+    as described in VGGT: Visual Geometry Grounded Transformer.
+
+
+    Args:
+        img_size (int): Image size in pixels.
+        patch_size (int): Size of each patch for PatchEmbed.
+        embed_dim (int): Dimension of the token embeddings.
+        depth (int): Number of blocks.
+        num_heads (int): Number of attention heads.
+        mlp_ratio (float): Ratio of MLP hidden dim to embedding dim.
+        num_register_tokens (int): Number of register tokens.
+        block_fn (nn.Module): The block type used for attention (Block by default).
+        qkv_bias (bool): Whether to include bias in QKV projections.
+        proj_bias (bool): Whether to include bias in the output projection.
+        ffn_bias (bool): Whether to include bias in MLP layers.
+        patch_embed (str): Type of patch embed. e.g., "conv" or "dinov2_vitl14_reg".
+        aa_order (list[str]): The order of alternating attention, e.g. ["frame", "global"].
+        aa_block_size (int): How many blocks to group under each attention type before switching. If not necessary, set to 1.
+        qk_norm (bool): Whether to apply QK normalization.
+        rope_freq (int): Base frequency for rotary embedding. -1 to disable.
+        init_values (float): Init scale for layer scale.
+    """
+
+    def __init__(
+        self,
+        img_size=518,
+        patch_size=14,
+        embed_dim=1024,
+        depth=24,
+        num_heads=16,
+        mlp_ratio=4.0,
+        num_register_tokens=4,
+        block_fn=Block,
+        qkv_bias=True,
+        proj_bias=True,
+        ffn_bias=True,
+        patch_embed="dinov2_vitl14_reg",
+        aa_order=["frame", "global"],
+        aa_block_size=1,
+        qk_norm=True,
+        rope_freq=100,
+        init_values=0.01,
+    ):
+        super().__init__()
+
+        self.__build_patch_embed__(patch_embed, img_size, patch_size, num_register_tokens, embed_dim=embed_dim)
+
+        # Initialize rotary position embedding if frequency > 0
+        self.rope = RotaryPositionEmbedding2D(frequency=rope_freq) if rope_freq > 0 else None
+        self.position_getter = PositionGetter() if self.rope is not None else None
+
+        self.frame_blocks = nn.ModuleList(
+            [
+                block_fn(
+                    dim=embed_dim,
+                    num_heads=num_heads,
+                    mlp_ratio=mlp_ratio,
+                    qkv_bias=qkv_bias,
+                    proj_bias=proj_bias,
+                    ffn_bias=ffn_bias,
+                    init_values=init_values,
+                    qk_norm=qk_norm,
+                    rope=self.rope,
+                )
+                for _ in range(depth)
+            ]
+        )
+
+        self.global_blocks = nn.ModuleList(
+            [
+                block_fn(
+                    dim=embed_dim,
+                    num_heads=num_heads,
+                    mlp_ratio=mlp_ratio,
+                    qkv_bias=qkv_bias,
+                    proj_bias=proj_bias,
+                    ffn_bias=ffn_bias,
+                    init_values=init_values,
+                    qk_norm=qk_norm,
+                    rope=self.rope,
+                )
+                for _ in range(depth)
+            ]
+        )
+
+        self.depth = depth
+        self.aa_order = aa_order
+        self.patch_size = patch_size
+        self.aa_block_size = aa_block_size
+
+        # Validate that depth is divisible by aa_block_size
+        if self.depth % self.aa_block_size != 0:
+            raise ValueError(f"depth ({depth}) must be divisible by aa_block_size ({aa_block_size})")
+
+        self.aa_block_num = self.depth // self.aa_block_size
+
+        # Note: We have two camera tokens, one for the first frame and one for the rest
+        # The same applies for register tokens
+        self.camera_token = nn.Parameter(torch.randn(1, 2, 1, embed_dim))
+        self.register_token = nn.Parameter(torch.randn(1, 2, num_register_tokens, embed_dim))
+
+        # The patch tokens start after the camera and register tokens
+        self.patch_start_idx = 1 + num_register_tokens
+
+        self.time_conditioning_token = nn.Parameter(torch.randn(1, 1, embed_dim))
+        self.patch_start_idx += 1
+
+        # Initialize parameters with small values
+        nn.init.normal_(self.camera_token, std=1e-6)
+        nn.init.normal_(self.register_token, std=1e-6)
+
+        # Register normalization constants as buffers
+        for name, value in (
+            ("_resnet_mean", _RESNET_MEAN),
+            ("_resnet_std", _RESNET_STD),
+        ):
+            self.register_buffer(
+                name,
+                torch.FloatTensor(value).view(1, 1, 3, 1, 1),
+                persistent=False,
+            )
+
+        self.use_reentrant = False # hardcoded to False
+
+    def __build_patch_embed__(
+        self,
+        patch_embed,
+        img_size,
+        patch_size,
+        num_register_tokens,
+        interpolate_antialias=True,
+        interpolate_offset=0.0,
+        block_chunks=0,
+        init_values=1.0,
+        embed_dim=1024,
+    ):
+        """
+        Build the patch embed layer. If 'conv', we use a
+        simple PatchEmbed conv layer. Otherwise, we use a vision transformer.
+        """
+
+        if "conv" in patch_embed:
+            self.patch_embed = PatchEmbed(img_size=img_size, patch_size=patch_size, in_chans=3, embed_dim=embed_dim)
+        else:
+            vit_models = {
+                "dinov2_vitl14_reg": vit_large,
+                "dinov2_vitb14_reg": vit_base,
+                "dinov2_vits14_reg": vit_small,
+                "dinov2_vitg2_reg": vit_giant2,
+            }
+
+            self.patch_embed = vit_models[patch_embed](
+                img_size=img_size,
+                patch_size=patch_size,
+                num_register_tokens=num_register_tokens,
+                interpolate_antialias=interpolate_antialias,
+                interpolate_offset=interpolate_offset,
+                block_chunks=block_chunks,
+                init_values=init_values,
+            )
+
+            # Disable gradient updates for mask token
+            if hasattr(self.patch_embed, "mask_token"):
+                self.patch_embed.mask_token.requires_grad_(False)
+
+    def forward(
+        self,
+        images: torch.Tensor,
+    ) -> Tuple[List[torch.Tensor], int]:
+        """
+        Args:
+            images (torch.Tensor): Input images with shape [B, S, 3, H, W], in range [0, 1].
+                B: batch size, S: sequence length, 3: RGB channels, H: height, W: width
+
+        Returns:
+            (list[torch.Tensor], int):
+                The list of outputs from the attention blocks,
+                and the patch_start_idx indicating where patch tokens begin.
+        """
+        B, S, C_in, H, W = images.shape
+
+        if C_in != 3:
+            raise ValueError(f"Expected 3 input channels, got {C_in}")
+
+        # Normalize images and reshape for patch embed
+        images = (images - self._resnet_mean) / self._resnet_std
+
+        # Reshape to [B*S, C, H, W] for patch embedding
+        images = images.view(B * S, C_in, H, W)
+        patch_tokens = self.patch_embed(images)
+
+        if isinstance(patch_tokens, dict):
+            patch_tokens = patch_tokens["x_norm_patchtokens"]
+
+        _, P, C = patch_tokens.shape
+
+        # Expand camera and register tokens to match batch size and sequence length
+        camera_token = slice_expand_and_flatten(self.camera_token, B, S)
+        register_token = slice_expand_and_flatten(self.register_token, B, S)
+        # do something similar for time_conditioning_token
+        time_conditioning_token = slice_expand_and_flatten_single(self.time_conditioning_token, B, S)
+        # Concatenate special tokens with patch tokens
+        tokens = torch.cat([camera_token, time_conditioning_token, register_token, patch_tokens], dim=1)
+
+        pos = None
+        if self.rope is not None:
+            pos = self.position_getter(B * S, H // self.patch_size, W // self.patch_size, device=images.device)
+
+        if self.patch_start_idx > 0:
+            # do not use position embedding for special tokens (camera and register tokens)
+            # so set pos to 0 for the special tokens
+            pos = pos + 1
+            pos_special = torch.zeros(B * S, self.patch_start_idx, 2).to(images.device).to(pos.dtype)
+            pos = torch.cat([pos_special, pos], dim=1)
+
+        # update P because we added special tokens
+        _, P, C = tokens.shape
+
+        frame_idx = 0
+        global_idx = 0
+        output_list = []
+
+        for _ in range(self.aa_block_num):
+            for attn_type in self.aa_order:
+                if attn_type == "frame":
+                    tokens, frame_idx, frame_intermediates = self._process_frame_attention(
+                        tokens, B, S, P, C, frame_idx, pos=pos
+                    )
+                elif attn_type == "global":
+                    tokens, global_idx, global_intermediates = self._process_global_attention(
+                        tokens, B, S, P, C, global_idx, pos=pos
+                    )
+                else:
+                    raise ValueError(f"Unknown attention type: {attn_type}")
+
+            for i in range(len(frame_intermediates)):
+                # concat frame and global intermediates, [B x S x P x 2C]
+                concat_inter = torch.cat([frame_intermediates[i], global_intermediates[i]], dim=-1)
+                output_list.append(concat_inter)
+
+        del concat_inter
+        del frame_intermediates
+        del global_intermediates
+        return output_list, self.patch_start_idx
+
+    def _process_frame_attention(self, tokens, B, S, P, C, frame_idx, pos=None):
+        """
+        Process frame attention blocks. We keep tokens in shape (B*S, P, C).
+        """
+        # If needed, reshape tokens or positions:
+        if tokens.shape != (B * S, P, C):
+            tokens = tokens.view(B, S, P, C).view(B * S, P, C)
+
+        if pos is not None and pos.shape != (B * S, P, 2):
+            pos = pos.view(B, S, P, 2).view(B * S, P, 2)
+
+        intermediates = []
+
+        # by default, self.aa_block_size=1, which processes one block at a time
+        for _ in range(self.aa_block_size):
+            if self.training:
+                tokens = checkpoint(self.frame_blocks[frame_idx], tokens, pos, use_reentrant=self.use_reentrant)
+            else:
+                tokens = self.frame_blocks[frame_idx](tokens, pos=pos)
+            frame_idx += 1
+            intermediates.append(tokens.view(B, S, P, C))
+
+        return tokens, frame_idx, intermediates
+
+    def _process_global_attention(self, tokens, B, S, P, C, global_idx, pos=None):
+        """
+        Process global attention blocks. We keep tokens in shape (B, S*P, C).
+        """
+        if tokens.shape != (B, S * P, C):
+            tokens = tokens.view(B, S, P, C).view(B, S * P, C)
+
+        if pos is not None and pos.shape != (B, S * P, 2):
+            pos = pos.view(B, S, P, 2).view(B, S * P, 2)
+
+        intermediates = []
+
+        # by default, self.aa_block_size=1, which processes one block at a time
+        for _ in range(self.aa_block_size):
+            if self.training:
+                tokens = checkpoint(self.global_blocks[global_idx], tokens, pos, use_reentrant=self.use_reentrant)
+            else:
+                tokens = self.global_blocks[global_idx](tokens, pos=pos)
+            global_idx += 1
+            intermediates.append(tokens.view(B, S, P, C))
+
+        return tokens, global_idx, intermediates
+
+
+def slice_expand_and_flatten(token_tensor, B, S):
+    """
+    Processes specialized tokens with shape (1, 2, X, C) for multi-frame processing:
+    1) Uses the first position (index=0) for the first frame only
+    2) Uses the second position (index=1) for all remaining frames (S-1 frames)
+    3) Expands both to match batch size B
+    4) Concatenates to form (B, S, X, C) where each sequence has 1 first-position token
+       followed by (S-1) second-position tokens
+    5) Flattens to (B*S, X, C) for processing
+
+    Returns:
+        torch.Tensor: Processed tokens with shape (B*S, X, C)
+    """
+
+    # Slice out the "query" tokens => shape (1, 1, ...)
+    query = token_tensor[:, 0:1, ...].expand(B, 1, *token_tensor.shape[2:])
+    # Slice out the "other" tokens => shape (1, S-1, ...)
+    others = token_tensor[:, 1:, ...].expand(B, S - 1, *token_tensor.shape[2:])
+    # Concatenate => shape (B, S, ...)
+    combined = torch.cat([query, others], dim=1)
+
+    # Finally flatten => shape (B*S, ...)
+    combined = combined.view(B * S, *combined.shape[2:])
+    return combined
+
+
+def slice_expand_and_flatten_single(token_tensor, B, S):
+    """
+    Processes specialized tokens with shape (1, 2, X, C) for multi-frame processing:
+    1) Uses the first position (index=0) for the first frame only
+    2) Uses the second position (index=1) for all remaining frames (S-1 frames)
+    3) Expands both to match batch size B
+    4) Concatenates to form (B, S, X, C) where each sequence has 1 first-position token
+       followed by (S-1) second-position tokens
+    5) Flattens to (B*S, X, C) for processing
+
+    Returns:
+        torch.Tensor: Processed tokens with shape (B*S, X, C)
+    """
+
+    # Slice out the "query" tokens => shape (1, 1, ...)
+    token = token_tensor.expand(B, S, *token_tensor.shape[2:])
+
+    # Finally flatten => shape (B*S, ...)
+    token = token.view(B * S, 1, *token.shape[2:])
+    return token

dpm/decoder.py

@@ -0,0 +1,416 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE-VGGT file in the root directory of this source tree.
+
+import logging
+import torch
+from torch import nn, Tensor
+from torch.utils.checkpoint import checkpoint
+from typing import List, Callable
+from dataclasses import dataclass
+
+from einops import repeat
+
+from vggt.layers.block import drop_add_residual_stochastic_depth
+from vggt.layers.rope import RotaryPositionEmbedding2D, PositionGetter
+
+from vggt.layers.attention import Attention
+from vggt.layers.drop_path import DropPath
+from vggt.layers.layer_scale import LayerScale
+from vggt.layers.mlp import Mlp
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModulationOut:
+    shift: Tensor
+    scale: Tensor
+    gate: Tensor
+
+
+class Modulation(nn.Module):
+    def __init__(self, dim: int, double: bool):
+        super().__init__()
+        self.is_double = double
+        self.multiplier = 6 if double else 3
+        self.lin = nn.Linear(dim, self.multiplier * dim, bias=True)
+
+    def forward(self, vec: Tensor) -> tuple[ModulationOut, ModulationOut | None]:
+        out = self.lin(nn.functional.silu(vec))[:, None, :].chunk(self.multiplier, dim=-1)
+
+        return (
+            ModulationOut(*out[:3]),
+            ModulationOut(*out[3:]) if self.is_double else None,
+        )
+
+
+class ConditionalBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = True,
+        proj_bias: bool = True,
+        ffn_bias: bool = True,
+        drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values=None,
+        drop_path: float = 0.0,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+        attn_class: Callable[..., nn.Module] = Attention,
+        ffn_layer: Callable[..., nn.Module] = Mlp,
+        qk_norm: bool = False,
+        fused_attn: bool = True,  # use F.scaled_dot_product_attention or not
+        rope=None,
+    ) -> None:
+        super().__init__()
+
+        self.norm1 = norm_layer(dim, elementwise_affine=False)
+        self.modulation = Modulation(dim, double=False)
+
+        self.attn = attn_class(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            proj_bias=proj_bias,
+            attn_drop=attn_drop,
+            proj_drop=drop,
+            qk_norm=qk_norm,
+            fused_attn=fused_attn,
+            rope=rope,
+        )
+
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = ffn_layer(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_layer=act_layer,
+            drop=drop,
+            bias=ffn_bias,
+        )
+        self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.sample_drop_ratio = drop_path
+
+    def forward(self, x: Tensor, pos=None, cond=None, is_global=False) -> Tensor:
+        B, S = cond.shape[:2]
+        C = x.shape[-1]
+        if is_global:
+            P = x.shape[1] // S
+        cond = cond.view(B * S, C)
+        mod, _ = self.modulation(cond)
+
+        def attn_residual_func(x: Tensor, pos=None) -> Tensor:
+            """
+            conditional attention following DiT implementation from Flux
+            https://github.com/black-forest-labs/flux/blob/main/src/flux/modules/layers.py#L194-L239
+            """
+            def prepare_for_mod(y):
+                """reshape to modulate the patch tokens with correct conditioning one"""
+                return y.view(B, S, P, C).view(B * S, P, C) if is_global else y
+            def restore_after_mod(y):
+                """reshape back to global sequence"""
+                return y.view(B, S, P, C).view(B, S * P, C) if is_global else y
+
+            x = prepare_for_mod(x)
+            x = (1 + mod.scale) * self.norm1(x) + mod.shift
+            x = restore_after_mod(x)
+
+            x = self.attn(x, pos=pos)
+
+            x = prepare_for_mod(x)
+            x = mod.gate * x
+            x = restore_after_mod(x)
+
+            return x
+
+        def ffn_residual_func(x: Tensor) -> Tensor:
+            return self.ls2(self.mlp(self.norm2(x)))
+
+        if self.training and self.sample_drop_ratio > 0.1:
+            # the overhead is compensated only for a drop path rate larger than 0.1
+            x = drop_add_residual_stochastic_depth(
+                x,
+                pos=pos,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+        elif self.training and self.sample_drop_ratio > 0.0:
+            x = x + self.drop_path1(attn_residual_func(x, pos=pos))
+            x = x + self.drop_path1(ffn_residual_func(x))  # FIXME: drop_path2
+        else:
+            x = x + attn_residual_func(x, pos=pos)
+            x = x + ffn_residual_func(x)
+        return x
+
+
+class Decoder(nn.Module):
+    """Attention blocks after encoder per DPT input feature
+    to generate point maps at a given time.
+    """
+
+    def __init__(
+        self,
+        cfg,
+        dim_in: int,
+        intermediate_layer_idx: List[int] = [4, 11, 17, 23],
+        patch_size=14,
+        embed_dim=1024,
+        depth=2,
+        num_heads=16,
+        mlp_ratio=4.0,
+        block_fn=ConditionalBlock,
+        qkv_bias=True,
+        proj_bias=True,
+        ffn_bias=True,
+        aa_order=["frame", "global"],
+        aa_block_size=1,
+        qk_norm=True,
+        rope_freq=100,
+        init_values=0.01,
+    ):
+        super().__init__()
+        self.cfg = cfg
+        self.intermediate_layer_idx = intermediate_layer_idx
+
+        self.depth = depth
+        self.aa_order = aa_order
+        self.patch_size = patch_size
+        self.aa_block_size = aa_block_size
+
+        # Validate that depth is divisible by aa_block_size
+        if self.depth % self.aa_block_size != 0:
+            raise ValueError(f"depth ({depth}) must be divisible by aa_block_size ({aa_block_size})")
+
+        self.aa_block_num = self.depth // self.aa_block_size
+
+        self.rope = (
+            RotaryPositionEmbedding2D(frequency=rope_freq) if rope_freq > 0 else None
+        )
+        self.position_getter = PositionGetter() if self.rope is not None else None
+
+        self.dim_in = dim_in
+
+        self.old_decoder = False
+        if self.old_decoder:
+            self.frame_blocks = nn.ModuleList(
+                [
+                    block_fn(
+                        dim=embed_dim*2,
+                        num_heads=num_heads,
+                        mlp_ratio=mlp_ratio,
+                        qkv_bias=qkv_bias,
+                        proj_bias=proj_bias,
+                        ffn_bias=ffn_bias,
+                        init_values=init_values,
+                        qk_norm=qk_norm,
+                        rope=self.rope,
+                    )
+                    for _ in range(depth)
+                ]
+            )
+            self.global_blocks = nn.ModuleList(
+                [
+                    block_fn(
+                        dim=embed_dim*2,
+                        num_heads=num_heads,
+                        mlp_ratio=mlp_ratio,
+                        qkv_bias=qkv_bias,
+                        proj_bias=proj_bias,
+                        ffn_bias=ffn_bias,
+                        init_values=init_values,
+                        qk_norm=qk_norm,
+                        rope=self.rope,
+                    )
+                    for _ in range(depth)
+                ]
+            )
+        else:
+            depths = [depth]
+            self.frame_blocks = nn.ModuleList([
+                nn.ModuleList([
+                    block_fn(
+                        dim=embed_dim*2,
+                        num_heads=num_heads,
+                        mlp_ratio=mlp_ratio,
+                        qkv_bias=qkv_bias,
+                        proj_bias=proj_bias,
+                        ffn_bias=ffn_bias,
+                        init_values=init_values,
+                        qk_norm=qk_norm,
+                        rope=self.rope,
+                    )
+                    for _ in range(d)
+                ])
+                for d in depths
+            ])
+
+            self.global_blocks = nn.ModuleList([
+                nn.ModuleList([
+                    block_fn(
+                        dim=embed_dim*2,
+                        num_heads=num_heads,
+                        mlp_ratio=mlp_ratio,
+                        qkv_bias=qkv_bias,
+                        proj_bias=proj_bias,
+                        ffn_bias=ffn_bias,
+                        init_values=init_values,
+                        qk_norm=qk_norm,
+                        rope=self.rope,
+                    )
+                    for _ in range(d)
+                ])
+                for d in depths
+            ])
+
+        self.use_reentrant = False # hardcoded to False
+
+    def get_condition_tokens(
+        self,
+        aggregated_tokens_list: List[torch.Tensor],
+        cond_view_idxs: torch.Tensor
+    ):
+        # Use tokens from the last block for conditioning
+        tokens_last = aggregated_tokens_list[-1]  # [B S N_tok D]
+        # Extract the camera tokens
+        cond_token_idx = 1
+        camera_tokens = tokens_last[:, :, [cond_token_idx]]  # [B S D]
+
+        cond_view_idxs = cond_view_idxs.to(camera_tokens.device)
+        cond_view_idxs = repeat(
+            cond_view_idxs,
+            "b s -> b s c d",
+            c=camera_tokens.shape[2],
+            d=camera_tokens.shape[3],
+        )
+        cond_tokens = torch.gather(camera_tokens, 1, cond_view_idxs)
+
+        return cond_tokens
+
+    def forward(
+        self,
+        images: torch.Tensor,
+        aggregated_tokens_list: List[torch.Tensor],
+        patch_start_idx: int,
+        cond_view_idxs: torch.Tensor,
+    ):
+        B, S, _, H, W = images.shape
+
+        cond_tokens = self.get_condition_tokens(
+            aggregated_tokens_list, cond_view_idxs
+        )
+
+        input_tokens = []
+        for k, layer_idx in enumerate(self.intermediate_layer_idx):
+            layer_tokens = aggregated_tokens_list[layer_idx].clone()
+            input_tokens.append(layer_tokens)
+
+        _, _, P, C = input_tokens[0].shape
+
+        pos = None
+        if self.rope is not None:
+            pos = self.position_getter(
+                B * S, H // self.patch_size, W // self.patch_size, device=images.device
+            )
+        if patch_start_idx > 0:
+            # do not use position embedding for special tokens (camera and register tokens)
+            # so set pos to 0 for the special tokens
+            pos = pos + 1
+            pos_special = torch.zeros(B * S, patch_start_idx, 2).to(images.device).to(pos.dtype)
+            pos = torch.cat([pos_special, pos], dim=1)
+
+        frame_idx = 0
+        global_idx = 0
+        depth = len(self.frame_blocks[0])
+        N = len(input_tokens)
+        # stack all intermediate layer tokens along batch dimension
+        # they are all processed by the same decoder
+        s_tokens = torch.cat(input_tokens)
+        s_cond_tokens = torch.cat([cond_tokens] * N, dim=0)
+        s_pos = torch.cat([pos] * N, dim=0)
+
+        # perform time conditioned attention
+        for _ in range(depth):
+            for attn_type in self.aa_order:
+                token_idx = 0
+
+                if attn_type == "frame":
+                    s_tokens, frame_idx, _ = self._process_frame_attention(
+                        s_tokens, s_cond_tokens, B * N, S, P, C, frame_idx, pos=s_pos, token_idx=token_idx
+                    )
+                elif attn_type == "global":
+                    s_tokens, global_idx, _ = self._process_global_attention(
+                        s_tokens, s_cond_tokens, B * N, S, P, C, global_idx, pos=s_pos, token_idx=token_idx
+                    )
+                else:
+                    raise ValueError(f"Unknown attention type: {attn_type}")
+        processed = [t.view(B, S, P, C) for t in s_tokens.split(B, dim=0)]
+
+        return processed
+
+    def _process_frame_attention(self, tokens, cond_tokens, B, S, P, C, frame_idx, pos=None, token_idx=0):
+        """
+        Process frame attention blocks. We keep tokens in shape (B*S, P, C).
+        """
+        # If needed, reshape tokens or positions:
+        if tokens.shape != (B * S, P, C):
+            tokens = tokens.view(B, S, P, C).view(B * S, P, C)
+
+        if pos is not None and pos.shape != (B * S, P, 2):
+            pos = pos.view(B, S, P, 2).view(B * S, P, 2)
+
+        intermediates = []
+        # by default, self.aa_block_size=1, which processes one block at a time
+        for _ in range(self.aa_block_size):
+            if self.training:
+                tokens = checkpoint(self.frame_blocks[token_idx][frame_idx], tokens, pos, cond_tokens, use_reentrant=self.use_reentrant)
+            else:
+                if self.old_decoder:
+                    tokens = self.frame_blocks[frame_idx](tokens, pos=pos, cond=cond_tokens)
+                else:
+                    tokens = self.frame_blocks[0][frame_idx](tokens, pos=pos, cond=cond_tokens)
+
+            frame_idx += 1
+            intermediates.append(tokens.view(B, S, P, C))
+
+        return tokens, frame_idx, intermediates
+
+    def _process_global_attention(self, tokens, cond_tokens, B, S, P, C, global_idx, pos=None, token_idx=0):
+        """
+        Process global attention blocks. We keep tokens in shape (B, S*P, C).
+        """
+        if tokens.shape != (B, S * P, C):
+            tokens = tokens.view(B, S, P, C).view(B, S * P, C)
+
+        if pos is not None and pos.shape != (B, S * P, 2):
+            pos = pos.view(B, S, P, 2).view(B, S * P, 2)
+
+        intermediates = []
+
+        # by default, self.aa_block_size=1, which processes one block at a time
+        for _ in range(self.aa_block_size):
+            if self.training:
+                tokens = checkpoint(self.global_blocks[token_idx][global_idx], tokens, pos, cond_tokens, True, use_reentrant=self.use_reentrant)
+            else:
+                if self.old_decoder:
+                    tokens = self.global_blocks[global_idx](tokens, pos=pos, cond=cond_tokens, is_global=True)
+                else:
+                    tokens = self.global_blocks[0][global_idx](tokens, pos=pos, cond=cond_tokens, is_global=True)
+            global_idx += 1
+            intermediates.append(tokens.view(B, S, P, C))
+
+        return tokens, global_idx, intermediates

dpm/model.py

@@ -0,0 +1,149 @@
+import torch
+import torch.nn as nn
+
+from vggt.heads.camera_head import CameraHead
+from vggt.heads.dpt_head import DPTHead
+
+from .aggregator import Aggregator
+from .decoder import Decoder
+
+
+def freeze_all_params(modules):
+    for module in modules:
+        try:
+            for n, param in module.named_parameters():
+                param.requires_grad = False
+        except AttributeError:
+            # module is directly a parameter
+            module.requires_grad = False
+
+
+class VDPM(nn.Module):
+    def __init__(self, cfg, img_size=518, patch_size=14, embed_dim=1024):
+        super().__init__()
+        self.cfg = cfg
+
+        self.aggregator = Aggregator(
+            img_size=img_size,
+            patch_size=patch_size,
+            embed_dim=embed_dim,
+        )
+        self.decoder = Decoder(
+            cfg,
+            dim_in=2*embed_dim,
+            embed_dim=embed_dim,
+            depth=cfg.model.decoder_depth
+        )
+        self.point_head = DPTHead(dim_in=2 * embed_dim, output_dim=4, activation="inv_log", conf_activation="expp1")
+
+        self.camera_head = CameraHead(dim_in=2 * embed_dim)
+        self.set_freeze()
+
+    def set_freeze(self):
+        to_be_frozen = [self.aggregator.patch_embed]
+        freeze_all_params(to_be_frozen)
+
+    def forward(
+        self,
+        views, autocast_dpt=None
+    ):
+        images = torch.stack([view["img"] for view in views], dim=1)
+        aggregated_tokens_list, patch_start_idx = self.aggregator(images)
+
+        res_dynamic = dict()
+
+        if self.decoder is not None:
+            cond_view_idxs = torch.stack([view["view_idxs"][:, 1] for view in views], dim=1)
+            decoded_tokens = self.decoder(images, aggregated_tokens_list, patch_start_idx, cond_view_idxs)
+
+        if autocast_dpt is None:
+            autocast_dpt = torch.amp.autocast("cuda", enabled=False)
+
+        with autocast_dpt:
+            pts3d, pts3d_conf = self.point_head(
+                aggregated_tokens_list, images, patch_start_idx
+            )
+
+            padded_decoded_tokens = [None] * len(aggregated_tokens_list)
+            for idx, layer_idx in enumerate(self.point_head.intermediate_layer_idx):
+                padded_decoded_tokens[layer_idx] = decoded_tokens[idx]
+            pts3d_dyn, pts3d_dyn_conf = self.point_head(
+                padded_decoded_tokens, images, patch_start_idx
+            )
+
+            res_dynamic |= {
+                "pts3d": pts3d_dyn,
+                "conf": pts3d_dyn_conf
+            }
+
+            pose_enc_list = self.camera_head(aggregated_tokens_list)
+            res_dynamic |= {"pose_enc_list": pose_enc_list}
+
+        res_static = dict(
+            pts3d=pts3d,
+            conf=pts3d_conf
+        )
+        return res_static, res_dynamic
+
+    def inference(
+        self,
+        views,
+        images=None,
+        num_timesteps=None
+    ):
+        autocast_amp = torch.amp.autocast("cuda", enabled=True, dtype=torch.bfloat16)
+
+        if images is None:
+            images = torch.stack([view["img"] for view in views], dim=1)
+
+        with autocast_amp:
+            aggregated_tokens_list, patch_start_idx = self.aggregator(images)
+        S = images.shape[1]
+
+        # Determine number of timesteps to query
+        if num_timesteps is None:
+             # Default to S if not specified (legacy behavior)
+             # But if views has indices, try to infer max time
+            if views is not None and "view_idxs" in views[0]:
+                try:
+                    all_idxs = torch.cat([v["view_idxs"][:, 1] for v in views])
+                    num_timesteps = int(all_idxs.max().item()) + 1
+                except:
+                    num_timesteps = S
+            else:
+                num_timesteps = S
+
+        predictions = dict()
+        pointmaps = []
+        ones = torch.ones(1, S, dtype=torch.int64)
+        for time_ in range(num_timesteps):
+            cond_view_idxs = ones * time_
+
+            with autocast_amp:
+                decoded_tokens = self.decoder(images, aggregated_tokens_list, patch_start_idx, cond_view_idxs)
+            padded_decoded_tokens = [None] * len(aggregated_tokens_list)
+            for idx, layer_idx in enumerate(self.point_head.intermediate_layer_idx):
+                padded_decoded_tokens[layer_idx] = decoded_tokens[idx]
+            
+            # ... existing code ...
+
+            pts3d, pts3d_conf = self.point_head(
+                padded_decoded_tokens, images, patch_start_idx
+            )
+
+            pointmaps.append(dict(
+                pts3d=pts3d,
+                conf=pts3d_conf
+            ))
+
+        pose_enc_list = self.camera_head(aggregated_tokens_list)
+        predictions["pose_enc"] = pose_enc_list[-1]  # pose encoding of the last iteration
+        predictions["pose_enc_list"] = pose_enc_list
+        predictions["pointmaps"] = pointmaps
+        return predictions
+
+    def load_state_dict(self, ckpt, is_VGGT_static=False, **kw):
+        # don't load these VGGT heads as not needed
+        exclude = ["depth_head", "track_head"]
+        ckpt = {k:v for k, v in ckpt.items() if k.split('.')[0] not in exclude}
+        return super().load_state_dict(ckpt, **kw)

examples/videos/camel.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3db92c240efbd1b97a466565988a9a06687fd422086656dc0a29e12c5b99b9bb
+size 1301172

examples/videos/car.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd74efdb4d4d59fc17356fefa5dadd4c5b787641c98ce3172ecd8e5a180e76a6
+size 1015132

examples/videos/figure1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae285726e5d247e904bb1ea7887ee96733c0beea913b421abba39150a3299cd5
+size 465850

examples/videos/figure2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b2b030dd564cffbb9b2795e7fcdf97fa50e3a518df5b71dfb3dfb36f431dfa4
+size 516209

examples/videos/figure3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a4144a53f14bd2dc671376d26ecbb42b06c9b8810e1700f21a16d3e11dfbf5c
+size 559096

examples/videos/goldfish.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28912e59d0d9e6b20d26973efee4806e89e115c7f1e63aec7206384ac3d0bf78
+size 668862

examples/videos/horse.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8227c7d901a936aeab6a2b41f104dd17e5544315d4cde7dac37f5787319947e7
+size 1223145

examples/videos/paragliding.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acab90bf2ac105ac0a263559722503e7e7a09aed22164d83cb8b3a5ca1d1504d
+size 814941

examples/videos/pstudio.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12a598cce787ce9b39c2e4abd33c28e1223b59823258287f3a6f5ffb8abe3b47
+size 167366

examples/videos/stroller.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7a88fc629c994bb0067535e181226519ad0750df0d1decbddd01a3e7c5d3c92
+size 1137267

examples/videos/swing.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11d0cb318514b326ac2ed94d0765e29181d58401a84d64aa57ddd4cb1e865dcc
+size 812797

examples/videos/tennis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50bee7fd257e38c66765a82412734be5abacbe30aa9e9ba04f5387b7865a380e
+size 467310

examples/videos/tesla.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c74333ee25fdb87d26a5a8db080d64d51edc418bab56f3aae98792ad4dee2704
+size 588952

gradio_demo.py

@@ -0,0 +1,981 @@
+import gc
+import glob
+import os
+import shutil
+import sys
+import time
+from datetime import datetime
+
+import cv2
+import gradio as gr
+import matplotlib
+import numpy as np
+import plotly.graph_objects as go
+import torch
+from hydra import compose, initialize
+from hydra.core.global_hydra import GlobalHydra
+
+from dpm.model import VDPM
+from vggt.utils.load_fn import load_and_preprocess_images
+
+
+# ============================================================================
+# MEMORY OPTIMIZATION SETTINGS FOR 8GB GPUs (RTX 3070 Ti, 3060 Ti, etc.)
+# ============================================================================
+# Model size: 1.66B parameters (~3GB FP16 weights, ~12GB total with activations)
+# 
+# Memory reduction options (choose one):
+#   USE_HALF_PRECISION = True: FP16 model -> ~1.5GB weights, ~6-7GB total (RECOMMENDED FOR GPU)
+#   USE_QUANTIZATION = True:  INT8 quantization -> CPU ONLY, not supported on CUDA
+#   Both False: FP16/BF16 inference only -> ~3GB weights, ~8-10GB total (may OOM)
+#
+# MAX_FRAMES: Limit input frames (5 recommended for 8GB GPUs)
+# ============================================================================
+
+MAX_POINTS_PER_FRAME = 50_000
+TRAIL_LENGTH = 20
+MAX_TRACKS = 150
+STATIC_THRESHOLD = 0.025
+VIDEO_SAMPLE_HZ = 1.0
+
+# Dynamic Configuration based on Helper/Hardware
+USE_QUANTIZATION = False 
+USE_HALF_PRECISION = True
+MAX_FRAMES = 5  # Default for 8GB
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+if device == "cuda":
+    # Enable TF32
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    
+    # Check VRAM to auto-scale MAX_FRAMES
+    vram_bytes = torch.cuda.get_device_properties(0).total_memory
+    vram_gb = vram_bytes / (1024**3)
+    
+    print(f"\u2713 GPU Detected: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
+    
+    if vram_gb > 22: # A10G (24GB), A100 (40/80GB), RTX 3090/4090 (24GB)
+        MAX_FRAMES = 80
+        print(f"   -> High VRAM detected! Increased MAX_FRAMES to {MAX_FRAMES}")
+    elif vram_gb > 14: # T4 (16GB), 4080 (16GB)
+        MAX_FRAMES = 16
+        print(f"   -> Medium VRAM detected! Increased MAX_FRAMES to {MAX_FRAMES}")
+    else:
+        MAX_FRAMES = 5
+        print(f"   -> Low VRAM (<14GB). Keeping MAX_FRAMES at {MAX_FRAMES} to prevent OOM")
+    print(f"\u2713 TF32 enabled for faster matrix operations")
+
+
+
+def load_cfg_from_cli() -> "omegaconf.DictConfig":
+    if GlobalHydra.instance().is_initialized():
+        GlobalHydra.instance().clear()
+    overrides = sys.argv[1:]
+    with initialize(config_path="configs"):
+        return compose(config_name="visualise", overrides=overrides)
+
+
+def load_model(cfg) -> VDPM:
+    model = VDPM(cfg).to(device)
+
+    _URL = "https://huggingface.co/edgarsucar/vdpm/resolve/main/model.pt"
+    sd = torch.hub.load_state_dict_from_url(
+        _URL,
+        file_name="vdpm_model.pt",
+        progress=True
+    )
+    print(model.load_state_dict(sd, strict=True))
+
+    model.eval()
+    
+    # Option 1: Use FP16 for all model weights (simple, ~2x memory reduction)
+    if USE_HALF_PRECISION and not USE_QUANTIZATION:
+        print("Converting model to FP16 precision...")
+        model = model.half()
+        print("✓ Model converted to FP16: ~2x memory reduction (3GB -> 1.5GB)")
+    
+    # Option 2: Apply INT8 dynamic quantization (more aggressive, ~3-4x reduction)
+    if USE_QUANTIZATION:
+        try:
+            print("Applying INT8 dynamic quantization to reduce memory usage...")
+            # Move to CPU for quantization, then back to GPU
+            model = model.cpu()
+            model = torch.quantization.quantize_dynamic(
+                model,
+                {torch.nn.Linear, torch.nn.Conv2d},  # Quantize these layer types
+                dtype=torch.qint8
+            )
+            model = model.to(device)
+            print("✓ Model quantized: ~3x memory reduction (3GB -> 1GB)")
+        except Exception as e:
+            print(f"⚠️  Quantization failed: {e}")
+            print("Continuing with FP16/BF16 precision...")
+            model = model.to(device)
+    
+    # Enable torch.compile for faster inference (PyTorch 2.0+)
+    # Note: Disable compile if using quantization as they may conflict
+    if not USE_QUANTIZATION:
+        try:
+            print("Compiling model with torch.compile for faster inference...")
+            model = torch.compile(model, mode="reduce-overhead")
+            print("✓ Model compilation successful")
+        except Exception as e:
+            print(f"Warning: torch.compile not available or failed: {e}")
+    
+    return model
+
+
+def require_cuda():
+    if device != "cuda":
+        raise ValueError("CUDA is not available. Check your environment.")
+
+
+def gradio_file_path(file_obj):
+    if file_obj is None:
+        return None
+    if isinstance(file_obj, dict) and "name" in file_obj:
+        return file_obj["name"]
+    return file_obj
+
+
+def ensure_nhwc_images(images: np.ndarray) -> np.ndarray:
+    if images.ndim == 4 and images.shape[1] == 3:
+        return np.transpose(images, (0, 2, 3, 1))
+    return images
+
+
+def compute_scene_bounds(world_points: np.ndarray):
+    all_pts = world_points.reshape(-1, 3)
+    raw_min = all_pts.min(axis=0)
+    raw_max = all_pts.max(axis=0)
+
+    center = 0.5 * (raw_min + raw_max)
+    half_extent = 0.5 * (raw_max - raw_min) * 1.05
+
+    if np.all(half_extent < 1e-6):
+        half_extent[:] = 1.0
+    else:
+        half_extent[half_extent < 1e-6] = half_extent.max()
+
+    global_min = center - half_extent
+    global_max = center + half_extent
+
+    max_half = half_extent.max()
+    aspectratio = {
+        "x": float(half_extent[0] / max_half),
+        "y": float(half_extent[1] / max_half),
+        "z": float(half_extent[2] / max_half),
+    }
+    return global_min, global_max, aspectratio
+
+
+def stride_downsample(pts: np.ndarray, cols: np.ndarray, max_points: int):
+    n = pts.shape[0]
+    if n <= max_points:
+        return pts, cols
+    step = int(np.ceil(n / max_points))
+    idx = np.arange(0, n, step)[:max_points]
+    return pts[idx], cols[idx]
+
+
+# ============================================================
+# NEW: Single shared mask function (used by points + tracks)
+# ============================================================
+def compute_point_mask(
+    conf_score: np.ndarray | None,
+    cols: np.ndarray,
+    conf_thres: float,
+    mask_black_bg: bool,
+    mask_white_bg: bool,
+) -> np.ndarray:
+    """
+    conf_score: (N,) or None
+    cols: (N,3) uint8
+    Returns: (N,) boolean mask
+    """
+    mask = np.ones(cols.shape[0], dtype=bool)
+
+    # confidence percentile threshold (same semantics as before)
+    if conf_score is not None and conf_thres > 0:
+        thresh = np.percentile(conf_score, conf_thres)
+        mask &= (conf_score >= thresh) & (conf_score > 1e-5)
+
+    # background masks (same as before)
+    if mask_black_bg:
+        mask &= (cols.sum(axis=1) >= 16)
+    if mask_white_bg:
+        mask &= ~((cols[:, 0] > 240) & (cols[:, 1] > 240) & (cols[:, 2] > 240))
+
+    return mask
+
+
+def sample_frame_points(
+    world_points: np.ndarray,
+    images_nhwc: np.ndarray,
+    conf: np.ndarray | None,
+    idx: int,
+    conf_thres: float,
+    mask_black_bg: bool,
+    mask_white_bg: bool,
+    max_points: int,
+):
+    i = int(np.clip(idx, 0, world_points.shape[0] - 1))
+    pts = world_points[i].reshape(-1, 3)
+    cols = (images_nhwc[i].reshape(-1, 3) * 255).astype(np.uint8)
+
+    conf_score = conf[i].reshape(-1) if (conf is not None) else None
+
+    mask = compute_point_mask(
+        conf_score=conf_score,
+        cols=cols,
+        conf_thres=conf_thres,
+        mask_black_bg=mask_black_bg,
+        mask_white_bg=mask_white_bg,
+    )
+
+    pts = pts[mask]
+    cols = cols[mask]
+
+    pts, cols = stride_downsample(pts, cols, max_points)
+
+    if pts.size == 0:
+        pts = np.array([[0.0, 0.0, 0.0]])
+        cols = np.array([[255, 255, 255]], dtype=np.uint8)
+
+    colors_str = [f"#{r:02x}{g:02x}{b:02x}" for r, g, b in cols]
+    return pts, colors_str
+
+
+# ============================================================
+# UPDATED: prepare_tracks now applies the SAME masks as points
+# ============================================================
+def prepare_tracks(
+    world_points: np.ndarray,
+    images_nhwc: np.ndarray,
+    conf: np.ndarray | None,
+    conf_thres: float,
+    mask_black_bg: bool,
+    mask_white_bg: bool,
+):
+    S, H, W, _ = world_points.shape
+    N = H * W
+    if S < 2 or N == 0:
+        return None, None, None
+
+    tracks_xyz = world_points.reshape(S, N, 3)
+
+    disp = np.linalg.norm(tracks_xyz - tracks_xyz[0:1], axis=-1)
+    dynamic_mask = disp.max(axis=0) > STATIC_THRESHOLD
+
+    # build a per-point confidence score (across time)
+    conf_score = None
+    if conf is not None:
+        conf_flat = conf.reshape(S, N)
+        conf_score = conf_flat.mean(axis=0)
+
+    # Use reference-frame colors for background masking (stable, consistent)
+    ref_cols = (images_nhwc[0].reshape(-1, 3) * 255).astype(np.uint8)
+
+    point_mask = compute_point_mask(
+        conf_score=conf_score,
+        cols=ref_cols,
+        conf_thres=conf_thres,
+        mask_black_bg=mask_black_bg,
+        mask_white_bg=mask_white_bg,
+    )
+
+    dynamic_mask &= point_mask
+
+    idx_tracks = np.nonzero(dynamic_mask)[0]
+    if idx_tracks.size == 0:
+        return None, None, None
+
+    if idx_tracks.size > MAX_TRACKS:
+        step = int(np.ceil(idx_tracks.size / MAX_TRACKS))
+        idx_tracks = idx_tracks[::step][:MAX_TRACKS]
+
+    tracks_xyz = tracks_xyz[:, idx_tracks, :]
+    order = np.argsort(tracks_xyz[0, :, 1])
+    tracks_xyz = tracks_xyz[:, order, :]
+
+    num_tracks = tracks_xyz.shape[1]
+    cmap = matplotlib.colormaps.get_cmap("hsv")
+    norm = matplotlib.colors.Normalize(vmin=0, vmax=max(num_tracks - 1, 1))
+
+    colorscale = []
+    for t in range(num_tracks):
+        r, g, b, _ = cmap(norm(t))
+        r, g, b = int(r * 255), int(g * 255), int(b * 255)
+        pos = t / max(num_tracks - 1, 1)
+        colorscale.append([pos, f"rgb({r},{g},{b})"])
+
+    track_ids = np.arange(num_tracks, dtype=float)
+    return tracks_xyz, colorscale, track_ids
+
+
+def track_segments_for_frame(tracks_xyz: np.ndarray | None, track_ids: np.ndarray | None, f: int):
+    if tracks_xyz is None or track_ids is None or f <= 0:
+        return np.array([]), np.array([]), np.array([]), np.array([])
+
+    start_t = max(0, f - TRAIL_LENGTH)
+    num_tracks = tracks_xyz.shape[1]
+
+    xs, ys, zs, cs = [], [], [], []
+    for j in range(num_tracks):
+        seg = tracks_xyz[start_t : f + 1, j, :]
+        if seg.shape[0] < 2:
+            continue
+
+        xs.extend([seg[:, 0], np.array([np.nan])])
+        ys.extend([seg[:, 1], np.array([np.nan])])
+        zs.extend([seg[:, 2], np.array([np.nan])])
+        cs.append(np.full(seg.shape[0] + 1, track_ids[j], dtype=float))
+
+    x = np.concatenate(xs) if xs else np.array([])
+    y = np.concatenate(ys) if ys else np.array([])
+    z = np.concatenate(zs) if zs else np.array([])
+    c = np.concatenate(cs) if cs else np.array([])
+
+    return x, y, z, c
+
+
+def build_pointcloud_figure_update(
+    data,
+    conf_thres: float,
+    mask_black_bg: bool,
+    mask_white_bg: bool,
+):
+    if data is None:
+        return go.Figure()
+
+    world_points = data["world_points"]
+    conf = data.get("world_points_conf")
+    images = ensure_nhwc_images(data["images"])
+    S = world_points.shape[0]
+
+    global_min, global_max, aspectratio = compute_scene_bounds(world_points)
+
+    # UPDATED: pass same masks into prepare_tracks
+    tracks_xyz, colorscale, track_ids = prepare_tracks(
+        world_points=world_points,
+        images_nhwc=images,
+        conf=conf,
+        conf_thres=conf_thres,
+        mask_black_bg=mask_black_bg,
+        mask_white_bg=mask_white_bg,
+    )
+    track_cmax = max(len(track_ids) - 1, 1) if track_ids is not None else 1
+
+    pts_xyz = [None] * S
+    pts_cols = [None] * S
+    trk_xyz = [None] * S
+    trk_c = [None] * S
+
+    for i in range(S):
+        pts_i, cols_i = sample_frame_points(
+            world_points=world_points,
+            images_nhwc=images,
+            conf=conf,
+            idx=i,
+            conf_thres=conf_thres,
+            mask_black_bg=mask_black_bg,
+            mask_white_bg=mask_white_bg,
+            max_points=MAX_POINTS_PER_FRAME,
+        )
+        pts_xyz[i] = pts_i
+        pts_cols[i] = cols_i
+
+        x, y, z, c = track_segments_for_frame(tracks_xyz, track_ids, f=i)
+        trk_xyz[i] = (x, y, z)
+        trk_c[i] = c
+
+    p0 = pts_xyz[0]
+    c0 = pts_cols[0]
+    x0, y0, z0 = trk_xyz[0]
+    tc0 = trk_c[0]
+
+    scene_cfg = dict(
+        xaxis=dict(
+            visible=False,
+            showbackground=False,
+            showgrid=False,
+            zeroline=False,
+            showticklabels=False,
+            range=[float(global_min[0]), float(global_max[0])],
+        ),
+        yaxis=dict(
+            visible=False,
+            showbackground=False,
+            showgrid=False,
+            zeroline=False,
+            showticklabels=False,
+            range=[float(global_min[1]), float(global_max[1])],
+        ),
+        zaxis=dict(
+            visible=False,
+            showbackground=False,
+            showgrid=False,
+            zeroline=False,
+            showticklabels=False,
+            range=[float(global_min[2]), float(global_max[2])],
+        ),
+        aspectmode="manual",
+        aspectratio=aspectratio,
+        dragmode="orbit",
+        camera=dict(
+            eye=dict(x=0.0, y=0.0, z=-1.0),
+            center=dict(x=0.0, y=0.0, z=0.0),
+            up=dict(x=0.0, y=-1.0, z=0.0),
+        ),
+    )
+
+    fig = go.Figure(
+        data=[
+            go.Scatter3d(
+                x=p0[:, 0],
+                y=p0[:, 1],
+                z=p0[:, 2],
+                mode="markers",
+                marker=dict(size=2, color=c0),
+                showlegend=False,
+                name="points",
+            ),
+            go.Scatter3d(
+                x=x0,
+                y=y0,
+                z=z0,
+                mode="lines",
+                line=dict(
+                    width=2,
+                    color=tc0 if (tc0 is not None and tc0.size) else None,
+                    colorscale=colorscale if colorscale is not None else None,
+                    cmin=0,
+                    cmax=track_cmax,
+                ),
+                hoverinfo="skip",
+                showlegend=False,
+                name="tracks",
+            ),
+        ]
+    )
+
+    steps = []
+    for i in range(S):
+        pi = pts_xyz[i]
+        ci = pts_cols[i]
+        xi, yi, zi = trk_xyz[i]
+        ti = trk_c[i]
+
+        steps.append(
+            dict(
+                method="update",
+                label=str(i),
+                args=[
+                    {
+                        "x": [pi[:, 0], xi],
+                        "y": [pi[:, 1], yi],
+                        "z": [pi[:, 2], zi],
+                        "marker.color": [ci, None],
+                        "line.color": [None, ti if (ti is not None and len(ti)) else None],
+                    },
+                    {},
+                ],
+            )
+        )
+
+    sliders = [
+        dict(
+            active=0,
+            currentvalue={"prefix": "Frame: ", "visible": True, "font": {"size": 14}},
+            pad={"t": 10},
+            len=0.6,
+            x=0.2,
+            font={"size": 8},
+            steps=steps,
+        )
+    ]
+
+    fig.update_layout(
+        margin=dict(l=0, r=0, t=30, b=0),
+        scene=scene_cfg,
+        sliders=sliders,
+        showlegend=False,
+        title="Scrub frames with the slider below",
+        uirevision="keep-camera",
+        height=700,
+    )
+    return fig
+
+
+def run_model(target_dir: str, model: VDPM, frame_id_arg=0) -> dict:
+    require_cuda()
+
+    image_names = sorted(glob.glob(os.path.join(target_dir, "images", "*")))
+    if not image_names:
+        raise ValueError("No images found. Check your upload.")
+
+    # Load metadata for Multi-View sync (Load BEFORE slicing to respect view count)
+    meta_path = os.path.join(target_dir, "meta.json")
+    num_views = 1
+    if os.path.exists(meta_path):
+        try:
+            import json
+            with open(meta_path, 'r') as f:
+                num_views = json.load(f).get("num_views", 1)
+        except:
+            pass
+
+    # Limit frames to prevent OOM on 8GB GPUs
+    if len(image_names) > MAX_FRAMES:
+        # Round down to nearest multiple of num_views to preserve full scenes
+        limit = (MAX_FRAMES // num_views) * num_views
+        if limit == 0:
+            limit = num_views # At least one full timestep
+            print(f"⚠️  Warning: MAX_FRAMES={MAX_FRAMES} is smaller than num_views={num_views}. Processing 1 full timestep anyway (may OOM).")
+        
+        print(f"⚠️  Limiting to {limit} frames ({limit // num_views} timesteps * {num_views} views) to fit in GPU memory")
+        image_names = image_names[:limit]
+
+    images = load_and_preprocess_images(image_names).to(device)
+
+    if device == "cuda":
+        print(f"GPU memory before inference: {torch.cuda.memory_allocated() / 1024**3:.2f} GB / {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+    
+    print(f"Running inference on {len(image_names)} images ({num_views} synchronized views)...")
+    
+    # Construct 'views' dictionaries with correct time indices
+    views = []
+    for i in range(len(image_names)):
+        t_idx = i // num_views
+        views.append({
+            "img": images[i].unsqueeze(0), # (1, C, H, W)
+            "view_idxs": torch.tensor([[0, t_idx]], device=device, dtype=torch.long)
+        })
+
+    inference_start = time.time()
+    
+    with torch.no_grad():
+        with torch.amp.autocast('cuda'):
+            # Pass constructed views so model uses correct time query
+            predictions = model.inference(views=views)
+    
+    inference_time = time.time() - inference_start
+    print(f"✓ Inference completed in {inference_time:.2f}s ({inference_time/len(image_names):.2f}s per frame)")
+
+    # Move results to CPU immediately to free GPU memory
+    pts_list = [pm["pts3d"].detach().cpu().numpy() for pm in predictions["pointmaps"]]
+    conf_list = [pm["conf"].detach().cpu().numpy() for pm in predictions["pointmaps"]]
+    
+    # Clear predictions from GPU to save memory
+    del predictions
+    if device == "cuda":
+        torch.cuda.empty_cache()
+        print(f"GPU memory after inference: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+
+    world_points = np.concatenate(pts_list, axis=0)
+    world_points_conf = np.concatenate(conf_list, axis=0)
+
+    try:
+        frame_id = int(frame_id_arg)
+    except Exception:
+        frame_id = 0
+
+    if frame_id >= world_points.shape[0]:
+        frame_id = 0
+
+    world_points_s = world_points[:, frame_id, ::2, ::2, :]
+    single_mask = world_points_conf[frame_id, frame_id, ::2, ::2]
+    world_points_conf_s = np.tile(single_mask[np.newaxis, ...], (world_points.shape[0], 1, 1))
+
+    img_np = images.detach().cpu().numpy()
+    img_np = img_np[frame_id : frame_id + 1, :, ::2, ::2]
+    img_np = np.repeat(img_np, world_points.shape[0], axis=0)
+
+    torch.cuda.empty_cache()
+    return {
+        "world_points": world_points_s,
+        "world_points_conf": world_points_conf_s,
+        "images": img_np,
+    }
+
+
+def handle_uploads(input_video, input_images):
+    start_time = time.time()
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    target_dir = f"input_images_{timestamp}"
+    target_dir_images = os.path.join(target_dir, "images")
+
+    if os.path.exists(target_dir):
+        shutil.rmtree(target_dir)
+    os.makedirs(target_dir_images, exist_ok=True)
+
+    image_paths = []
+
+    if input_images:
+        for file_obj in input_images:
+            src = gradio_file_path(file_obj)
+            if not src:
+                continue
+            dst = os.path.join(target_dir_images, os.path.basename(src))
+            shutil.copy(src, dst)
+            image_paths.append(dst)
+
+    if input_video:
+        # Check if input is a list (Gradio 4.x/5.x or file_count="multiple")
+        input_video_list = input_video if isinstance(input_video, list) else [input_video]
+        
+        # Determine starting frame number based on existing images
+        existing_files = os.listdir(target_dir_images)
+        frame_num = len(existing_files)
+        
+        # Modified for Interleaved/Synchronized processing
+        # 1. Open all videos
+        captures = []
+        capture_meta = []
+        for idx, vid_obj in enumerate(input_video_list):
+            video_path = gradio_file_path(vid_obj)
+            print(f"Preparing video {idx+1}/{len(input_video_list)}: {video_path}")
+            
+            vs = cv2.VideoCapture(video_path)
+            fps = float(vs.get(cv2.CAP_PROP_FPS) or 0.0)
+            if fps <= 0: fps = 30.0 # Fallback
+            
+            frame_interval = max(int(fps / max(VIDEO_SAMPLE_HZ, 1e-6)), 1)
+            captures.append(vs)
+            capture_meta.append({"interval": frame_interval, "name": video_path})
+            
+        # 2. Step through them together
+        print("Processing videos in interleaved mode...")
+        step_count = 0
+        active_videos = True
+        
+        while active_videos:
+            active_videos = False
+            for i, vs in enumerate(captures):
+                if not vs.isOpened():
+                    continue
+                
+                gotit, frame = vs.read()
+                if gotit:
+                    active_videos = True # Keep going as long as at least one video has frames
+                    
+                    if step_count % capture_meta[i]["interval"] == 0:
+                        out_path = os.path.join(target_dir_images, f"{frame_num:06}.png")
+                        cv2.imwrite(out_path, frame)
+                        image_paths.append(out_path)
+                        frame_num += 1
+                else:
+                    vs.release()
+            
+            step_count += 1
+
+
+    image_paths.sort()
+    
+    # Save metadata about capture structure (num_views)
+    num_views = len(input_video_list) if input_video else 1
+    meta_path = os.path.join(target_dir, "meta.json")
+    try:
+        import json
+        with open(meta_path, 'w') as f:
+            json.dump({"num_views": num_views}, f)
+    except Exception as e:
+        print(f"Warning: could not save metadata: {e}")
+
+    print(f"Files copied to {target_dir_images}; took {time.time() - start_time:.3f} seconds")
+    return target_dir, image_paths
+
+
+def update_gallery_on_upload(input_video, input_images):
+    if not input_video and not input_images:
+        return None, None, None, None
+    target_dir, image_paths = handle_uploads(input_video, input_images)
+    return None, target_dir, image_paths, "Upload complete. Click 'Reconstruct' to begin 3D processing."
+
+
+def gradio_reconstruct(
+    target_dir,
+    conf_thres=50.0,
+    mask_black_bg=False,
+    mask_white_bg=False,
+    frame_id_val=0,
+):
+    if not os.path.isdir(target_dir) or target_dir == "None":
+        return None, "No valid target directory found. Please upload first.", None
+
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    target_dir_images = os.path.join(target_dir, "images")
+    num_frames = len(os.listdir(target_dir_images)) if os.path.isdir(target_dir_images) else 0
+
+    with torch.no_grad():
+        predictions = run_model(target_dir, model, frame_id_val)
+
+    fig = build_pointcloud_figure_update(predictions, conf_thres, mask_black_bg, mask_white_bg)
+
+    torch.cuda.empty_cache()
+    msg = f"Reconstruction Success ({num_frames} frames processed, showing frame {frame_id_val})."
+    return fig, msg, predictions
+
+
+def update_plot(
+    target_dir,
+    predictions,
+    conf_thres,
+    mask_black_bg,
+    mask_white_bg,
+    is_example,
+):
+    if is_example == "True" or predictions is None:
+        return None, "No reconstruction available. Please click the Reconstruct button first."
+
+    fig = build_pointcloud_figure_update(predictions, conf_thres, mask_black_bg, mask_white_bg)
+    return fig, "Updated visualization with new settings. Use the slider below the plot to scrub frames."
+
+
+def clear_fields():
+    return None
+
+
+def update_log():
+    return "Loading and Reconstructing..."
+
+
+def example_pipeline(
+    input_video_ex,
+    num_images_str,
+    input_images_ex,
+    conf_thres_val,
+    mask_black_bg_val,
+    mask_white_bg_val,
+    is_example_str,
+    frame_id_val,
+):
+    target_dir, image_paths = handle_uploads(input_video_ex, input_images_ex)
+    fig, log_msg, predictions = gradio_reconstruct(
+        target_dir,
+        conf_thres_val,
+        mask_black_bg_val,
+        mask_white_bg_val,
+        frame_id_val,
+    )
+    return fig, log_msg, target_dir, predictions, image_paths
+
+
+colosseum_video = "examples/videos/Colosseum.mp4"
+camel_video = "examples/videos/camel.mp4"
+tennis_video = "examples/videos/tennis.mp4"
+paragliding_video = "examples/videos/paragliding.mp4"
+stroller_video = "examples/videos/stroller.mp4"
+goldfish_video = "examples/videos/goldfish.mp4"
+horse_video = "examples/videos/horse.mp4"
+swing_video = "examples/videos/swing.mp4"
+car_video = "examples/videos/car.mp4"
+figure1_video = "examples/videos/figure1.mp4"
+figure2_video = "examples/videos/figure2.mp4"
+figure3_video = "examples/videos/figure3.mp4"
+tesla_video = "examples/videos/tesla.mp4"
+pstudio_video = "examples/videos/pstudio.mp4"
+
+theme = gr.themes.Default(
+    primary_hue=gr.themes.colors.slate,
+    secondary_hue=gr.themes.colors.zinc,
+    neutral_hue=gr.themes.colors.slate,
+).set(
+    checkbox_label_background_fill_selected="*button_primary_background_fill",
+    checkbox_label_text_color_selected="*button_primary_text_color",
+    body_background_fill="#FFFFFF",
+)
+
+css = """
+.custom-log * {
+    font-style: italic;
+    font-size: 22px !important;
+    background-image: linear-gradient(120deg, #1f2937 0%, #4b5563 100%);
+    -webkit-background-clip: text;
+    background-clip: text;
+    font-weight: bold !important;
+    color: transparent !important;
+    text-align: center !important;
+}
+
+.example-log * {
+    font-style: italic;
+    font-size: 16px !important;
+    background-image: linear-gradient(120deg, #1f2937 0%, #4b5563 100%);
+    -webkit-background-clip: text;
+    background-clip: text;
+    color: transparent !important;
+}
+
+#my_radio .wrap {
+    display: flex;
+    flex-wrap: nowrap;
+    justify-content: center;
+    align-items: center;
+}
+
+#my_radio .wrap label {
+    display: flex;
+    width: 50%;
+    justify-content: center;
+    align-items: center;
+    margin: 0;
+    padding: 10px 0;
+    box-sizing: border-box;
+}
+"""
+
+cfg = load_cfg_from_cli()
+model = load_model(cfg)
+
+with gr.Blocks(theme=theme, css=css) as demo:
+    is_example = gr.Textbox(label="is_example", visible=False, value="None")
+    num_images = gr.Textbox(label="num_images", visible=False, value="None")
+    frame_id_state = gr.Textbox(label="frame_id", visible=False, value="0")
+
+    gr.HTML(
+        """
+        <h1>V-DPM: Video Reconstruction with Dynamic Point Maps</h1>
+        <p>
+        <a href="https://github.com/eldar/vdpm">🐙 GitHub Repository</a> |
+        <a href="https://www.robots.ox.ac.uk/~vgg/research/vdpm/">Project Page</a>
+        </p>
+        <div style="font-size: 16px; line-height: 1.5;">
+        <p>Upload a video (or multiple videos for multi-view setup) or a set of images to create a dynamic point map reconstruction of a scene or object.</p>
+        </div>
+        """
+    )
+
+    target_dir_output = gr.Textbox(label="Target Dir", visible=False, value="None")
+    predictions_state = gr.State(value=None)
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            # Change Video input to File input to allow multiple videos for multi-view support
+            gr.Markdown("### Input")
+            input_video = gr.File(
+                label="Upload Video(s)", 
+                file_count="multiple", 
+                file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"],
+                interactive=True
+            )
+            input_images = gr.File(file_count="multiple", label="Upload Images", interactive=True)
+            image_gallery = gr.Gallery(
+                label="Preview",
+                columns=4,
+                height="300px",
+                show_download_button=True,
+                object_fit="contain",
+                preview=True,
+            )
+
+        with gr.Column(scale=5):
+            gr.Markdown("**3D Reconstruction (Point Cloud)**")
+            log_output = gr.Markdown(
+                "Please upload a video or images, then click Reconstruct.", elem_classes=["custom-log"]
+            )
+            reconstruction_output = gr.Plot(label="3D Point Cloud")
+
+            with gr.Row():
+                submit_btn = gr.Button("Reconstruct", scale=1, variant="primary")
+                gr.ClearButton(
+                    [input_video, input_images, reconstruction_output, log_output, target_dir_output, image_gallery],
+                    scale=1,
+                )
+
+            with gr.Row():
+                conf_thres = gr.Slider(0, 100, value=50, step=1, label="Confidence Threshold (%)")
+                with gr.Column():
+                    mask_black_bg = gr.Checkbox(label="Filter Black Background", value=False)
+                    mask_white_bg = gr.Checkbox(label="Filter White Background", value=False)
+
+    examples = [
+        [camel_video, "17", None, 15.0, False, False, "True", "8"],
+        [horse_video, "18", None, 50.0, False, False, "True", "2"],
+        [tennis_video, "11", None, 5.0, False, False, "True", "0"],
+        [paragliding_video, "11", None, 5.0, False, False, "True", "0"],
+        [stroller_video, "17", None, 10.0, False, False, "True", "8"],
+        [goldfish_video, "11", None, 12.0, False, False, "True", "5"],
+        [swing_video, "10", None, 40.0, False, False, "True", "4"],
+        [car_video, "13", None, 15.0, False, False, "True", "7"],
+        [figure1_video, "10", None, 25.0, False, False, "True", "0"],
+        [figure2_video, "12", None, 25.0, False, False, "True", "6"],
+        [figure3_video, "13", None, 30.0, False, False, "True", "0"],
+        [tesla_video, "18", None, 20.0, False, True, "True", "0"],
+        [pstudio_video, "12", None, 0.0, False, False, "True", "6"],
+    ]
+
+    gr.Markdown("Click any row to load an example.", elem_classes=["example-log"])
+    gr.Examples(
+        examples=examples,
+        inputs=[
+            input_video,
+            num_images,
+            input_images,
+            conf_thres,
+            mask_black_bg,
+            mask_white_bg,
+            is_example,
+            frame_id_state,
+        ],
+        outputs=[
+            reconstruction_output,
+            log_output,
+            target_dir_output,
+            predictions_state,
+            image_gallery,
+        ],
+        fn=example_pipeline,
+        cache_examples=False,
+        examples_per_page=50,
+    )
+
+    submit_btn.click(fn=clear_fields, inputs=[], outputs=[reconstruction_output]).then(
+        fn=update_log, inputs=[], outputs=[log_output]
+    ).then(
+        fn=gradio_reconstruct,
+        inputs=[
+            target_dir_output,
+            conf_thres,
+            mask_black_bg,
+            mask_white_bg,
+            frame_id_state,
+        ],
+        outputs=[reconstruction_output, log_output, predictions_state],
+    ).then(
+        fn=lambda: "False", inputs=[], outputs=[is_example]
+    )
+
+    for ctrl in (conf_thres, mask_black_bg, mask_white_bg):
+        ctrl.change(
+            fn=update_plot,
+            inputs=[
+                target_dir_output,
+                predictions_state,
+                conf_thres,
+                mask_black_bg,
+                mask_white_bg,
+                is_example,
+            ],
+            outputs=[reconstruction_output, log_output],
+        )
+
+    input_video.change(
+        fn=update_gallery_on_upload,
+        inputs=[input_video, input_images],
+        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+    )
+    input_images.change(
+        fn=update_gallery_on_upload,
+        inputs=[input_video, input_images],
+        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+    )
+
+    demo.queue(max_size=20).launch(show_error=True, share=True)