Upload 77 files

.gitattributes

@@ -33,3 +33,13 @@ 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
+VideoLLaMA2/assets/cat_and_chicken.mp4 filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/assets/logo.png filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/assets/pipeline.png filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/assets/sora.mp4 filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/assets/sora.png filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/videollama2/serve/examples/1034346401.mp4 filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/videollama2/serve/examples/desert.jpg filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/videollama2/serve/examples/sample_demo_1.mp4 filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/videollama2/serve/examples/sample_demo_3.mp4 filter=lfs diff=lfs merge=lfs -text
+VideoLLaMA2/videollama2/serve/examples/sample_demo_9.mp4 filter=lfs diff=lfs merge=lfs -text

VideoLLaMA2/.gitignore

@@ -0,0 +1,58 @@
+# Python
+__pycache__
+*.pyc
+*.egg-info
+dist
+
+# Log
+*.log
+*.log.*
+*.json
+*.jsonl
+log_dir*/
+temp*/
+
+# Data
+!**/alpaca-data-conversation.json
+
+# Editor
+.idea
+*.swp
+
+# Other
+.DS_Store
+3rd_parties
+
+# jupyter
+.ipynb_checkpoints
+*.ipynb
+
+# DevContainer
+!.devcontainer/*
+
+# Demo
+serve_images/
+temp/
+
+# data folder
+data/
+dataset/
+datasets/
+
+# training folder
+wandb
+ckpts*
+output
+output/
+checkpoints
+checkpoints/
+work_dirs*/
+
+# evaluation folder
+/eval
+/eval*
+
+# pretrained weights
+pretrained/
+publish_models/
+public_models/

VideoLLaMA2/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

VideoLLaMA2/README.md

@@ -0,0 +1,372 @@
+<p align="center">
+    <img src="https://github.com/DAMO-NLP-SG/VideoLLaMA2/blob/e7bc34e0e9a96d77947a75b54399d9f96ccf209d/assets/logo.png" width="150" style="margin-bottom: 0.2;"/>
+<p>
+
+<h3 align="center"><a href="https://arxiv.org/abs/2406.07476" style="color:#9C276A">
+VideoLLaMA 2: Advancing Spatial-Temporal Modeling and Audio Understanding in Video-LLMs</a></h3>
+<h5 align="center"> If our project helps you, please give us a star ⭐ on GitHub to support us. 🙏🙏 </h2>
+
+<h5 align="center">
+
+[![hf_space](https://img.shields.io/badge/🤗-AV--Demo-9C276A.svg)](https://huggingface.co/spaces/lixin4ever/VideoLLaMA2-AV)
+[![hf_space](https://img.shields.io/badge/🤗-Demo-9C276A.svg)](https://huggingface.co/spaces/lixin4ever/VideoLLaMA2)
+[![hf_checkpoint](https://img.shields.io/badge/🤗-Checkpoints-9C276A.svg)](https://huggingface.co/collections/DAMO-NLP-SG/videollama-2-6669b6b6f0493188305c87ed)
+[![hf_data](https://img.shields.io/badge/🤗-MSVC-9C276A.svg)](https://huggingface.co/datasets/DAMO-NLP-SG/Multi-Source-Video-Captioning) <br>
+[![License](https://img.shields.io/badge/License-Apache%202.0-yellow)](https://github.com/DAMO-NLP-SG/VideoLLaMA2/blob/main/LICENSE) 
+[![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2FDAMO-NLP-SG%2FVideoLLaMA2&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=Visitor&edge_flat=false)](https://hits.seeyoufarm.com)
+[![GitHub issues](https://img.shields.io/github/issues/DAMO-NLP-SG/VideoLLaMA2?color=critical&label=Issues)](https://github.com/DAMO-NLP-SG/VideoLLaMA2/issues?q=is%3Aopen+is%3Aissue)
+[![GitHub closed issues](https://img.shields.io/github/issues-closed/DAMO-NLP-SG/VideoLLaMA2?color=success&label=Issues)](https://github.com/DAMO-NLP-SG/VideoLLaMA2/issues?q=is%3Aissue+is%3Aclosed)  <br>
+[![hf_paper](https://img.shields.io/badge/🤗-Paper%20In%20HF-red.svg)](https://huggingface.co/papers/2406.07476)
+[![arXiv](https://img.shields.io/badge/Arxiv-2406.07476-AD1C18.svg?logo=arXiv)](https://arxiv.org/abs/2406.07476) <br>
+
+</h5>
+
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/videollama-2-advancing-spatial-temporal/zero-shot-video-question-answer-on-egoschema-1)](https://paperswithcode.com/sota/zero-shot-video-question-answer-on-egoschema-1?p=videollama-2-advancing-spatial-temporal) <br>
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/videollama-2-advancing-spatial-temporal/video-question-answering-on-perception-test)](https://paperswithcode.com/sota/video-question-answering-on-perception-test?p=videollama-2-advancing-spatial-temporal) <br>
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/videollama-2-advancing-spatial-temporal/video-question-answering-on-mvbench)](https://paperswithcode.com/sota/video-question-answering-on-mvbench?p=videollama-2-advancing-spatial-temporal) <br>
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/videollama-2-advancing-spatial-temporal/zero-shot-video-question-answer-on-video-mme-1)](https://paperswithcode.com/sota/zero-shot-video-question-answer-on-video-mme-1?p=videollama-2-advancing-spatial-temporal) <br>
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/videollama-2-advancing-spatial-temporal/zero-shot-video-question-answer-on-video-mme)](https://paperswithcode.com/sota/zero-shot-video-question-answer-on-video-mme?p=videollama-2-advancing-spatial-temporal) <br>
+
+<details open><summary>💡 Some other multimodal-LLM projects from our team may interest you ✨. </summary><p>
+<!--  may -->
+
+> [**VideoLLaMA 3: Frontier Multimodal Foundation Models for Image and Video Understanding**](https://github.com/DAMO-NLP-SG/VideoLLaMA3) <br>
+> Boqiang Zhang<sup>* </sup>, Kehan Li<sup>* </sup>, Zesen Cheng<sup>* </sup>, Zhiqiang Hu<sup>* </sup>, Yuqian Yuan<sup>* </sup>, Guanzheng Chen<sup>* </sup>, Sicong Leng<sup>* </sup>, Yuming Jiang<sup>* </sup>, Hang Zhang<sup>* </sup>, Xin Li<sup>* </sup>, Peng Jin, Wenqi Zhang, Fan Wang, Lidong Bing, Deli Zhao <br>
+[![github](https://img.shields.io/badge/-Github-black?logo=github)](https://github.com/DAMO-NLP-SG/VideoLLaMA3)  [![github](https://img.shields.io/github/stars/DAMO-NLP-SG/VideoLLaMA3.svg?style=social)](https://github.com/DAMO-NLP-SG/VideoLLaMA3) [![arXiv](https://img.shields.io/badge/Arxiv-2501.13106-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2501.13106) <br>
+
+> [**Video-LLaMA: An Instruction-tuned Audio-Visual Language Model for Video Understanding**](https://github.com/DAMO-NLP-SG/Video-LLaMA) <br>
+> Hang Zhang, Xin Li, Lidong Bing <br>
+[![github](https://img.shields.io/badge/-Github-black?logo=github)](https://github.com/DAMO-NLP-SG/Video-LLaMA)  [![github](https://img.shields.io/github/stars/DAMO-NLP-SG/Video-LLaMA.svg?style=social)](https://github.com/DAMO-NLP-SG/Video-LLaMA) [![arXiv](https://img.shields.io/badge/Arxiv-2306.02858-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2306.02858) <br>
+
+> [**VCD: Mitigating Object Hallucinations in Large Vision-Language Models through Visual Contrastive Decoding**](https://arxiv.org/abs/2311.16922) <br>
+> Sicong Leng<sup>* </sup>, Hang Zhang<sup>* </sup>, Guanzheng Chen, Xin Li, Shijian Lu, Chunyan Miao, Lidong Bing <br>
+[![github](https://img.shields.io/badge/-Github-black?logo=github)](https://github.com/DAMO-NLP-SG/VCD)  [![github](https://img.shields.io/github/stars/DAMO-NLP-SG/VCD.svg?style=social)](https://github.com/DAMO-NLP-SG/VCD)  [![arXiv](https://img.shields.io/badge/Arxiv-2311.16922-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2311.16922) <br>
+
+> [**The Curse of Multi-Modalities: Evaluating Hallucinations of Large Multimodal Models across Language, Visual, and Audio**](https://arxiv.org/abs/2410.12787) <br>
+> Sicong Leng, Yun Xing, Zesen Cheng, Yang Zhou, Hang Zhang, Xin Li, Deli Zhao, Shijian Lu, Chunyan Miao, Lidong Bing <br>
+[![github](https://img.shields.io/badge/-Github-black?logo=github)](https://github.com/DAMO-NLP-SG/CMM)  [![github](https://img.shields.io/github/stars/DAMO-NLP-SG/CMM.svg?style=social)](https://github.com/DAMO-NLP-SG/CMM)  [![arXiv](https://img.shields.io/badge/Arxiv-2410.12787-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2410.12787) <br>
+
+> [**Breaking the Memory Barrier: Near Infinite Batch Size Scaling for Contrastive Loss**](https://arxiv.org/abs/2410.17243) <br>
+> Zesen Cheng*, Hang Zhang*, Kehan Li*, Sicong Leng, Zhiqiang Hu, Fei Wu, Deli Zhao, Xin Li, Lidong Bing <br>
+[![github](https://img.shields.io/badge/-Github-black?logo=github)](https://github.com/DAMO-NLP-SG/Inf-CLIP)  [![github](https://img.shields.io/github/stars/DAMO-NLP-SG/Inf-CLIP.svg?style=social)](https://github.com/DAMO-NLP-SG/Inf-CLIP)  [![arXiv](https://img.shields.io/badge/Arxiv-2410.17243-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2410.17243) <br>
+
+</p></details>
+
+<div align="center"><video src="https://github.com/DAMO-NLP-SG/VideoLLaMA2/assets/18526640/e0e7951c-f392-42ed-afad-b2c7984d3e38" width="800"></div>
+
+
+## 📰 News
+* **[2025.01.21]** 🚀🚀 We are excited to officially launch [VideoLLaMA3](https://github.com/DAMO-NLP-SG/VideoLLaMA3), featuring enhanced performance across image and video benchmarks, along with a variety of easy-to-follow inference cookbooks. Try it out today! 
+* **[2024.10.22]**  Release checkpoints of [VideoLLaMA2.1-7B-AV](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-AV). The audio_visual branch code can be seen here: https://github.com/DAMO-NLP-SG/VideoLLaMA2/tree/audio_visual.
+* **[2024.10.15]**  Release checkpoints of [VideoLLaMA2.1-7B-16F-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base) and [VideoLLaMA2.1-7B-16F](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-16F).
+* **[2024.08.14]**  Release checkpoints of [VideoLLaMA2-72B-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-72B-Base) and [VideoLLaMA2-72B](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-72B).
+* **[2024.07.30]**  Release checkpoints of [VideoLLaMA2-8x7B-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-8x7B-Base) and [VideoLLaMA2-8x7B](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-8x7B).
+* **[2024.06.25]**  🔥🔥 As of Jun 25, our [VideoLLaMA2-7B-16F](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B-16F) is the **Top-1** ~7B-sized VideoLLM on the [MLVU Leaderboard](https://github.com/JUNJIE99/MLVU?tab=readme-ov-file#trophy-mini-leaderboard).
+* **[2024.06.18]**  🔥🔥 As of Jun 18, our [VideoLLaMA2-7B-16F](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B-16F) is the **Top-1** ~7B-sized VideoLLM on the [VideoMME Leaderboard](https://video-mme.github.io/home_page.html#leaderboard).
+* **[2024.06.17]**  👋👋 Update technical report with the latest results and the missing references. If you have works closely related to VideoLLaMA 2 but not mentioned in the paper, feel free to let us know.  
+* **[2024.06.14]**  🔥🔥 [Online Demo](https://huggingface.co/spaces/lixin4ever/VideoLLaMA2) is available.
+* **[2024.06.03]**  Release training, evaluation, and serving codes of VideoLLaMA 2.
+
+
+<img src="https://github.com/DAMO-NLP-SG/VideoLLaMA2/assets/18526640/b9faf24f-bdd2-4728-9385-acea17ea086d" width="800" />
+
+## 🛠️ Requirements and Installation
+Basic Dependencies:
+* Python >= 3.8
+* Pytorch >= 2.2.0
+* CUDA Version >= 11.8
+* transformers == 4.40.0 (for reproducing paper results)
+* tokenizers == 0.19.1
+
+**[Online Mode]** Install required packages (better for development):
+```bash
+git clone https://github.com/DAMO-NLP-SG/VideoLLaMA2
+cd VideoLLaMA2
+pip install -r requirements.txt
+pip install flash-attn==2.5.8 --no-build-isolation
+```
+
+**[Offline Mode]** Install VideoLLaMA2 as a Python package (better for direct use):
+```bash
+git clone https://github.com/DAMO-NLP-SG/VideoLLaMA2
+cd VideoLLaMA2
+pip install --upgrade pip  # enable PEP 660 support
+pip install -e .
+pip install flash-attn==2.5.8 --no-build-isolation
+```
+
+## 🚀 Main Results
+
+### Multi-Choice Video QA & Video Captioning
+<p><img src="https://github.com/user-attachments/assets/e87fe4cf-07ea-4fde-998b-a0c63671c3b4" width="800" "/></p>
+
+###  Open-Ended Video QA
+<p><img src="https://github.com/user-attachments/assets/80b16c04-75ac-43b8-bc22-6952fdf994bb" width="800" "/></p>
+
+### Audio QA 
+<p><img src="https://github.com/user-attachments/assets/46e55952-5a54-4564-bcd4-cfa4edd7f36a" width="800" "/></p>
+
+### Audio-Visual QA 
+<p><img src="https://github.com/user-attachments/assets/8114c1e3-7f93-401b-9ea6-9ce7c96d7b05" width="800" "/></p>
+
+
+## :earth_americas: Model Zoo
+### Vision-only Checkpoints
+| Model Name     | Model Type | Visual Encoder | Language Decoder | # Training Frames |
+|:----------------|:------------:|:----------------|:------------------|:----------------:|
+| [VideoLLaMA2-7B-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B-Base)  | Base  | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Mistral-7B-Instruct-v0.2](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2)  | 8 |
+| [VideoLLaMA2-7B](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B)  | Chat | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Mistral-7B-Instruct-v0.2](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2)  | 8 |
+| [VideoLLaMA2-7B-16F-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B-16F-Base)  | Base  | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Mistral-7B-Instruct-v0.2](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2)  | 16 |
+| [VideoLLaMA2-7B-16F](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B-16F)  | Chat | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Mistral-7B-Instruct-v0.2](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2)  | 16 |
+| [VideoLLaMA2-8x7B-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-8x7B-Base)  | Base | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Mixtral-8x7B-Instruct-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1)  | 8 |
+| [VideoLLaMA2-8x7B](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-8x7B)  | Chat | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Mixtral-8x7B-Instruct-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1)  | 8 |
+| [VideoLLaMA2-72B-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-72B-Base)  | Base | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Qwen2-72B-Instruct](https://huggingface.co/Qwen/Qwen2-72B-Instruct)  | 8 |
+| [VideoLLaMA2-72B](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-72B)  | Chat | [clip-vit-large-patch14-336](https://huggingface.co/openai/clip-vit-large-patch14-336) | [Qwen2-72B-Instruct](https://huggingface.co/Qwen/Qwen2-72B-Instruct)  | 8 |
+| [VideoLLaMA2.1-7B-16F-Base](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base) | Base | [siglip-so400m-patch14-384](https://huggingface.co/google/siglip-so400m-patch14-384) | [Qwen2-7B-Instruct](https://huggingface.co/Qwen/Qwen2-7B-Instruct)  | 16 |
+| [VideoLLaMA2.1-7B-16F](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-16F)  | Chat | [siglip-so400m-patch14-384](https://huggingface.co/google/siglip-so400m-patch14-384) | [Qwen2-7B-Instruct](https://huggingface.co/Qwen/Qwen2-7B-Instruct)  | 16 |
+
+
+### Audio-Visual Checkpoints
+| Model Name     | Type | Audio Encoder | Language Decoder |
+|:-------------------|:----------------|:----------------|:------------------|
+| [VideoLLaMA2.1-7B-AV](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-AV)  | Chat | [Fine-tuned BEATs_iter3+(AS2M)(cpt2)](https://1drv.ms/u/s!AqeByhGUtINrgcpj8ujXH1YUtxooEg?e=E9Ncea) | [VideoLLaMA2.1-7B-16F](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2.1-7B-16F)  |
+
+
+
+## [🤗 Demo](https://huggingface.co/spaces/lixin4ever/VideoLLaMA2)
+
+It is highly recommended to try our [online demo](https://huggingface.co/spaces/lixin4ever/VideoLLaMA2) first.
+
+To run a video-based LLM (Large Language Model) web demonstration on your device, you will first need to ensure that you have the necessary model checkpoints prepared, followed by adhering to the steps outlined to successfully launch the demo.
+
+### Single-model Version
+
+* Launch a gradio app directly ([VideoLLaMA2-7B](https://huggingface.co/DAMO-NLP-SG/VideoLLaMA2-7B) is adopted by default):
+```bash
+python videollama2/serve/gradio_web_server_adhoc.py
+```
+
+### Multiple-model Version
+
+1. Launch a global controller
+```bash
+cd /path/to/VideoLLaMA2
+python -m videollama2.serve.controller --host 0.0.0.0 --port 10000
+```
+
+2. Launch a gradio webserver
+```bash
+python -m videollama2.serve.gradio_web_server --controller http://localhost:10000 --model-list-mode reload
+```
+
+3. Launch one or multiple model workers
+```bash
+#  export HF_ENDPOINT=https://hf-mirror.com  # If you are unable to access Hugging Face, try to uncomment this line.
+python -m videollama2.serve.model_worker --host 0.0.0.0 --controller http://localhost:10000 --port 40000 --worker http://localhost:40000 --model-path /PATH/TO/MODEL1
+python -m videollama2.serve.model_worker --host 0.0.0.0 --controller http://localhost:10000 --port 40001 --worker http://localhost:40001 --model-path /PATH/TO/MODEL2
+python -m videollama2.serve.model_worker --host 0.0.0.0 --controller http://localhost:10000 --port 40002 --worker http://localhost:40002 --model-path /PATH/TO/MODEL3
+...
+```
+
+
+## 🗝️ Training & Evaluation
+
+### Quick Start
+
+To facilitate further development on top of our codebase, we provide a quick-start guide on how to train a customized [VideoLLaMA2](https://github.com/DAMO-NLP-SG/VideoLLaMA2) with [VideoLLaVA](https://github.com/PKU-YuanGroup/Video-LLaVA) dataset and evaluate the trained model on the mainstream video-llm benchmarks.
+
+1. Training Data Structure:
+```bash
+VideoLLaMA2
+├── datasets
+│   ├── videollava_pt
+|   |   ├── llava_image/ # Available at: https://pan.baidu.com/s/17GYcE69FcJjjUM0e4Gad2w?pwd=9ga3 or https://drive.google.com/drive/folders/1QmFj2FcMAoWNCUyiUtdcW0-IOhLbOBcf?usp=drive_link
+|   |   ├── valley/      # Available at: https://pan.baidu.com/s/1jluOimE7mmihEBfnpwwCew?pwd=jyjz or https://drive.google.com/drive/folders/1QmFj2FcMAoWNCUyiUtdcW0-IOhLbOBcf?usp=drive_link
+|   |   └── valley_llavaimage.json # Available at: https://drive.google.com/file/d/1zGRyVSUMoczGq6cjQFmT0prH67bu2wXD/view, including 703K video-text and 558K image-text pairs
+│   ├── videollava_sft
+|   |   ├── llava_image_tune/  # Available at: https://pan.baidu.com/s/1l-jT6t_DlN5DTklwArsqGw?pwd=o6ko
+|   |   ├── videochatgpt_tune/ # Available at: https://pan.baidu.com/s/10hJ_U7wVmYTUo75YHc_n8g?pwd=g1hf
+|   |   └── videochatgpt_llavaimage_tune.json # Available at: https://drive.google.com/file/d/1zGRyVSUMoczGq6cjQFmT0prH67bu2wXD/view, including 100K video-centric, 625K image-centric and 40K text-only conversations
+```
+2. Command:
+```bash
+# VideoLLaMA2-vllava pretraining
+bash scripts/vllava/pretrain.sh
+# VideoLLaMA2-vllava finetuning
+bash scripts/vllava/finetune.sh
+```
+3. Evaluation Data Structure:
+```bash
+VideoLLaMA2
+├── eval
+│   ├── egoschema # Official website: https://github.com/egoschema/EgoSchema
+|   |   ├── good_clips_git/ # Available at: https://drive.google.com/drive/folders/1SS0VVz8rML1e5gWq7D7VtP1oxE2UtmhQ
+|   |   └── questions.json  # Available at: https://github.com/egoschema/EgoSchema/blob/main/questions.json
+│   ├── mvbench # Official website: https://huggingface.co/datasets/OpenGVLab/MVBench
+|   |   ├── video/
+|   |   |   ├── clever/
+|   |   |   └── ...
+|   |   └── json/
+|   |   |   ├── action_antonym.json
+|   |   |   └── ...
+│   ├── perception_test_mcqa # Official website: https://huggingface.co/datasets/OpenGVLab/MVBench
+|   |   ├── videos/ # Available at: https://storage.googleapis.com/dm-perception-test/zip_data/test_videos.zip
+|   |   └── mc_question_test.json # Download from https://storage.googleapis.com/dm-perception-test/zip_data/mc_question_test_annotations.zip
+│   ├── videomme # Official website: https://video-mme.github.io/home_page.html#leaderboard
+|   |   ├── test-00000-of-00001.parquet
+|   |   ├── videos/
+|   |   └── subtitles/
+│   ├── Activitynet_Zero_Shot_QA # Official website: https://github.com/MILVLG/activitynet-qa
+|   |   ├── all_test/   # Available at: https://mbzuaiac-my.sharepoint.com/:u:/g/personal/hanoona_bangalath_mbzuai_ac_ae/EatOpE7j68tLm2XAd0u6b8ABGGdVAwLMN6rqlDGM_DwhVA?e=90WIuW
+|   |   ├── test_q.json # Available at: https://github.com/MILVLG/activitynet-qa/tree/master/dataset
+|   |   └── test_a.json # Available at: https://github.com/MILVLG/activitynet-qa/tree/master/dataset
+│   ├── MSVD_Zero_Shot_QA # Official website: https://github.com/xudejing/video-question-answering
+|   |   ├── videos/     
+|   |   ├── test_q.json 
+|   |   └── test_a.json
+│   ├── videochatgpt_gen # Official website: https://github.com/mbzuai-oryx/Video-ChatGPT/tree/main/quantitative_evaluation
+|   |   ├── Test_Videos/ # Available at: https://mbzuaiac-my.sharepoint.com/:u:/g/personal/hanoona_bangalath_mbzuai_ac_ae/EatOpE7j68tLm2XAd0u6b8ABGGdVAwLMN6rqlDGM_DwhVA?e=90WIuW
+|   |   ├── Test_Human_Annotated_Captions/ # Available at: https://mbzuaiac-my.sharepoint.com/personal/hanoona_bangalath_mbzuai_ac_ae/_layouts/15/onedrive.aspx?id=%2Fpersonal%2Fhanoona%5Fbangalath%5Fmbzuai%5Fac%5Fae%2FDocuments%2FVideo%2DChatGPT%2FData%5FCode%5FModel%5FRelease%2FQuantitative%5FEvaluation%2Fbenchamarking%2FTest%5FHuman%5FAnnotated%5FCaptions%2Ezip&parent=%2Fpersonal%2Fhanoona%5Fbangalath%5Fmbzuai%5Fac%5Fae%2FDocuments%2FVideo%2DChatGPT%2FData%5FCode%5FModel%5FRelease%2FQuantitative%5FEvaluation%2Fbenchamarking&ga=1
+|   |   ├── generic_qa.json     # These three json files available at: https://mbzuaiac-my.sharepoint.com/personal/hanoona_bangalath_mbzuai_ac_ae/_layouts/15/onedrive.aspx?id=%2Fpersonal%2Fhanoona%5Fbangalath%5Fmbzuai%5Fac%5Fae%2FDocuments%2FVideo%2DChatGPT%2FData%5FCode%5FModel%5FRelease%2FQuantitative%5FEvaluation%2Fbenchamarking%2FBenchmarking%5FQA&ga=1
+|   |   ├── temporal_qa.json
+|   |   └── consistency_qa.json
+```
+4. Command:
+```bash
+# mvbench evaluation
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash scripts/eval/eval_video_qa_mvbench.sh
+# activitynet-qa evaluation (need to set azure openai key/endpoint/deployname)
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash scripts/eval/eval_video_qa_mvbench.sh
+```
+
+### Data Format
+
+If you want to train a video-llm on your data, you need to follow the procedures below to prepare the video/image sft data:
+
+1. Suppose your data structure is like:
+```bash
+VideoLLaMA2
+├── datasets
+│   ├── custom_sft
+│   |   ├── images
+│   |   ├── videos
+|   |   └── custom.json
+```
+2. Then you should re-organize the annotated video/image sft data according to the following format:
+```json
+[
+    {
+        "id": 0,
+        "video": "images/xxx.jpg",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nWhat are the colors of the bus in the image?"
+            },
+            {
+                "from": "gpt",
+                "value": "The bus in the image is white and red."
+            },
+            ...
+        ],
+    }
+    {
+        "id": 1,
+        "video": "videos/xxx.mp4",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<video>\nWhat are the main activities that take place in the video?"
+            },
+            {
+                "from": "gpt",
+                "value": "The main activities that take place in the video are the preparation of camera equipment by a man, a group of men riding a helicopter, and a man sailing a boat through the water."
+            },
+            ...
+        ],
+    },
+    ...
+]
+```
+3. Modify the `scripts/custom/finetune.sh`:
+```bash
+...
+--data_path datasets/custom_sft/custom.json
+--data_folder datasets/custom_sft/
+--pretrain_mm_mlp_adapter CONNECTOR_DOWNLOAD_PATH (e.g., DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base)
+...
+```
+
+## 🤖 Inference
+
+Video/Image Inference:
+```python
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+
+def inference():
+    disable_torch_init()
+
+    # Video Inference
+    modal = 'video'
+    modal_path = 'assets/cat_and_chicken.mp4' 
+    instruct = 'What animals are in the video, what are they doing, and how does the video feel?'
+    # Reply:
+    # The video features a kitten and a baby chick playing together. The kitten is seen laying on the floor while the baby chick hops around. The two animals interact playfully with each other, and the video has a cute and heartwarming feel to it.
+
+    # Image Inference
+    modal = 'image'
+    modal_path = 'assets/sora.png'
+    instruct = 'What is the woman wearing, what is she doing, and how does the image feel?'
+    # Reply:
+    # The woman in the image is wearing a black coat and sunglasses, and she is walking down a rain-soaked city street. The image feels vibrant and lively, with the bright city lights reflecting off the wet pavement, creating a visually appealing atmosphere. The woman's presence adds a sense of style and confidence to the scene, as she navigates the bustling urban environment.
+
+    model_path = 'DAMO-NLP-SG/VideoLLaMA2.1-7B-16F'
+    # Base model inference (only need to replace model_path)
+    # model_path = 'DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base'
+    model, processor, tokenizer = model_init(model_path)
+    output = mm_infer(processor[modal](modal_path), instruct, model=model, tokenizer=tokenizer, do_sample=False, modal=modal)
+
+    print(output)
+
+if __name__ == "__main__":
+    inference()
+```
+
+## 📑 Citation
+
+If you find VideoLLaMA useful for your research and applications, please cite using this BibTeX:
+```bibtex
+@article{damonlpsg2024videollama2,
+  title={VideoLLaMA 2: Advancing Spatial-Temporal Modeling and Audio Understanding in Video-LLMs},
+  author={Cheng, Zesen and Leng, Sicong and Zhang, Hang and Xin, Yifei and Li, Xin and Chen, Guanzheng and Zhu, Yongxin and Zhang, Wenqi and Luo, Ziyang and Zhao, Deli and Bing, Lidong},
+  journal={arXiv preprint arXiv:2406.07476},
+  year={2024},
+  url = {https://arxiv.org/abs/2406.07476}
+}
+
+@article{damonlpsg2023videollama,
+  title = {Video-LLaMA: An Instruction-tuned Audio-Visual Language Model for Video Understanding},
+  author = {Zhang, Hang and Li, Xin and Bing, Lidong},
+  journal = {arXiv preprint arXiv:2306.02858},
+  year = {2023},
+  url = {https://arxiv.org/abs/2306.02858}
+}
+```
+
+## 👍 Acknowledgement
+The codebase of VideoLLaMA 2 is adapted from [**LLaVA 1.5**](https:github.com/haotian-liu/LLaVA) and [**FastChat**](https://github.com/lm-sys/FastChat). We are also grateful for the following projects our VideoLLaMA 2 arise from:
+* [**LLaMA 2**](https://github.com/meta-llama/llama), [**Mistral-7B**](https://mistral.ai/news/announcing-mistral-7b/), [**OpenAI CLIP**](https://openai.com/index/clip/), [**Qwen2**](https://huggingface.co/collections/Qwen/qwen2-6659360b33528ced941e557f), [**SigLIP**](https://huggingface.co/collections/google/siglip-659d5e62f0ae1a57ae0e83ba), [**Honeybee**](https://github.com/kakaobrain/honeybee).
+* [**Video-ChatGPT**](https://github.com/mbzuai-oryx/Video-ChatGPT), [**Video-LLaVA**](https://github.com/PKU-YuanGroup/Video-LLaVA). 
+* [**WebVid**](https://github.com/m-bain/webvid), [**Panda-70M**](https://github.com/snap-research/Panda-70M), [**LanguageBind**](https://github.com/PKU-YuanGroup/LanguageBind), [**InternVid**](https://github.com/OpenGVLab/InternVideo/tree/main/Data/InternVid).
+* [**VideoChat2**](https://github.com/OpenGVLab/Ask-Anything/tree/main/video_chat2), [**Valley**](https://github.com/RupertLuo/Valley), [**VTimeLLM**](https://github.com/huangb23/VTimeLLM), [**ShareGPT4V**](https://sharegpt4v.github.io/).
+* [**Magpie**](https://github.com/magpie-align/magpie), [**ALLaVA**](https://github.com/FreedomIntelligence/ALLaVA), [**AVInstruct**](https://github.com/rikeilong/Bay-CAT/tree/main/AVinstruct).
+
+
+## 🔒 License
+
+This project is released under the Apache 2.0 license as found in the LICENSE file.
+The service is a research preview intended for **non-commercial use ONLY**, subject to the model Licenses of LLaMA and Mistral, Terms of Use of the data generated by OpenAI, and Privacy Practices of ShareGPT. Please get in touch with us if you find any potential violations.

VideoLLaMA2/assets/cat_and_chicken.mp4

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

VideoLLaMA2/assets/sora.mp4

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

VideoLLaMA2/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
+
+[project]
+name = "videollama2"
+version = "1.0"
+authors = [
+    {name = "Zesen Cheng", email = "[email protected]"},
+    {name = "Hang Zhang"},
+    {name = "Xin Li"},
+]
+description = "Release of VideoLLaMA2"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+]
+dependencies = [
+    "torch==2.2.0", "torchvision==0.17.0", 
+    "transformers==4.40.0", "tokenizers==0.19.1", 
+    "deepspeed==0.13.1", "accelerate==0.26.1",
+    "peft==0.4.0", "timm==1.0.3", "numpy==1.24.4",
+    "decord==0.6.0", "imageio==2.34.0", "imageio-ffmpeg==0.4.9",
+    "moviepy==1.0.3", "opencv-python==4.6.0.66", "pysubs2",
+    "scikit-learn==1.2.2", "huggingface_hub==0.23.4", "sentencepiece==0.1.99",
+    "shortuuid", "einops==0.6.1", "einops-exts==0.0.4", 
+    "bitsandbytes==0.43.0", "pydantic>=2.0", "markdown2[all]", 
+    "gradio==3.50.0", "gradio_client==0.6.1", "httpx==0.24.1",
+    "requests", "openai", "uvicorn", "fastapi", "tensorboard", "wandb", "tabulate"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/DAMO-NLP-SG/VideoLLaMA2"
+"Bug Tracker" = "https://github.com/DAMO-NLP-SG/VideoLLaMA2/issues"
+
+[tool.pdm.build]
+excludes = ["./.git"]
+package-dir = "."
+includes = ["./videollama2"]

VideoLLaMA2/requirements.txt

@@ -0,0 +1,39 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+# basic dependencies
+torch==2.2.0
+torchvision==0.17.0
+transformers==4.40.0
+tokenizers==0.19.1
+deepspeed==0.13.1
+accelerate==0.26.1
+peft==0.4.0
+timm==1.0.3
+numpy==1.24.4
+# data processing
+decord==0.6.0
+imageio==2.34.0
+imageio-ffmpeg==0.4.9
+moviepy==1.0.3
+opencv-python==4.6.0.66
+pysubs2
+# misc
+scikit-learn==1.2.2
+huggingface_hub==0.23.4
+sentencepiece==0.1.99
+shortuuid
+einops==0.6.1
+einops-exts==0.0.4
+bitsandbytes==0.43.0
+pydantic>=2.0
+markdown2[all]
+gradio==3.50.0
+gradio_client==0.6.1
+httpx==0.24.1
+requests
+openai
+uvicorn
+fastapi
+tensorboard
+wandb
+tabulate
+spaces==0.29.2

VideoLLaMA2/scripts/custom/finetune.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Environment Variables
+ARG_WORLD_SIZE=${1:-1}
+ARG_NPROC_PER_NODE=${2:-8}
+ARG_MASTER_ADDR="127.0.0.1"
+ARG_MASTER_PORT=16666
+ARG_RANK=${3:-0}
+
+# Multiple conditions
+if [ ! -n "$WORLD_SIZE" ] || [ ! -n "$NPROC_PER_NODE" ]; then
+    WORLD_SIZE=$ARG_WORLD_SIZE
+    NPROC_PER_NODE=$ARG_NPROC_PER_NODE
+fi
+if [ ! -n "$MASTER_ADDR" ] || [ ! -n "$MASTER_PORT" ] || [ ! -n "$RANK" ]; then
+    MASTER_ADDR=$ARG_MASTER_ADDR
+    MASTER_PORT=$ARG_MASTER_PORT
+    RANK=$ARG_RANK
+fi
+
+echo "WORLD_SIZE: $WORLD_SIZE"
+echo "NPROC_PER_NODE: $NPROC_PER_NODE"
+
+# Training Arguments
+GLOBAL_BATCH_SIZE=128
+LOCAL_BATCH_SIZE=4
+GRADIENT_ACCUMULATION_STEPS=$[$GLOBAL_BATCH_SIZE/($WORLD_SIZE*$NPROC_PER_NODE*$LOCAL_BATCH_SIZE)]
+
+# Log Arguments
+export TRANSFORMERS_OFFLINE=1
+export WANDB_PROJECT=videollama2qwen2_downstream_sft
+RUN_NAME=siglip_tcv35_7b_16f
+DATA_DIR=datasets
+OUTP_DIR=work_dirs
+
+torchrun --nnodes $WORLD_SIZE \
+    --nproc_per_node $NPROC_PER_NODE \
+    --master_addr=$MASTER_ADDR \
+    --master_port=$MASTER_PORT \
+    --node_rank $RANK \
+    videollama2/train.py \
+    --deepspeed scripts/zero3.json \
+    --model_type videollama2_qwen2 \
+    --model_path Qwen/Qwen2-7B-Instruct \
+    --vision_tower google/siglip-so400m-patch14-384 \
+    --mm_projector_type stc_connector_v35 \
+    --pretrain_mm_mlp_adapter DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base/mm_projector.bin \
+    --data_path   ${DATA_DIR}/videollava_sft/videochatgpt_llavaimage_tune.json \
+    --data_folder ${DATA_DIR}/videollava_sft/ \
+    --mm_vision_select_layer -2 \
+    --image_aspect_ratio pad \
+    --num_frames 16 \
+    --bf16 True \
+    --tf32 True \
+    --fp16 False \
+    --output_dir ${OUTP_DIR}/${WANDB_PROJECT}/finetune_${RUN_NAME} \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $LOCAL_BATCH_SIZE \
+    --per_device_eval_batch_size 4 \
+    --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+    --save_strategy "steps" \
+    --save_steps 500 \
+    --save_total_limit 99 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --model_max_length 2048 \
+    --gradient_checkpointing True \
+    --dataloader_num_workers 4 \
+    --report_to tensorboard \
+    --run_name $RUN_NAME \

VideoLLaMA2/scripts/custom/finetune_lora.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Environment Variables
+ARG_WORLD_SIZE=${1:-1}
+ARG_NPROC_PER_NODE=${2:-8}
+ARG_MASTER_ADDR="127.0.0.1"
+ARG_MASTER_PORT=16666
+ARG_RANK=${3:-0}
+
+# Multiple conditions
+if [ ! -n "$WORLD_SIZE" ] || [ ! -n "$NPROC_PER_NODE" ]; then
+    WORLD_SIZE=$ARG_WORLD_SIZE
+    NPROC_PER_NODE=$ARG_NPROC_PER_NODE
+fi
+if [ ! -n "$MASTER_ADDR" ] || [ ! -n "$MASTER_PORT" ] || [ ! -n "$RANK" ]; then
+    MASTER_ADDR=$ARG_MASTER_ADDR
+    MASTER_PORT=$ARG_MASTER_PORT
+    RANK=$ARG_RANK
+fi
+
+echo "WORLD_SIZE: $WORLD_SIZE"
+echo "NPROC_PER_NODE: $NPROC_PER_NODE"
+
+# Training Arguments
+GLOBAL_BATCH_SIZE=128
+LOCAL_BATCH_SIZE=4
+GRADIENT_ACCUMULATION_STEPS=$[$GLOBAL_BATCH_SIZE/($WORLD_SIZE*$NPROC_PER_NODE*$LOCAL_BATCH_SIZE)]
+
+# Log Arguments
+export TRANSFORMERS_OFFLINE=1
+export WANDB_PROJECT=videollama2qwen2_downstream_sft
+RUN_NAME=siglip_tcv35_7b_16f_lora
+DATA_DIR=datasets
+OUTP_DIR=work_dirs
+
+torchrun --nnodes $WORLD_SIZE \
+    --nproc_per_node $NPROC_PER_NODE \
+    --master_addr=$MASTER_ADDR \
+    --master_port=$MASTER_PORT \
+    --node_rank $RANK \
+    videollama2/train.py \
+    --lora_enable True --lora_r 128 --lora_alpha 256 --mm_projector_lr 2e-5 \
+    --deepspeed scripts/zero3.json \
+    --model_type videollama2_qwen2 \
+    --model_path Qwen/Qwen2-7B-Instruct \
+    --vision_tower google/siglip-so400m-patch14-384 \
+    --mm_projector_type stc_connector_v35 \
+    --pretrain_mm_mlp_adapter DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base/mm_projector.bin \
+    --data_path   ${DATA_DIR}/videollava_sft/videochatgpt_llavaimage_tune.json \
+    --data_folder ${DATA_DIR}/videollava_sft/ \
+    --mm_vision_select_layer -2 \
+    --image_aspect_ratio pad \
+    --num_frames 16 \
+    --bf16 True \
+    --tf32 True \
+    --fp16 False \
+    --output_dir ${OUTP_DIR}/${WANDB_PROJECT}/finetune_${RUN_NAME} \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $LOCAL_BATCH_SIZE \
+    --per_device_eval_batch_size 4 \
+    --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+    --save_strategy "steps" \
+    --save_steps 500 \
+    --save_total_limit 99 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --model_max_length 2048 \
+    --gradient_checkpointing True \
+    --dataloader_num_workers 4 \
+    --report_to tensorboard \
+    --run_name $RUN_NAME \

VideoLLaMA2/scripts/custom/finetune_qlora.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Environment Variables
+ARG_WORLD_SIZE=${1:-1}
+ARG_NPROC_PER_NODE=${2:-8}
+ARG_MASTER_ADDR="127.0.0.1"
+ARG_MASTER_PORT=16666
+ARG_RANK=${3:-0}
+
+# Multiple conditions
+if [ ! -n "$WORLD_SIZE" ] || [ ! -n "$NPROC_PER_NODE" ]; then
+    WORLD_SIZE=$ARG_WORLD_SIZE
+    NPROC_PER_NODE=$ARG_NPROC_PER_NODE
+fi
+if [ ! -n "$MASTER_ADDR" ] || [ ! -n "$MASTER_PORT" ] || [ ! -n "$RANK" ]; then
+    MASTER_ADDR=$ARG_MASTER_ADDR
+    MASTER_PORT=$ARG_MASTER_PORT
+    RANK=$ARG_RANK
+fi
+
+echo "WORLD_SIZE: $WORLD_SIZE"
+echo "NPROC_PER_NODE: $NPROC_PER_NODE"
+
+# Training Arguments
+GLOBAL_BATCH_SIZE=128
+LOCAL_BATCH_SIZE=4
+GRADIENT_ACCUMULATION_STEPS=$[$GLOBAL_BATCH_SIZE/($WORLD_SIZE*$NPROC_PER_NODE*$LOCAL_BATCH_SIZE)]
+
+# Log Arguments
+export TRANSFORMERS_OFFLINE=1
+export WANDB_PROJECT=videollama2qwen2_downstream_sft
+RUN_NAME=siglip_tcv35_7b_16f_qlora
+DATA_DIR=datasets
+OUTP_DIR=work_dirs
+
+torchrun --nnodes $WORLD_SIZE \
+    --nproc_per_node $NPROC_PER_NODE \
+    --master_addr=$MASTER_ADDR \
+    --master_port=$MASTER_PORT \
+    --node_rank $RANK \
+    videollama2/train.py \
+    --lora_enable True --lora_r 128 --lora_alpha 256 --mm_projector_lr 2e-5 --bits 4 \
+    --deepspeed scripts/zero2.json \
+    --model_type videollama2_qwen2 \
+    --model_path Qwen/Qwen2-7B-Instruct \
+    --vision_tower google/siglip-so400m-patch14-384 \
+    --mm_projector_type stc_connector_v35 \
+    --pretrain_mm_mlp_adapter DAMO-NLP-SG/VideoLLaMA2.1-7B-16F-Base/mm_projector.bin \
+    --data_path   ${DATA_DIR}/videollava_sft/videochatgpt_llavaimage_tune.json \
+    --data_folder ${DATA_DIR}/videollava_sft/ \
+    --mm_vision_select_layer -2 \
+    --image_aspect_ratio pad \
+    --num_frames 16 \
+    --bf16 True \
+    --tf32 True \
+    --fp16 False \
+    --output_dir ${OUTP_DIR}/${WANDB_PROJECT}/finetune_${RUN_NAME} \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $LOCAL_BATCH_SIZE \
+    --per_device_eval_batch_size 4 \
+    --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+    --save_strategy "steps" \
+    --save_steps 500 \
+    --save_total_limit 99 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --model_max_length 2048 \
+    --gradient_checkpointing True \
+    --dataloader_num_workers 4 \
+    --report_to tensorboard \
+    --run_name $RUN_NAME \

VideoLLaMA2/scripts/eval/eval_video_cap_msvc.sh

@@ -0,0 +1,67 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/merge.json
+
+# judge if the number of json lines is 0
+if [ ! -f "$output_file" ] || [ $(cat "$output_file" | wc -l) -eq 0 ]; then
+    rm -f ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/*.json
+fi
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_cap_msvc.py \
+          --model-path ${CKPT} \
+          --video-folder ${EVAL_DATA_DIR}/msvc \
+          --question-file ${EVAL_DATA_DIR}/msvc/msvc.json \
+          --output-file ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+          --num-chunks $CHUNKS \
+          --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_cap_msvc_correctness.py \
+    --pred-path $output_file \
+    --output-dir ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/correctness_gpt \
+    --output-json ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/correctness_results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4 \
+
+python3 videollama2/eval/eval_video_cap_msvc_detailedness.py \
+    --pred-path $output_file \
+    --output-dir ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/detailedness_gpt \
+    --output-json ${OUTPUT_DIR}/msvc/answers/${CKPT_NAME}/detailedness_results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4 \

VideoLLaMA2/scripts/eval/eval_video_mcqa_egoschema.sh

@@ -0,0 +1,41 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/egoschema/answers/${CKPT_NAME}/merge.csv
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_mcqa_egoschema.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/egoschema/good_clips_git \
+            --question-file ${EVAL_DATA_DIR}/egoschema/questions.json \
+            --answer-file ${OUTPUT_DIR}/egoschema/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.csv \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    echo 'q_uid, answer' >> "$output_file"
+
+    # Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/egoschema/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.csv >> "$output_file"
+    done
+fi

VideoLLaMA2/scripts/eval/eval_video_mcqa_mvbench.sh

@@ -0,0 +1,46 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/mvbench/answers/${CKPT_NAME}/merge.json
+
+# judge if the number of json lines is 0
+if [ ! -f "$output_file" ] || [ $(cat "$output_file" | wc -l) -eq 0 ]; then
+    rm -f ${OUTPUT_DIR}/mvbench/answers/${CKPT_NAME}/*.json
+fi
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_mcqa_mvbench.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/mvbench/video \
+            --question-file ${EVAL_DATA_DIR}/mvbench/json \
+            --answer-file ${OUTPUT_DIR}/mvbench/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    # Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/mvbench/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+fi
+
+python3 videollama2/eval/eval_video_mcqa_mvbench.py \
+    --pred_path ${output_file} \

VideoLLaMA2/scripts/eval/eval_video_mcqa_perception_test_mcqa.sh

@@ -0,0 +1,45 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/perception_test_mcqa/answers/${CKPT_NAME}/merge.json
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")    
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_mcqa_perception_test_mcqa.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/perception_test_mcqa/videos \
+            --question-file ${EVAL_DATA_DIR}/perception_test_mcqa/mc_question_test.json \
+            --answer-file ${OUTPUT_DIR}/perception_test_mcqa/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    echo "{" >> "$output_file"
+
+    # Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/perception_test_mcqa/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+
+    sed -i '$s/.$//' $output_file
+
+    echo "}" >> "$output_file"
+fi

VideoLLaMA2/scripts/eval/eval_video_mcqa_videomme.sh

@@ -0,0 +1,84 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/videomme/answers/${CKPT_NAME}/merge.json
+output_sub_file=${OUTPUT_DIR}/videomme/answers/${CKPT_NAME}/merge_sub.json
+
+# judge if the number of json lines is 0
+if [ ! -f "$output_file" ] || [ $(cat "$output_file" | wc -l) -eq 0 ]; then
+    rm -f ${OUTPUT_DIR}/videomme/answers/${CKPT_NAME}/*.json
+fi
+
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_mcqa_videomme.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/videomme/videos \
+            --subtitle-folder ${EVAL_DATA_DIR}/videomme/subtitles \
+            --question-file ${EVAL_DATA_DIR}/videomme/test-00000-of-00001.parquet \
+            --answer-file ${OUTPUT_DIR}/videomme/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    echo "[" >> "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videomme/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+
+    sed -i '$s/.$//' $output_file
+
+    echo "]" >> "$output_file"
+
+    # Clear out the output file if it exists.
+    > "$output_sub_file"
+
+    echo "[" >> "$output_sub_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videomme/answers/${CKPT_NAME}/${CHUNKS}_${IDX}_sub.json >> "$output_sub_file"
+    done
+
+    sed -i '$s/.$//' $output_sub_file
+
+    echo "]" >> "$output_sub_file"
+fi
+
+
+python videollama2/eval/eval_video_mcqa_videomme.py \
+    --results_file $output_file \
+    --video_duration_type "short,medium,long" \
+    --return_categories_accuracy \
+    --return_sub_categories_accuracy \
+    --return_task_types_accuracy \
+    --skip_missing \
+
+python videollama2/eval/eval_video_mcqa_videomme.py \
+    --results_file $output_sub_file \
+    --video_duration_type "short,medium,long" \
+    --return_categories_accuracy \
+    --return_sub_categories_accuracy \
+    --return_task_types_accuracy \
+    --skip_missing \

VideoLLaMA2/scripts/eval/eval_video_oqa_activitynet.sh

@@ -0,0 +1,54 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/Activitynet_Zero_Shot_QA/answers/${CKPT_NAME}/merge.json
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_oqa_activitynet.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/Activitynet_Zero_Shot_QA/all_test \
+            --question-file ${EVAL_DATA_DIR}/Activitynet_Zero_Shot_QA/test_q.json \
+            --answer-file ${EVAL_DATA_DIR}/Activitynet_Zero_Shot_QA/test_a.json \
+            --output-file ${OUTPUT_DIR}/Activitynet_Zero_Shot_QA/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/Activitynet_Zero_Shot_QA/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_activitynet.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/Activitynet_Zero_Shot_QA/answers/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/Activitynet_Zero_Shot_QA/answers/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/eval/eval_video_oqa_msvd.sh

@@ -0,0 +1,54 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/MSVD_Zero_Shot_QA/answers/${CKPT_NAME}/merge.json
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_oqa_activitynet.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/MSVD_Zero_Shot_QA/videos \
+            --question-file ${EVAL_DATA_DIR}/MSVD_Zero_Shot_QA/test_q.json \
+            --answer-file ${EVAL_DATA_DIR}/MSVD_Zero_Shot_QA/test_a.json \
+            --output-file ${OUTPUT_DIR}/MSVD_Zero_Shot_QA/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/MSVD_Zero_Shot_QA/answers/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_activitynet.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/MSVD_Zero_Shot_QA/answers/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/MSVD_Zero_Shot_QA/answers/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/eval/eval_video_oqa_vcgpt_1_correctness.sh

@@ -0,0 +1,58 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/merge.json
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_oqa_vcgpt_general.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/videochatgpt_gen/Test_Videos \
+            --question-file ${EVAL_DATA_DIR}/videochatgpt_gen/generic_qa.json \
+            --answer-file ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+
+    mkdir -p ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}
+    mkdir -p ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}
+    cp ${output_file} ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/merge.json
+    cp ${output_file} ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}/merge.json
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_vcgpt_1_correctness.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/eval/eval_video_oqa_vcgpt_2_detail.sh

@@ -0,0 +1,58 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/merge.json
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/run_inference_video_qa_gpt_general.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/videochatgpt_gen/Test_Videos \
+            --question-file ${EVAL_DATA_DIR}/videochatgpt_gen/generic_qa.json \
+            --answer-file ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+
+    mkdir -p ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}
+    mkdir -p ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}
+    cp ${output_file} ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/merge.json
+    cp ${output_file} ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}/merge.json
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_vcgpt_2_detailed_orientation.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/eval/eval_video_oqa_vcgpt_3_context.sh

@@ -0,0 +1,58 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}/merge.json
+
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/run_inference_video_qa_gpt_general.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/videochatgpt_gen/Test_Videos \
+            --question-file ${EVAL_DATA_DIR}/videochatgpt_gen/generic_qa.json \
+            --answer-file ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+
+    mkdir -p ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}
+    mkdir -p ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}
+    cp ${output_file} ${OUTPUT_DIR}/videochatgpt_gen/answers/correctness/${CKPT_NAME}/merge.json
+    cp ${output_file} ${OUTPUT_DIR}/videochatgpt_gen/answers/detail/${CKPT_NAME}/merge.json
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_vcgpt_3_context.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/videochatgpt_gen/answers/context/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/eval/eval_video_oqa_vcgpt_4_temporal.sh

@@ -0,0 +1,54 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/videochatgpt_gen/answers/temporal/${CKPT_NAME}/merge.json
+
+# if output_file not exists then inference
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_oqa_vcgpt_general.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/videochatgpt_gen/Test_Videos \
+            --question-file ${EVAL_DATA_DIR}/videochatgpt_gen/temporal_qa.json \
+            --answer-file ${OUTPUT_DIR}/videochatgpt_gen/answers/temporal/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videochatgpt_gen/answers/temporal/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_vcgpt_4_temporal.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/videochatgpt_gen/answers/temporal/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/videochatgpt_gen/answers/temporal/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/eval/eval_video_oqa_vcgpt_5_consistency.sh

@@ -0,0 +1,54 @@
+set -x
+
+EVAL_DATA_DIR=eval
+OUTPUT_DIR=eval_output
+CKPT=DAMO-NLP-SG/VideoLLaMA2.1-7B-16F
+CKPT_NAME=$(echo $CKPT | rev | cut -d'/' -f1 | rev)
+
+gpu_list="${CUDA_VISIBLE_DEVICES:-0}"
+IFS=',' read -ra GPULIST <<< "$gpu_list"
+
+# divide data via the number of GPUs per task
+GPUS_PER_TASK=1
+CHUNKS=$((${#GPULIST[@]}/$GPUS_PER_TASK))
+
+output_file=${OUTPUT_DIR}/videochatgpt_gen/answers/consistency/${CKPT_NAME}/merge.json
+
+# if output_file not exists then inference
+if [ ! -f "$output_file" ]; then
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        # select the GPUs for the task
+        gpu_devices=$(IFS=,; echo "${GPULIST[*]:$(($IDX*$GPUS_PER_TASK)):$GPUS_PER_TASK}")
+        TRANSFORMERS_OFFLINE=1 CUDA_VISIBLE_DEVICES=${gpu_devices} python3 videollama2/eval/inference_video_oqa_vcgpt_consistency.py \
+            --model-path ${CKPT} \
+            --video-folder ${EVAL_DATA_DIR}/videochatgpt_gen/Test_Videos \
+            --question-file ${EVAL_DATA_DIR}/videochatgpt_gen/consistency_qa.json \
+            --answer-file ${OUTPUT_DIR}/videochatgpt_gen/answers/consistency/${CKPT_NAME}/${CHUNKS}_${IDX}.json \
+            --num-chunks $CHUNKS \
+            --chunk-idx $IDX &
+    done
+
+    wait
+
+    # Clear out the output file if it exists.
+    > "$output_file"
+
+    #Loop through the indices and concatenate each file.
+    for IDX in $(seq 0 $((CHUNKS-1))); do
+        cat ${OUTPUT_DIR}/videochatgpt_gen/answers/consistency/${CKPT_NAME}/${CHUNKS}_${IDX}.json >> "$output_file"
+    done
+fi
+
+
+AZURE_API_KEY=your_key
+AZURE_API_ENDPOINT=your_endpoint
+AZURE_API_DEPLOYNAME=your_deployname
+
+python3 videollama2/eval/eval_video_oqa_vcgpt_5_consistency.py \
+    --pred-path ${output_file} \
+    --output-dir ${OUTPUT_DIR}/videochatgpt_gen/answers/consistency/${CKPT_NAME}/gpt \
+    --output-json ${OUTPUT_DIR}/videochatgpt_gen/answers/consistency/${CKPT_NAME}/results.json \
+    --api-key $AZURE_API_KEY \
+    --api-endpoint $AZURE_API_ENDPOINT \
+    --api-deployname $AZURE_API_DEPLOYNAME \
+    --num-tasks 4

VideoLLaMA2/scripts/vllava/finetune.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Environment Variables
+ARG_WORLD_SIZE=${1:-1}
+ARG_NPROC_PER_NODE=${2:-8}
+ARG_MASTER_ADDR="127.0.0.1"
+ARG_MASTER_PORT=16666
+ARG_RANK=${3:-0}
+
+# Multiple conditions
+if [ ! -n "$WORLD_SIZE" ] || [ ! -n "$NPROC_PER_NODE" ]; then
+    WORLD_SIZE=$ARG_WORLD_SIZE
+    NPROC_PER_NODE=$ARG_NPROC_PER_NODE
+fi
+if [ ! -n "$MASTER_ADDR" ] || [ ! -n "$MASTER_PORT" ] || [ ! -n "$RANK" ]; then
+    MASTER_ADDR=$ARG_MASTER_ADDR
+    MASTER_PORT=$ARG_MASTER_PORT
+    RANK=$ARG_RANK
+fi
+
+echo "WORLD_SIZE: $WORLD_SIZE"
+echo "NPROC_PER_NODE: $NPROC_PER_NODE"
+
+# Training Arguments
+GLOBAL_BATCH_SIZE=128
+LOCAL_BATCH_SIZE=4
+GRADIENT_ACCUMULATION_STEPS=$[$GLOBAL_BATCH_SIZE/($WORLD_SIZE*$NPROC_PER_NODE*$LOCAL_BATCH_SIZE)]
+
+# Log Arguments
+export TRANSFORMERS_OFFLINE=1
+export WANDB_PROJECT=videollama2qwen2_vllava
+RUN_NAME=siglip_tcv35_7b_16f
+DATA_DIR=datasets
+OUTP_DIR=work_dirs
+
+torchrun --nnodes $WORLD_SIZE \
+    --nproc_per_node $NPROC_PER_NODE \
+    --master_addr=$MASTER_ADDR \
+    --master_port=$MASTER_PORT \
+    --node_rank $RANK \
+    videollama2/train.py \
+    --deepspeed scripts/zero3.json \
+    --model_type videollama2_qwen2 \
+    --model_path Qwen/Qwen2-7B-Instruct \
+    --vision_tower google/siglip-so400m-patch14-384 \
+    --mm_projector_type stc_connector_v35 \
+    --pretrain_mm_mlp_adapter ${OUTP_DIR}/${WANDB_PROJECT}/pretrain_${RUN_NAME}/mm_projector.bin \
+    --data_path   ${DATA_DIR}/videollava_sft/videochatgpt_llavaimage_tune.json \
+    --data_folder ${DATA_DIR}/videollava_sft/ \
+    --mm_vision_select_layer -2 \
+    --image_aspect_ratio pad \
+    --num_frames 16 \
+    --bf16 True \
+    --tf32 True \
+    --fp16 False \
+    --output_dir ${OUTP_DIR}/${WANDB_PROJECT}/finetune_${RUN_NAME} \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $LOCAL_BATCH_SIZE \
+    --per_device_eval_batch_size 4 \
+    --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+    --save_strategy "steps" \
+    --save_steps 500 \
+    --save_total_limit 99 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --model_max_length 2048 \
+    --gradient_checkpointing True \
+    --dataloader_num_workers 4 \
+    --report_to tensorboard \
+    --run_name $RUN_NAME \

VideoLLaMA2/scripts/vllava/pretrain.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Environment Variables
+ARG_WORLD_SIZE=${1:-1}
+ARG_NPROC_PER_NODE=${2:-8}
+ARG_MASTER_ADDR="127.0.0.1"
+ARG_MASTER_PORT=16666
+ARG_RANK=${3:-0}
+
+# Multiple conditions
+if [ ! -n "$WORLD_SIZE" ] || [ ! -n "$NPROC_PER_NODE" ]; then
+    WORLD_SIZE=$ARG_WORLD_SIZE
+    NPROC_PER_NODE=$ARG_NPROC_PER_NODE
+fi
+if [ ! -n "$MASTER_ADDR" ] || [ ! -n "$MASTER_PORT" ] || [ ! -n "$RANK" ]; then
+    MASTER_ADDR=$ARG_MASTER_ADDR
+    MASTER_PORT=$ARG_MASTER_PORT
+    RANK=$ARG_RANK
+fi
+
+echo "WORLD_SIZE: $WORLD_SIZE"
+echo "NPROC_PER_NODE: $NPROC_PER_NODE"
+
+# Training Arguments
+GLOBAL_BATCH_SIZE=256
+LOCAL_BATCH_SIZE=8
+GRADIENT_ACCUMULATION_STEPS=$[$GLOBAL_BATCH_SIZE/($WORLD_SIZE*$NPROC_PER_NODE*$LOCAL_BATCH_SIZE)]
+
+# Log Arguments
+export TRANSFORMERS_OFFLINE=1
+export WANDB_PROJECT=videollama2qwen2_vllava
+RUN_NAME=siglip_tcv35_7b_16f
+DATA_DIR=datasets
+OUTP_DIR=work_dirs
+
+torchrun --nnodes $WORLD_SIZE \
+    --nproc_per_node $NPROC_PER_NODE  \
+    --master_addr=$MASTER_ADDR \
+    --master_port=$MASTER_PORT \
+    --node_rank $RANK \
+    videollama2/train.py \
+    --deepspeed scripts/zero3.json \
+    --model_type videollama2_qwen2 \
+    --model_path Qwen/Qwen2-7B-Instruct \
+    --vision_tower google/siglip-so400m-patch14-384 \
+    --mm_projector_type stc_connector_v35 \
+    --tune_mm_mlp_adapter True \
+    --data_path   ${DATA_DIR}/videollava_pt/valley_llavaimage.json \
+    --data_folder ${DATA_DIR}/videollava_pt/ \
+    --mm_vision_select_layer -2 \
+    --num_frames 16 \
+    --bf16 True \
+    --tf32 True \
+    --fp16 False \
+    --output_dir ${OUTP_DIR}/${WANDB_PROJECT}/pretrain_${RUN_NAME} \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $LOCAL_BATCH_SIZE \
+    --per_device_eval_batch_size 4 \
+    --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+    --evaluation_strategy "no" \
+    --save_strategy "steps" \
+    --save_steps 500 \
+    --save_total_limit 99 \
+    --learning_rate 1e-3 \
+    --weight_decay 0. \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --model_max_length 2048 \
+    --gradient_checkpointing True \
+    --dataloader_num_workers 4 \
+    --report_to tensorboard \
+    --run_name $RUN_NAME \

VideoLLaMA2/scripts/zero2.json

@@ -0,0 +1,23 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "train_micro_batch_size_per_gpu": "auto",
+    "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "zero_optimization": {
+        "stage": 2,
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "sub_group_size": 1e9,
+        "reduce_bucket_size": "auto"
+    }
+}

VideoLLaMA2/scripts/zero3.json

@@ -0,0 +1,28 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "train_micro_batch_size_per_gpu": "auto",
+    "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "zero_optimization": {
+        "stage": 3,
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "sub_group_size": 1e9,
+        "reduce_bucket_size": "auto",
+        "stage3_prefetch_bucket_size": "auto",
+        "stage3_param_persistence_threshold": "auto",
+        "stage3_max_live_parameters": 1e9,
+        "stage3_max_reuse_distance": 1e9,
+        "stage3_gather_16bit_weights_on_model_save": true
+    }
+}

VideoLLaMA2/videollama2/__init__.py

@@ -0,0 +1,114 @@
+import os
+import copy
+import warnings
+import shutil
+from functools import partial
+
+import torch
+
+from .model import load_pretrained_model
+from .mm_utils import process_image, process_video, tokenizer_multimodal_token, get_model_name_from_path, KeywordsStoppingCriteria
+from .constants import NUM_FRAMES, DEFAULT_IMAGE_TOKEN, DEFAULT_VIDEO_TOKEN, MODAL_INDEX_MAP
+
+
+def model_init(model_path=None, **kwargs):
+    model_path = "DAMO-NLP-SG/VideoLLaMA2-7B" if model_path is None else model_path
+    model_name = get_model_name_from_path(model_path)
+    tokenizer, model, processor, context_len = load_pretrained_model(model_path, None, model_name, **kwargs)
+
+    if tokenizer.pad_token is None and tokenizer.unk_token is not None:
+        tokenizer.pad_token = tokenizer.unk_token
+
+    num_frames = model.config.num_frames if hasattr(model.config, "num_frames") else NUM_FRAMES
+
+    processor = {
+        'image': partial(process_image, processor=processor, aspect_ratio=None),
+        'video': partial(process_video, processor=processor, aspect_ratio=None, num_frames=num_frames),
+    }
+
+    return model, processor, tokenizer
+
+
+def mm_infer(image_or_video, instruct, model, tokenizer, modal='video', **kwargs):
+    """inference api of VideoLLaMA2 for video understanding.
+
+    Args:
+        model: VideoLLaMA2 model.
+        image_or_video (torch.Tensor): image tensor (1, C, H, W) / video tensor (T, C, H, W).
+        instruct (str): text instruction for understanding video.
+        tokenizer: tokenizer.
+        do_sample (bool): whether to sample.
+        modal (str): inference modality.
+    Returns:
+        str: response of the model.
+    """
+
+    # 1. text preprocess (tag process & generate prompt).
+    if modal == 'image':
+        modal_token = DEFAULT_IMAGE_TOKEN
+    elif modal == 'video':
+        modal_token = DEFAULT_VIDEO_TOKEN
+    elif modal == 'text':
+        modal_token = ''
+    else:
+        raise ValueError(f"Unsupported modal: {modal}")
+
+    # 1. vision preprocess (load & transform image or video).
+    if modal == 'text':
+        tensor = None
+    else:
+        tensor = image_or_video.half().cuda()
+        tensor = [(tensor, modal)]
+
+    # 2. text preprocess (tag process & generate prompt).
+    if isinstance(instruct, str):
+        message = [{'role': 'user', 'content': modal_token + '\n' + instruct}]
+    elif isinstance(instruct, list):
+        message = copy.deepcopy(instruct)
+        message[0]['content'] = modal_token + '\n' + message[0]['content']
+    else:
+        raise ValueError(f"Unsupported type of instruct: {type(instruct)}")
+
+    if model.config.model_type in ['videollama2', 'videollama2_mistral', 'videollama2_mixtral']:
+        system_message = [
+            {'role': 'system', 'content': (
+            """<<SYS>>\nYou are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature."""
+            """\n"""
+            """If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.\n<</SYS>>""")
+            }
+        ]
+    else:
+        system_message = []
+
+    message = system_message + message
+    prompt = tokenizer.apply_chat_template(message, tokenize=False, add_generation_prompt=True)
+
+    input_ids = tokenizer_multimodal_token(prompt, tokenizer, modal_token, return_tensors='pt').unsqueeze(0).long().cuda()
+    attention_masks = input_ids.ne(tokenizer.pad_token_id).long().cuda()
+
+    # 3. generate response according to visual signals and prompts. 
+    keywords = [tokenizer.eos_token]
+    stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
+
+    do_sample = kwargs.get('do_sample', False)
+    temperature = kwargs.get('temperature', 0.2 if do_sample else 0.0)
+    top_p = kwargs.get('top_p', 0.9)
+    max_new_tokens = kwargs.get('max_new_tokens', 2048)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids,
+            attention_mask=attention_masks,
+            images=tensor,
+            do_sample=do_sample,
+            temperature=temperature,
+            max_new_tokens=max_new_tokens,
+            top_p=top_p,
+            use_cache=True,
+            stopping_criteria=[stopping_criteria],
+            pad_token_id=tokenizer.eos_token_id,
+        )
+
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+
+    return outputs

VideoLLaMA2/videollama2/constants.py

@@ -0,0 +1,32 @@
+CONTROLLER_HEART_BEAT_EXPIRATION = 30
+WORKER_HEART_BEAT_INTERVAL = 15
+
+LOGDIR = "."
+
+# Model Constants
+IGNORE_INDEX = -100
+
+# Image arguments
+IMAGE_TOKEN_INDEX = -200
+DEFAULT_IMAGE_TOKEN = "<image>"
+DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
+DEFAULT_IM_START_TOKEN = "<im_start>"
+DEFAULT_IM_END_TOKEN = "<im_end>"
+IMAGE_PLACEHOLDER = "<image-placeholder>"
+
+# Video arguments
+VIDEO_TOKEN_INDEX = -201
+DEFAULT_VIDEO_TOKEN = "<video>"
+NUM_FRAMES = 8
+MAX_FRAMES = 32
+NUM_FRAMES_PER_SECOND = 1
+
+# Audio arguments
+AUDIO_TOKEN_INDEX = -202
+DEFAULT_AUDIO_TOKEN = "<audio>"
+
+MODAL_INDEX_MAP = {
+    "<image>": -200,
+    "<video>": -201,
+    "<audio>": -202,
+}

VideoLLaMA2/videollama2/conversation.py

@@ -0,0 +1,507 @@
+import base64
+import dataclasses
+from io import BytesIO
+from enum import auto, Enum
+from typing import List, Tuple
+
+from PIL import Image
+from .constants import LOGDIR, NUM_FRAMES
+
+
+class SeparatorStyle(Enum):
+    """Different separator style."""
+    SINGLE = auto()
+    TWO = auto()
+    PLAIN = auto()
+    LLAMA2 = auto()
+    QWEN = auto()
+
+@dataclasses.dataclass
+class Conversation:
+    """A class that keeps all conversation history."""
+    system: str
+    roles: List[str]
+    messages: List[List[str]]
+    offset: int
+    sep_style: SeparatorStyle = SeparatorStyle.SINGLE
+    sep: str = "###"
+    sep2: str = None
+    version: str = "Unknown"
+
+    skip_next: bool = False
+    modality: str = "image"
+
+    def get_prompt(self):
+        messages = self.messages
+        modality_token = f"<{self.modality}>"
+        if len(messages) > 0 and type(messages[0][1]) is tuple:
+            messages = self.messages.copy()
+            init_role, init_msg = messages[0].copy()
+            init_msg = init_msg[0].replace(modality_token, "").strip()
+            if 'mmtag' in self.version:
+                messages[0] = (init_role, init_msg)
+                messages.insert(0, (self.roles[0], "<Image><image></Image>"))
+                messages.insert(1, (self.roles[1], "Received."))
+            else:
+                messages[0] = (init_role, f"{modality_token}\n" + init_msg)
+
+        if self.sep_style == SeparatorStyle.SINGLE:
+            ret = self.system + self.sep
+            for role, message in messages:
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + ": " + message + self.sep
+                else:
+                    ret += role + ":"
+        elif self.sep_style == SeparatorStyle.TWO:
+            seps = [self.sep, self.sep2]
+            ret = self.system + seps[0]
+            for i, (role, message) in enumerate(messages):
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + ": " + message + seps[i % 2]
+                else:
+                    ret += role + ":"
+        elif self.sep_style == SeparatorStyle.LLAMA2:
+            wrap_sys = lambda msg: f"<<SYS>>\n{msg}\n<</SYS>>\n\n"
+            wrap_inst = lambda msg: f"[INST] {msg} [/INST]"
+            ret = ""
+
+            for i, (role, message) in enumerate(messages):
+                if i == 0:
+                    assert message, "first message should not be none"
+                    assert role == self.roles[0], "first message should come from user"
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    if i == 0: message = wrap_sys(self.system) + message
+                    if i % 2 == 0:
+                        message = wrap_inst(message)
+                        ret += self.sep + message
+                    else:
+                        ret += " " + message + " " + self.sep2
+                else:
+                    ret += ""
+            ret = ret.lstrip(self.sep)
+        elif self.sep_style == SeparatorStyle.QWEN:
+            ret = ""
+            # 1. Add system prompt
+            ret += self.system + self.sep + "\n"
+            # 2. Iterate message
+            for i, (role, message) in enumerate(messages):
+                if i == 0:
+                    assert message, "first message should not be none"
+                    assert role == self.roles[0], "first message should come from user"
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    # 2.1 Add role and message
+                    ret += role + message + self.sep + "\n"
+                else:
+                    # 2.2 Add generation prompt
+                    ret += role
+        elif self.sep_style == SeparatorStyle.PLAIN:
+            seps = [self.sep, self.sep2]
+            ret = self.system
+            for i, (role, message) in enumerate(messages):
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + message + seps[i % 2]
+                else:
+                    ret += role
+        else:
+            raise ValueError(f"Invalid style: {self.sep_style}")
+
+        return ret
+
+    def append_message(self, role, message):
+        self.messages.append([role, message])
+
+    def process_image(self, image, image_process_mode, return_pil=False, image_format='PNG', max_len=800, min_len=400):
+        if image_process_mode == "Pad":
+            def expand2square(pil_img, background_color=(122, 116, 104)):
+                width, height = pil_img.size
+                if width == height:
+                    return pil_img
+                elif width > height:
+                    result = Image.new(pil_img.mode, (width, width), background_color)
+                    result.paste(pil_img, (0, (width - height) // 2))
+                    return result
+                else:
+                    result = Image.new(pil_img.mode, (height, height), background_color)
+                    result.paste(pil_img, ((height - width) // 2, 0))
+                    return result
+            image = expand2square(image)
+        elif image_process_mode in ["Default", "Crop"]:
+            pass
+        elif image_process_mode == "Resize":
+            image = image.resize((336, 336))
+        else:
+            raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
+        if max(image.size) > max_len:
+            max_hw, min_hw = max(image.size), min(image.size)
+            aspect_ratio = max_hw / min_hw
+            shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+            longest_edge = int(shortest_edge * aspect_ratio)
+            W, H = image.size
+            if H > W:
+                H, W = longest_edge, shortest_edge
+            else:
+                H, W = shortest_edge, longest_edge
+            image = image.resize((W, H))
+        if return_pil:
+            return image
+        else:
+            buffered = BytesIO()
+            image.save(buffered, format=image_format)
+            img_b64_str = base64.b64encode(buffered.getvalue()).decode()
+            return img_b64_str
+
+
+    def get_videos(self, return_pil=False):
+        video_frames = []
+        for i, (role, msg) in enumerate(self.messages[self.offset:]):
+            if i % 2 == 0:
+                if type(msg) is tuple:
+                    from decord import VideoReader, cpu
+                    import numpy as np
+                    # here video is the file path of input video
+                    msg, video, image_process_mode = msg
+                    if not return_pil:
+                        # return filepath
+                        video_frames.append(video)
+                    else:
+                        # read video using decord.VideoReader
+                        decord_vr = VideoReader(uri=video, ctx=cpu(0))
+                        duration = len(decord_vr)
+                        frame_id_list = np.linspace(0, duration-1, NUM_FRAMES, dtype=int)
+                        # convert the extracted image frames into PIL objects
+                        all_images = [Image.fromarray(f) for f in decord_vr.get_batch(frame_id_list).asnumpy()]
+                        video_frames.extend([self.process_image(image, image_process_mode, return_pil=return_pil) for image in all_images])
+        return video_frames
+
+
+    def get_images(self, return_pil=False):
+        images = []
+        for i, (role, msg) in enumerate(self.messages[self.offset:]):
+            if i % 2 == 0:
+                if type(msg) is tuple:
+                    msg, image, image_process_mode = msg
+                    image = self.process_image(image, image_process_mode, return_pil=return_pil)
+                    images.append(image)
+
+                    # import base64
+                    # from io import BytesIO
+                    # from PIL import Image
+                    # # here image is a PIL object
+                    # msg, image, image_process_mode = msg
+                    # if image_process_mode == "Pad":
+                    #     def expand2square(pil_img, background_color=(122, 116, 104)):
+                    #         width, height = pil_img.size
+                    #         if width == height:
+                    #             return pil_img
+                    #         elif width > height:
+                    #             result = Image.new(pil_img.mode, (width, width), background_color)
+                    #             result.paste(pil_img, (0, (width - height) // 2))
+                    #             return result
+                    #         else:
+                    #             result = Image.new(pil_img.mode, (height, height), background_color)
+                    #             result.paste(pil_img, ((height - width) // 2, 0))
+                    #             return result
+                    #     image = expand2square(image)
+                    # elif image_process_mode in ["Default", "Crop"]:
+                    #     pass
+                    # elif image_process_mode == "Resize":
+                    #     image = image.resize((336, 336))
+                    # else:
+                    #     raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
+                    # max_hw, min_hw = max(image.size), min(image.size)
+                    # aspect_ratio = max_hw / min_hw
+                    # max_len, min_len = 800, 400
+                    # shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+                    # longest_edge = int(shortest_edge * aspect_ratio)
+                    # W, H = image.size
+                    # if longest_edge != max(image.size):
+                    #     if H > W:
+                    #         H, W = longest_edge, shortest_edge
+                    #     else:
+                    #         H, W = shortest_edge, longest_edge
+                    #     image = image.resize((W, H))
+                    # if return_pil:
+                    #     images.append(image)
+                    # else:
+                    #     buffered = BytesIO()
+                    #     image.save(buffered, format="PNG")
+                    #     img_b64_str = base64.b64encode(buffered.getvalue()).decode()
+                    #     images.append(img_b64_str)
+        return images
+
+    def to_gradio_chatbot(self):
+        ret = []
+        for i, (role, msg) in enumerate(self.messages[self.offset:]):
+            if i % 2 == 0:
+                if type(msg) is tuple:
+                    # import base64
+                    # from io import BytesIO
+                    # from PIL import Image
+                    # msg, image, image_process_mode = msg
+                    # max_hw, min_hw = max(image.size), min(image.size)
+                    # aspect_ratio = max_hw / min_hw
+                    # max_len, min_len = 800, 400
+                    # shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+                    # longest_edge = int(shortest_edge * aspect_ratio)
+                    # W, H = image.size
+                    # if H > W:
+                    #     H, W = longest_edge, shortest_edge
+                    # else:
+                    #     H, W = shortest_edge, longest_edge
+                    # image = image.resize((W, H))
+                    # buffered = BytesIO()
+                    # image.save(buffered, format="JPEG")
+                    # img_b64_str = base64.b64encode(buffered.getvalue()).decode()
+                    # img_str = f'<img src="data:image/png;base64,{img_b64_str}" alt="user upload image" />'
+                    # display image/video in the textbox
+                    msg, image_or_video, image_process_mode = msg
+                    ##print("imagebox:", image)
+                    if isinstance(image_or_video, Image.Image):
+                        # image is PIL object
+                        img_b64_str = self.process_image(image_or_video, "Default", return_pil=False, image_format='JPEG')
+                        img_str = f'<img src="data:image/jpeg;base64,{img_b64_str}" alt="user upload image" />'
+                        msg = img_str + msg.replace('<image>', '').strip()
+                    else:
+                        # video is file path
+                        vid_str = f'<video controls playsinline width="500" style="display: inline-block;" src="./file={image_or_video}"></video><br>'
+                        msg = vid_str + msg.replace('<video>', '').strip()
+                    ret.append([msg, None])
+                else:
+                    ret.append([msg, None])
+            else:
+                ret[-1][-1] = msg
+        return ret
+
+    def copy(self):
+        return Conversation(
+            system=self.system,
+            roles=self.roles,
+            messages=[[x, y] for x, y in self.messages],
+            offset=self.offset,
+            sep_style=self.sep_style,
+            sep=self.sep,
+            sep2=self.sep2,
+            version=self.version)
+
+    def dict(self):
+        if (self.modality == "image" and len(self.get_images()) > 0) or \
+            (self.modality == "video" and len(self.get_videos()) > 0):
+            return {
+                "system": self.system,
+                "roles": self.roles,
+                "messages": [[x, y[0] if type(y) is tuple else y] for x, y in self.messages],
+                "offset": self.offset,
+                "sep": self.sep,
+                "sep2": self.sep2,
+                "modality": self.modality
+            }
+        return {
+            "system": self.system,
+            "roles": self.roles,
+            "messages": self.messages,
+            "offset": self.offset,
+            "sep": self.sep,
+            "sep2": self.sep2,
+        }
+
+
+conv_vicuna_v0 = Conversation(
+    system="A chat between a curious human and an artificial intelligence assistant. "
+           "The assistant gives helpful, detailed, and polite answers to the human's questions.",
+    roles=("Human", "Assistant"),
+    messages=(
+        ("Human", "What are the key differences between renewable and non-renewable energy sources?"),
+        ("Assistant",
+            "Renewable energy sources are those that can be replenished naturally in a relatively "
+            "short amount of time, such as solar, wind, hydro, geothermal, and biomass. "
+            "Non-renewable energy sources, on the other hand, are finite and will eventually be "
+            "depleted, such as coal, oil, and natural gas. Here are some key differences between "
+            "renewable and non-renewable energy sources:\n"
+            "1. Availability: Renewable energy sources are virtually inexhaustible, while non-renewable "
+            "energy sources are finite and will eventually run out.\n"
+            "2. Environmental impact: Renewable energy sources have a much lower environmental impact "
+            "than non-renewable sources, which can lead to air and water pollution, greenhouse gas emissions, "
+            "and other negative effects.\n"
+            "3. Cost: Renewable energy sources can be more expensive to initially set up, but they typically "
+            "have lower operational costs than non-renewable sources.\n"
+            "4. Reliability: Renewable energy sources are often more reliable and can be used in more remote "
+            "locations than non-renewable sources.\n"
+            "5. Flexibility: Renewable energy sources are often more flexible and can be adapted to different "
+            "situations and needs, while non-renewable sources are more rigid and inflexible.\n"
+            "6. Sustainability: Renewable energy sources are more sustainable over the long term, while "
+            "non-renewable sources are not, and their depletion can lead to economic and social instability.\n")
+    ),
+    offset=2,
+    sep_style=SeparatorStyle.SINGLE,
+    sep="###",
+)
+
+conv_llava_plain = Conversation(
+    system="",
+    roles=("", ""),
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.PLAIN,
+    sep="",
+    sep2="\n"
+)
+
+conv_llava_v0_mmtag = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+           "The assistant is able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
+           "The visual content will be provided with the following format: <Image>visual content</Image>.",
+    roles=("Human", "Assistant"),
+    messages=(
+    ),
+    offset=0,
+    sep_style=SeparatorStyle.SINGLE,
+    sep="###",
+    version="v0_mmtag",
+)
+
+conv_llava_v0 = Conversation(
+    system="A chat between a curious human and an artificial intelligence assistant. "
+           "The assistant gives helpful, detailed, and polite answers to the human's questions.",
+    roles=("Human", "Assistant"),
+    messages=(
+    ),
+    offset=0,
+    sep_style=SeparatorStyle.SINGLE,
+    sep="###",
+)
+
+conv_vicuna_v1 = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+    "The assistant gives helpful, detailed, and polite answers to the user's questions.",
+    roles=("USER", "ASSISTANT"),
+    version="v1",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.TWO,
+    sep=" ",
+    sep2="</s>",
+)
+
+conv_llava_v1_mmtag = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+           "The assistant is able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
+           "The visual content will be provided with the following format: <Image>visual content</Image>.",
+    roles=("USER", "ASSISTANT"),
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.TWO,
+    sep=" ",
+    sep2="</s>",
+    version="v1_mmtag",
+)
+
+conv_llava_v1 = Conversation(
+    system="A chat between a curious human and an artificial intelligence assistant. "
+           "The assistant gives helpful, detailed, and polite answers to the human's questions.",
+    roles=("USER", "ASSISTANT"),
+    version="v1",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.TWO,
+    sep=" ",
+    sep2="</s>",
+)
+
+conv_llava_llama2 = Conversation(
+    system="You are a helpful language and vision assistant. "
+           "You are able to understand the visual content that the user provides, "
+           "and assist the user with a variety of tasks using natural language.",
+    roles=("USER", "ASSISTANT"),
+    version="llama2",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA2,
+    sep="<s>",
+    sep2="</s>",
+)
+
+conv_llama2 = Conversation(
+    system="""You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature.
+
+If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.""",
+    roles=("USER", "ASSISTANT"),
+    version="llama2",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA2,
+    sep="<s>",
+    sep2="</s>",
+)
+
+conv_mistral = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+    "The assistant gives helpful, detailed, and polite answers to the user's questions.",
+    roles=("USER", "ASSISTANT"),
+    version="llama2",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA2,
+    sep="",
+    sep2="</s>",
+)
+
+conv_qwen = Conversation(
+    system="<|im_start|>system\nYou are a helpful assistant.",
+    roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.QWEN,
+    sep="<|im_end|>",
+    version="qwen",
+)
+
+conv_qwen_plain = Conversation(
+    system="",
+    roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.PLAIN,
+    sep="<|im_end|>",
+    sep2="<|im_end|>",
+    version="qwen_plain",
+)
+
+default_conversation = conv_mistral
+conv_templates = {
+    "default": conv_vicuna_v0,
+    # pretrain template
+    "plain": conv_llava_plain,
+    # llava v0
+    "v0": conv_vicuna_v0,
+    "v0_plain": conv_llava_plain,
+    "v0_mmtag": conv_llava_v0_mmtag,
+    "llava_v0": conv_llava_v0,
+    # llava v1
+    "v1": conv_vicuna_v1,
+    "v1_mmtag": conv_llava_v1_mmtag,
+    "llava_v1": conv_llava_v1,
+    "vicuna_v1": conv_vicuna_v1,
+    # llava v1.5
+    "llava_llama2": conv_llava_llama2,
+    # llama2
+    "llama2": conv_llama2,
+    # mistral
+    "mistral": conv_mistral,
+    # qwen
+    "qwen": conv_qwen,
+    "qwen_plain": conv_qwen_plain,
+}
+
+
+if __name__ == "__main__":
+    print(default_conversation.get_prompt())

VideoLLaMA2/videollama2/eval/eval_video_cap_msvc_correctness.py

@@ -0,0 +1,259 @@
+import re
+import os
+import ast
+import time
+import json
+import argparse
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+import openai
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir):
+    """
+    Evaluates question and answer pairs using GPT-3
+    Returns a score for correctness.
+    """
+    
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = str(qa_set['a'])
+        pred = qa_set['pred']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content": 
+                            "You are an intelligent chatbot designed for evaluating the factual accuracy of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with these correct answers and determine if they are factually consistent. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the factual consistency between the predicted answer and the correct answer. The predicted answer should not contain any misinterpretations or misinformation.\n"
+                            "- The predicted answer must be factually accurate and align with the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Evaluate the factual accuracy of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answers: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a factual accuracy score where the factual accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of factual consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the factual accuracy score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+            # # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+        
+    time.sleep(1)
+
+
+def longest_repeating_substring(s):
+    n = len(s)
+    dp = [[0] * (n+1) for _ in range(n+1)]
+    res = ""
+    res_length = 0
+
+    index = 0
+    for i in range(1, n+1):
+        for j in range(i+1, n+1):
+            if (dp[i-1][j-1] > 0 and dp[i-1][j-1] < (j-i)) or s[i-1] == s[j-1]:
+                dp[i][j] = dp[i-1][j-1] + 1
+                if dp[i][j] > res_length:
+                    res_length = dp[i][j]
+                    index = max(i, index)
+            else:
+                dp[i][j] = 0
+
+    if res_length > 0:
+        for i in range(index-res_length+1, index+1):
+            res = res + s[i-1]
+
+    return res
+
+
+def main(args):
+    if args.num_chunks > 1:
+        pred_contents = []
+        for _idx in range(args.num_chunks):
+            file = os.path.join(args.pred_path, f"{args.num_chunks}_{_idx}.json")
+            pred_contents += [json.loads(line) for line in open(file)]
+    else:
+        pred_contents = [json.loads(line) for line in open(args.pred_path)]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample["video_name"]
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample["video_name"] = f"{video_id.split('/')[-1].split('.')[0]}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x["video_name"] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample["video_name"]
+        # print(sample)
+        question = sample["question"]
+        answer = sample["answer"]
+        pred = sample["pred"]
+        qa_set = {"q": question, "a": answer, "pred": pred}
+        prediction_set[id] = qa_set
+
+    # # Set the OpenAI API key.
+    # openai.api_key = args.api_key  # Your API key here
+    # if args.api_base:
+    #     openai.api_base = args.api_base  # Your API base here
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i : i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir) for part in all_parts]
+            print("Generate", len(all_parts), "subprocess.")
+
+            # Use a pool of workers to process the files in parallel.
+            # with Pool() as pool:
+                # pool.starmap(annotate, task_args)
+            # import pdb;pdb.set_trace()
+            annotate(*task_args[0])
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in os.listdir(output_dir):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                try:
+                    content = json.load(json_file)
+                    combined_contents[file_name[:-5]] = content
+                except Exception as e:
+                    print(f"Error: {e}")
+                    pass
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        try:
+            # key = result[0].keys()[0]
+            # import pdb; pdb.set_trace()
+            for _ in result[0].keys():
+                score_match = result[0][_]
+                score = int(score_match)
+                score_sum += score
+                break
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+            import pdb; pdb.set_trace()
+    average_score = score_sum / count
+    combined_contents["average_score"] = average_score
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file, indent=4)
+    print("Average score for correctness:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--num_chunks", default=1, type=int, help="Result splits")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_cap_msvc_detailedness.py

@@ -0,0 +1,257 @@
+import re
+import os
+import ast
+import time
+import json
+import argparse
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+import openai
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir):
+    """
+    Evaluates question and answer pairs using GPT-3
+    Returns a score for correctness.
+    """
+    
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = str(qa_set['a'])
+        pred = qa_set['pred']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content": "You are an intelligent chatbot designed for evaluating the detail orientation of generative outputs for video-based question-answer pairs. "
+                        "Your task is to compare the predicted answer with these correct answers and determine its level of detail, considering both completeness and specificity. Here's how you can accomplish the task:"
+                        "------"
+                        "##INSTRUCTIONS: "
+                        "- Check if the predicted answer covers all major points from the video. The response should not leave out any key aspects.\n"
+                        "- Evaluate whether the predicted answer includes specific details rather than just generic points. It should provide comprehensive information that is tied to specific elements of the video.\n"
+                        "- Consider synonyms or paraphrases as valid matches.\n"
+                        "- Provide a single evaluation score that reflects the level of detail orientation of the prediction, considering both completeness and specificity.",
+                    },
+                    {
+                        "role": "user",
+                        "content": "Please evaluate the following video-based question-answer pair:\n\n"
+                        f"Question: {question}\n"
+                        f"Correct Answers: {answer}\n"
+                        f"Predicted Answer: {pred}\n\n"
+                        "Provide your evaluation only as a detail orientation score where the detail orientation score is an integer value between 0 and 5, with 5 indicating the highest level of detail orientation. "
+                        "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the detail orientation score in INTEGER, not STRING."
+                        "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                        "For example, your response should look like this: {''score': 4.8}.",
+                    },
+                ]
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+            # # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+        
+    time.sleep(1)
+
+
+def longest_repeating_substring(s):
+    n = len(s)
+    dp = [[0] * (n+1) for _ in range(n+1)]
+    res = ""
+    res_length = 0
+
+    index = 0
+    for i in range(1, n+1):
+        for j in range(i+1, n+1):
+            if (dp[i-1][j-1] > 0 and dp[i-1][j-1] < (j-i)) or s[i-1] == s[j-1]:
+                dp[i][j] = dp[i-1][j-1] + 1
+                if dp[i][j] > res_length:
+                    res_length = dp[i][j]
+                    index = max(i, index)
+            else:
+                dp[i][j] = 0
+
+    if res_length > 0:
+        for i in range(index-res_length+1, index+1):
+            res = res + s[i-1]
+
+    return res
+
+
+def main(args):
+    if args.num_chunks > 1:
+        pred_contents = []
+        for _idx in range(args.num_chunks):
+            file = os.path.join(args.pred_path, f"{args.num_chunks}_{_idx}.json")
+            pred_contents += [json.loads(line) for line in open(file)]
+    else:
+        pred_contents = [json.loads(line) for line in open(args.pred_path)]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample["video_name"]
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample["video_name"] = f"{video_id.split('/')[-1].split('.')[0]}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x["video_name"] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample["video_name"]
+        # print(sample)
+        question = sample["question"]
+        answer = sample["answer"]
+        pred = sample["pred"]
+        qa_set = {"q": question, "a": answer, "pred": pred}
+        prediction_set[id] = qa_set
+
+    # # Set the OpenAI API key.
+    # openai.api_key = args.api_key  # Your API key here
+    # if args.api_base:
+    #     openai.api_base = args.api_base  # Your API base here
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i : i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir) for part in all_parts]
+            print("Generate", len(all_parts), "subprocess.")
+
+            # Use a pool of workers to process the files in parallel.
+            # with Pool() as pool:
+                # pool.starmap(annotate, task_args)
+            # import pdb;pdb.set_trace()
+            annotate(*task_args[0])
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in os.listdir(output_dir):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                try:
+                    content = json.load(json_file)
+                    combined_contents[file_name[:-5]] = content
+                except Exception as e:
+                    print(f"Error: {e}")
+                    pass
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        try:
+            # key = result[0].keys()[0]
+            # import pdb; pdb.set_trace()
+            for _ in result[0].keys():
+                score_match = result[0][_]
+                score = int(score_match)
+                score_sum += score
+                break
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+            import pdb; pdb.set_trace()
+    average_score = score_sum / count
+    combined_contents["average_score"] = average_score
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file, indent=4)
+    print("Average score for detailedness:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--num_chunks", default=1, type=int, help="Result splits")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_mcqa_mvbench.py

@@ -0,0 +1,64 @@
+import json
+import argparse
+from tabulate import tabulate
+
+
+tasks = {
+    "Action Sequence": ("action_sequence.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Prediction": ("action_prediction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Antonym": ("action_antonym.json", "ssv2_video/", "video", False),
+    "Fine-grained Action": ("fine_grained_action.json", "pMoments_in_Time_Raw/videos/", "video", False),
+    "Unexpected Action": ("unexpected_action.json", "FunQA_test/test/", "video", False),
+    "Object Existence": ("object_existence.json", "clevrer/video_validation/", "video", False),
+    "Object Interaction": ("object_interaction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Object Shuffle": ("object_shuffle.json", "perception/videos/", "video", False),
+    "Moving Direction": ("moving_direction.json", "clevrer/video_validation/", "video", False),
+    "Action Localization": ("action_localization.json", "sta/sta_video/", "video", True),  # has start & end
+    "Scene Transition": ("scene_transition.json", "scene_qa/video/", "video", False),
+    "Action Count": ("action_count.json", "perception/videos/", "video", False),
+    "Moving Count": ("moving_count.json", "clevrer/video_validation/", "video", False),
+    "Moving Attribute": ("moving_attribute.json", "clevrer/video_validation/", "video", False),
+    "State Change": ("state_change.json", "perception/videos/", "video", False),
+    "Fine-grained Pose": ("fine_grained_pose.json", "nturgbd/", "video", False),
+    "Character Order": ("character_order.json", "perception/videos/", "video", False),
+    "Egocentric Navigation": ("egocentric_navigation.json", "vlnqa/", "video", False),
+    "Episodic Reasoning": ("episodic_reasoning.json", "tvqa/frames_fps3_hq/", "frame", True),  # has start & end, read frame
+    "Counterfactual Inference": ("counterfactual_inference.json", "clevrer/video_validation/", "video", False),
+}
+
+
+def main():
+    args = parse_args()
+    res = [eval(x.strip()) for x in open(args.pred_path, 'r').readlines()]
+    task_types = tasks.keys()
+    task_acc = {x: [] for x in task_types}
+    acc = []
+    for i, x in enumerate(res):
+        value = 1
+        if x['pred'] != x['gt']:
+            value = 0
+        acc.append(value)
+        task_acc[x['task_type']].append(value)
+    acc = sum(acc) * 100 / len(acc)
+    task_acc = {x: sum(task_acc[x]) * 100 / len(task_acc[x]) for x in task_acc}
+    print(f"{args.pred_path}:", acc)
+    task_names = list(tasks.keys())
+    
+    table_data = []
+    for i in range(len(task_names) // 4):
+        row_task_names = task_names[i * 4: (i + 1) * 4]
+        row_task_acc = [task_acc[x] for x in row_task_names]
+        table_data.append(row_task_names)
+        table_data.append(row_task_acc)
+    print(tabulate(table_data, floatfmt=".1f"), '\n')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Evaluate video captioning.")
+    parser.add_argument("--pred_path", default=r'', help="The path to file containing prediction.")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    main()

VideoLLaMA2/videollama2/eval/eval_video_mcqa_videomme.py

@@ -0,0 +1,277 @@
+import os
+import re
+import json
+import argparse
+from typing import List, Dict, Optional, Union
+
+CATEGORIES = [
+    "Knowledge",
+    "Film & Television",
+    "Sports Competition",
+    "Artistic Performance",
+    "Life Record",
+    "Multilingual"
+]
+
+SUB_CATEGORIES = [
+    "Humanity & History",
+    "Literature & Art",
+    "Biology & Medicine",
+    "Finance & Commerce",
+    "Astronomy",
+    "Geography",
+    "Law",
+    "Life Tip",
+    "Technology",
+    "Animation",
+    "Movie & TV Show",
+    "Documentary",
+    "News Report",
+    "Esports",
+    "Basketball",
+    "Football",
+    "Athletics",
+    "Other Sports",
+    "Stage Play",
+    "Magic Show",
+    "Variety Show",
+    "Acrobatics",
+    "Handicraft",
+    "Food",
+    "Fashion",
+    "Daily Life",
+    "Travel",
+    "Pet & Animal",
+    "Exercise",
+    "Multilingual"
+]
+
+TASK_CATEGORIES = [
+    "Temporal Perception",
+    "Spatial Perception",
+    "Attribute Perception",
+    "Action Recognition",
+    "Object Recognition",
+    "OCR Problems",
+    "Counting Problem",
+    "Temporal Reasoning",
+    "Spatial Reasoning",
+    "Action Reasoning",
+    "Object Reasoning",
+    "Information Synopsis",
+]
+
+
+def extract_characters_regex(s):
+    s = s.strip()
+    answer_prefixes = [
+        "The best answer is",
+        "The correct answer is",
+        "The answer is",
+        "The answer",
+        "The best option is"
+        "The correct option is",
+        "Best answer:"
+        "Best option:",
+    ]
+    for answer_prefix in answer_prefixes:
+        s = s.replace(answer_prefix, "")
+
+    if len(s.split()) > 10 and not re.search("[ABCD]", s):
+        return ""
+    matches = re.search(r'[ABCD]', s)
+    if matches is None:
+        return ""
+    return matches[0]
+
+
+def eval_your_results(
+        your_results_path: str, 
+        video_types: Optional[Union[List[str], str]] = None,
+        skip_missing: Optional[bool] = True,
+        return_categories_accuracy: Optional[bool] = True,
+        return_sub_categories_accuracy: Optional[bool] = False,
+        return_task_types_accuracy: Optional[bool] = False,
+        gt_answer_key: Optional[str] = "answer",
+        your_answer_key: Optional[str] = "response"
+
+    ):
+    """
+    Evaluate your results against the ground truth
+
+    Args:
+    - your_results_path (str): Path to your results file
+    - video_types (Optional[List[str], str]): List of video types to evaluate. 
+    - skip_missing (Optional[bool]): If True, missing files will be skipped. If False, an error will be raised if there are missing files.
+    - return_categories_accuracy (Optional[bool]): If True, the accuracy for each video category will be returned.
+    - return_sub_categories_accuracy (Optional[bool]): If True, the accuracy for each video sub category will be returned.
+    - return_task_types_accuracy (Optional[bool]): If True, the accuracy for each task category will be returned.
+    - gt_answer_key (Optional[str]): Key to access the ground truth answer in the results file.
+    - your_answer_key (Optional[str]): Key to access your answer in the results file.
+    """
+
+    # Load your results
+    with open(your_results_path, 'r') as f:
+        your_results = json.load(f)
+
+    if isinstance(video_types, str):
+        video_types = video_types.split(",")
+
+    q_type_dict = {}
+    v_type_dict = {}
+    v_sub_type_dict = {}
+
+
+    for video_type in video_types:
+
+        # Filter your results based on video types
+        your_results_video_type = [item for item in your_results if item["duration"] == video_type]
+
+        # Task Categories
+        q_type_dict[video_type] = {}
+        for q_type in TASK_CATEGORIES:
+            q_type_dict[video_type][q_type] = {"correct": 0, "answered": 0}
+
+        # Video categories
+        v_type_dict[video_type] = {}
+        for v_type in CATEGORIES:
+            v_type_dict[video_type][v_type] = {"correct": 0, "answered": 0}
+        
+        v_sub_type_dict[video_type] = {}
+        for v_sub_type in SUB_CATEGORIES:
+            v_sub_type_dict[video_type][v_sub_type] = {"correct": 0, "answered": 0}
+
+        if not skip_missing:
+            # Check if the number of files in your results and ground truth are the same
+            assert len(your_results_video_type) == 300, f"Number of files in {video_type} is not 300. Check if there are missing files."
+
+        for item in your_results_video_type:
+
+            if skip_missing and item["missing"]:
+                continue
+
+            # Get the video category, sub category and question category
+            video_category = item["domain"]
+            video_sub_category = item["sub_category"]
+            
+            questions = item["questions"]
+
+            for question in questions:
+                q_type = question["task_type"]
+
+                # Get the ground truth and your response
+                gt_answer = question[gt_answer_key]
+                response = question[your_answer_key]
+
+                # Extract the answer from the response
+                extration = extract_characters_regex(response)
+    
+                if extration != "":
+                    q_type_dict[video_type][q_type]["answered"] += 1
+                    q_type_dict[video_type][q_type]["correct"] += extration == gt_answer
+
+                    v_type_dict[video_type][video_category]["answered"] += 1
+                    v_type_dict[video_type][video_category]["correct"] += extration == gt_answer
+
+                    v_sub_type_dict[video_type][video_sub_category]["answered"] += 1
+                    v_sub_type_dict[video_type][video_sub_category]["correct"] += extration == gt_answer
+
+
+    # Print the results for each video type
+    for video_type in video_types:
+
+        print("=====================================")
+        print(f"Evaluation on video Type: {video_type}")
+        print("=====================================")
+        if return_categories_accuracy:
+            print("-------------------------------------")
+            print("Video Domains")
+            print("-------------------------------------")
+            for v_type in v_type_dict[video_type]:
+                print(f"{v_type}: {100 * v_type_dict[video_type][v_type]['correct'] / v_type_dict[video_type][v_type]['answered'] if v_type_dict[video_type][v_type]['answered'] > 0 else 0 : .1f}%")
+        if return_sub_categories_accuracy:
+            print("-------------------------------------")
+            print("Video Sub Categories")
+            print("-------------------------------------")
+            for v_sub_type in v_sub_type_dict[video_type]:
+                print(f"{v_sub_type}: {100 * v_sub_type_dict[video_type][v_sub_type]['correct'] / v_sub_type_dict[video_type][v_sub_type]['answered'] if v_sub_type_dict[video_type][v_sub_type]['answered'] > 0 else 0 : .1f}%")
+        if return_task_types_accuracy:
+            print("-------------------------------------")
+            print("Task Categories")
+            print("-------------------------------------")
+            for q_type in q_type_dict[video_type]:
+                print(f"{q_type}: {100 * q_type_dict[video_type][q_type]['correct'] / q_type_dict[video_type][q_type]['answered'] if q_type_dict[video_type][q_type]['answered'] > 0 else 0 : .1f}%")
+        
+        print("-------------------------------------")
+        print("Overall Performance")
+        print("-------------------------------------")
+        total_correct = sum([q_type_dict[video_type][q_type]["correct"] for q_type in TASK_CATEGORIES])
+        total_answered = sum([q_type_dict[video_type][q_type]["answered"] for q_type in TASK_CATEGORIES])
+        print(f"Overall: {100 * total_correct / total_answered if total_answered > 0 else 0 : .1f}%")
+
+        print("\n")
+
+    # Print the results for the entire dataset
+    print("=====================================")
+    print("Evaluation on the entire dataset")
+    print("=====================================")
+
+    if return_categories_accuracy:
+        print("-------------------------------------")
+        print("Video Categories")
+        print("-------------------------------------")
+        for v_type in CATEGORIES:
+            total_correct = sum([v_type_dict[video_type][v_type]["correct"] for video_type in video_types])
+            total_answered = sum([v_type_dict[video_type][v_type]["answered"] for video_type in video_types])
+            print(f"{v_type}: {100 * total_correct / total_answered if total_answered > 0 else 0 : .1f}%")
+    
+
+    if return_sub_categories_accuracy:
+        print("-------------------------------------")
+        print("Video Sub Categories")
+        print("-------------------------------------")
+
+        for v_sub_type in SUB_CATEGORIES:
+            total_correct = sum([v_sub_type_dict[video_type][v_sub_type]["correct"] for video_type in video_types])
+            total_answered = sum([v_sub_type_dict[video_type][v_sub_type]["answered"] for video_type in video_types])
+            print(f"{v_sub_type}: {100 * total_correct / total_answered if total_answered > 0 else 0 : .1f}%")
+
+
+    if return_task_types_accuracy:
+        print("-------------------------------------")
+        print("Task Categories")
+        print("-------------------------------------")
+        for q_type in TASK_CATEGORIES:
+
+            total_correct = sum([q_type_dict[video_type][q_type]["correct"] for video_type in video_types])
+            total_answered = sum([q_type_dict[video_type][q_type]["answered"] for video_type in video_types])
+            print(f"{q_type}: {100 * total_correct / total_answered if total_answered > 0 else 0 : .1f}%")
+
+    print("-------------------------------------")
+    print("Overall Performance")
+    print("-------------------------------------")
+    total_correct = sum([sum([q_type_dict[video_type][q_type]["correct"] for q_type in TASK_CATEGORIES]) for video_type in video_types])
+    total_answered = sum([sum([q_type_dict[video_type][q_type]["answered"] for q_type in TASK_CATEGORIES]) for video_type in video_types])
+    print(f"Overall: {100 * total_correct / total_answered if total_answered > 0 else 0 : .1f}%")
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--results_file", type=str, required=True)
+    parser.add_argument("--video_duration_type", type=str, required=True)
+    parser.add_argument("--return_categories_accuracy", action="store_true")
+    parser.add_argument("--return_sub_categories_accuracy", action="store_true")
+    parser.add_argument("--return_task_types_accuracy", action="store_true")
+    parser.add_argument("--skip_missing", action="store_true")
+
+    args = parser.parse_args()
+
+    eval_your_results(
+        args.results_file, 
+        video_types=args.video_duration_type,
+        skip_missing=args.skip_missing,
+        return_categories_accuracy=args.return_categories_accuracy,
+        return_sub_categories_accuracy=args.return_sub_categories_accuracy,
+        return_task_types_accuracy=args.return_task_types_accuracy,
+    )

VideoLLaMA2/videollama2/eval/eval_video_oqa_activitynet.py

@@ -0,0 +1,210 @@
+import os
+import ast
+import json
+import time
+import argparse
+import traceback
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def prompt_gpt(question, answer, pred, key, qa_set, output_dir):
+    message = [
+        {
+            "role": "system",
+            "content":
+                "You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs. "
+                "Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:"
+                "------"
+                "##INSTRUCTIONS: "
+                "- Focus on the meaningful match between the predicted answer and the correct answer.\n"
+                "- Consider synonyms or paraphrases as valid matches.\n"
+                "- Evaluate the correctness of the prediction compared to the answer."
+        },
+        {
+            "role": "user",
+            "content":
+                "Please evaluate the following video-based question-answer pair:\n\n"
+                f"Question: {question}\n"
+                f"Correct Answer: {answer}\n"
+                f"Predicted Answer: {pred}\n\n"
+                "Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match. "
+                "Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is  a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING."
+                "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                "For example, your response should look like this: {'pred': 'yes', 'score': 4.8}."
+        }
+    ]
+    completion = interaction(client, message)
+    # Convert response to a Python dictionary.
+    response_message = completion.choices[0].message.content
+    response_dict = ast.literal_eval(response_message)
+    result_qa_pair = [response_dict, qa_set]
+    # # Save the question-answer pairs to a json file.
+    with open(f"{output_dir}/{key}.json", "w") as f:
+        json.dump(result_qa_pair, f)
+
+
+def annotate(task_arg):
+    """
+    Evaluates question and answer pairs using GPT-3
+    Returns a score for correctness.
+    """
+    prediction_set, caption_files, output_dir, args = task_arg
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            prompt_gpt(question, answer, pred, key, qa_set, output_dir)
+        except Exception as e:
+            prompt_gpt(question, answer, pred[:50], key, qa_set, output_dir)
+            traceback.print_exc()
+
+    time.sleep(1)
+
+
+def main(args):
+
+    file = open(args.pred_path)
+    new_pred_contents = [eval(i.strip()) for i in file.readlines()]
+
+    # Generating list of id's and corresponding files
+    id_list = [x['id'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['id']
+        question = sample['question']
+        answer = sample['answer']
+        pred = sample['pred']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with ThreadPoolExecutor(max_workers=args.num_tasks) as executor:
+                list(tqdm(executor.map(annotate, task_args), total=len(task_args)))
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # multiprocessing to combine json files
+    def combine_json(file_name):
+        file_path = os.path.join(output_dir, file_name)
+        with open(file_path, "r") as json_file:
+            content = json.load(json_file)
+            return (file_name[:-5], content)
+
+    files = os.listdir(output_dir)
+    with ThreadPoolExecutor(max_workers=64) as executor:
+        combined_contents = list(tqdm(executor.map(combine_json, files), total=len(files)))
+
+    # Calculate average score and accuracy
+    score_sum = 0
+    count = 0
+    yes_count = 0
+    no_count = 0
+    for key, result in tqdm(combined_contents):
+        try:
+            # Computing score
+            count += 1
+            score_match = result[0]['score']
+            score = int(score_match)
+            score_sum += score
+
+            # Computing accuracy
+            pred = result[0]['pred']
+            if "yes" in pred.lower():
+                yes_count += 1
+            elif "no" in pred.lower():
+                no_count += 1
+        except:
+            print(result)
+
+    average_score = score_sum / count
+    accuracy = yes_count / (yes_count + no_count)
+    print("Yes count:", yes_count)
+    print("No count:", no_count)
+    print("Accuracy:", accuracy)
+    print("Average score:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_oqa_vcgpt_1_correctness.py

@@ -0,0 +1,210 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3
+    Returns a score for correctness.
+    """
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content": 
+                            "You are an intelligent chatbot designed for evaluating the factual accuracy of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine if they are factually consistent. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the factual consistency between the predicted answer and the correct answer. The predicted answer should not contain any misinterpretations or misinformation.\n"
+                            "- The predicted answer must be factually accurate and align with the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Evaluate the factual accuracy of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a factual accuracy score where the factual accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of factual consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the factual accuracy score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            traceback.print_exc()
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for correctness:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_oqa_vcgpt_2_detailed_orientation.py

@@ -0,0 +1,210 @@
+import os
+import argparse
+import json
+import ast
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3 and
+    returns a score for detailed orientation.
+    """
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            # Compute the detailed-orientation score
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the detail orientation of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine its level of detail, considering both completeness and specificity. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Check if the predicted answer covers all major points from the video. The response should not leave out any key aspects.\n"
+                            "- Evaluate whether the predicted answer includes specific details rather than just generic points. It should provide comprehensive information that is tied to specific elements of the video.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Provide a single evaluation score that reflects the level of detail orientation of the prediction, considering both completeness and specificity."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a detail orientation score where the detail orientation score is an integer value between 0 and 5, with 5 indicating the highest level of detail orientation. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the detail orientation score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for detailed orientation:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_oqa_vcgpt_3_context.py

@@ -0,0 +1,212 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3 and
+    returns a score for contextual understanding.
+    """
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            # Compute the contextual understanding score
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the contextual understanding of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine if the generated response aligns with the overall context of the video content. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Evaluate whether the predicted answer aligns with the overall context of the video content. It should not provide information that is out of context or misaligned.\n"
+                            "- The predicted answer must capture the main themes and sentiments of the video.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Provide your evaluation of the contextual understanding of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a contextual understanding score where the contextual understanding score is an integer value between 0 and 5, with 5 indicating the highest level of contextual understanding. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is contextual understanding score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for contextual understanding:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_oqa_vcgpt_4_temporal.py

@@ -0,0 +1,206 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the temporal understanding of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine if they correctly reflect the temporal sequence of events in the video content. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the temporal consistency between the predicted answer and the correct answer. The predicted answer should correctly reflect the sequence of events or details as they are presented in the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches, but only if the temporal order is maintained.\n"
+                            "- Evaluate the temporal accuracy of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a temporal accuracy score where the temporal accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of temporal consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the temporal accuracy score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e: 
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in os.listdir(output_dir):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score temporal understanding:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/eval_video_oqa_vcgpt_5_consistency.py

@@ -0,0 +1,218 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3 and
+    returns a score for consistency.
+    """
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question1 = qa_set['q1']
+        question2 = qa_set['q2']
+        answer = qa_set['a']
+        pred1 = qa_set['p1']
+        pred2 = qa_set['p2']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the consistency of generative outputs for similar video-based question-answer pairs. "
+                            "You will be given two very similar questions, a common answer common to both the questions and predicted answers for the two questions ."
+                            "Your task is to compare the predicted answers for two very similar question, with a common correct answer and determine if they are consistent. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the consistency between the two predicted answers and the correct answer. Both predicted answers should correspond to the correct answer and to each other, and should not contain any contradictions or significant differences in the conveyed information.\n"
+                            "- Both predicted answers must be consistent with each other and the correct answer, in terms of the information they provide about the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches, but only if they maintain the consistency in the conveyed information.\n"
+                            "- Evaluate the consistency of the two predicted answers compared to the correct answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question 1: {question1}\n"
+                            f"Question 2: {question2}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer to Question 1: {pred1}\n"
+                            f"Predicted Answer to Question 2: {pred2}\n\n"
+                            "Provide your evaluation only as a consistency score where the consistency score is an integer value between 0 and 5, with 5 indicating the highest level of consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the consistency score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question1 = sample['Q1']
+        question2 = sample['Q2']
+        answer = sample['A']
+        pred1 = sample['P1']
+        pred2 = sample['P2']
+        qa_set = {"q1": question1, "q2": question2, "a": answer, "p1": pred1, "p2": pred2}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e: 
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in os.listdir(output_dir):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for consistency:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

VideoLLaMA2/videollama2/eval/inference_video_cap_msvc.py

@@ -0,0 +1,120 @@
+import math
+import os
+import argparse
+import json
+import warnings
+from tqdm import tqdm
+
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class MSVCDataset(Dataset):
+
+    video_formats = ['.mp4', '.webm', '.avi', '.mov', '.mkv']
+
+    def __init__(self, folder, questions, processor):
+        self.folder = folder
+        self.questions = questions
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.questions)
+    
+    def __getitem__(self, idx):
+        sample = self.questions[idx]
+
+        video_name = sample['video_path']
+        question   = sample['question']
+        answer     = sample['captions']
+
+        video_path = os.path.join(self.folder, video_name)
+        video_tensor = self.processor(video_path)
+
+        return {
+            'video':       video_tensor,
+            'video_name':  video_name,
+            'question':    question,
+            'answer':      answer,
+        }
+
+
+def collate_fn(batch):
+    vid  = [x['video'] for x in batch]
+    v_id = [x['video_name'] for x in batch]
+    qus  = [x['question'] for x in batch]
+    ans  = [x['answer'] for x in batch]
+    return vid, v_id, qus, ans
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    model, processor, tokenizer = model_init(args.model_path)
+
+    gt_questions = json.load(open(args.question_file, "r"))
+    gt_questions = get_chunk(gt_questions, args.num_chunks, args.chunk_idx)
+
+    answer_file = os.path.join(args.output_file)
+    os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = MSVCDataset(args.video_folder, gt_questions, processor['video'])
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    # Iterate over each sample in the ground truth file
+    for idx, (video_tensors, video_names, questions, answers) in enumerate(tqdm(dataloader)):
+        video_tensor = video_tensors[0]
+        video_name   = video_names[0]
+        question     = questions[0]
+        answer       = answers[0]
+
+        output = mm_infer(
+            video_tensor,
+            question, 
+            model=model,
+            tokenizer=tokenizer,
+            modal='video',
+            do_sample=False,
+        )
+
+        sample_set = {'video_name': video_name, 'question': question, 'answer': answer, 'pred': output}
+        ans_file.write(json.dumps(sample_set) + "\n")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--output-file', help='Directory to save the model results JSON.', required=True)
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

VideoLLaMA2/videollama2/eval/inference_video_mcqa_egoschema.py

@@ -0,0 +1,153 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+import traceback
+
+from tqdm import tqdm
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class EgoschemaDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_folder, data_list, processor):
+        self.data_folder = data_folder
+        self.data_list = data_list
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        q_uid = line['q_uid']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(self.data_folder, f"{q_uid}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        video_tensor = self.processor(video_path)
+
+        question = line['question']
+        a0 = line['option 0']
+        a1 = line['option 1']
+        a2 = line['option 2']
+        a3 = line['option 3']
+        a4 = line['option 4']
+        axs = [a0, a1, a2, a3, a4]
+        ops = ['(A)', '(B)', '(C)', '(D)', '(E)']
+
+        instruct = f'Select the best answer to the following multiple-choice question based on the video.\n{question}\nOptions:\n(A) {a0}\n(B) {a1}\n(C) {a2}\n(D) {a3}\n(E) {a4}\nAnswer with the option\'s letter from the given choices directly and only give the best option. The best answer is: ' 
+
+        return {
+            'q_uid': q_uid,
+            'video': video_tensor, 
+            'instruct': instruct,
+        }
+
+
+def build_egoschema_eval(args, processor):
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    dataset = EgoschemaDataset(args.video_folder, questions, processor)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
+
+    return dataloader
+
+
+def egoschema_dump(ans_file, line, outputs):
+    for idx, output in enumerate(outputs):
+        q_uid = line['q_uid'][idx]
+        instruct = line['instruct'][idx]
+        letters = ['A', 'B', 'C', 'D', 'E']
+
+        output = output.replace('answer', '')
+        output = output.replace('Answer', '')
+        pred_answer = re.findall('[\(\ ]*[A-E][\)\ ]*', output)
+        try:
+            
+            assert len(pred_answer) >= 1, 'The video \"{}\" instruct: \n\"{}\"\n output: \n\"{}\"\n is not in the expected format'.format(line['q_uid'], instruct, output)
+            pred_answer = pred_answer[0].strip()
+            pred_answer = pred_answer.strip('()')
+            pred_idx = letters.index(pred_answer)
+        except:
+            traceback.print_exc()
+            pred_idx = 2
+
+        ans_file.write(f'{q_uid}, {pred_idx}\n')
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    model, processor, tokenizer = model_init(args.model_path)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    val_loader = build_egoschema_eval(args, processor['video'])
+
+    # Iterate over each sample in the ground truth file
+    for i, line in enumerate(tqdm(val_loader)):
+        video_tensor = line['video'][0]
+        instruct = line['instruct'][0]
+
+        try:
+            pred = mm_infer(
+                video_tensor,
+                instruct,
+                model=model,
+                tokenizer=tokenizer,
+                modal='video',
+                do_sample=False,
+            )
+        except:
+            traceback.print_exc()
+            pred = 'C'
+
+        egoschema_dump(ans_file, line, [pred])
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Multiple-Choice Video QA Evaluation Script.')
+
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--num-workers", type=int, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

VideoLLaMA2/videollama2/eval/inference_video_mcqa_mvbench.py

@@ -0,0 +1,203 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+import traceback
+
+import torch
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+from decord import VideoReader, cpu
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class MVBenchDataset(Dataset):
+
+    def __init__(self, data_list, processor):
+        self.data_list = data_list
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.data_list)
+
+    def __getitem__(self, idx):
+        bound = (None, None)
+        if self.data_list[idx]['bound']:
+            bound = (self.data_list[idx]['data']['start'], self.data_list[idx]['data']['end'])
+        video_path = os.path.join(self.data_list[idx]['prefix'], self.data_list[idx]['data']['video'])
+        torch_imgs = self.processor(video_path, s=bound[0], e=bound[1])
+        question = self.data_list[idx]['data']['question']
+        options = self.data_list[idx]['data']['candidates']
+        answer = self.data_list[idx]['data']['answer']
+        task_type = self.data_list[idx]['task_type']
+
+        answer_idx = -1
+        letters = []
+        options_string = ''
+        for option_idx, c in enumerate(options):
+            letters.append(f"{chr(ord('A') + option_idx)}")
+            options_string += f"({chr(ord('A') + option_idx)}) {c}\n"
+            if c == answer:
+                answer_idx = option_idx
+
+        instruct = f'Question: {question}\nOptions:\n{options_string}Answer with the option\'s letter from the given choices directly and only give the best option.' 
+
+        return {
+            'video': torch_imgs, 
+            'video_path': video_path,
+            'instruct': instruct,
+            'letters': letters,
+            'options': options,
+            'answer_idx': answer_idx,
+            'task_type': task_type
+        }
+
+
+tasks = {
+    "Action Sequence": ("action_sequence.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Prediction": ("action_prediction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Antonym": ("action_antonym.json", "ssv2_video/", "video", False),
+    "Fine-grained Action": ("fine_grained_action.json", "Moments_in_Time_Raw/videos/", "video", False),
+    "Unexpected Action": ("unexpected_action.json", "FunQA_test/test/", "video", False),
+    "Object Existence": ("object_existence.json", "clevrer/video_validation/", "video", False),
+    "Object Interaction": ("object_interaction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Object Shuffle": ("object_shuffle.json", "perception/videos/", "video", False),
+    "Moving Direction": ("moving_direction.json", "clevrer/video_validation/", "video", False),
+    "Action Localization": ("action_localization.json", "sta/sta_video/", "video", True),  # has start & end
+    "Scene Transition": ("scene_transition.json", "scene_qa/video/", "video", False),
+    "Action Count": ("action_count.json", "perception/videos/", "video", False),
+    "Moving Count": ("moving_count.json", "clevrer/video_validation/", "video", False),
+    "Moving Attribute": ("moving_attribute.json", "clevrer/video_validation/", "video", False),
+    "State Change": ("state_change.json", "perception/videos/", "video", False),
+    "Fine-grained Pose": ("fine_grained_pose.json", "nturgbd/", "video", False),
+    "Character Order": ("character_order.json", "perception/videos/", "video", False),
+    "Egocentric Navigation": ("egocentric_navigation.json", "vlnqa/", "video", False),
+    "Episodic Reasoning": ("episodic_reasoning.json", "tvqa/frames_fps3_hq/", "frame", True),  # has start & end, read frame
+    "Counterfactual Inference": ("counterfactual_inference.json", "clevrer/video_validation/", "video", False),
+}
+
+
+def build_mvbench_eval(args, processor):
+    data_list = []
+    for task_name, task in tasks.items():
+        json_file = os.path.join(args.question_file, task[0])
+        vis_folder = os.path.join(args.video_folder, task[1])
+        with open(json_file, 'r') as f:
+            json_data = json.load(f)
+        for data in json_data:
+            data_list.append({
+                'task_type': task_name,
+                'prefix': vis_folder,
+                'data_type': task[2],
+                'bound': task[3],
+                'data': data
+            })
+    data_list = get_chunk(data_list, args.num_chunks, args.chunk_idx)
+    dataset = MVBenchDataset(data_list, processor)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
+
+    return dataloader
+
+
+def mvbench_dump(vid, instruct, letters, options, output):
+    
+    output = output.replace('answer', '')
+    output = output.replace('Answer', '')
+    pred_answer = re.findall(f'[\(,\ ]*[{letters[0]}-{letters[-1]}][\),\ ]*', output)
+    try:
+        find_flag = False
+        if len(pred_answer) == 0:
+            for idx, opt in enumerate(options):
+                # Arabic numerals -> English words
+                if opt.lower() in output.lower():
+                    pred_idx = idx
+                    find_flag = True
+                    break
+        else:
+            pred_answer = pred_answer[0].strip()
+            pred_answer = pred_answer.strip('()')
+            pred_idx = letters.index(pred_answer)
+            find_flag = True
+
+        assert find_flag, 'The video \"{}\" instruct: \n\"{}\"\n output: \n\"{}\"\n is not in the expected format'.format(vid, instruct, output)
+    except:
+        traceback.print_exc()
+        pred_idx = 2
+    
+    return pred_idx
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    model, processor, tokenizer = model_init(args.model_path)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    val_loader = build_mvbench_eval(args, processor['video'])
+
+    # NOTE: only support batch size 1 for now
+    for i, line in enumerate(tqdm(val_loader)):
+        vid = line['video_path'][0]
+        video_tensor = line['video'][0]
+        task_type = line['task_type'][0]
+        instruct  = line['instruct'][0]
+        letters   = list(zip(*line['letters']))[0]
+        options   = list(zip(*line['options']))[0]
+        answer_idx = line['answer_idx'][0].item()
+
+        output = mm_infer(
+            video_tensor,
+            instruct,
+            model=model,
+            tokenizer=tokenizer,
+            modal='video',
+            do_sample=False,
+        )
+
+        pred_idx = mvbench_dump(vid, instruct, letters, options, output)
+
+        ans_file.write(json.dumps({"vid": vid, "task_type": task_type, "pred": pred_idx, "gt": answer_idx}) + '\n')
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--num-workers", type=int, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

VideoLLaMA2/videollama2/eval/inference_video_mcqa_perception_test_mcqa.py

@@ -0,0 +1,169 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+import traceback
+from tqdm import tqdm
+
+import torch
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class PerceptionTestMCQADataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor):
+        self.data_list = data_list
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        video_name = line['metadata']['video_id']
+        mc_questions = line['mc_question']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+        
+        video_tensor = self.processor(video_path)
+
+        instructs = []
+        qids = []
+        ops = []
+        for q in mc_questions:
+            question = q['question']
+            qid = q['id']
+            options = q['options']
+            instruct = f'Question: {question}\nOptions:\n(A) {options[0]}\n(B) {options[1]}\n(C) {options[2]}\nAnswer with the option\'s letter from the given choices directly and only give the best option.'
+
+            instructs.append(instruct)
+            qids.append(qid)
+            ops.append(options)
+
+        return {
+            'video': video_tensor,
+            'video_id': video_name,
+            'instructs': instructs,
+            'question_ids': qids,
+            'options': ops,
+        }
+
+
+def collate_fn(batch):
+    vid = [x['video'] for x in batch]
+    v_id = [x['video_id'] for x in batch]
+    ins = [x['instructs'] for x in batch]
+    q_ids = [x['question_ids'] for x in batch]
+    ops = [x['options'] for x in batch]
+    vid = torch.stack(vid, dim=0)
+    return vid, v_id, ins, q_ids, ops
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    model, processor, tokenizer = model_init(args.model_path)
+
+    questions = json.load(open(args.question_file, "r"))
+    questions = list(questions.values())
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = PerceptionTestMCQADataset(questions, processor['video'])
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    # Iterate over each sample in the ground truth file
+    for i, (video_tensor, video_id, instructs, question_ids, options) in enumerate(tqdm(dataloader)):
+
+        # reduce batch dimension
+        video_tensor = video_tensor[0]
+        video_id = video_id[0]
+        instructs = instructs[0]
+        question_ids = question_ids[0]
+        options = options[0]
+
+        qas = []
+        for idx, instruct in enumerate(instructs):
+            letters = ['(A)', '(B)', '(C)']
+            question_id = question_ids[idx]
+            _options = options[idx]
+
+            output = mm_infer(
+                video_tensor,
+                instruct,
+                model=model,
+                tokenizer=tokenizer,
+                modal='video',
+                do_sample=False,
+            )
+
+            output = output.replace('answer', '')
+            output = output.replace('Answer', '')
+            pred_answer = re.findall('\(*[A-C]\)*', output)
+            try:
+                assert len(pred_answer) >= 1, 'The video \"{}\" instruct: \n\"{}\"\n output: \n\"{}\"\n is not in the expected format'.format(video_id, instruct, output)
+                pred_answer = pred_answer[0].strip()
+                # if not pred_answer.startswith('('):
+                pred_answer = pred_answer.strip('()')
+                pred_answer = f'({pred_answer})'
+                pred_idx = letters.index(pred_answer)
+            except:
+                traceback.print_exc()
+                tmp_options = [x.lower() for x in _options]
+                if output.lower() in tmp_options:
+                    tmp_options = [x.lower() for x in _options]
+                    pred_idx = tmp_options.index(output.lower())
+                else:
+                    pred_idx = 2
+
+            qas.append({'id': question_id, 'answer_id': pred_idx, 'answer': _options[pred_idx]})
+
+        ans_file.write('\"{}\": {},\n'.format(video_id, json.dumps(qas)))
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

VideoLLaMA2/videollama2/eval/inference_video_mcqa_videomme.py

@@ -0,0 +1,304 @@
+import os
+import re
+import math
+import json
+import copy
+import argparse
+import warnings
+import traceback
+
+import cv2
+import torch
+import pysubs2
+import numpy as np
+import pyarrow.parquet as pq
+from tqdm import tqdm
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+def get_seq_frames(total_num_frames, desired_num_frames):
+    """
+    Calculate the indices of frames to extract from a video.
+
+    Parameters:
+    total_num_frames (int): Total number of frames in the video.
+    desired_num_frames (int): Desired number of frames to extract.
+
+    Returns:
+    list: List of indices of frames to extract.
+    """
+
+    # Calculate the size of each segment from which a frame will be extracted
+    seg_size = float(total_num_frames - 1) / desired_num_frames
+
+    seq = []
+    for i in range(desired_num_frames):
+        # Calculate the start and end indices of each segment
+        start = int(np.round(seg_size * i))
+        end = int(np.round(seg_size * (i + 1)))
+
+        # Append the middle index of the segment to the list
+        seq.append((start + end) // 2)
+
+    return seq
+
+
+class VideoMMEDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, video_folder, subtitle_folder, data_list, processor):
+        self.video_folder = video_folder
+        self.subtitle_folder = subtitle_folder
+        self.data_list = data_list
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+
+        video_ytid = line['url'].split('watch?v=')[-1]
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(self.video_folder, f'{video_ytid}{fmt}')
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        subtitle_path = os.path.join(self.subtitle_folder, f'{video_ytid}.srt')
+
+        try:
+            video_tensor = self.processor(video_path)
+            num_frames = video_tensor.shape[0]
+        except:
+            traceback.print_exc()
+            print(f'It occurs error when reading {video_ytid}')
+            video_tensor = None
+            num_frames = 0
+
+        if video_tensor is not None and os.path.exists(subtitle_path):
+            cv2_vr = cv2.VideoCapture(video_path)
+            duration = int(cv2_vr.get(cv2.CAP_PROP_FRAME_COUNT))
+            fps = cv2_vr.get(cv2.CAP_PROP_FPS)
+            selected_frame_ids = get_seq_frames(duration, num_frames)
+
+            subs = pysubs2.load(subtitle_path, encoding="utf-8")
+            subtitles = []
+            for seleced_frame_id in selected_frame_ids:
+                sub_text = ""
+                cur_time = pysubs2.make_time(fps=fps, frames=seleced_frame_id)
+                for sub in subs:
+                    if sub.start < cur_time and sub.end > cur_time:
+                        sub_text = sub.text.replace("\\N", " ")
+                        break
+                if sub_text.strip():
+                    subtitles.append(sub_text)
+            subtitles = "\n".join(subtitles)
+        else:
+            subtitles = ""
+
+        return {
+            'video': video_tensor,
+            'subtitle': subtitles,
+            'record': line,
+        }
+
+
+def collate_fn(batch):
+    vid = [x['video'] for x in batch]
+    sub = [x['subtitle'] for x in batch]
+    rcs = [x['record'] for x in batch]
+    return vid, sub, rcs
+
+
+def load_parquet(parquet_file):
+    table = pq.read_table(parquet_file)
+
+    # Convert PyArrow Table to pandas DataFrame
+    df = table.to_pandas()
+
+    jsons = []
+    for record in df.itertuples():
+
+        if len(jsons) < int(record.video_id):
+            jsons.append({
+                "video_id": record.video_id,
+                "youtube_id": record.videoID,
+                "url": record.url,
+                "duration": record.duration,
+                "domain": record.domain,
+                "sub_category": record.sub_category,
+                "questions": [
+                    {
+                        "question_id": record.question_id,
+                        "task_type": record.task_type,
+                        "question": record.question,
+                        "choices": list(record.options),
+                        "answer": record.answer,
+                    }
+                ]
+            })
+        else:
+            jsons[-1]['questions'].append({
+                "question_id": record.question_id,
+                "task_type": record.task_type,
+                "question": record.question,
+                "choices": list(record.options),
+                "answer": record.answer,
+            })
+
+    return jsons
+
+
+def build_videomme_eval(args, processor):
+    # convert parquet to json
+    questions = load_parquet(args.question_file)
+    # questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    dataset = VideoMMEDataset(args.video_folder, args.subtitle_folder, questions, processor)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    return dataloader
+
+
+def videomme_dump(record, instruct, options, output):
+    letters = ['A', 'B', 'C', 'D']
+
+    digit2word = {
+        '1': 'one',
+        '2': 'two',
+        '3': 'three',
+        '4': 'four',
+        '5': 'five',
+        '6': 'six',
+        '7': 'seven',
+        '8': 'eight',
+        '9': 'nine',
+        '0': 'zero',
+    }
+
+    output = output.replace('answer', '')
+    output = output.replace('Answer', '')
+    pred_answer = re.findall('[\(\ \[]*([A-D])[\)\.\ \]]*', output)
+    try:
+        find_flag = False
+        if len(pred_answer) == 0:
+            for idx, opt in enumerate(options):
+                # Arabic numerals -> English words
+                opt2 = opt
+                if opt in digit2word:
+                    opt2 = digit2word[opt]
+                if opt.lower() in output.lower() or opt2.lower() in output.lower():
+                    pred_idx = idx
+                    find_flag = True
+                    break
+        else:
+            pred_answer = pred_answer[0].strip()
+            pred_answer = pred_answer.strip('()')
+            pred_idx = letters.index(pred_answer)
+            find_flag = True
+
+        assert find_flag, 'The video \"{}\" instruct: \n\"{}\"\n output: \n\"{}\"\n is not in the expected format'.format(record['youtube_id'], instruct, output)
+    except:
+        traceback.print_exc()
+        pred_idx = 2
+
+    return letters[pred_idx]
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    # Initialize the model
+    model, processor, tokenizer = model_init(args.model_path)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    answer_sub_file = answer_file.replace('.json', '_sub.json')
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+    ans_sub_file = open(answer_sub_file, "w")
+
+    val_loader = build_videomme_eval(args, processor['video'])
+
+    # Iterate over each sample in the ground truth file
+    for i, (videos, subtitles, records) in enumerate(tqdm(val_loader)):
+        video_tensor  = videos[0]
+        subtitle = subtitles[0]
+        record = records[0]
+
+        new_record = copy.deepcopy(record)
+        new_record_sub = copy.deepcopy(record)
+
+        if video_tensor is None:
+            new_record['missing'] = True
+            ans_file.write(json.dumps(new_record) + ",\n")
+            new_record_sub['missing'] = True
+            ans_sub_file.write(json.dumps(new_record_sub) + ",\n")
+            continue
+        else:
+            new_record['missing'] = False
+            new_record_sub['missing'] = False
+
+        questions = record['questions']
+        for idx, question in enumerate(questions):
+            q = question['question']
+            choices = question['choices']
+            options = [re.findall('[A-D]\. (.*).', c)[0] for c in choices]
+
+            instruct = "Select the best answer to the following multiple-choice question based on the video. Respond with only the letter (A, B, C, or D) of the correct option.\n"
+            instruct += f"{q}\n"
+            for cho_idx, cho in enumerate(choices):
+                instruct += f"{cho}\n"
+            # instruct += "The best option is: "
+            instruct += "Answer with the option\'s letter from the given choices directly and only give the best option. The best answer is: "
+            output = mm_infer(video_tensor, instruct, model=model, tokenizer=tokenizer, modal='video', do_sample=False)
+            new_record['questions'][idx]['response'] = videomme_dump(record, instruct, options, output)
+
+            instruct = f"This video's subtitles are listed below:\n{subtitle}\n" + instruct
+            output = mm_infer(video_tensor, instruct, model=model, tokenizer=tokenizer, modal='video', do_sample=False)
+            new_record_sub['questions'][idx]['response'] = videomme_dump(record, instruct, options, output)
+
+        ans_file.write(json.dumps(new_record) + ",\n")
+        ans_sub_file.write(json.dumps(new_record_sub) + ",\n")
+
+    ans_file.close()
+    ans_sub_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--subtitle-folder', help='Directory containing subtitle files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--num-workers", type=int, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

VideoLLaMA2/videollama2/eval/inference_video_oqa_activitynet.py

@@ -0,0 +1,150 @@
+import os
+import json
+import math
+import argparse
+import warnings
+import traceback
+from tqdm import tqdm
+
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class ActivitynetDataset(Dataset):
+
+    video_formats = ['.mp4', '.webm', '.avi', '.mov', '.mkv']
+
+    def __init__(self, questions, answers, processor):
+        self.questions = questions
+        self.answers   = answers
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.questions)
+    
+    def __getitem__(self, idx):
+        sample = self.questions[idx]
+        answer = self.answers[idx]
+
+        video_name  = sample['video_name']
+        question    = sample['question']
+        question_id = sample['question_id']
+        answer      = answer['answer']
+
+        video_path = None
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"v_{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+            # BUG: compatibility for MSVD, MSRVTT, TGIF
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        if video_path is None:
+            raise FileNotFoundError(f"Video file not found for {os.path.join(args.video_folder, video_name)}")
+
+        video_tensor = self.processor(video_path)
+
+        return {
+            'video':       video_tensor,
+            'video_name':  video_name,
+            'question':    question,
+            'question_id': question_id,
+            'answer':      answer,
+        }
+
+
+def collate_fn(batch):
+    vid  = [x['video'] for x in batch]
+    v_id = [x['video_name'] for x in batch]
+    qus  = [x['question'] for x in batch]
+    qid  = [x['question_id'] for x in batch]
+    ans  = [x['answer'] for x in batch]
+    return vid, v_id, qus, qid, ans
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    # Initialize the model
+    model, processor, tokenizer = model_init(args.model_path)
+
+    gt_questions = json.load(open(args.question_file, "r"))
+    gt_questions = get_chunk(gt_questions, args.num_chunks, args.chunk_idx)
+    gt_answers = json.load(open(args.answer_file, "r"))
+    gt_answers = get_chunk(gt_answers, args.num_chunks, args.chunk_idx)
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = ActivitynetDataset(gt_questions, gt_answers, processor['video'])
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    answer_file = os.path.join(args.output_file)
+    os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    # Iterate over each sample in the ground truth file
+    for i, (video_tensors, video_names, questions, question_ids, answers) in enumerate(tqdm(dataloader)):
+        video_tensor = video_tensors[0]
+        video_name   = video_names[0]
+        question     = questions[0]
+        question_id  = question_ids[0]
+        answer       = answers[0]
+
+        # question = question + '\n' + 'Answer the question using a single word or a short phrase with multiple words.'
+
+        try:
+            output = mm_infer(
+                video_tensor,
+                question,
+                model=model,
+                tokenizer=tokenizer,
+                modal='video',
+                do_sample=False,
+            )
+        except:
+            traceback.print_exc()
+            output = "error"
+
+        sample_set = {'id': question_id, 'question': question, 'answer': answer, 'pred': output}
+        ans_file.write(json.dumps(sample_set) + "\n")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument('--output-file', help='Directory to save the model results JSON.', required=True)
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

VideoLLaMA2/videollama2/eval/inference_video_oqa_vcgpt_consistency.py

@@ -0,0 +1,150 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+from tqdm import tqdm
+
+import torch
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2 import model_init, mm_infer
+from videollama2.utils import disable_torch_init
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class VCGPTDataset(Dataset):
+
+    video_formats = ['.mp4', '.webm', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor):
+        self.data_list = data_list
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        question1 = line['Q1']
+        question2 = line['Q2']
+        answer = line['A']
+        video_name = line['video_name']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        video_tensor = self.processor(video_path)
+
+        return {
+            'video': video_tensor,
+            'video_name': video_name,
+            'question1': question1,
+            'question2': question2,
+            'answer': answer,
+        }
+
+
+def collate_fn(batch):
+    vid = [x['video'] for x in batch]
+    v_id = [x['video_name'] for x in batch]
+    qus1 = [x['question1'] for x in batch]
+    qus2 = [x['question2'] for x in batch]
+    ans = [x['answer'] for x in batch]
+    vid = torch.stack(vid, dim=0)
+    return vid, v_id, qus1, qus2, ans
+
+
+def run_inference(args):
+    disable_torch_init()
+
+    # Initialize the model
+    model, processor, tokenizer = model_init(args.model_path)
+
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = VCGPTDataset(questions, processor['video'])
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    output_list = []  # List to store the output results
+
+    # Iterate over each sample in the ground truth file
+    for i, (video_tensors, video_names, questions1, questions2, answers) in enumerate(tqdm(dataloader)):
+
+        # reduce batch dimension
+        video_tensor = video_tensors[0]
+        video_name = video_names[0]
+        question1 = questions1[0]
+        question2 = questions2[0]
+        answer = answers[0]
+
+        output1 = mm_infer(
+            video_tensor,
+            question1, 
+            model=model,
+            tokenizer=tokenizer,
+            modal='video',
+            do_sample=False,
+        )
+
+        output2 = mm_infer(
+            video_tensor,
+            question2,
+            model=model,
+            tokenizer=tokenizer,
+            do_sample=False,
+            modal='video',
+        )
+
+        qa = {'video_name': video_name, 'Q1': question1, 'Q2': question2, 'A': answer, 'P1': output1, 'P2': output2}
+
+        ans_file.write(json.dumps(qa) + "\n")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    # Define the command-line arguments
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--model_base', help='', default=None, type=str, required=False)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+
+    args = parser.parse_args()
+
+    run_inference(args)