Upload folder using huggingface_hub

.gitattributes

@@ -483,3 +483,4 @@ checkpoints/pi05_libero_stage2p5_joint/pi05_track_and_action/15000/params/ocdbt.
 checkpoints/pi05_libero_stage2p5_joint/pi05_track_and_action/15000/params/ocdbt.process_0/d/ab851ee680b0b7172638559f7884464d filter=lfs diff=lfs merge=lfs -text
 checkpoints/pi05_libero_stage2p5_joint/pi05_track_and_action/15000/params/ocdbt.process_0/d/fd926748ce15ae92bec61681149c99a2 filter=lfs diff=lfs merge=lfs -text
 vlac/evo_vlac/examples/videos/pick-bowl-ref.mov filter=lfs diff=lfs merge=lfs -text
+VLAC/evo_vlac/examples/videos/pick-bowl-ref.mov filter=lfs diff=lfs merge=lfs -text

VLAC/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.py[cod]
+*$py.class
+evo_vlac.egg-info/
+build/

VLAC/1.txt

@@ -0,0 +1,9 @@
+index,value,critic,done
+1,0.0,0.0,0
+2,0.0,0.0,0
+3,12.4,12.4,0
+4,25.0,12.6,0
+5,27.3,2.3,0
+6,32.9,5.6,0
+7,41.2,8.3,0
+8,50.0,8.8,1

VLAC/2.txt

@@ -0,0 +1,9 @@
+index,value,critic,done
+1,0.0,0.0,0
+2,0.0,0.0,0
+3,10.0,10.0,0
+4,5.0,-5.0,0
+5,15.2,10.2,0
+6,30.0,14.8,0
+7,25.2,-4.8,0
+8,35.1,10.1,0

VLAC/LICENSE

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

VLAC/README.md

@@ -0,0 +1,186 @@
+# VLAC: A Vision-Language-Action-Critic Model for Robotic Real-World Reinforcement Learning
+<div align="center">
+
+[[paper]](data/VLAC_EAI.pdf)
+[[code]](https://github.com/InternRobotics/VLAC)
+[[model]](https://huggingface.co/InternRobotics/VLAC)
+
+</div>
+
+## 🚀 Interactive Demo & Homepage
+
+<div align="center">
+
+### [🎮 **Try Interactive & Homepage**](https://vlac.intern-ai.org.cn/)
+> **Online Demo is available now in Homepage, Try as you like!!!**
+
+</div>
+
+<div align="center">
+  <img src="data/title_banner-2.gif" alt="VLAC banner" width="800"></img>
+</div>
+
+## VLAC
+
+VLAC is a general-purpose pair-wise critic and manipulation model which designed for real world robot reinforcement learning and data refinement. 
+
+It provides robust evaluation capabilities for task progress prediction and task completion verification base one images and task description.
+
+VLAC trained on 3000h+ human egocentric data, 1200h+ comprehensive public robotic manipulation data, and 15h+ self-collected manipulation data.
+
+## ✨ Key Features
+
+• **Pair-wise comparison mechanism** for improved progressing dense critic accuracy, better recognition of state changes, and each step can be the start of the trajectory.
+
+• **Multi-modal capabilities** - Supports process tracking, task completion judgment, task description estimation, visual question answering, and even embodied action output, equipped with VLA capabilities.
+
+• **Flexible zero-shot and one-shot** - in-context capabilities, maintaining excellent performance across entities, scenarios, and tasks.
+
+• **Human-task synesthesia** - Based on the ego4D human dataset, model understands common tasks and build synesthesia for real-world human tasks and embodied tasks.
+
+• **Trajectory quality screening** - VLAC can evaluate the collected trajectories and filters out low score trajectories based on the VOC value and mask the action with negative pair-wise score, that is, data with low fluency and quality, improving the effect and efficiency of imitation learning.
+
+## Framework
+
+<div align="center">
+  <img src="data/framework.png" alt="VLAC Framework" width="800"/>
+</div>
+
+*The VLAC model is trained on a combination of comprehensive public robotic manipulation datasets, human demonstration data, self-collected manipulation data, and various image understanding datasets. Video data is processed into pair-wise samples to learn the different task progress between any two frames, supplemented with task descriptions and task completion evaluation to enable task progress understanding and action generation, as illustrated in the bottom-left corner. As shown in the diagram on the right, the model demonstrates strong generalization capabilities to new robots, scenarios, and tasks not covered in the training dataset. It can predict task progress and distinguish failure action or trajectory, providing dense reward feedback for real-world reinforcement learning and offering guidance for data refinement. Additionally, the model can directly perform manipulation tasks, exhibiting zero-shot capabilities to handle different scenarios.*
+
+## Performance
+
+Details about the model's performance and evaluation metrics can be found in the [Homepage](https://vlac.intern-ai.org.cn/).
+
+## 🛠️ Installation
+
+To install from source:
+```shell
+git clone https://github.com/InternRobotics/VLAC.git
+cd VLAC
+pip install -e .
+```
+Running Environment:
+
+|              | Range        | Recommended | Notes                                     |
+| ------------ |--------------| ----------- | ----------------------------------------- |
+| python       | >=3.9        | 3.10        |                                           |
+| cuda         |              | cuda12      | No need to install if using CPU, NPU, MPS |
+| torch        | >=2.0        |             |                                           |
+| transformers | >=4.51       | 4.51.3      |                                           |
+| peft | >=0.15.2       |      |                                           |
+| ms-swift |        | 3.3      |                                           |
+
+
+## 🚀 Quick Start
+
+```python
+from evo_vlac import GAC_model
+from evo_vlac.utils.video_tool import compress_video
+import os
+#Consistent with the web interface, the value and citic rewards of video input can be evaluated.
+
+
+#assign local model path
+model_path="set to your local model path"
+#download model form https://huggingface.co/InternRobotics/VLAC
+
+#assign video path and task description
+test_video='evo_vlac/examples/videos/pick-bowl-test.mp4'
+ref_video='evo_vlac/examples/videos/pick-bowl-ref.mov'
+task_description='Put up the bowl and place it back in the white storage box.'
+
+#init model
+Critic=GAC_model(tag='critic')
+Critic.init_model(model_path=model_path,model_type='internvl2',device_map=f'cuda:0')
+Critic.temperature=0.5
+Critic.top_k=1
+Critic.set_config()
+Critic.set_system_prompt()
+
+# transform video
+test_video_compressed = os.path.join(os.path.dirname(test_video),"test.mp4")
+_,output_fps=compress_video(test_video, test_video_compressed,fps=5)
+reference_video_compressed = None
+if ref_video:
+    reference_video_compressed = os.path.join(os.path.dirname(ref_video),"ref.mp4")
+    compress_video(ref_video, reference_video_compressed,fps=5)
+
+
+# generate Critic results
+result_path,value_list,critic_list,done_list = Critic.web_trajectory_critic(
+    task_description=task_description,
+    main_video_path=test_video_compressed,
+    reference_video_path=reference_video_compressed,#if None means no reference video, only use task_description to indicate the task
+    batch_num=5,#batch number
+    ref_num=6,#image number used in reference video
+    think=False,# whether to CoT
+    skip=5,#pair-wise step
+    rich=False,#whether to output decimal value
+    reverse_eval=False,#whether to reverse the evaluation(for VROC evaluation)
+    output_path="results",
+    fps=float(output_fps),
+    frame_skip=True,#whether to skip frames(if false, each frame while be evaluated, cost more time)
+    done_flag=False,#whether to out put done value
+    in_context_done=False,#whether use reference video to generate done value
+    done_threshold=0.9,#done threshold
+    video_output=True#whether to output video
+)
+
+
+print("=" * 100)
+print(">>>>>>>>>Critic results<<<<<<<<<<")
+print(" ")
+
+print(f"result path: {result_path}")
+print(f"task description: {task_description}")
+print("=" * 50)
+
+print("value_list:")
+print(value_list)
+print("=" * 50)
+
+print("critic_list:")
+print(critic_list)
+print("=" * 50)
+
+print("done_list:")
+print(done_list)
+print("=" * 100)
+```
+If the GPU memory is insufficient, please reduce the number of "batch_num".
+
+More examples  of 
+
+• pair-wise image inputs critic. Please check [this example](evo_vlac/examples/image_pair-wise_critic_example.py)
+
+• vla action generation. Please check [this example](evo_vlac/examples/vla_example.py)
+
+• data refinement. Please check [this example](evo_vlac/examples/data_filtering_example.py)
+
+
+For training code, please refer to [InternVL2](https://huggingface.co/OpenGVLab/InternVL2-2B#quick-start).
+
+## 🔗 Citation
+
+If you find our work helpful, please cite:
+
+```bibtex
+@article{zhai2025vision,
+  title={A Vision-Language-Action-Critic Model for Robotic Real-World Reinforcement Learning},
+  author={Zhai, Shaopeng and Zhang, Qi and Zhang, Tianyi and Huang, Fuxian and Zhang, Haoran and Zhou, Ming and Zhang, Shengzhe and Liu, Litao and Lin, Sixu and Pang, Jiangmiao},
+  journal={arXiv preprint arXiv:2509.15937},
+  year={2025}
+}
+```
+
+## 📄 License
+
+This project is licensed under the MIT License.
+
+## 🙏 Acknowledgments
+
+- [SWIFT](https://github.com/modelscope/ms-swift)
+- [InternVL](https://github.com/OpenGVLab/InternVL)
+
+

VLAC/evo_vlac/__init__.py

@@ -0,0 +1,21 @@
+# 项目元信息
+__version__ = "1.0.0"
+__author__ = "zhangqi"
+__email__ = "zhangqi1@pjlab.org"
+__description__ = "internEVO Critic and VLA"
+
+# 导入主要组件
+from . import utils
+
+# 修复导入路径
+from .utils import data_processing_vlm
+from .utils import model_utils
+from .utils.model_utils import GAC_model
+from .utils import video_tool
+# 包级别的便捷函数
+def get_version():
+    """获取项目版本"""
+    return __version__
+
+# 定义包的公开接口
+__all__ = ["utils", "model_utils", "data_processing_vlm", "get_version","GAC_model","video_tool"]

VLAC/evo_vlac/examples/data_filtering_example.py

@@ -0,0 +1,63 @@
+from evo_vlac import GAC_model
+from evo_vlac.utils.video_tool import compress_video
+import os
+#Consistent with the web interface, the value and citic rewards of video input can be evaluated.
+
+
+#assign local model path
+model_path="set to your local model path"
+
+#assign video path and task description
+test_video='./videos/pick-bowl-test.mp4'
+ref_video='./videos/pick-bowl-ref.mov'#optional
+task_description='Put up the bowl and place it back in the white storage box.'
+
+#init model
+Critic=GAC_model(tag='critic')
+Critic.init_model(model_path=model_path,model_type='internvl2',device_map=f'cuda:0')
+Critic.temperature=0.5
+Critic.top_k=1
+Critic.set_config()
+Critic.set_system_prompt()
+
+# transform video
+test_video_compressed = os.path.join(os.path.dirname(test_video),"test.mp4")
+_,output_fps=compress_video(test_video, test_video_compressed,fps=5)
+reference_video_compressed = None
+if ref_video:
+    reference_video_compressed = os.path.join(os.path.dirname(ref_video),"ref.mp4")
+    compress_video(ref_video, reference_video_compressed,fps=5)
+
+
+# generate Critic results
+result_path,value_list,critic_list,done_list = Critic.web_trajectory_critic(
+    task_description=task_description,
+    main_video_path=test_video_compressed,
+    reference_video_path=reference_video_compressed,#if None means no reference video, only use task_description to indicate the task
+    batch_num=5,#batch number
+    ref_num=6,#image number used in reference video
+    think=False,# whether to CoT
+    skip=5,#pair-wise step
+    rich=False,#whether to output decimal value
+    reverse_eval=False,#whether to reverse the evaluation(for VROC evaluation)
+    output_path="results",
+    fps=float(output_fps),
+    frame_skip=True,#whether to skip frames(if false, each frame while be evaluated, cost more time)
+    video_output=False
+)
+
+value_list=Critic.critic_to_value_simple(critic_list,'mix_f')
+voc=Critic.compute_voc(value_list)
+nr=Critic.compute_negative_rate(critic_list)
+print("=" * 100)
+print(">>>>>>>>>DATA diagnose<<<<<<<<<<")
+print(" ")
+print(f'Negative rate: {nr}')
+print(f"VOC: {voc}")
+print("The larger the VOC value(-1~+1) and lower Negative rate(0~1), the better the data quality; overly values can directly filter out data, and specific thresholds can be selected based on the specific task.")
+print("=" * 50)
+
+print("critic_list:")
+print(critic_list)
+print("Actions corresponding to steps with a negative Critic can be filtered out to avoid interference with imitation learning by incorrect movements.")
+print("=" * 50)

VLAC/evo_vlac/examples/image_pair.py

@@ -0,0 +1,45 @@
+from evo_vlac import GAC_model
+from evo_vlac.utils.video_tool import compress_video
+import os
+#Example code for inputting images and evaluating pair-wise
+
+#assign local model path
+model_path="/scratch1/home/zhicao/VLAC/model/VLAC-8b"
+
+#Input n images, output a critic_list of length n-1 and a value_list of length n. The critic evaluates the results of adjacent images (i, i+1); if i+1 is closer to accomplishing the task than i, the evaluation result is positive; otherwise, it is negative. It can evaluate the action rewards between any pair-wise images. The value_list is calculated based on the critic.
+test_images=['./images/test/0.png','./images/test/1.png','./images/test/2.png','./images/test/3.png','./images/test/4.png','./images/test/5.png','./images/test/6.png','./images/test/7.png']
+#（optional）Input up to 11 images as reference trajectories for tasks, significantly improving adaptation to new tasks and environments.
+ref_images=['./images/ref/0.png','./images/ref/1.png','./images/ref/2.png','./images/ref/3.png','./images/ref/4.png','./images/ref/5.png','./images/ref/6.png','./images/ref/7.png','./images/ref/8.png','./images/ref/9.png','./images/ref/10.png']
+task_description='Close the bottom drawer of the cabinet demo.'
+
+#init model
+Critic=GAC_model(tag='critic')
+Critic.init_model(model_path=model_path,model_type='internvl2',device_map=f'cuda:0')
+Critic.temperature=0.5
+Critic.top_k=1
+Critic.set_config()
+Critic.set_system_prompt()
+
+# generate Critic results
+critic_list, value_list=Critic.get_trajectory_critic(
+    task=task_description,
+    image_list=test_images,
+    ref_image_list=None,
+    batch_num=5,#max batch number when generating critic
+    ref_num=len(ref_images),#image number used in ref_images
+    rich=False,#whether to output decimal value
+    reverse_eval=False,#whether to reverse the evaluation(for VROC evaluation)
+)
+
+
+print("=" * 100)
+print(">>>>>>>>>Critic results<<<<<<<<<<")
+print(" ")
+
+print("value_list:")
+print(value_list)
+print("=" * 50)
+
+print("critic_list:")
+print(critic_list)
+print("=" * 50)

VLAC/evo_vlac/examples/video_trajectory_critic_example.py

@@ -0,0 +1,71 @@
+from evo_vlac import GAC_model
+from evo_vlac.utils.video_tool import compress_video
+import os
+#Consistent with the web interface, the value and citic rewards of video input can be evaluated.
+
+
+#assign local model path
+model_path="set to your local model path"
+
+#assign video path and task description
+test_video='./videos/pick-bowl-test.mp4'
+ref_video='./videos/pick-bowl-ref.mov'
+task_description='Put up the bowl and place it back in the white storage box.'
+
+#init model
+Critic=GAC_model(tag='critic')
+Critic.init_model(model_path=model_path,model_type='internvl2',device_map=f'cuda:0')
+Critic.temperature=0.5
+Critic.top_k=1
+Critic.set_config()
+Critic.set_system_prompt()
+
+# transform video
+test_video_compressed = os.path.join(os.path.dirname(test_video),"test.mp4")
+_,output_fps=compress_video(test_video, test_video_compressed,fps=5)
+reference_video_compressed = None
+if ref_video:
+    reference_video_compressed = os.path.join(os.path.dirname(ref_video),"ref.mp4")
+    compress_video(ref_video, reference_video_compressed,fps=5)
+
+
+# generate Critic results
+result_path,value_list,critic_list,done_list = Critic.web_trajectory_critic(
+    task_description=task_description,
+    main_video_path=test_video_compressed,
+    reference_video_path=reference_video_compressed,#if None means no reference video, only use task_description to indicate the task
+    batch_num=5,#batch number
+    ref_num=6,#image number used in reference video
+    think=False,# whether to CoT
+    skip=5,#pair-wise step
+    rich=False,#whether to output decimal value
+    reverse_eval=False,#whether to reverse the evaluation(for VROC evaluation)
+    output_path="results",
+    fps=float(output_fps),
+    frame_skip=True,#whether to skip frames(if false, each frame while be evaluated, cost more time)
+    done_flag=False,#whether to out put done value
+    in_context_done=False,#whether use reference video to generate done value
+    done_threshold=0.9,#done threshold
+    video_output=True#whether to output video
+)
+
+
+print("=" * 100)
+print(">>>>>>>>>Critic results<<<<<<<<<<")
+print(" ")
+
+print(f"result path: {result_path}")
+print(f"task description: {task_description}")
+print("=" * 50)
+
+print("value_list:")
+print(value_list)
+print("=" * 50)
+
+print("critic_list:")
+print(critic_list)
+print("=" * 50)
+
+print("done_list:")
+print(done_list)
+print("=" * 100)

VLAC/evo_vlac/examples/videos/pick-bowl-ref.mov

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

VLAC/evo_vlac/examples/videos/pick-bowl-test.mp4

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

VLAC/evo_vlac/examples/vla_example.py

@@ -0,0 +1,51 @@
+from evo_vlac import GAC_model
+from evo_vlac.utils.video_tool import compress_video
+import os
+#Example code for realizing VLA inference with open tasks and multi-perspective generalization capability, inputs 1-3 images and eef position, outputs delta eef actions, most friendly to songling (pika) robotic arms.
+#This is a preview version, fine-tuning code for different robotic arms will be released together with the paper.
+
+#assign local model path
+model_path="/scratch1/home/zhicao/VLAC/models/VLAC"
+
+view_images=["./images/test/595-44-565-0.jpg","./images/test/595-44-565-2.jpg"]
+eef_position=[
+    -18151,
+    11685,
+    418833,
+    -124631,
+    65461,
+    -133783,
+    27510
+]#The unit of xyz is 0.001mm, and the unit of rpy is 0.001 degrees
+task_description='Scoop the rice into the rice cooker.'
+
+
+history=False#whether to use history chat
+complete_requests_list=None#chat history
+
+#init model
+Policy=GAC_model(tag='Policy')
+Policy.init_model(model_path=model_path,model_type='internvl2',device_map=f'cuda:0')
+Policy.temperature=0.5
+Policy.top_k=1
+Policy.set_config()
+Policy.set_system_prompt()
+
+query=Policy.get_action_prompt(task=task_description,view_num=len(view_images),position_output=False,simple=False,state=Policy.format_state(eef_position,gripper_format=False),think=False)
+infer_requests=Policy.get_infer_requests(prompt=query,images=view_images)
+if history:
+    if complete_requests_list:
+        complete_requests_list[0].images.extend(infer_requests[0].images)
+        complete_requests_list[0].messages.append(infer_requests[0].messages[1])
+        if len(complete_requests_list[0].images)>history_image_num:
+            complete_requests_list[0].images=complete_requests_list[0].images[len(infer_requests[0].images):]
+            complete_requests_list[0].messages=complete_requests_list[0].messages[:1]+complete_requests_list[0].messages[3:]
+        infer_requests=complete_requests_list
+response_list,infer_time=Policy.chat(infer_requests)
+answers_list,complete_requests_list=Policy.results_format(response_list,infer_requests,rich=True)
+
+
+print("=" * 100)
+print(">>>>>>>>>VLA results<<<<<<<<<<")
+print(" ")
+print(f'action:{answers_list}')

VLAC/evo_vlac/utils/data_processing_vlm.py

@@ -0,0 +1,692 @@
+import os
+import json
+import tqdm
+import random
+import numpy as np
+import cv2
+import pickle
+from typing import Any, Dict, List, Literal, Optional, Set, Tuple, Union
+from loguru import logger
+
+import matplotlib.pyplot as plt
+from collections import defaultdict
+from scipy.stats import truncnorm
+from PIL import Image, ImageEnhance, ImageFilter
+from pathlib import Path
+import math
+import copy
+import re
+from collections import defaultdict, Counter
+import matplotlib.pyplot as plt
+import pandas as pd
+
+
+def transform_images(text: str) -> str:
+    occurrences = re.findall(r"<image>\n", text)
+    
+    if len(occurrences) <= 1:
+        return text
+    
+    count = 0
+    def replace_func(match):
+        nonlocal count
+        count += 1
+        return f"Image-{count}: <image>\n"
+
+    transformed_text = re.sub(r"<image>\n", replace_func, text)
+    
+    return transformed_text
+
+
+
+def is_image_black(image_array):
+    # Check if all pixel values are 0 (black image)
+    return np.all(image_array == 0)
+
+def is_image_almost_black(image_array, threshold=0.80, tolerance=10):
+    """
+    Check if the RGB image is almost entirely black.
+
+    Parameters:
+    image_array (ndarray): The input RGB image array of shape (height, width, 3).
+    threshold (float): The fraction of pixels that must be close to black for the image to be considered almost black.
+    tolerance (int): The maximum value a pixel can have in each channel to be considered black (0-255 scale).
+
+    Returns:
+    bool: True if the image is almost black, False otherwise.
+    """
+    # Check if all channels are below the tolerance for each pixel
+    nearly_black_pixels = np.sum(np.all(image_array <= tolerance, axis=-1))
+    total_pixels = image_array.shape[0] * image_array.shape[1]
+
+    fraction_black = nearly_black_pixels / total_pixels
+
+    return fraction_black >= threshold
+
+def is_image_path_almost_black(image_path):
+    try:
+        img = Image.open(image_path).convert('RGB')
+    except:
+        return False
+    image_array = np.array(img)
+    return is_image_almost_black(image_array)
+
+
+def is_image_path_black(image_path):
+    try:
+        img = Image.open(image_path).convert('RGB')
+    except:
+        return False
+    image_array = np.array(img)
+    return np.all(image_array == 0)
+
+def compare_images(image1_path, image2_path):
+    # Load the images
+    try:
+        img1 = Image.open(image1_path).convert('RGB')
+        img2 = Image.open(image2_path).convert('RGB')
+    except:
+        return -1
+    
+    if img1.size != img2.size:
+        img2 = img2.resize(img1.size)
+    
+    img1_array = np.array(img1)
+    img2_array = np.array(img2)
+
+    if is_image_almost_black(img1_array) or is_image_almost_black(img2_array):
+        return -1
+    
+    difference = np.abs(img1_array - img2_array)
+    
+    num_different_pixels = np.sum(difference > 0)
+    
+    total_pixels = img1_array.size
+    
+    percentage_difference = (num_different_pixels / total_pixels) * 100
+    
+    return percentage_difference
+
+def denormalize_with_params(normalized_data, params):
+    """
+    使用参数将归一化的数据还原到原始范围
+    
+    Args:
+        normalized_data: 归一化后的任意维度数组，但最后一个维度必须是7
+        params: 归一化参数字典
+        
+    Returns:
+        numpy.ndarray: 还原后的数据，维度与输入一致
+    """
+    # 转换为numpy数组
+    data_array = np.array(normalized_data)
+    original_shape = data_array.shape
+    
+    # 检查最后一个维度是否为7
+    if len(original_shape) < 2:
+        raise ValueError(f"输入数据至少应该是2维的，但得到的是{len(original_shape)}维")
+    
+    if original_shape[-1] != 7:
+        raise ValueError(f"输入数据的最后一个维度应该是7，但得到的是{original_shape[-1]}")
+    
+    # 将数据reshape为(..., 7)的形状，然后flatten前面的维度
+    working_data = data_array.reshape(-1, 7)
+    
+    # 提取参数
+    scale = np.array(params['scale'])
+    offset = np.array(params['offset'])
+    
+    # 反向变换: x = normalized * scale + offset
+    original_data = working_data * scale + offset
+    
+    # 恢复原始形状
+    original_data = original_data.reshape(original_shape)
+    
+    return original_data
+
+def agibot_process(action,action_type='action'):
+    if action_type=='fast-chunk':
+        return action
+    def convert_to_int(element):
+        if isinstance(element, list):
+            return [convert_to_int(sub_element) for sub_element in element]
+        else:
+            try:
+                return int(element)
+            except ValueError:
+                return element  # Return the element unchanged if it can't be converted
+
+    return convert_to_int(action)
+
+
+def songling_process_single(action,action_type='action'):
+    if type(action) is list:
+        for i in range(3,6):
+            if abs(action[i])>180000:
+                action[i]=((action[i] + 180000) % 360000) - 180000
+        if action_type=='fast-chunk':
+            new_action=action[:-1]+[int(action[-1]/1000)]
+        else:
+            new_action=[int(temp/1000.0) for temp in action]
+        if action_type=='action' or action_type=='fast-chunk':
+            if new_action[-1]<0:
+                new_action[-1]=0
+            elif new_action[-1]>=1:
+                new_action[-1]=1
+            else:
+                new_action[-1]=0
+        if action_type=='state':
+            new_action[-1]=round((new_action[-1]//10000)/7.0,1)
+        return new_action
+    else:
+        return None
+
+def songling_process(action, action_type='action'):
+    if type(action) is list:
+        if len(action) == 7 and all(not isinstance(item, list) for item in action):
+            return songling_process_single(action, action_type)
+        else:
+            new_action = []
+            for one_action in action:
+                processed = songling_process(one_action, action_type)
+                if processed is not None:
+                    new_action.append(processed)
+            return new_action if new_action else None
+    else:
+        return None
+
+
+def format_songling(action):
+    if action is None:
+        return 'None'
+    elif type(action) is list:
+        if type(action[0]) is list:
+            if len(action)==2:
+                return "\nleft: <action> {{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}} </action> \nright: <action> {{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}} </action>".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6],action[1][0],action[1][1],action[1][2],action[1][3],action[1][4],action[1][5],action[1][6])
+            elif len(action)==1:
+                return "{{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}}".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6])
+            else:
+                return 'None'
+        else:
+            return "{{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}}".format(action[0],action[1],action[2],action[3],action[4],action[5],action[6])
+    else:
+        return 'End-Effector with units in mm and degrees'
+
+def normalize_angle(angle):
+    if abs(angle)>180:
+        return (angle + 180) % 360 - 180
+    else:
+        return angle
+
+
+def format_songling_v2(action,state=False,data_type=None):
+    if action is None:
+        return 'None'
+    elif type(action) is list:
+        if type(action[0]) is list:
+            pass
+        else:
+            action = [action]
+        if state:
+            pass
+        else:
+            for i in range(len(action)):
+                action[i][3]=normalize_angle(action[i][3])
+                action[i][4]=normalize_angle(action[i][4])
+                action[i][5]=normalize_angle(action[i][5])
+        if len(action)==2:
+            if state:
+                return "\nleft: <position> {{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}} </position> \nright: <position> {{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}} </position>".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6],action[1][0],action[1][1],action[1][2],action[1][3],action[1][4],action[1][5],action[1][6])
+            else:
+                return "\nleft: <action> {{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}} </action> \nright: <action> {{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}} </action>".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6],action[1][0],action[1][1],action[1][2],action[1][3],action[1][4],action[1][5],action[1][6])
+        elif len(action)==1:
+            return "{{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}}".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6])
+        else:
+            return 'None'
+    else:
+        if data_type:
+            return f'{data_type} End-Effector with units in mm and degrees'
+        return 'End-Effector with units in mm and degrees'
+
+def format_songling_simple(action,state=False,data_type=None):
+    if action is None:
+        return 'None'
+    elif type(action) is list:
+        if type(action[0]) is list:
+            pass
+        else:
+            action = [action]
+        if state:
+            pass
+        else:
+            for i in range(len(action)):
+                action[i][3]=normalize_angle(action[i][3])
+                action[i][4]=normalize_angle(action[i][4])
+                action[i][5]=normalize_angle(action[i][5])
+        if len(action)==2:
+            if state:
+                return "\nleft: <(position)> ({} {} {} {} {} {} {}) </(position)> \nright: <(position)> ({}, {}, {}, {}, {}, {}, {}) </(position)>".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6],action[1][0],action[1][1],action[1][2],action[1][3],action[1][4],action[1][5],action[1][6])
+            else:
+                return "\nleft: <(action)> ({} {} {} {} {} {} {}) </(action)> \nright: <(action)> ({}, {}, {}, {}, {}, {}, {}) </(action)>".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6],action[1][0],action[1][1],action[1][2],action[1][3],action[1][4],action[1][5],action[1][6])
+        elif len(action)==1:
+            return "({} {} {} {} {} {} {})".format(action[0][0],action[0][1],action[0][2],action[0][3],action[0][4],action[0][5],action[0][6])
+        else:
+            return 'None'
+    else:
+        if data_type:
+            return f'{data_type} End-Effector hide units in mm and degrees within () format'
+        return 'End-Effector hide units in mm and degrees within () format'
+
+def trojectory_example_prompt(images,task):
+    prompt=f"<trajectory> <task> {task} </task>:"
+    t_len=len(images)-1
+    for i,one in enumerate(range(len(images))):
+        temp_p=int((i/t_len)*100)
+        prompt=prompt+f" {temp_p}% <image>\n"
+    prompt=prompt+'</trajectory>'
+    return prompt
+
+
+def describe_move(move_vec):
+    names = [
+        {-1: "backward", 0: None, 1: "forward"},
+        {-1: "right", 0: None, 1: "left"},
+        {-1: "down", 0: None, 1: "up"},
+        {-1: "tilt down", 0: None, 1: "tilt up"},
+        {},
+        {-1: "rotate clockwise", 0: None, 1: "rotate counterclockwise"},
+        # {-1: "close gripper", 0: None, 1: "open gripper"},
+        {0: "close gripper", 1: "open gripper"},
+    ]
+
+    xyz_move = [names[i][move_vec[i]] for i in range(0, 3)]
+    xyz_move = [m for m in xyz_move if m is not None]
+
+    if len(xyz_move) != 0:
+        description = "move " + " ".join(xyz_move)
+    else:
+        description = ""
+
+    if move_vec[3] == 0:
+        move_vec[3] = move_vec[4]  # identify rolling and pitching
+
+    if move_vec[3] != 0:
+        if len(description) > 0:
+            description = description + ", "
+
+        description = description + names[3][move_vec[3]]
+
+    if move_vec[5] != 0:
+        if len(description) > 0:
+            description = description + ", "
+
+        description = description + names[5][move_vec[5]]
+
+    if move_vec[6] != -2:
+        if len(description) > 0:
+            description = description + ", "
+
+        description = description + names[6][move_vec[6]]
+
+    if len(description) == 0:
+        description = "stop"
+
+    return description
+
+def denoise_action(action):
+    xyz = action[:3]
+    rpy = action[3:6]
+    open_val = action[6]
+
+    def normalize_angle(angle):
+        return (angle + 180) % 360 - 180
+
+    def process_dims(values, ref_max=None):
+        abs_values = [abs(v) for v in values]
+        max_val = max(abs_values)
+        
+        if max_val == 0:
+            return [0, 0, 0]
+            
+        processed = [0, 0, 0]
+        main_idx = abs_values.index(max_val)
+        processed[main_idx] = 1 if values[main_idx] > 0 else -1
+        
+        for i in range(3):
+            if i == main_idx:
+                continue
+            threshold = max_val * 0.25
+            if abs(values[i]) < threshold:
+                processed[i] = 0
+            else:
+                processed[i] = 1 if values[i] > 0 else (-1 if values[i] < 0 else 0)
+        return processed
+
+    adjusted_rpy = [normalize_angle(v) for v in rpy]
+    
+    xyz_processed = process_dims(xyz)
+    max_xyz = max(abs(v) for v in xyz)
+    
+    rpy_abs = [abs(v) for v in adjusted_rpy]
+    max_rpy = max(rpy_abs)
+    
+    if max_rpy < max_xyz * 0.25 and max_rpy <= 4:
+        rpy_processed = [0, 0, 0]
+    else:
+        rpy_processed = process_dims(adjusted_rpy)
+
+    if max_xyz < max_rpy * 0.25 and max_xyz <= 5:
+        xyz_processed = [0, 0, 0]
+    else:
+        pass
+    return xyz_processed + rpy_processed + [open_val]
+
+def describe_action(action,threshold=0.3,denoise=True):
+    if denoise:
+        action=denoise_action(action)
+    else:
+        for i in range(len(action)-1):
+            if action[i]<-threshold:
+                action[i]=-1
+            elif action[i]>threshold:
+                action[i]=1
+            else:
+                action[i]=0
+
+    return describe_move(action), action
+
+def format_songling_think_one(action,threshold=0.3,denoise=True):
+    #think_threshold dis when denoise true
+    if action is None:
+        return 'None'
+    elif type(action) is list:
+        if type(action[0]) is list:
+            if len(action)==2:
+                return f"left: <action> {describe_action(action[0],threshold,denoise)[0]} </action> \nright: <action> {describe_action(action[1],threshold,denoise)[0]} </action>"
+            elif len(action)==1:
+                return f"{describe_action(action[0],threshold,denoise)[0]}"
+            else:
+                return 'None'
+        else:
+            return f"{describe_action(action,threshold,denoise)[0]}"
+    else:
+        return 'None'
+
+def format_songling_think(action,threshold=0.3,denoise=True,multi=False):
+    if multi:
+        pass
+    else:
+        action = [action]
+    if len(action)==1:
+        return f"<think> {format_songling_think_one(action[0],threshold,denoise)} </think> "
+    action_think_str=''
+    for i,one in enumerate(action):
+        action_think_str+=f'{i+1}. '+format_songling_think_one(one,threshold,denoise)+'\n'
+    return f"<think> {action_think_str} </think> "
+
+def bridge_action_preprocess(one,data,key,td=1):
+    trajectory_id,step_id,step_num,view_id= key.split('-')
+    step_id=int(step_id)
+    step_num=int(step_num)
+    next_key=f'{trajectory_id}-{step_id+td}-{step_num}-{view_id}'
+    next_one=data.get(next_key)
+    if td>1:
+        temp_one=data.get(f'{trajectory_id}-{step_id+td-1}-{step_num}-{view_id}')
+    else:
+        temp_one=one
+    if next_one is None:
+        return None
+    if temp_one is None:
+        return None
+    one_state=one['position_7d']
+    next_state=next_one['position_7d']
+    action=[next_state[i]-one_state[i] for i in range(6)]
+    action+=[round(temp_one['action'][-1])]
+    return action
+
+def droid_action_preprocess(one,data,key,td=1):
+    trajectory_id,step_id,step_num,view_id= key.split('-')
+    step_id=int(step_id)
+    step_num=int(step_num)
+    next_key=f'{trajectory_id}-{step_id+td}-{step_num}-{view_id}'
+    next_one=data.get(next_key)
+    if next_one is None:
+        return None
+    one_state=one['position_7d']
+    next_state=next_one['position_7d']
+    action=[next_state[i]-one_state[i] for i in range(6)]
+    open_action=next_state[-1]-one_state[-1]
+    if open_action>0:
+        open_action=1
+    elif open_action<0:
+        open_action=0
+    else:
+        open_action=1 if next_state[-1] >=0.85 else 0
+    action+=[open_action]
+    return action
+
+def bridge_position_preprocess(one=None,data=None,key=None,td=1,action=True):
+    if action:
+        trajectory_id,step_id,step_num,view_id= key.split('-')
+        step_id=int(step_id)
+        step_num=int(step_num)
+        next_key=f'{trajectory_id}-{step_id+td}-{step_num}-{view_id}'
+        next_one=data.get(next_key)
+        if next_one is None:
+            return None
+        position=next_one['position_7d']
+    else:
+        position=one['position_7d']
+    if type(position) is list:
+        processed_position = [
+            max(min(int(position[i] * 1000), 999), -999) if i < 3 
+            else int(position[i] * 360 / 3.1416)
+            for i in range(6)
+        ]
+        processed_position+=[int(position[-1])*100]
+        return processed_position
+    else:
+        return None
+
+def songling_position_preprocess(one=None,data=None,key=None,td=1,action=True):
+    if action:
+        trajectory_id,step_id,step_num,view_id= key.split('-')
+        step_id=int(step_id)
+        step_num=int(step_num)
+        next_key=f'{trajectory_id}-{step_id+td}-{step_num}-{view_id}'
+        next_one=data.get(next_key)
+        if next_one is None:
+            return None
+        position=next_one['position_7d']
+    else:
+        position=one['position_7d']
+    if type(position) is list:
+        if type(position[0]) is list:
+            new_position=[]
+            for one_position in position:
+                processed_position = [int(temp/1000.0) for temp in position]
+                new_position.append(processed_position)
+            return new_position
+        else:
+            processed_position = [int(temp/1000.0) for temp in position]
+            return processed_position
+    else:
+        return None
+
+def agibot_position_preprocess(one=None,data=None,key=None,td=1,action=True):
+    if action:
+        trajectory_id,step_id,step_num,view_id= key.split('-')
+        step_id=int(step_id)
+        step_num=int(step_num)
+        next_key=f'{trajectory_id}-{step_id+td}-{step_num}-{view_id}'
+        next_one=data.get(next_key)
+        if next_one is None:
+            return None
+        position=next_one['position_7d']
+    else:
+        position=one['position_7d']
+    if type(position) is list:
+        if type(position[0]) is list:
+            new_position=[]
+            for one_position in position:
+                processed_position = [int(temp) for temp in one_position]
+                processed_position[2] = processed_position[2]-200
+                new_position.append(processed_position)
+            return new_position
+        else:
+            processed_position = [int(temp) for temp in position]
+            processed_position[2] = processed_position[2]-200
+            return processed_position
+    else:
+        return None
+
+def default_position_preprocess(one=None,data=None,key=None,td=1,action=True):
+    if action:
+        trajectory_id,step_id,step_num,view_id= key.split('-')
+        step_id=int(step_id)
+        step_num=int(step_num)
+        next_key=f'{trajectory_id}-{step_id+td}-{step_num}-{view_id}'
+        next_one=data.get(next_key)
+        if next_one is None:
+            return None
+        position=next_one['position_7d']
+    else:
+        position=one['position_7d']
+    return position
+
+def default_position_process(position,action_type='action'):
+    return position
+
+def default_action_preprocess(one,data=None,key=None,td=1):
+    return one['action']
+
+def default_process(action,action_type='action'):
+    if action_type=='fast-chunk':
+        return action
+    return [int(temp) for temp in action]
+
+def droid_process_single(action,action_type='action'):
+    if action_type=='fast-chunk':
+        return action
+    if type(action) is list:
+        processed_action = [
+            max(min(int(action[i] * 1000), 999), -999) if i < 3 
+            else int(action[i] * 360 / 3.1416)
+            for i in range(6)
+        ]
+        processed_action+=[action[-1]]
+        return processed_action
+    else:
+        return None
+
+def droid_process(action,action_type='action'):
+    if type(action) is list:
+        if type(action[0]) is list:
+            new_action=[]
+            for one_action in action:
+                new_action.append(droid_process_single(one_action,action_type))
+            return new_action
+        else:
+            return droid_process_single(action,action_type)
+    else:
+        return None
+
+
+class DataProcessor():
+    def __init__(self):
+        self.action_process={
+            'songling':songling_process,
+            'agibot':agibot_process,
+            'bridge':droid_process,
+            'droid':droid_process,
+            'default':default_process
+        }
+        self.action_format={
+            'songling':format_songling_v2,
+            'agibot':format_songling_v2,
+            'bridge':format_songling_v2,
+            'droid':format_songling_v2,
+            'default':format_songling_v2
+        }
+        self.action_format_simple={
+            'songling':format_songling_simple,
+            'agibot':format_songling_simple,
+            'bridge':format_songling_simple,
+            'droid':format_songling_simple,
+            'default':format_songling_simple
+        }
+        self.action_think_format={
+            'songling':format_songling_think,
+            'agibot':format_songling_think,
+            'bridge':format_songling_think,
+            'droid':format_songling_think,
+            'default':format_songling_think
+        }
+        self.action_preprocess={
+            'songling':default_action_preprocess,
+            'agibot':default_action_preprocess,
+            'bridge':bridge_action_preprocess,
+            'droid':droid_action_preprocess,
+            'default':default_action_preprocess
+        }
+        self.position_preprocess={
+            'songling':songling_position_preprocess,
+            'agibot':agibot_position_preprocess,
+            'bridge':bridge_position_preprocess,
+            'droid':bridge_position_preprocess,
+            'default':default_position_preprocess
+        }
+        self.position_process={
+            'songling':default_position_process,
+            'agibot':default_position_process,
+            'bridge':default_position_process,
+            'droid':default_position_process,
+            'default':default_position_process
+        }
+
+        self.image_prompt_templete={
+            1:'<image>\n',
+            2:'Image-1: <image>\nImage-2: <image>\n',
+            3:'Image-1: <image>\nImage-2: <image>\nImage-3: <image>\n'}
+        self.system_prompt='You are a visual-language assistant designed to interpret spatial and task-related information from images and text. Provide precise, context-aware responses and actionable guidance to assist in achieving task objectives.'
+        self.prompt_templete={
+            "v3":"Image-1: <image>\nImage-2: <image>\nCompare two images and evaluate whether the second image is closer to achieving task objectives compared to the first image.\nPlease directly rate score following below rules:\nPositive Score: If the second image is closer to achieving task objectives than the first image, assign a positive score based on the significance of the improvement.\nNegative Score: If the second image deviates further from the task objectives compared to the first image, assign a negative score based on the degree of deterioration.\nZero Score: If both images demonstrate the same level of task completion, assign a score of 0.\nThe task needs to accomplish is: <task> {} </task> <score>",
+
+            "v3_think":"0% <image>\nThis image is the trajectory beginning of the following two images\nImage-1: <image>\nImage-2: <image>\nCompare two images and evaluate whether the second image is closer to achieving task objectives compared to the first image.\nPlease directly rate score following below rules:\nPositive Score: If the second image is closer to achieving task objectives than the first image, assign a positive score based on the significance of the improvement.\nNegative Score: If the second image deviates further from the task objectives compared to the first image, assign a negative score based on the degree of deterioration.\nZero Score: If both images demonstrate the same level of task completion, assign a score of 0.\nThe task needs to accomplish is: <task> {} </task> <score>",
+
+            'think':" Please give reasoning process enclosed within <think> reasoning process here </think>.",
+
+            "vqa":"{}",
+
+            "task_vqa":"Image-1: <image>\nImage-2: <image>\nCompare two images and infer what kind of task is achieving. <infer> <task>",
+
+            "task_done":"The 1 means yes, the 0 means no. Check if the robot has completed its task: <task> {} </task> <done>",
+
+            "context_task_done":"<goal> <task> {} </task>: <image>\n<goal>\n<image>\n The 1 means yes, the 0 means no. Refer to the goal, check if the robot has completed its task: <task> {} </task> <done>",
+
+            "image_done":"<goal> <image>\n<goal>\n<image>\n The 1 means yes, the 0 means no. Check if the robot has completed its image goal <done>",
+
+            "action_inverse":"Image-1: <image>\nImage-2: <image>\nCompare two images and infer what action between them. <infer> <action>",
+
+            "task_action":"The current position state of the robotic arm's end gripper in the image is as follows: <state> {} </state>. What action should the robot take to get better completion of instruction: <task> {} </task> <action>",
+
+            "fast_action":"The current position state of the robotic arm's end gripper in the image is as follows: <state> {} </state>. What action chunks should the robot take to get better completion of instruction: <task> {} </task> <chunk>",
+
+            "task_action_simple":"The current position state of the robotic arm's end gripper in the image is as follows: <state> {} </state>. What action should the robot take to get better completion of instruction: <task> {} </task> <(action)>",
+
+            "task_position":"The current position state of the robotic arm's end gripper in the image is as follows: <position> {} </position>. What position should the robot take to get better completion of instruction: <task> {} </task> <position>",
+
+            "task_position_simple":"The current position state of the robotic arm's end gripper in the image is as follows: <(position)> {} </(position)>. What position should the robot take to get better completion of instruction: <task> {} </task> <(position)>",
+
+            "task_action_score":"The current position state of the robotic arm's end gripper in the image is as follows: <state> {} </state>. The action robot take now: <action> {} </action>. Please rate score of the action for achieving task: <task> {} </task> <score>",
+
+            'action':"{{x: {}mm, y: {}mm, z: {}mm, roll: {} degrees, pitch: {} degrees, yaw: {} degrees, open: {}}}"}
+        self.answer_templete={
+            "v3":"{}",
+            "vqa":"{}",
+            "task_vqa":"{}",
+            "task_done":"{}",
+            "action_inverse":"{}",
+            "task_action":"{}",
+            "task_action_score":"{}"
+        }

VLAC/evo_vlac/utils/magic_detect.py

@@ -0,0 +1,1092 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy import signal
+from typing import Tuple, List, Optional, Dict
+import warnings
+from scipy import stats
+from enum import Enum
+
+def adaptive_peak_valley_detection(
+    data: np.ndarray,
+    assist_peaks: np.ndarray=None,
+    window_size: Optional[int] = None,
+    min_distance: Optional[int] = None,
+    prominence_threshold: float = 0.1,
+    max_iterations: int = 10,
+    verbose: bool = False,
+    outlier_sensitivity=1.5,
+    min_amplitude_ratio=0.1
+) -> Dict[str, np.ndarray]:
+    """
+    自适应峰谷检测函数，使用滚动窗口方法并通过多轮迭代优化
+    
+    Parameters:
+    -----------
+    data : np.ndarray
+        输入时间序列数据
+    window_size : int, optional
+        滚动窗口大小，如果为None则自动计算
+    min_distance : int, optional
+        峰谷间最小距离，如果为None则自动计算
+    prominence_threshold : float
+        突出度阈值比例
+    max_iterations : int
+        最大迭代次数
+    verbose : bool
+        是否输出详细信息
+        
+    Returns:
+    --------
+    dict : 包含peaks, valleys, segments, window_size, iterations等信息
+    """
+    
+    if len(data) < 3:
+        raise ValueError("Data length must be >= 3")
+    
+    data = np.array(data)
+    n = len(data)
+    
+    # 自适应窗口大小计算
+    if window_size is None:
+        window_size = _calculate_adaptive_window_size(data)
+    
+    # 自适应最小距离计算
+    if min_distance is None:
+        min_distance = max(1, window_size // 3)
+    
+    if verbose:
+        print(f"Data length: {n}")
+        print(f"Adaptive window size: {window_size}")
+        print(f"Min distance: {min_distance}")
+    
+    # 第一轮：基于滚动窗口的初始检测
+    if assist_peaks:
+        initial_peaks=assist_peaks
+        initial_valleys=[int((assist_peaks[k]+assist_peaks[k-1])/2)for k in range(1,len(assist_peaks))]
+    else:
+        initial_peaks, initial_valleys = _rolling_window_detection(
+            data, window_size, min_distance, prominence_threshold
+        )
+
+    
+    if verbose:
+        print(f"Initial detection - Peaks: {len(initial_peaks)}, Valleys: {len(initial_valleys)}")
+    
+    # 多轮迭代优化
+    peaks, valleys, iterations = _iterative_peak_valley_optimization(
+        data, initial_peaks, initial_valleys, max_iterations, verbose,outlier_method='iqr',outlier_sensitivity=outlier_sensitivity,min_amplitude_ratio=min_amplitude_ratio
+    )
+    
+    # 生成序列分段
+    segments = _generate_segments(peaks, valleys, n)
+    
+    # 计算统计信息
+    stats = _calculate_statistics(data, peaks, valleys)
+    
+    return {
+        'peaks': peaks,
+        'valleys': valleys,
+        'segments': segments,
+        'window_size': window_size,
+        'min_distance': min_distance,
+        'iterations': iterations,
+        'stats': stats
+    }
+
+
+def _calculate_adaptive_window_size(data: np.ndarray) -> int:
+    """Adaptive window size calculation based on first-order difference periodicity"""
+    n = len(data)
+    
+    if n < 10:
+        return 3
+    
+    # Calculate first-order difference
+    diff_data = np.diff(data)
+    diff_n = len(diff_data)
+    
+    try:
+        # Method 1: Autocorrelation of first-order difference
+        diff_centered = diff_data - np.mean(diff_data)
+        autocorr = np.correlate(diff_centered, diff_centered, mode='full')
+        autocorr = autocorr[autocorr.size // 2:]
+        
+        # Normalize autocorrelation
+        if autocorr[0] > 0:
+            autocorr = autocorr / autocorr[0]
+        
+        # Find first significant peak (excluding lag 0)
+        # Look for peaks with minimum height and distance
+        min_lag = max(2, diff_n // 50)  # Minimum lag to consider
+        max_lag = min(diff_n // 3, 100)  # Maximum lag to consider
+        
+        if max_lag > min_lag:
+            search_autocorr = autocorr[min_lag:max_lag]
+            peaks_auto, properties = signal.find_peaks(
+                search_autocorr, 
+                height=0.1,  # Minimum correlation
+                distance=max(1, min_lag // 2)
+            )
+            
+            if len(peaks_auto) > 0:
+                # First significant peak indicates period
+                period = peaks_auto[0] + min_lag
+                window_size = min(max(period // 2, 5), n // 4)
+            else:
+                # Fallback: find first local maximum
+                for i in range(1, min(50, len(search_autocorr) - 1)):
+                    if (search_autocorr[i] > search_autocorr[i-1] and 
+                        search_autocorr[i] > search_autocorr[i+1] and
+                        search_autocorr[i] > 0.05):
+                        period = i + min_lag
+                        window_size = min(max(period // 2, 5), n // 4)
+                        break
+                else:
+                    window_size = min(max(int(np.sqrt(n)), 5), n // 4)
+        else:
+            window_size = min(max(int(np.sqrt(n)), 5), n // 4)
+            
+    except Exception as e:
+        # Fallback method: FFT-based period detection on difference
+        try:
+            # Remove DC component
+            diff_fft = np.fft.fft(diff_data - np.mean(diff_data))
+            freqs = np.fft.fftfreq(diff_n)
+            
+            # Find dominant frequency (excluding DC)
+            power_spectrum = np.abs(diff_fft[1:diff_n//2])
+            if len(power_spectrum) > 0:
+                dominant_freq_idx = np.argmax(power_spectrum) + 1
+                dominant_freq = freqs[dominant_freq_idx]
+                
+                if dominant_freq > 0:
+                    period = int(1 / dominant_freq)
+                    window_size = min(max(period // 2, 5), n // 4)
+                else:
+                    window_size = min(max(int(np.sqrt(n)), 5), n // 4)
+            else:
+                window_size = min(max(int(np.sqrt(n)), 5), n // 4)
+        except:
+            window_size = min(max(int(np.sqrt(n)), 5), n // 4)
+    
+    # Method 2: Statistical approach on difference
+    try:
+        # Find significant changes in first-order difference
+        diff_abs = np.abs(diff_data)
+        threshold = np.mean(diff_abs) + 0.5 * np.std(diff_abs)
+        change_points = np.where(diff_abs > threshold)[0]
+        
+        if len(change_points) > 2:
+            # Calculate average distance between change points
+            distances = np.diff(change_points)
+            if len(distances) > 0:
+                avg_distance = np.median(distances)  # Use median for robustness
+                window_size_v2 = min(max(int(avg_distance), 5), n // 4)
+                # Combine with autocorrelation result
+                window_size = int((window_size + window_size_v2) / 2)
+    except:
+        pass
+    
+    # Ensure window size is odd and within reasonable bounds
+    window_size = max(3, min(window_size, n // 3))
+    if window_size % 2 == 0:
+        window_size += 1
+    
+    return window_size
+
+
+def _rolling_window_detection(
+    data: np.ndarray, 
+    window_size: int, 
+    min_distance: int, 
+    prominence_threshold: float
+) -> Tuple[np.ndarray, np.ndarray]:
+    """基于滚动窗口的初始峰谷检测"""
+    n = len(data)
+    half_window = window_size // 2
+    peaks = []
+    valleys = []
+    
+    # 计算全局统计用于突出度判断
+    global_std = np.std(data)
+    threshold = global_std * prominence_threshold
+    
+    for i in range(half_window, n - half_window):
+        # 提取窗口数据
+        window_start = max(0, i - half_window)
+        window_end = min(n, i + half_window + 1)
+        window_data = data[window_start:window_end]
+        window_indices = np.arange(window_start, window_end)
+        
+        current_value = data[i]
+        window_max = np.max(window_data)
+        window_min = np.min(window_data)
+        
+        # 检测峰值
+        if (current_value == window_max and 
+            current_value - window_min > threshold and
+            (len(peaks) == 0 or i - peaks[-1] >= min_distance)):
+            peaks.append(i)
+        
+        # 检测谷值
+        elif (current_value == window_min and 
+              window_max - current_value > threshold and
+              (len(valleys) == 0 or i - valleys[-1] >= min_distance)):
+            valleys.append(i)
+    
+    return np.array(peaks), np.array(valleys)
+
+
+def _iterative_peak_valley_optimization(
+    data: np.ndarray, 
+    initial_peaks: np.ndarray, 
+    initial_valleys: np.ndarray, 
+    max_iterations: int, 
+    verbose: bool,
+    outlier_method: str = 'iqr',
+    outlier_sensitivity: float = 1.5,
+    min_amplitude_ratio: float = 0.1
+) -> Tuple[np.ndarray, np.ndarray, int]:
+    """
+    多轮迭代优化峰谷检测结果，并在结束后进行基于差值分布的后处理
+    
+    Parameters:
+    -----------
+    data : np.ndarray
+        输入时间序列数据
+    initial_peaks : np.ndarray
+        初始峰值索引
+    initial_valleys : np.ndarray
+        初始谷值索引
+    max_iterations : int
+        最大迭代次数
+    verbose : bool
+        是否输出详细信息
+    outlier_method : str
+        离群点检测方法 ['iqr', 'zscore', 'percentile', 'mad', 'dbscan']
+    outlier_sensitivity : float
+        离群点检测灵敏度参数
+    min_amplitude_ratio : float
+        最小振幅比例（相对于数据标准差）
+        
+    Returns:
+    --------
+    Tuple[np.ndarray, np.ndarray, int] : 峰值索引, 谷值索引, 迭代次数
+    """
+    
+    peaks = initial_peaks.copy()
+    valleys = initial_valleys.copy()
+    
+    # 原有的迭代优化过程
+    for iteration in range(max_iterations):
+        old_peaks = peaks.copy()
+        old_valleys = valleys.copy()
+        
+        # 合并所有关键点并排序
+        all_points = []
+        for p in peaks:
+            all_points.append((p, 'peak', data[p]))
+        for v in valleys:
+            all_points.append((v, 'valley', data[v]))
+        
+        all_points.sort(key=lambda x: x[0])
+        
+        if len(all_points) < 2:
+            break
+        
+        # 优化规则1: 确保峰谷交替
+        optimized_points = _enforce_alternating_pattern(all_points, data)
+        
+        # 优化规则2: 确保峰是两谷间最高点，谷是两峰间最低点
+        optimized_points = _optimize_local_extrema(optimized_points, data)
+        
+        # 分离峰谷
+        new_peaks = []
+        new_valleys = []
+        for point in optimized_points:
+            if point[1] == 'peak':
+                new_peaks.append(point[0])
+            else:
+                new_valleys.append(point[0])
+        
+        peaks = np.array(new_peaks)
+        valleys = np.array(new_valleys)
+        
+        if verbose:
+            print(f"Iteration {iteration + 1}: Peaks {len(peaks)}, Valleys {len(valleys)}")
+        
+        # Check convergence
+        if (np.array_equal(peaks, old_peaks) and 
+            np.array_equal(valleys, old_valleys)):
+            if verbose:
+                print(f"Converged after {iteration + 1} iterations")
+            break
+    
+    # 新增：基于峰谷差值分布的后处理
+    if verbose:
+        print("Starting post-processing based on peak-valley amplitude distribution...")
+    
+    peaks, valleys = _postprocess_amplitude_filtering(
+        data, peaks, valleys, outlier_method, outlier_sensitivity, 
+        min_amplitude_ratio, verbose
+    )
+    
+    return peaks, valleys, iteration + 1
+
+
+def _postprocess_amplitude_filtering(
+    data: np.ndarray,
+    peaks: np.ndarray,
+    valleys: np.ndarray,
+    outlier_method: str,
+    outlier_sensitivity: float,
+    min_amplitude_ratio: float,
+    verbose: bool
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    基于峰谷差值分布进行后处理，过滤掉差值过小的峰谷对
+    """
+    
+    if len(peaks) == 0 or len(valleys) == 0:
+        return peaks, valleys
+    
+    # 1. 计算相邻峰谷之间的差值
+    peak_valley_pairs, amplitudes = _calculate_peak_valley_amplitudes(data, peaks, valleys)
+    
+    if len(amplitudes) == 0:
+        return peaks, valleys
+    
+    if verbose:
+        print(f"Found {len(amplitudes)} peak-valley pairs")
+        print(f"Amplitude statistics: mean={np.mean(amplitudes):.3f}, std={np.std(amplitudes):.3f}")
+        print(f"Amplitude range: [{np.min(amplitudes):.3f}, {np.max(amplitudes):.3f}]")
+    
+    # 2. 检测差值过小的离群点
+    outlier_indices = _detect_amplitude_outliers(
+        amplitudes, outlier_method, outlier_sensitivity, verbose
+    )
+    
+    # 3. 应用最小振幅比例过滤
+    data_std = np.std(data)
+    min_amplitude = min_amplitude_ratio * data_std
+    small_amplitude_indices = np.where(amplitudes < min_amplitude)[0]
+    
+    # 合并两种过滤方法的结果
+    all_outlier_indices = np.unique(np.concatenate([outlier_indices, small_amplitude_indices]))
+    
+    if verbose and len(all_outlier_indices) > 0:
+        print(f"Detected {len(outlier_indices)} statistical outliers")
+        print(f"Detected {len(small_amplitude_indices)} small amplitude pairs (< {min_amplitude:.3f})")
+        print(f"Total pairs to filter: {len(all_outlier_indices)}")
+    
+    # 4. 根据离群点删除相应的峰谷点
+    if len(all_outlier_indices) > 0:
+        peaks, valleys = _remove_outlier_peak_valley_pairs(
+            data, peaks, valleys, peak_valley_pairs, all_outlier_indices, verbose
+        )
+    
+    # 5. 确保最终结果满足峰谷相间且谷是峰间最低值的要求
+    peaks, valleys = _final_peak_valley_validation(data, peaks, valleys, verbose)
+    
+    return peaks, valleys
+
+
+def _calculate_peak_valley_amplitudes(
+    data: np.ndarray, 
+    peaks: np.ndarray, 
+    valleys: np.ndarray
+) -> Tuple[List[Tuple], np.ndarray]:
+    """
+    计算相邻峰谷之间的差值（振幅）
+    
+    Returns:
+    --------
+    peak_valley_pairs : List[Tuple]
+        每个元素为 (peak_idx, valley_idx, amplitude, pair_type)
+        pair_type: 'peak_to_valley' 或 'valley_to_peak'
+    amplitudes : np.ndarray
+        所有振幅值的数组
+    """
+    
+    # 合并峰谷点并排序
+    all_extrema = []
+    for p in peaks:
+        all_extrema.append((p, 'peak', data[p]))
+    for v in valleys:
+        all_extrema.append((v, 'valley', data[v]))
+    
+    all_extrema.sort(key=lambda x: x[0])
+    
+    peak_valley_pairs = []
+    amplitudes = []
+    
+    # 计算相邻极值点之间的振幅
+    for i in range(len(all_extrema) - 1):
+        current = all_extrema[i]
+        next_point = all_extrema[i + 1]
+        
+        # 只计算峰谷相邻的情况
+        if current[1] != next_point[1]:
+            amplitude = abs(current[2] - next_point[2])
+            pair_type = f"{current[1]}_to_{next_point[1]}"
+            
+            peak_valley_pairs.append((
+                current[0] if current[1] == 'peak' else next_point[0],  # peak_idx
+                current[0] if current[1] == 'valley' else next_point[0],  # valley_idx
+                amplitude,
+                pair_type
+            ))
+            amplitudes.append(amplitude)
+    
+    return peak_valley_pairs, np.array(amplitudes)
+
+
+def _detect_amplitude_outliers(
+    amplitudes: np.ndarray,
+    method: str,
+    sensitivity: float,
+    verbose: bool
+) -> np.ndarray:
+    """
+    检测振幅中的离群点（差值过小的点）
+    
+    Parameters:
+    -----------
+    amplitudes : np.ndarray
+        振幅数组
+    method : str
+        检测方法 ['iqr', 'zscore', 'percentile', 'mad', 'dbscan']
+    sensitivity : float
+        灵敏度参数
+    verbose : bool
+        是否输出详细信息
+        
+    Returns:
+    --------
+    np.ndarray : 离群点的索引
+    """
+    
+    if len(amplitudes) < 3:
+        return np.array([])
+    
+    outlier_indices = []
+    
+    if method == 'iqr':
+        # IQR方法：检测下四分位数以下的异常小值
+        q1 = np.percentile(amplitudes, 25)
+        q3 = np.percentile(amplitudes, 75)
+        iqr = q3 - q1
+        lower_bound = q1 - sensitivity * iqr
+        
+        outlier_indices = np.where(amplitudes < lower_bound)[0]
+        
+        if verbose:
+            print(f"IQR method: Q1={q1:.3f}, Q3={q3:.3f}, IQR={iqr:.3f}")
+            print(f"Lower bound: {lower_bound:.3f}")
+    
+    elif method == 'zscore':
+        # Z-score方法：检测标准化后绝对值过大的点（但这里我们关注小值）
+        z_scores = np.abs(stats.zscore(amplitudes))
+        mean_amp = np.mean(amplitudes)
+        
+        # 找出既是统计离群点又是小于均值的点
+        small_values = amplitudes < mean_amp
+        statistical_outliers = z_scores > sensitivity
+        outlier_indices = np.where(small_values & statistical_outliers)[0]
+        
+        if verbose:
+            print(f"Z-score method: mean={mean_amp:.3f}, threshold={sensitivity}")
+    
+    elif method == 'percentile':
+        # 百分位数方法：直接取最小的sensitivity比例的点
+        threshold_percentile = sensitivity * 100 if sensitivity <= 1 else sensitivity
+        threshold_value = np.percentile(amplitudes, threshold_percentile)
+        outlier_indices = np.where(amplitudes <= threshold_value)[0]
+        
+        if verbose:
+            print(f"Percentile method: {threshold_percentile:.1f}th percentile = {threshold_value:.3f}")
+    
+    elif method == 'mad':
+        # MAD (Median Absolute Deviation) 方法
+        median_amp = np.median(amplitudes)
+        mad = np.median(np.abs(amplitudes - median_amp))
+        
+        if mad > 0:
+            modified_z_scores = 0.6745 * (amplitudes - median_amp) / mad
+            # 找出负的modified z-scores中绝对值较大的（即明显小于中位数的）
+            outlier_indices = np.where(modified_z_scores < -sensitivity)[0]
+        else:
+            outlier_indices = np.array([])
+        
+        if verbose:
+            print(f"MAD method: median={median_amp:.3f}, MAD={mad:.3f}")
+    
+    elif method == 'dbscan':
+        # DBSCAN聚类方法（需要sklearn）
+        try:
+            from sklearn.cluster import DBSCAN
+            
+            # 将振幅作为一维特征进行聚类
+            X = amplitudes.reshape(-1, 1)
+            
+            # 调整eps参数基于sensitivity
+            eps = sensitivity * np.std(amplitudes)
+            min_samples = max(2, len(amplitudes) // 10)
+            
+            dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+            labels = dbscan.fit_predict(X)
+            
+            # 找出被标记为噪声的点（label = -1）和小振幅的聚类
+            noise_points = np.where(labels == -1)[0]
+            
+            # 在非噪声点中，找出平均值最小的聚类
+            unique_labels = np.unique(labels[labels != -1])
+            if len(unique_labels) > 1:
+                cluster_means = []
+                for label in unique_labels:
+                    cluster_indices = np.where(labels == label)[0]
+                    cluster_mean = np.mean(amplitudes[cluster_indices])
+                    cluster_means.append((label, cluster_mean))
+                
+                # 找出平均振幅最小的聚类
+                min_cluster_label = min(cluster_means, key=lambda x: x[1])[0]
+                min_cluster_indices = np.where(labels == min_cluster_label)[0]
+                
+                outlier_indices = np.concatenate([noise_points, min_cluster_indices])
+            else:
+                outlier_indices = noise_points
+                
+            if verbose:
+                print(f"DBSCAN method: eps={eps:.3f}, min_samples={min_samples}")
+                print(f"Found {len(unique_labels)} clusters and {len(noise_points)} noise points")
+                
+        except ImportError:
+            if verbose:
+                print("DBSCAN method requires sklearn, falling back to IQR method")
+            return _detect_amplitude_outliers(amplitudes, 'iqr', sensitivity, verbose)
+    
+    else:
+        raise ValueError(f"Unknown outlier detection method: {method}")
+    
+    if verbose and len(outlier_indices) > 0:
+        outlier_amplitudes = amplitudes[outlier_indices]
+        print(f"Detected {len(outlier_indices)} outliers with amplitudes: {outlier_amplitudes}")
+    
+    return np.array(outlier_indices)
+
+
+def _remove_outlier_peak_valley_pairs(
+    data: np.ndarray,
+    peaks: np.ndarray,
+    valleys: np.ndarray,
+    peak_valley_pairs: List[Tuple],
+    outlier_indices: np.ndarray,
+    verbose: bool
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    根据离群点索引删除相应的峰谷点
+    """
+    
+    points_to_remove = set()
+    
+    for idx in outlier_indices:
+        if idx < len(peak_valley_pairs):
+            pair = peak_valley_pairs[idx]
+            peak_idx, valley_idx = pair[0], pair[1]
+            
+            # 优先删除谷点，如果谷点被多个峰共享，则可能需要合并峰
+            points_to_remove.add(('valley', valley_idx))
+            
+            if verbose:
+                print(f"Marking for removal - Peak: {peak_idx}, Valley: {valley_idx}, "
+                      f"Amplitude: {pair[2]:.3f}")
+    
+    # 删除标记的谷点
+    valleys_to_keep = []
+    for v in valleys:
+        if ('valley', v) not in points_to_remove:
+            valleys_to_keep.append(v)
+    
+    new_valleys = np.array(valleys_to_keep)
+    
+    # 处理峰点：如果相邻的峰之间的谷被删除了，需要合并峰点（保留更高的）
+    new_peaks = _merge_adjacent_peaks(data, peaks, new_valleys, verbose)
+    
+    if verbose:
+        print(f"After outlier removal: Peaks {len(peaks)} -> {len(new_peaks)}, "
+              f"Valleys {len(valleys)} -> {len(new_valleys)}")
+    
+    return new_peaks, new_valleys
+
+
+def _merge_adjacent_peaks(
+    data: np.ndarray,
+    peaks: np.ndarray,
+    valleys: np.ndarray,
+    verbose: bool
+) -> np.ndarray:
+    """
+    合并相邻的峰点（当它们之间没有谷点时）
+    """
+    
+    if len(peaks) <= 1:
+        return peaks
+    
+    # 创建所有极值点的排序列表
+    all_points = []
+    for p in peaks:
+        all_points.append((p, 'peak'))
+    for v in valleys:
+        all_points.append((v, 'valley'))
+    
+    all_points.sort(key=lambda x: x[0])
+    
+    # 找出相邻的峰点并合并
+    merged_peaks = []
+    i = 0
+    
+    while i < len(all_points):
+        if all_points[i][1] == 'peak':
+            # 收集连续的峰点
+            consecutive_peaks = [all_points[i][0]]
+            j = i + 1
+            
+            while j < len(all_points) and all_points[j][1] == 'peak':
+                consecutive_peaks.append(all_points[j][0])
+                j += 1
+            
+            # 在连续的峰点中保留最高的
+            if len(consecutive_peaks) > 1:
+                peak_values = [data[p] for p in consecutive_peaks]
+                best_peak_idx = consecutive_peaks[np.argmax(peak_values)]
+                merged_peaks.append(best_peak_idx)
+                
+                if verbose:
+                    print(f"Merged {len(consecutive_peaks)} consecutive peaks, "
+                          f"kept peak at index {best_peak_idx} with value {data[best_peak_idx]:.3f}")
+            else:
+                merged_peaks.append(consecutive_peaks[0])
+            
+            i = j
+        else:
+            i += 1
+    
+    return np.array(merged_peaks)
+
+
+def _final_peak_valley_validation(
+    data: np.ndarray,
+    peaks: np.ndarray,
+    valleys: np.ndarray,
+    verbose: bool
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    最终验证：确保峰谷相间且谷是峰间的最低值
+    """
+    
+    if len(peaks) == 0 or len(valleys) == 0:
+        return peaks, valleys
+    
+    # 创建交替的峰谷序列
+    all_points = []
+    for p in peaks:
+        all_points.append((p, 'peak'))
+    for v in valleys:
+        all_points.append((v, 'valley'))
+    
+    all_points.sort(key=lambda x: x[0])
+    
+    # 确保峰谷交替
+    validated_points = []
+    if len(all_points) > 0:
+        validated_points.append(all_points[0])
+        
+        for i in range(1, len(all_points)):
+            current = all_points[i]
+            prev = validated_points[-1]
+            
+            if current[1] != prev[1]:  # 类型不同，保留
+                validated_points.append(current)
+            else:  # 类型相同，保留更极端的
+                if current[1] == 'peak':
+                    if data[current[0]] > data[prev[0]]:
+                        validated_points[-1] = current
+                else:  # valley
+                    if data[current[0]] < data[prev[0]]:
+                        validated_points[-1] = current
+    
+    # 分离最终的峰谷
+    final_peaks = []
+    final_valleys = []
+    
+    for point in validated_points:
+        if point[1] == 'peak':
+            final_peaks.append(point[0])
+        else:
+            final_valleys.append(point[0])
+    
+    # 验证谷是峰间的最低值
+    final_valleys = _validate_valleys_between_peaks(data, final_peaks, final_valleys, verbose)
+    
+    if verbose:
+        print(f"Final validation: Peaks {len(peaks)} -> {len(final_peaks)}, "
+              f"Valleys {len(valleys)} -> {len(final_valleys)}")
+    
+    return np.array(final_peaks), np.array(final_valleys)
+
+
+def _validate_valleys_between_peaks(
+    data: np.ndarray,
+    peaks: np.ndarray,
+    valleys: np.ndarray,
+    verbose: bool
+) -> np.ndarray:
+    """
+    验证每个谷点确实是相邻峰点之间的最低点
+    """
+    
+    if len(peaks) < 2 or len(valleys) == 0:
+        return valleys
+    
+    validated_valleys = []
+    peaks_sorted = np.sort(peaks)
+    
+    for i in range(len(peaks_sorted) - 1):
+        left_peak = peaks_sorted[i]
+        right_peak = peaks_sorted[i + 1]
+        
+        # 找出在这两个峰之间的谷点
+        between_valleys = [v for v in valleys if left_peak < v < right_peak]
+        
+        if len(between_valleys) == 0:
+            # 如果没有谷点，在这个区间找最低点
+            search_start = left_peak + 1
+            search_end = right_peak
+            if search_start < search_end:
+                segment = data[search_start:search_end]
+                min_idx = np.argmin(segment) + search_start
+                validated_valleys.append(min_idx)
+                if verbose:
+                    print(f"Added missing valley at index {min_idx} between peaks {left_peak} and {right_peak}")
+        
+        elif len(between_valleys) == 1:
+            # 验证这个谷点是否真的是最低的
+            valley_idx = between_valleys[0]
+            search_start = left_peak + 1
+            search_end = right_peak
+            
+            if search_start < search_end:
+                segment = data[search_start:search_end]
+                true_min_idx = np.argmin(segment) + search_start
+                
+                if true_min_idx == valley_idx:
+                    validated_valleys.append(valley_idx)
+                else:
+                    validated_valleys.append(true_min_idx)
+                    if verbose:
+                        print(f"Corrected valley position from {valley_idx} to {true_min_idx}")
+            else:
+                validated_valleys.append(valley_idx)
+        
+        else:
+            # 多个谷点，保留最低的
+            valley_values = [data[v] for v in between_valleys]
+            best_valley = between_valleys[np.argmin(valley_values)]
+            validated_valleys.append(best_valley)
+            
+            if verbose:
+                print(f"Multiple valleys between peaks {left_peak} and {right_peak}, "
+                      f"kept valley at {best_valley}")
+    
+    return np.array(validated_valleys)
+
+
+# 需要同时导入的辅助函数（保持原有实现）
+def _enforce_alternating_pattern(all_points: List, data: np.ndarray) -> List:
+    """确保峰谷交替出现"""
+    if len(all_points) < 2:
+        return all_points
+    
+    optimized = [all_points[0]]
+    
+    for i in range(1, len(all_points)):
+        current = all_points[i]
+        prev = optimized[-1]
+        
+        # 如果类型相同，保留值更极端的点
+        if current[1] == prev[1]:
+            if current[1] == 'peak':
+                # 保留更高的峰
+                if current[2] > prev[2]:
+                    optimized[-1] = current
+            else:
+                # 保留更低的谷
+                if current[2] < prev[2]:
+                    optimized[-1] = current
+        else:
+            optimized.append(current)
+    
+    return optimized
+
+
+def _optimize_local_extrema(points: List, data: np.ndarray) -> List:
+    """优化局部极值点位置"""
+    if len(points) < 3:
+        return points
+    
+    optimized = [points[0]]
+    
+    for i in range(1, len(points) - 1):
+        current = points[i]
+        prev_idx = optimized[-1][0]
+        next_idx = points[i + 1][0]
+        
+        # 在相邻点之间寻找真正的极值
+        search_start = max(prev_idx + 1, current[0] - 5)
+        search_end = min(next_idx, current[0] + 6)
+        
+        if search_start >= search_end:
+            optimized.append(current)
+            continue
+        
+        search_range = range(search_start, search_end)
+        search_data = data[search_start:search_end]
+        
+        if current[1] == 'peak':
+            # 寻找最高点
+            max_idx = np.argmax(search_data)
+            actual_idx = search_start + max_idx
+            optimized.append((actual_idx, 'peak', data[actual_idx]))
+        else:
+            # 寻找最低点
+            min_idx = np.argmin(search_data)
+            actual_idx = search_start + min_idx
+            optimized.append((actual_idx, 'valley', data[actual_idx]))
+    
+    optimized.append(points[-1])
+    
+
+
+def _enforce_alternating_pattern(all_points: List, data: np.ndarray) -> List:
+    """确保峰谷交替出现"""
+    if len(all_points) < 2:
+        return all_points
+    
+    optimized = [all_points[0]]
+    
+    for i in range(1, len(all_points)):
+        current = all_points[i]
+        prev = optimized[-1]
+        
+        # 如果类型相同，保留值更极端的点
+        if current[1] == prev[1]:
+            if current[1] == 'peak':
+                # 保留更高的峰
+                if current[2] > prev[2]:
+                    optimized[-1] = current
+            else:
+                # 保留更低的谷
+                if current[2] < prev[2]:
+                    optimized[-1] = current
+        else:
+            optimized.append(current)
+    
+    return optimized
+
+
+def _optimize_local_extrema(points: List, data: np.ndarray) -> List:
+    """优化局部极值点位置"""
+    if len(points) < 3:
+        return points
+    
+    optimized = [points[0]]
+    
+    for i in range(1, len(points) - 1):
+        current = points[i]
+        prev_idx = optimized[-1][0]
+        next_idx = points[i + 1][0]
+        
+        # 在相邻点之间寻找真正的极值
+        search_start = max(prev_idx + 1, current[0] - 5)
+        search_end = min(next_idx, current[0] + 6)
+        
+        if search_start >= search_end:
+            optimized.append(current)
+            continue
+        
+        search_range = range(search_start, search_end)
+        search_data = data[search_start:search_end]
+        
+        if current[1] == 'peak':
+            # 寻找最高点
+            max_idx = np.argmax(search_data)
+            actual_idx = search_start + max_idx
+            optimized.append((actual_idx, 'peak', data[actual_idx]))
+        else:
+            # 寻找最低点
+            min_idx = np.argmin(search_data)
+            actual_idx = search_start + min_idx
+            optimized.append((actual_idx, 'valley', data[actual_idx]))
+    
+    optimized.append(points[-1])
+    
+    return optimized
+
+
+def _generate_segments(peaks: np.ndarray, valleys: np.ndarray, data_length: int) -> List[Tuple[int, int]]:
+    """生成序列分段"""
+    all_points = []
+    for p in peaks:
+        all_points.append(p)
+    for v in valleys:
+        all_points.append(v)
+    
+    all_points = sorted(all_points)
+    
+    segments = []
+    start = 0
+    
+    for point in all_points:
+        if point > start:
+            segments.append((start, point))
+            start = point
+    
+    # 添加最后一段
+    if start < data_length - 1:
+        segments.append((start, data_length - 1))
+    
+    return segments
+
+
+def _calculate_statistics(data: np.ndarray, peaks: np.ndarray, valleys: np.ndarray) -> Dict:
+    """计算统计信息"""
+    stats = {
+        'peak_count': len(peaks),
+        'valley_count': len(valleys),
+        'peak_values': data[peaks] if len(peaks) > 0 else np.array([]),
+        'valley_values': data[valleys] if len(valleys) > 0 else np.array([]),
+    }
+    
+    if len(peaks) > 0:
+        stats['avg_peak_value'] = np.mean(data[peaks])
+        stats['max_peak_value'] = np.max(data[peaks])
+        stats['min_peak_value'] = np.min(data[peaks])
+    
+    if len(valleys) > 0:
+        stats['avg_valley_value'] = np.mean(data[valleys])
+        stats['max_valley_value'] = np.max(data[valleys])
+        stats['min_valley_value'] = np.min(data[valleys])
+    
+    # 计算平均间距
+    if len(peaks) > 1:
+        stats['avg_peak_distance'] = np.mean(np.diff(peaks))
+    if len(valleys) > 1:
+        stats['avg_valley_distance'] = np.mean(np.diff(valleys))
+    
+    return stats
+
+
+def plot_results(data: np.ndarray, result: Dict, title: str = "Peak Valley Detection", save_path: str = None):
+    """Plot detection results"""
+    plt.figure(figsize=(15, 8))
+    
+    # Main plot
+    plt.subplot(2, 1, 1)
+    plt.plot(data, 'b-', linewidth=1.5, label='Original Data', alpha=0.7)
+    
+    peaks = result['peaks']
+    valleys = result['valleys']
+    
+    if len(peaks) > 0:
+        # Ensure peaks are valid indices
+        valid_peaks = peaks[peaks < len(data)]
+        if len(valid_peaks) > 0:
+            plt.plot(valid_peaks, [data[k] for k in valid_peaks], 'ro', 
+                    markersize=8, label=f'Peaks ({len(valid_peaks)})')
+    
+    if len(valleys) > 0:
+        # Ensure valleys are valid indices
+        valid_valleys = valleys[valleys < len(data)]
+        if len(valid_valleys) > 0:
+            plt.plot(valid_valleys, [data[k] for k in valid_valleys], 'go', 
+                    markersize=8, label=f'Valleys ({len(valid_valleys)})')
+    
+    plt.title(f'{title} (Window: {result["window_size"]}, Iterations: {result["iterations"]})')
+    plt.xlabel('Time')
+    plt.ylabel('Value')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    
+    # Segmentation plot
+    plt.subplot(2, 1, 2)
+    segments = result['segments']
+    colors = plt.cm.Set3(np.linspace(0, 1, max(len(segments), 1)))
+    
+    for i, (start, end) in enumerate(segments):
+        # Ensure segment indices are valid
+        start = max(0, min(start, len(data) - 1))
+        end = max(start, min(end, len(data) - 1))
+        
+        if start < end:
+            plt.plot(range(start, end + 1), data[start:end + 1], 
+                    color=colors[i % len(colors)], linewidth=2, label=f'Segment {i+1}')
+        elif start == end:
+            plt.plot([start], [data[start]], 'o',
+                    color=colors[i % len(colors)], markersize=6, label=f'Segment {i+1}')
+    
+    plt.title('Sequence Segmentation')
+    plt.xlabel('Time')
+    plt.ylabel('Value')
+    if len(segments) <= 10:  # Only show legend if not too many segments
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Plot saved to: {save_path}")
+    else:
+        plt.show()
+
+
+def demo():
+    """Demo function"""
+
+    value_list=[0.0, 0.2, -0.02, -0.04, 0.141, -0.059, 0.301, 0.7, 1.137, 1.769, 2.418, 2.906, 3.333, 3.623, 4.567, 4.644, 6.15, 6.638, 7.777, 11.19, 12.895, 13.853, 13.853, 12.854, 11.599, 9.813, 8.298, 7.454, 6.159, 7.491, 6.714, 5.707, 5.707, 7.027, 3.624, 1.831, 2.283, 3.162, 0.799, 1.593, 1.593, 8.6, 12.31, 15.73, 19.388, 21.564, 18.333, 15.311, 11.856, 9.317, 0.811, -12.818, -13.81, -14.243, -14.563, -14.792, -14.562, -14.241, -13.762, -13.102, -13.532, -13.804, -14.032, -14.26, -14.031, -13.803, -13.576, -13.803, -13.621, -13.621, -13.393, -13.824, -14.553, -14.301, -14.004, -14.232, -13.82, -13.502, -8.576, -9.444, -9.444, -9.576, -9.598, -9.861, -9.751, -9.795, -9.114, -9.55, -9.769, -9.55, -10.054, -9.724, -9.987, -9.833, -10.053, -10.273, -10.559, -10.958, -11.179, -10.89, -10.669, -10.447, -10.204, -10.204, -9.984, -9.588, -8.843, -8.56, -7.561, -6.464, -6.464, -6.464, -5.846, -5.571, -5.149, -4.749, -4.267, -4.059, -3.851, -3.955, -3.726, -3.498, -3.291, -3.084, -2.837, -1.52, -1.317, -0.811, -0.226, 0.295, 1.312, 1.707, 2.788, 3.877, 11.278, 10.444, 10.444, 9.119, 9.119, 9.119, 12.045, 15.475, 18.079, 16.653, 13.92, 16.571, 14.335, 11.217, -0.414, -0.414, -0.856, -0.614, -0.412, 0.13, 0.829, 0.829, 0.829, 0.829, 0.829, 0.829, 0.829, 0.829, 0.829, 0.829, 1.682, 1.682, 1.682, 1.996, 2.408, 2.896, 3.129, 3.323, 3.516, 3.709, 3.921, 3.729, 3.921, 4.229, 4.803, 5.565, 6.415, 7.519, 8.352, 8.352, 8.352, 8.755, 8.755, 8.755, 8.755, 9.813, 10.787, 10.413, 10.95, 11.342, 11.324, 11.271, 11.129, 10.987, 10.88, 10.506, 10.148, 10.615, 11.187, 11.844, 12.373, 13.022, 13.613, 13.959, 14.303, 15.108, 20.66, 20.041, 20.041, 20.041, 20.041, 21.321, 23.713, 25.559, 28.015, 26.691, 25.166, 23.894, 25.066, 15.429, 15.598, 15.784, 15.616, 15.548, 15.227, 15.058, 14.888, 14.718, 14.547, 14.718, 14.889, 15.093, 14.923, 14.753, 14.923, 15.093, 15.263, 15.839, 15.671, 15.84, 15.671, 15.469, 15.638, 15.638, 16.195, 16.379, 16.195, 16.195, 16.38, 16.58, 17.031, 17.529, 18.106, 18.319, 18.531, 18.759, 18.971, 19.116, 19.246, 20.215, 20.215, 20.534, 20.979, 21.358, 22.79, 23.577, 22.813, 23.338, 23.645, 23.645, 24.316, 24.316, 25.83, 25.83, 25.83, 25.83, 28.708, 30.889, 32.161, 31.089, 29.642, 24.351, 25.319, 26.231, 22.837, 22.39, 22.033, 21.814, 22.002, 22.189, 22.454, 22.624, 22.795, 23.011, 22.564, 22.502, 22.719, 23.121, 23.213, 23.398, 23.612, 23.887, 24.496, 24.813, 25.565, 26.801, 32.159, 33.76, 33.839, 33.839, 33.839, 34.713, 35.796, 37.402, 36.513, 35.675, 36.009, 36.534, 36.762, 37.003, 37.683, 38.032, 38.032, 38.317, 38.662, 39.448, 36.614, 36.322, 38.907, 38.907, 38.907, 38.907, 38.907, 40.435, 42.496, 43.347, 42.35, 40.816, 31.737, 30.932, 18.983, 18.691, 18.529, 18.675, 18.919, 19.519, 19.68, 19.889, 20.049, 20.417, 20.035, 20.195, 20.419, 20.848, 21.133, 21.465, 22.124, 23.028, 23.643, 24.544, 23.397, 23.673, 24.498, 24.498, 23.622, 23.622, 23.622, 24.92, 26.302, 26.921, 26.029, 26.429, 26.576, 26.884, 27.25, 27.686, 27.325, 27.063, 28.449, 29.179, 30.085, 30.728, 31.31, 31.942, 31.942, 37.033, 38.683, 41.307, 40.391, 39.318, 38.505, 32.454, 22.12, 21.948, 21.792, 22.027, 22.183, 22.494, 22.727, 22.835, 22.989, 23.143, 23.297, 23.481, 23.221, 23.236, 23.236, 23.482, 23.91, 24.215, 24.381, 25.243, 27.202, 30.871, 30.871, 30.871, 30.871, 33.111, 35.465, 35.904, 36.058, 36.314, 36.569, 36.759, 37.062, 37.314, 37.527, 37.765, 38.648, 39.029, 39.565, 40.303, 41.186, 41.516, 42.007, 42.575, 45.63, 45.63, 45.63, 45.63, 46.304, 47.958, 48.864, 47.596, 46.631, 45.425, 35.842, 35.649, 35.495, 35.714, 35.984, 36.151, 36.546, 36.851, 37.104, 37.506, 37.719, 38.217, 38.353, 38.772, 39.886, 40.536, 40.785, 42.68, 45.007, 45.007, 46.041, 47.164, 47.597, 47.859, 48.099, 48.317, 48.544, 48.822, 49.016, 49.129, 49.332, 49.444, 49.626, 50.24, 50.688, 51.507, 51.72, 53.506, 53.218, 53.218, 53.218, 53.218, 55.791, 57.506, 58.305, 57.288, 56.545, 55.78, 49.501, 49.662, 49.562, 49.662, 49.481, 49.582, 49.683, 49.864, 49.995, 50.275, 50.662, 50.899, 50.998, 50.89, 51.528, 51.722, 51.877, 51.982, 52.117, 52.117, 52.222, 52.71, 53.059, 53.059, 53.407, 53.407, 53.407, 53.407, 55.317, 55.407, 55.041, 54.933, 54.735, 54.554, 54.772, 54.916, 55.025, 54.935, 55.034, 55.807, 55.63, 55.453, 55.453, 55.631, 55.8, 56.489, 55.985, 55.069, 55.438, 57.167, 57.167, 57.167, 57.886, 58.493, 59.854, 60.633, 59.924, 58.858, 51.535, 51.642, 51.477, 51.293, 51.117, 50.961, 50.863, 50.863, 50.529, 50.638, 50.391, 50.54, 50.441, 50.342, 50.332, 50.332, 50.332, 50.332, 50.332]
+    data=value_list
+    
+    print("=" * 50)
+    print("Adaptive Peak Valley Detection Demo")
+    print("=" * 50)
+    
+    # Run detection
+    result = adaptive_peak_valley_detection(
+        data, 
+        window_size=None,  # Adaptive window size
+        verbose=True,
+        min_distance=10,
+        prominence_threshold=0.01,
+    )
+    
+    print(f"\nDetection Results:")
+    print(f"Peak count: {result['stats']['peak_count']}")
+    print(f"Valley count: {result['stats']['valley_count']}")
+    print(f"Segment count: {len(result['segments'])}")
+    
+    if result['stats']['peak_count'] > 0:
+        print(f"Average peak value: {result['stats']['avg_peak_value']:.2f}")
+        print(f"Average peak distance: {result['stats'].get('avg_peak_distance', 0):.1f}")
+    
+    if result['stats']['valley_count'] > 0:
+        print(f"Average valley value: {result['stats']['avg_valley_value']:.2f}")
+        print(f"Average valley distance: {result['stats'].get('avg_valley_distance', 0):.1f}")
+    
+    # Plot results
+    plot_results(data, result, save_path='demo_result.png')  # Set save_path if needed
+    
+    return result
+
+
+if __name__ == "__main__":
+    demo()

VLAC/evo_vlac/utils/model_utils.py

@@ -0,0 +1,956 @@
+import time
+from swift.llm import (
+    get_model_tokenizer, get_template, ModelType, load_dataset, EncodePreprocessor
+)
+from swift.utils import seed_everything
+from swift.tuners import Swift
+from typing import Any, Dict, List, Mapping, Optional, Tuple, Union,Literal
+from swift.llm import RequestConfig,InferRequest,TemplateInputs
+import  torch
+from loguru import logger
+import copy
+from PIL import Image
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from data_processing_vlm import DataProcessor,trojectory_example_prompt,denormalize_with_params
+from video_tool import images_get_from_video, video_trajectory
+import tqdm
+import math
+from collections import defaultdict
+import heapq
+from scipy.spatial import cKDTree
+from scipy.stats import spearmanr
+import random
+import numpy as np
+import requests
+import base64
+from io import BytesIO
+import re
+
+def clip_one(image):
+    width, height = image.size
+
+    if width > height:
+        left = (width - height) // 2
+        right = left + height
+        top = 0
+        bottom = height
+    else:
+        top = (height - width) // 2
+        bottom = top + width
+        left = 0
+        right = width
+    square_image = image.crop((left, top, right, bottom))
+    image=square_image
+    return image
+
+def to_device(data: Any, device: Union[str, torch.device, int]) -> Any:
+    """Move inputs to a device"""
+    if isinstance(data, Mapping):
+        return type(data)({k: to_device(v, device) for k, v in data.items()})
+    elif isinstance(data, (tuple, list)):
+        return type(data)(to_device(v, device) for v in data)
+    elif isinstance(data, torch.Tensor):
+        return data.to(device=device)
+    else:
+        return data
+
+
+class GAC_model():
+    def __init__(self,tag='critic'):
+        self.tag=tag
+        self.temperature=1
+        self.max_tokens=10240
+        self.do_sample=True
+        self.top_logprobs=10
+        self.logprobs=True
+        self.top_k=None
+        self.system_prompt=None
+        self.action_data={}
+        self.critic_data={}
+        self.sft_dataset=None
+        self.dataclient=DataProcessor()
+        self.dataclient.prompt_templete['v3']="Image-1: <image>\nImage-2: <image>\nCompare two images and evaluate whether the second image is closer to achieving task objectives compared to the first image. + score means the second image is closer, - score means the first image is closer\nResponse the relative progressing of target task follow <score>. The target task is: <task> {} </task> <score>"
+        self.dataclient.prompt_templete['v3_think']="0% <image>\nThis image is the trajectory beginning of the following two images\nImage-1: <image>\nImage-2: <image>\nCompare two images and evaluate whether the second image is closer to achieving task objectives compared to the first image. + score means the second image is closer, - score means the first image is closer\nResponse the relative progressing of target task follow <score>. The target task is: <task> {} </task> <score>"
+
+
+    def _songling_process(self,action):
+        action=copy.deepcopy(action)
+        for i in range(len(action)):
+            if i in [0, 1, 2]:
+                action[i]=action[i]//1000
+            elif i in [3,4,5]:
+                action[i]=action[i]//1000
+            elif i ==6:
+                pass
+            else:
+                pass
+        return action
+
+    def format_state(self,state,gripper_format=False):
+        state=self._songling_process(state)
+        if gripper_format:
+            state_open=round((state[6]//10000)/7.0,1)
+            state[6]=state_open
+        else:
+            state[6]=state[6]//1000
+        return state
+
+    def get_score_prompt(self,task,trajectory_len=0,think=False):
+        "two or len+3 image"
+        if trajectory_len>0:
+            trajectory_prompt=trojectory_example_prompt(list(range(trajectory_len)),task=task)
+            full_prompt=trajectory_prompt+self.dataclient.prompt_templete['v3_think'].format(task)
+        else:
+            full_prompt=self.dataclient.prompt_templete['v3'].format(task)
+        if think:
+            full_prompt+=self.dataclient.prompt_templete['think']
+        return full_prompt
+    def get_done_prompt(self,task):
+        "one image"
+        return self.dataclient.prompt_templete["task_done"].format(task)
+    
+    def get_in_context_done_prompt(self,task=None):
+        "two image"
+        if task:
+            return self.dataclient.prompt_templete["context_task_done"].format(task,task)
+        else:
+            return self.dataclient.prompt_templete["image_done"]
+    
+    def get_task_prompt(self):
+        "two image"
+        return self.dataclient.prompt_templete["task_vqa"]
+    def get_action_inverse_prompt(self):
+        "two image"
+        return self.dataclient.prompt_templete["action_inverse"]
+    
+    def get_action_score_prompt(self,task,state,action):
+        "one image"
+        format_fuction=self.dataclient.action_format['songling']
+        action_score_prompt=self.dataclient.prompt_templete['task_action_score'].format(format_fuction(state),format_fuction(action),task)
+        return action_score_prompt
+
+    def get_action_prompt(self,task,view_num=1,position_output=False,simple=False,state='type',output_num=1,think=False):
+        if simple:
+            format_fuction=self.dataclient.action_format_simple['songling']
+            action_key='task_action_simple'
+            if position_output:
+                action_key='task_position_simple'
+        else:
+            format_fuction=self.dataclient.action_format['songling']
+            action_key='task_action'
+            if position_output:
+                action_key='task_position'
+        "view_num(max 3) image"
+        image_prompt=self.dataclient.image_prompt_templete[view_num]
+        full_prompt=image_prompt+self.dataclient.prompt_templete[action_key].format(format_fuction(state,state=position_output),task)
+        if output_num>1:
+            full_prompt+=f'*{output_num}'
+        if think:
+            full_prompt+=self.dataclient.prompt_templete['think']
+        return full_prompt
+    
+    def get_fast_action_prompt(self,task,view_num=1,position_output=False,simple=False,state='type',output_num=1,think=False):
+        full_prompt = self.get_action_prompt(task,view_num,position_output,simple,state,output_num,think)
+        full_prompt+='<chunks>'
+        return full_prompt
+    def set_config(self):
+        self.request_config = RequestConfig(
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            top_k=self.top_k,
+            logprobs=self.logprobs,
+            top_logprobs=self.top_logprobs,
+            # repetition_penalty=args.repetition_penalty,
+            # stop=args.stop_words,
+            # stream=True
+        )
+        self.model.generation_config.max_new_tokens = self.max_tokens
+        self.model.generation_config.do_sample=self.do_sample
+        self.model.generation_config.temperature=self.temperature
+
+    def _get_internvl2_per_token_logps(self, model, inputs):
+        from trl.trainer.utils import selective_log_softmax
+        logits_to_keep = inputs['logits_to_keep']
+        input_ids = inputs['input_ids']
+        inputs = {
+            k: v
+            for k, v in inputs.items() if k not in
+            ['logits_to_keep', 'completion_mask', 'ref_per_token_logps', 'advantages', 'old_per_token_logps']
+        }
+        _, inputs = self.template.pre_forward_hook(self.model, None, inputs)
+        logits = model(**inputs).logits
+        # exclude the last logit: it corresponds to the next token pred
+        logits = logits[:, -(logits_to_keep + 1):-1, :]
+        logits = logits / self.temperature
+        input_ids = input_ids[:, -logits_to_keep:]
+        return selective_log_softmax(logits, input_ids) 
+    def init_model(self,model_path,model_type='internvl2',device_map:str = 'auto',torch_dtype=torch.bfloat16,adapter: str = None):
+        """
+        Args:
+            device_map: ['auto', 'cuda:0',...]
+        """
+        template_type = model_type
+        print(f'template_type: {template_type}')
+        self.model, tokenizer = get_model_tokenizer(model_id_or_path=model_path,
+                                            model_type=model_type,
+                                            torch_dtype=torch_dtype,
+                                            device_map=device_map,
+                                            attn_impl = 'flash_attn')
+        self.template = get_template(template_type, tokenizer)
+        if adapter:
+            self.model = Swift.from_pretrained(self.model, adapter, adapter_name=None)
+
+        from swift.llm import PtEngine
+        from swift.plugin import InferStats
+        self.engine = PtEngine.from_model_template(self.model, self.template, max_batch_size=0)
+
+        self.infer_stats = InferStats()
+        seed_everything(42)
+        logger.success("model initialized successfully")
+   
+    def chat(self,infer_requests):
+        start_t=time.time()
+        response_list = self.engine.infer(
+        infer_requests, template=self.template, request_config=self.request_config, metrics=[self.infer_stats])
+        end_t=time.time()
+        infer_time=end_t-start_t
+        return response_list,infer_time
+    
+    def results_format(self,response_list,infer_requests,rich=False):
+        infer_requests=copy.deepcopy(infer_requests)
+        answers=[]
+        for i in range(len(response_list)):
+            if rich:
+                rich_answer=''
+                for one in response_list[i].choices[0].logprobs['content'][:-1]:
+                    if one['token'].isdigit():
+                        temp_num=0
+                        temp_weight=0
+                        top_prob=math.e**one['top_logprobs'][0]['logprob']
+                        for one_tops in one['top_logprobs']:
+                            top_num=one_tops['token']
+                            if top_num.isdigit():
+                                prob=math.e**one_tops['logprob']
+                                if prob>top_prob*0.1:
+                                    temp_num+=float(top_num)*prob
+                                    temp_weight+=prob
+                        rich_answer+="{:.1f}".format(temp_num/temp_weight)
+                    else:
+                        rich_answer+=one['token']
+                answers.append(rich_answer)
+            else:
+                answers.append(response_list[i].choices[0].message.content)
+            infer_requests[i].messages.append({'role': 'assistant', 'content': response_list[i].choices[0].message.content})
+        return answers,infer_requests
+    
+
+    def fast_results_format(self,response_list,infer_requests,tokenizer,time_horizon=10,action_dim=7):
+        infer_requests=copy.deepcopy(infer_requests)
+        answers=[]
+        for i in range(len(response_list)):
+            temp=[]
+            text=[]
+            for one in response_list[i].choices[0].logprobs['content'][:-1]:
+                ids=tokenizer.encode(one['token'],add_special_tokens=False)
+                if 92537-ids[0]<=2048:
+                    temp.extend(ids)
+                # temp.extend(tokenizer.encode(one['token'],add_special_tokens=False))
+            temp=[[92537-one for one in temp]]
+            fast_chunk=tokenizer.fasttokenizer.decode(temp,time_horizon=time_horizon,action_dim=action_dim)
+            infer_requests[i].messages.append({'role': 'assistant', 'content': response_list[i].choices[0].message.content})
+        return fast_chunk,infer_requests
+    
+    def denormalize_fastchunk(self,fast_chunk,params):
+        return denormalize_with_params(fast_chunk,params)
+
+    def set_system_prompt(self,system_prompt=None):
+        if system_prompt is not None:
+            self.system_prompt=system_prompt
+        elif system_prompt=='default':
+            self.system_prompt=None
+        else:
+            self.system_prompt='You are a visual-language assistant designed to interpret spatial and task-related information from images and text. Provide precise, context-aware responses and actionable guidance to assist in achieving task objectives.'
+    
+    def _process_image_to_pil(self, image_input: Union[str, Image.Image]) -> Image.Image:
+        """
+        将各种格式的图像输入转换为448x448的PIL.Image
+        
+        Args:
+            image_input: 图像URL、文件路径、base64编码字符串或PIL.Image对象
+        
+        Returns:
+            PIL.Image: 调整为448x448尺寸的PIL图像
+        """
+        pil_image = None
+        
+        if isinstance(image_input, Image.Image):
+            pil_image = image_input
+        elif isinstance(image_input, str):
+            if image_input.startswith(('http://', 'https://')):
+                response = requests.get(image_input)
+                pil_image = Image.open(BytesIO(response.content))
+            elif image_input.startswith('data:image'):
+                header, encoded = image_input.split(',', 1)
+                image_data = base64.b64decode(encoded)
+                pil_image = Image.open(BytesIO(image_data))
+            elif len(image_input) > 100 and not '/' in image_input and not '\\' in image_input:
+                try:
+                    image_data = base64.b64decode(image_input)
+                    pil_image = Image.open(BytesIO(image_data))
+                except:
+                    pil_image = Image.open(image_input)
+            else:
+                pil_image = Image.open(image_input)
+        else:
+            raise ValueError(f"不支持的图像输入类型: {type(image_input)}")
+        
+        if pil_image.mode != 'RGB':
+            pil_image = pil_image.convert('RGB')
+        
+        pil_image = pil_image.resize((448, 448), Image.Resampling.LANCZOS)
+        
+        return pil_image
+    
+    def get_infer_requests(self,prompt,images:List[Union[str, Image.Image]] = None):
+        """
+        Args:
+            prompt: 提示文本
+            images: 可以是图像URL、文件路径、base64编码字符串或PIL.Image对象
+        """
+        if type(prompt)==str:
+            prompt=[prompt]
+            images=[images]
+        infer_requests=[]
+        for i in range(len(prompt)):
+            one_input=[]
+            if self.system_prompt:
+                one_input.append(
+                    {
+                        'role': 'system',
+                        'content': self.system_prompt
+                    }
+                )
+            one_input.append(
+                {
+                    'role': 'user',
+                    'content': prompt[i]
+                }
+            )
+            processed_images = None
+            if images[i] is not None:
+                if isinstance(images[i], list):
+                    processed_images = [self._process_image_to_pil(img) for img in images[i] if img is not None]
+                else:
+                    processed_images = [self._process_image_to_pil(images[i])]
+            
+            infer_requests.append(TemplateInputs(
+                messages=one_input,
+                images=processed_images,
+            ))
+            # infer_requests.append(TemplateInputs(
+            #     messages=one_input,
+            #     images=images[i],
+            # ))
+        return infer_requests
+    
+    def get_logprobs(self,infer_requests,return_mask=False,digit=False):
+        old_mode=self.template.mode
+        self.template.set_mode('train')
+        mini_batch_encoded_inputs = [self.template.encode(infer_request) for infer_request in infer_requests]
+        mini_batch_encoded_inputs = to_device(
+            self.template.data_collator(mini_batch_encoded_inputs), self.model.device)
+        labels = mini_batch_encoded_inputs.pop('labels')
+        logits_to_keep = (labels.shape[-1] - (torch.ne(labels, -100).int().argmax(-1))).max().item()
+        mini_batch_encoded_inputs['logits_to_keep'] = logits_to_keep
+        mini_batch_encoded_inputs['completion_mask'] = labels[:, -logits_to_keep:] != -100
+        per_token_logps = self._get_internvl2_per_token_logps(self.model, mini_batch_encoded_inputs)
+        self.template.set_mode(old_mode)
+        if return_mask:
+            if digit:
+                tokenizer = self.template.tokenizer
+                
+                digit_completion_mask = torch.zeros_like(labels[:, -logits_to_keep:], dtype=torch.bool)
+                for i in range(labels.shape[0]):
+                    for j in range(labels.shape[1] - logits_to_keep, labels.shape[1]):
+                        if labels[i, j] != -100:
+                            token_id = labels[i, j].item()
+                            token_str = tokenizer.decode([token_id]).strip()
+                            if re.search(r'[0-9+\-]', token_str):
+                                digit_completion_mask[i, j - (labels.shape[1] - logits_to_keep)] = True
+                return per_token_logps, mini_batch_encoded_inputs['completion_mask'],digit_completion_mask
+            else:
+                return per_token_logps,mini_batch_encoded_inputs['completion_mask']
+        else:
+            return per_token_logps
+
+
+    def get_in_context_done(self,task:str,first_image:List[Image.Image],n_pre_image:List[Image.Image],now_image:List[Image.Image],ref_image_list:List[Image.Image],ref_num=9,rich=False):
+        """
+        In context 的方式获取done
+        提供一段参考ref_image_list
+        first_image是你的轨迹的第一张图,这里为list是可以batch推理
+        n_pre_image是上一个时刻
+        now_image是当前时刻
+        """
+        if ref_image_list is not None:
+            ref_images=[ref_image_list[0]]
+            delta=(len(ref_image_list)-1)/(ref_num-1)
+            for i in range(1,ref_num):
+                ref_images.append(ref_image_list[int(i*delta)])
+        else:
+            ref_num=0
+        one_prompt=self.get_score_prompt(task=task,trajectory_len=ref_num,think=True)
+        batch_prompt=[]
+        batch_image=[]
+        for i in range(len(now_image)):
+            batch_prompt.append(one_prompt)
+            batch_image.append(ref_images+[first_image[i],n_pre_image[i],now_image[i]])
+        infer_requests=self.get_infer_requests(prompt=batch_prompt,images=batch_image)
+        response_list,infer_time=self.chat(infer_requests)
+        answers_list,complete_requests_list=self.results_format(response_list,infer_requests,rich=rich)
+        think_pre_value_list=[]
+        think_post_value_list=[]
+        think_critic_list=[]
+        for one in answers_list:
+            one_critic=one.split('</think>')[1]
+            one_pre_value=one.split('first image progressing: ')[1].split('%')[0]
+            one_post_value=one.split('second image progressing: ')[1].split('%')[0]
+            think_critic_list.append("{:.1f}".format((100-float(one_pre_value))*float(one_critic)/100.0))
+            think_pre_value_list.append(one_pre_value)
+            think_post_value_list.append("{:.3f}".format(float(one_post_value)/100.0))
+        batch_done=think_post_value_list
+        batch_related_critic=think_critic_list
+        return batch_done,batch_related_critic
+
+
+    def web_trajectory_critic(self, task_description, main_video_path, reference_video_path=None, 
+                            batch_num=20, ref_num=9, think=False, skip=1, rich=False, reverse_eval=False,output_path=None,fps=None,frame_skip=False,addition_scale=1,bias=0,positive_clip=0,negative_clip=0,related_critic=False,done_flag=False,in_context_done=False,done_threshold=False,video_output=True):
+        list_video=images_get_from_video(main_video_path)
+        ref_list=None
+        if reference_video_path is None:
+            ref_num=0
+        else:
+            ref_list=images_get_from_video(reference_video_path)
+        if done_flag:
+            if in_context_done:
+                done_ref=ref_list
+            else:
+                done_ref=None
+            done_list=self.get_trajectory_done(task=task_description,image_list=list_video,ref_image_list=done_ref,batch_num=batch_num,rich=True,ref_num=ref_num,threshold=done_threshold)
+            if frame_skip:
+                done_list=[done_list[i] for i in range(0,len(done_list),skip)]
+        else:
+            done_list=None
+        critic_list, think_value_list=self.get_trajectory_critic(task=task_description,image_list=list_video,ref_image_list=ref_list,batch_num=batch_num,ref_num=ref_num,think=think,skip=skip,rich=rich,reverse_eval=reverse_eval,frame_skip=frame_skip,addition_scale=addition_scale,bias=bias,positive_clip=positive_clip,negative_clip=negative_clip,related_critic=related_critic)
+        value_list=think_value_list
+        if video_output:
+            if ref_num>0:
+                ref_image_paths=ref_list
+            else:
+                ref_image_paths=None
+            if fps:
+                pass
+            else:
+                fps=5.0/skip
+            video_path = video_trajectory(
+                traj_id='temp',
+                view='0',
+                image_paths=[],
+                image_objects=list_video,
+                done_list=done_list,
+                critic_list=critic_list,
+                value_list=value_list,
+                task=task_description,
+                output_path=output_path,
+                fps=fps,
+                ref_image_paths=ref_image_paths,
+                n_num=ref_num
+            )
+        else:
+            video_path=None
+        return video_path,value_list,critic_list,done_list
+    
+    def web_trajectory_done(self, task_description, main_image_path, reference_image_path=None, rich=False):
+        done_list=self.get_trajectory_done(task=task_description,image_list=[main_image_path],batch_num=1,rich=rich)
+        return f"Task: {task_description}\nCritic Score: {done_list[0]}"
+    
+
+    def get_trajectory_task(self, image_list):
+        one_prompt=self.get_task_prompt()
+        infer_requests=self.get_infer_requests(prompt=one_prompt,images=[image_list[0],image_list[-1]])
+        response_list,infer_time=self.chat(infer_requests)
+        answers_list,complete_requests_list=self.results_format(response_list,infer_requests)
+        return answers_list
+
+    
+    def get_trajectory_done(self,task:str,image_list:List[Image.Image],ref_image_list:List[Image.Image]=None,batch_num:int=20,rich=False,ref_num=9,threshold=0,skip=1,goal_image:Image.Image=None):
+        """
+        输入一条trajectory的所有图片,输出每张图片的done,0~1的突变值
+        当有ref_image_list时,进行过程判断,输出0~1的渐变值
+        当有gaol_image时,进行最终状态判断,输出0~1的突变值(与当有ref_image_list冲突),task=None时只依靠图片
+        """
+        batch_prompt=[]
+        batch_image=[]
+        done_list=[]
+        if skip>1:
+            image_list=[image_list[i] for i in range(0,len(image_list),skip)]
+        if ref_image_list is None and goal_image is None:
+            for i in tqdm.tqdm(range(len(image_list)),desc='done processing'):
+                one_prompt=self.get_done_prompt(task=task)
+                batch_prompt.append(one_prompt)
+                batch_image.append([image_list[i]])
+                if (i+1) % batch_num==0 or i==len(image_list)-1:
+                    infer_requests=self.get_infer_requests(prompt=batch_prompt,images=batch_image)
+                    response_list,infer_time=self.chat(infer_requests)
+                    answers_list,complete_requests_list=self.results_format(response_list,infer_requests,rich=rich)
+                    print(f'infer_time:{infer_time}s')
+                    print(f'answers_list:{answers_list}')
+                    done_list.extend(answers_list)
+                    batch_prompt=[]
+                    batch_image=[]
+        elif ref_image_list:
+            first_image=[]
+            n_pre_image=[]
+            now_image=[]
+            for i in tqdm.tqdm(range(1,len(image_list)),desc='done processing'):
+                first_image.append(image_list[0])
+                n_pre_image.append(image_list[i-1])
+                now_image.append(image_list[i])
+                if (i+1) % batch_num==0 or i==len(image_list)-1:
+                    batch_done,batch_related_critic=self.get_in_context_done(task=task,first_image=first_image,n_pre_image=n_pre_image,now_image=now_image,ref_image_list=ref_image_list,ref_num=ref_num,rich=rich)
+                    print(f'answers_list:{batch_done}')
+                    done_list.extend(batch_done)
+                    first_image=[]
+                    n_pre_image=[]
+                    now_image=[]
+            done_list=[0]+done_list
+        else:
+            for i in tqdm.tqdm(range(len(image_list)),desc='done processing'):
+                one_prompt=self.get_in_context_done_prompt(task=task)
+                batch_prompt.append(one_prompt)
+                batch_image.append([goal_image,image_list[i]])
+                if (i+1) % batch_num==0 or i==len(image_list)-1:
+                    infer_requests=self.get_infer_requests(prompt=batch_prompt,images=batch_image)
+                    response_list,infer_time=self.chat(infer_requests)
+                    answers_list,complete_requests_list=self.results_format(response_list,infer_requests,rich=rich)
+                    print(f'infer_time:{infer_time}s')
+                    print(f'answers_list:{answers_list}')
+                    done_list.extend(answers_list)
+                    batch_prompt=[]
+                    batch_image=[]
+        done_list = [float(one) if float(one) > threshold else 0.0 for one in done_list]
+        return done_list
+
+    def get_trajectory_critic(self,task:str,image_list:List[Image.Image],ref_image_list:List[Image.Image]=None,batch_num:int=20,ref_num=9,think=False,skip=1,rich=False,reverse_eval=False,frame_skip=True,addition_scale=1,bias=0,related_critic=False,positive_clip=0,negative_clip=0,value_simple=True):
+        """
+        输入一条trajectory的所有图片,输出每张图片的critic和processing value
+        可以给一条参考轨迹
+        """
+        batch_prompt=[]
+        batch_image=[]
+        critic_list=[]
+        value_list=[]
+        if ref_image_list is not None:
+            ref_images=[ref_image_list[0]]
+            delta=(len(ref_image_list)-1)/(ref_num-1)
+            for i in range(1,ref_num):
+                ref_images.append(ref_image_list[int(i*delta)])
+        else:
+            ref_num=0
+        if frame_skip:
+            select_idx=range(skip,len(image_list),skip)
+        else:
+            select_idx=range(skip,len(image_list))
+        for i in tqdm.tqdm(select_idx,desc='critic processing'):
+            one_prompt=self.get_score_prompt(task=task,trajectory_len=ref_num,think=think)
+            batch_prompt.append(one_prompt)
+            if ref_image_list is not None:
+                if reverse_eval:
+                    batch_image.append(ref_images+[image_list[0],image_list[i],image_list[i-skip]])
+                else:
+                    batch_image.append(ref_images+[image_list[0],image_list[i-skip],image_list[i]])
+            else:
+                if reverse_eval:
+                    batch_image.append([image_list[i],image_list[i-skip]])
+                else:
+                    batch_image.append([image_list[i-skip],image_list[i]])
+            if (len(batch_prompt)) % batch_num==0 or len(critic_list)+len(batch_prompt)==len(select_idx):
+                infer_requests=self.get_infer_requests(prompt=batch_prompt,images=batch_image)
+                response_list,infer_time=self.chat(infer_requests)
+                answers_list,complete_requests_list=self.results_format(response_list,infer_requests,rich=rich)
+                print(f'infer_time:{infer_time}s')
+                print(f'answers_list:{answers_list}')
+                critic_list.extend(answers_list)
+                batch_prompt=[]
+                batch_image=[]
+        if think:
+            think_pre_value_list=[]
+            think_post_value_list=[]
+            think_critic_list=[]
+            for one in critic_list:
+                one_critic=one.split('</think>')[1]
+                one_pre_value=one.split('first image progressing: ')[1].split('%')[0]
+                one_post_value=one.split('second image progressing: ')[1].split('%')[0]
+                think_critic_list.append(one_critic)
+                think_pre_value_list.append(one_pre_value)
+                think_post_value_list.append(one_post_value)
+            if reverse_eval:
+                temp=think_pre_value_list
+                think_pre_value_list=think_post_value_list
+                think_post_value_list=temp
+                think_critic_list=[0-float(one) for one in think_critic_list]
+            think_pre_value_list=think_pre_value_list+think_post_value_list[-skip:]
+            think_post_value_list=think_pre_value_list[:skip]+think_post_value_list
+            critic_list=think_critic_list
+            if frame_skip:
+                pass
+            else:
+                critic_list=[float(one)/skip for one in critic_list]
+            critic_list=[float(one)/addition_scale for one in critic_list]
+            value_list=self.critic_to_value_simple(critic_list,simple=value_simple)
+        else:
+            if reverse_eval:
+                critic_list=[0-float(one) for one in critic_list]
+            if frame_skip:
+                pass
+            else:
+                critic_list=[float(one)/skip for one in critic_list]
+            critic_list=[float(one)/addition_scale for one in critic_list]
+            value_list=self.critic_to_value_simple(critic_list,simple=value_simple)
+        if related_critic:
+            critic_list=[value_list[i]-value_list[i-1] for i in range(1,len(value_list))]
+        if bias!=0:
+            critic_list=[one+bias for one in critic_list]
+        if positive_clip!=0:
+            critic_list=[one if (one<0 or one>positive_clip) else 0 for one in critic_list]
+        if negative_clip!=0:
+            critic_list=[one if (one>0 or one<-negative_clip) else 0 for one in critic_list]
+        if related_critic:
+            value_list=[0]
+            for one in critic_list:
+                value_list.append(value_list[-1]+one)
+        else:
+            value_list=self.critic_to_value_simple(critic_list,simple=value_simple)
+        #这里的value也是done，越接近100完成度越高
+        return critic_list,value_list
+
+    def magic_smooth(self,task,file_path,hz=10,value_simple='mix_f',ref_image_list=None,ref_num=9,think=False,max_skip=3):
+        import os
+        import pickle
+        import gzip
+        import subprocess
+        from video_tool import read_data_and_create_video,images_get_from_video
+        if type(ref_image_list)  == str:
+            if ref_image_list.endswith(".pkl.gz"):
+                ref_image_list = read_data_and_create_video(ref_image_list)
+            else:
+                ref_image_list=images_get_from_video(ref_image_list)
+        image_list=read_data_and_create_video(file_path, camera_name=None, create_video=False, output_path=None, fps=hz, start_frame=0, end_frame=None)
+        skip=int(hz/2)
+        critic_list,value_list=self.get_trajectory_critic(task=task,image_list=image_list,ref_image_list=ref_image_list,batch_num=10,ref_num=ref_num,think=think,skip=skip,rich=True,reverse_eval=False,frame_skip=True,addition_scale=1,bias=0,related_critic=False,positive_clip=0,negative_clip=0,value_simple=value_simple)
+
+        skip_idx_range=[]
+        skip_idxs=[]
+        i=0
+        while i <len(critic_list):
+            if float(critic_list[i])<=0:
+                skip_window=2
+                while i+skip_window<len(critic_list) and skip_window<=max_skip:
+                    two_image=[image_list[0],image_list[i*skip],image_list[(i+skip_window)*skip]]
+                    one_critic_list,_=self.get_trajectory_critic(task=task,image_list=two_image,ref_image_list=ref_image_list,batch_num=10,ref_num=ref_num,think=think,skip=1,rich=True,reverse_eval=False,frame_skip=True,addition_scale=1,bias=0,related_critic=False,positive_clip=0,negative_clip=0,value_simple=value_simple)
+                    if float(one_critic_list[-1])<0:
+                        skip_window+=1
+                    else:
+                        break
+                skip_idx_range.append([i,i+skip_window])
+                skip_idxs.extend(range(i*skip+1,(i+skip_window)*skip))
+                i+=skip_window
+                print("skip_window:",skip_window)
+            else:
+                i+=1
+        with gzip.open(file_path, 'rb') as f:
+            original_data = pickle.load(f)
+        
+        base_dir = os.path.dirname(file_path)
+        file_name = os.path.splitext(os.path.splitext(os.path.basename(file_path))[0])[0]  # 去掉.pkl.gz
+        output_dir = os.path.join(base_dir, f"{file_name}_smoothed")
+        os.makedirs(output_dir, exist_ok=True)
+        new_data=[one for i,one in enumerate(original_data) if i not in skip_idxs]
+        new_images=[one for i,one in enumerate(image_list) if i not in skip_idxs]
+
+        data_file = os.path.join(output_dir, f"{file_name}_smoothed.pkl.gz")
+            
+        with gzip.open(data_file, 'wb') as f:
+            pickle.dump(new_data, f)
+        
+        video_file = os.path.join(output_dir, f"{file_name}_smoothed.mp4")
+        
+        temp_dir = os.path.join(output_dir, f"temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        try:
+            for j, img in enumerate(new_images):
+                frame_file = os.path.join(temp_dir, f"frame_{j:06d}.png")
+                if hasattr(img, 'save'):
+                    img.save(frame_file)
+                else:
+                    from PIL import Image
+                    if isinstance(img, np.ndarray):
+                        Image.fromarray(img).save(frame_file)
+                    else:
+                        Image.fromarray(np.array(img)).save(frame_file)
+            
+            ffmpeg_cmd = [
+                'ffmpeg', '-y',
+                '-framerate', str(hz),
+                '-i', os.path.join(temp_dir, 'frame_%06d.png'),
+                '-c:v', 'libx264',
+                '-pix_fmt', 'yuv420p',
+                '-crf', '23',
+                video_file
+            ]
+            
+            subprocess.run(ffmpeg_cmd, check=True, capture_output=True)
+            print(f"Created video: {video_file}")
+            
+        except Exception as e:
+            print(f"Error creating video for segment {i}: {e}")
+            
+        finally:
+            import shutil
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+        return new_data
+        
+
+
+
+    def magic_split(self,task,file_path,hz=10,value_simple='mix_f',done_assist=False,ref_image_list=None):
+        import os
+        import pickle
+        import gzip
+        import subprocess
+        from video_tool import read_data_and_create_video,images_get_from_video
+        from magic_detect import adaptive_peak_valley_detection,plot_results
+        if type(ref_image_list)  == str:
+            if ref_image_list.endswith(".pkl.gz"):
+                ref_image_list = read_data_and_create_video(ref_image_list)
+            else:
+                ref_image_list=images_get_from_video(ref_image_list)
+        
+        skip=int(hz/2)
+        done_len=4
+        gap_merge_len=4#一般看数据的平均记录周期
+        image_list=read_data_and_create_video(file_path, camera_name=None, create_video=False, output_path=None, fps=hz, start_frame=0, end_frame=None)
+        critic_list,value_list=self.get_trajectory_critic(task=task,image_list=image_list,ref_image_list=ref_image_list,batch_num=10,ref_num=9,think=False,skip=skip,rich=True,reverse_eval=False,frame_skip=True,addition_scale=1,bias=0,related_critic=False,positive_clip=0,negative_clip=0,value_simple=value_simple)
+        
+        if done_assist:
+            done_list=self.get_trajectory_done(task=task,image_list=image_list,ref_image_list=None,batch_num=10,ref_num=2,rich=True,threshold=0.9,skip=skip)
+            assist_peaks={}
+            peak_window=[]
+            done_list=done_list+[0]
+            for k in range(len(done_list)):
+                if done_list[k]>=0.95:
+                    peak_window.append(k)
+                else:
+                    if len(peak_window)>=done_len:
+                        assist_peaks[peak_window[done_len-1]]=peak_window
+                    peak_window=[]
+            peak_list=list(assist_peaks.keys())
+            index=0
+            while index<len(peak_list)-1:
+                if assist_peaks[peak_list[index+1]][0]-assist_peaks[peak_list[index]][-1]<=gap_merge_len:
+                    assist_peaks[peak_list[index]].extend(assist_peaks[peak_list[index+1]])
+                    del assist_peaks[peak_list[index+1]]
+                    del peak_list[index+1]
+                else:
+                    index+=1
+            result = adaptive_peak_valley_detection(
+                        value_list, 
+                        assist_peaks=peak_list,
+                        window_size=None,  # Adaptive window size
+                        verbose=True,
+                        min_distance=10,
+                        prominence_threshold=0.1,
+                        outlier_sensitivity=3
+            )
+        else:
+            result = adaptive_peak_valley_detection(
+                        value_list, 
+                        window_size=None,  # Adaptive window size
+                        verbose=True,
+                        min_distance=10,
+                        prominence_threshold=0.01,
+                        outlier_sensitivity=1.5
+            )
+        
+
+        with gzip.open(file_path, 'rb') as f:
+            original_data = pickle.load(f)
+        
+        base_dir = os.path.dirname(file_path)
+        file_name = os.path.splitext(os.path.splitext(os.path.basename(file_path))[0])[0]  # 去掉.pkl.gz
+        output_dir = os.path.join(base_dir, f"{file_name}_segments")
+        os.makedirs(output_dir, exist_ok=True)
+        plot_results(value_list, result,save_path=os.path.join(output_dir, "peak_valley.png"))
+        peaks = [one*skip for one in result['peaks']]
+        valleys = [one*skip for one in result['valleys']]
+        
+        ascending_dir = os.path.join(output_dir, "ascending")
+        descending_dir = os.path.join(output_dir, "descending")
+        os.makedirs(ascending_dir, exist_ok=True)
+        os.makedirs(descending_dir, exist_ok=True)
+        
+        video_dir = os.path.join(output_dir, "videos")
+        os.makedirs(video_dir, exist_ok=True)
+        
+        all_points = []
+        for p in peaks:
+            all_points.append((p, 'peak'))
+        for v in valleys:
+            all_points.append((v, 'valley'))
+        all_points.sort(key=lambda x: x[0])
+        
+        segments = []
+        
+        for i, (point_idx, point_type) in enumerate(all_points):
+            if i == 0:
+                prev_type='valley'
+                start_idx = 0
+            else:
+                start_idx=all_points[i-1][0]
+                prev_type = all_points[i-1][1]
+
+            end_idx = point_idx
+            if prev_type == 'valley' and point_type == 'peak':
+                segment_type = 'ascending'
+            elif prev_type == 'peak' and point_type == 'valley':
+                segment_type = 'descending'
+            else:
+                continue
+                
+            data_segment = original_data[start_idx:end_idx]
+            image_segment = image_list[start_idx:end_idx]
+            
+            segments.append({
+                'type': segment_type,
+                'start': start_idx,
+                'end': end_idx,
+                'data': data_segment,
+                'images': image_segment
+            })
+            
+        
+        if segments and segments[-1]['type'] == 'descending':
+            segments.pop()
+        
+        for i, segment in enumerate(segments):
+            segment_type = segment['type']
+            
+            task_name = self.get_trajectory_task(segment['images'])[0].split('</task>')[0].strip().replace(' ', '_').replace('.', '_').replace(',', '_')
+            
+            if segment_type == 'ascending':
+                data_file = os.path.join(ascending_dir, f"{task_name}_{i:03d}.pkl.gz")
+            else:
+                data_file = os.path.join(descending_dir, f"{task_name}_{i:03d}.pkl.gz")
+                
+            with gzip.open(data_file, 'wb') as f:
+                pickle.dump(segment['data'], f)
+            
+            video_file = os.path.join(video_dir, f"{segment_type}_{task_name}_{i:03d}.mp4")
+            
+            temp_dir = os.path.join(output_dir, f"temp_{i}")
+            os.makedirs(temp_dir, exist_ok=True)
+            
+            try:
+                for j, img in enumerate(segment['images']):
+                    frame_file = os.path.join(temp_dir, f"frame_{j:06d}.png")
+                    if hasattr(img, 'save'):
+                        img.save(frame_file)
+                    else:
+                        from PIL import Image
+                        if isinstance(img, np.ndarray):
+                            Image.fromarray(img).save(frame_file)
+                        else:
+                            Image.fromarray(np.array(img)).save(frame_file)
+                
+                ffmpeg_cmd = [
+                    'ffmpeg', '-y',
+                    '-framerate', str(hz),
+                    '-i', os.path.join(temp_dir, 'frame_%06d.png'),
+                    '-c:v', 'libx264',
+                    '-pix_fmt', 'yuv420p',
+                    '-crf', '23',
+                    video_file
+                ]
+                
+                subprocess.run(ffmpeg_cmd, check=True, capture_output=True)
+                print(f"Created video: {video_file}")
+                
+            except Exception as e:
+                print(f"Error creating video for segment {i}: {e}")
+                
+            finally:
+                import shutil
+                if os.path.exists(temp_dir):
+                    shutil.rmtree(temp_dir)
+        
+        print(f"Processing complete. Segments saved to: {output_dir}")
+        print(f"Total segments: {len(segments)}")
+        print(f"Ascending segments: {sum(1 for s in segments if s['type'] == 'ascending')}")
+        print(f"Descending segments: {sum(1 for s in segments if s['type'] == 'descending')}")
+        
+        return segments
+    
+    def critic_to_value_simple(self,critic_list,simple=True):
+        """
+        将critic计算为0-100的value,输入需是一条轨迹按顺序的critic
+        """
+        value_list=[0]
+        for i in range(len(critic_list)):
+            if float(critic_list[i])>0 or simple is True:
+                value_list.append(value_list[-1]+(100-value_list[-1])*float(critic_list[i])/100.0)
+            else:
+                if simple=='mix_f':
+                    if value_list[-1]>50:
+                        value_list.append(max(10,100-max((100-value_list[-1]),1.0)/(100+float(critic_list[i]))*100.0))
+                    else:
+                        value_list.append(value_list[-1]+value_list[-1]*float(critic_list[i])/100.0)
+                else:
+                    value_list.append(100-max((100-value_list[-1]),1.0)/(100+float(critic_list[i]))*100.0)
+        return value_list
+    
+    def compute_voc(self,values_list):
+        """
+        计算Value-Order Correlation (VOC)
+        
+        参数:
+            predicted_values: 模型预测的值序列，形状为(T,)，其中T是时间步数
+            
+        返回:
+            voc: Value-Order Correlation值，范围从-1到1
+        """
+        T = len(values_list)
+        time_order = np.arange(T)
+        
+        correlation, _ = spearmanr(values_list, time_order)
+        return correlation
+    
+    def compute_negative_rate(self,critic_list):
+        """
+        计算逆序动作的比例
+        """
+        negative_critic=[one for one in critic_list if one<0]
+
+        return float(len(negative_critic))/len(critic_list)
+
+
+def import_external_file(file_path: str):
+    import importlib
+    file_path = os.path.abspath(os.path.expanduser(file_path))
+    py_dir, py_file = os.path.split(file_path)
+    assert os.path.isdir(py_dir), f'py_dir: {py_dir}'
+    sys.path.insert(0, py_dir)
+    return importlib.import_module(py_file.split('.', 1)[0])

VLAC/evo_vlac/utils/video_tool.py

@@ -0,0 +1,802 @@
+from loguru import logger
+import traceback
+import numpy as np
+import torch
+import json
+import os
+import io
+import shutil
+import matplotlib
+import matplotlib.pyplot as plt
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+import random
+import copy
+import re
+import tempfile
+import cv2
+import subprocess
+
+
+def images_get_from_video(video_path):
+    """
+    将 MP4 视频转换为 PIL Image 对象列表
+    
+    参数:
+        video_path (str): 视频文件的路径
+        
+    返回:
+        list: 包含视频每一帧的 PIL Image 对象的列表
+    """
+    import cv2
+    # 打开视频文件
+    video = cv2.VideoCapture(video_path)
+    
+    # 检查视频是否成功打开
+    if not video.isOpened():
+        raise ValueError(f"无法打开视频文件: {video_path}")
+    
+    image_list = []
+    
+    # 逐帧读取视频
+    while True:
+        # 读取一帧
+        ret, frame = video.read()
+        
+        # 如果读取失败，说明到达视频末尾
+        if not ret:
+            break
+        
+        # 将 OpenCV 的 BGR 格式转换为 RGB 格式
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        
+        # 将 NumPy 数组转换为 PIL Image 对象
+        pil_image = Image.fromarray(rgb_frame)
+        
+        # 将图像添加到列表
+        image_list.append(pil_image)
+    
+    # 释放视频资源
+    video.release()
+    
+    return image_list
+
+def video_trajectory(traj_id, view, image_paths, image_objects, done_list, critic_list, value_list, task, output_path, fps=5, ref_image_paths=None, n_num=5, critic_log_scale=False):
+    """
+    将轨迹图片与done和value曲线构建为视频，并在上方添加参考图片
+    
+    参数:
+    - traj_id: 轨迹ID
+    - view: 视角
+    - image_paths: 图片路径列表
+    - image_objects: 图片对象列表
+    - done_list: done状态列表
+    - critic_list: critic评价列表
+    - value_list: 价值评估列表
+    - task: 任务描述
+    - output_path: 输出路径
+    - fps: 视频帧率
+    - ref_image_paths: 参考图片路径列表(也可以是对象)
+    - n_num: 要展示的参考图片数量
+    - critic_log_scale: 是否对critic使用对数坐标
+    """
+    import os
+    import matplotlib.pyplot as plt
+    import numpy as np
+    import cv2
+    from PIL import Image, ImageDraw, ImageFont
+    import textwrap
+    import matplotlib
+    import subprocess
+    import tempfile
+    import shutil
+    matplotlib.use('Agg')  # 非交互式后端，避免显示图形
+    
+    # 创建输出目录
+    os.makedirs(output_path, exist_ok=True)
+    
+    # 视频文件路径
+    video_path = os.path.join(output_path, f"{traj_id}_{view}_trajectory.mp4")
+    
+    # 计算skip值 - 关键修改点
+    skip = 1
+    if value_list and len(image_objects) > len(value_list):
+        skip = round(len(image_objects) / len(value_list))
+        print(f"计算得到的skip值: {skip}")
+    
+    # 转换done_list为数值（如果不为None）
+    done_values = None
+    if done_list is not None and len(done_list) > 0:
+        try:
+            done_values = [float(d) if d is not None else 0 for d in done_list]
+        except:
+            done_values = None
+    
+    # 转换critic_list为数值（如果不为None）
+    critic_values = None
+    if critic_list is not None and len(critic_list) > 0:
+        try:
+            critic_values = [float(d) if d is not None else 0 for d in critic_list]
+        except:
+            critic_values = None
+    
+    # 转换value_list为数值（如果不为None）
+    value_values = None
+    if value_list is not None and len(value_list) > 0:
+        try:
+            value_values = [float(d) if d is not None else 0 for d in value_list]
+        except:
+            value_values = None
+    
+    # 处理critic_list，使其前方补0与value_list长度一致
+    if critic_values and value_values and len(critic_values) < len(value_values):
+        padding_length = len(value_values) - len(critic_values)
+        critic_values = [0] * padding_length + critic_values
+    
+    if len(image_paths) > len(image_objects):
+        image_objects = [Image.open(img) for img in image_paths]
+    
+    resized_images = []
+
+    for img in image_objects:
+        # 获取原始图片的宽度和高度
+        img_width, img_height = img.size
+        
+        # 计算缩放比例
+        scale_factor = 480 / img_height
+        
+        # 计算新的宽度和高度
+        new_width = int(img_width * scale_factor)
+        new_height = 480  # 高度固定为 480
+        
+        # 调整图片大小，使用新的 Resampling 方法
+        resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # 保存调整后的图片到新列表
+        resized_images.append(resized_img)
+    image_objects=resized_images
+    # 获取图片尺寸
+    sample_img = image_objects[0]
+    img_width, img_height = sample_img.size
+    
+    # 处理参考图���
+    ref_images = []
+    if ref_image_paths and n_num > 0:
+        # 等间隔采样参考图片
+        if len(ref_image_paths) <= n_num:
+            indices = range(len(ref_image_paths))
+        else:
+            indices = np.linspace(0, len(ref_image_paths) - 1, n_num, dtype=int)
+        
+        for idx in indices:
+            try:
+                if type(ref_image_paths[idx]) is str:
+                    ref_img = Image.open(ref_image_paths[idx])
+                else:
+                    ref_img = ref_image_paths[idx]
+                ref_images.append(ref_img)
+            except Exception as e:
+                print(f"无法加载参考图片 {ref_image_paths[idx]}: {e}")
+    
+    # 计算参考图片区域的高度和布局
+    ref_height = 0
+    reference_text_width = 80
+    
+    # 计算需要绘制的曲线数量
+    curves_count = 0
+    if done_values is not None:
+        curves_count += 1
+    if value_values is not None:
+        curves_count += 1
+    if critic_values is not None:
+        curves_count += 1
+    
+    # 根据曲线数量调整布局
+    if curves_count == 0:
+        plot_width = 200  # 如果没有曲线，只留信息区域
+    else:
+        plot_width = 448  # 有曲线时的宽度
+    
+    # 设置视频尺寸 - 确保所有内容都能显示
+    frame_width = img_width + plot_width
+    frame_height = img_height + (ref_height + 30 if ref_images else 0)  # 30px间距
+
+    if ref_images:
+        # 参考图片高度为主图高度的1/3，提升显示效果
+        ref_height = min(img_height // 3, 150)  # 增加最大高度
+        
+        # 计算单个参考图片的宽度
+        single_ref_width = int(ref_height * (ref_images[0].width / ref_images[0].height))
+        
+        # 确保参考图片序列不会超出整个frame宽度(包括右侧区域)
+        total_available_width = frame_width - reference_text_width - 40  # 留40px边距
+        max_ref_width = total_available_width // len(ref_images)
+        
+        if single_ref_width > max_ref_width:
+            single_ref_width = max_ref_width
+            ref_height = int(single_ref_width * (ref_images[0].height / ref_images[0].width))
+    
+    # 创建临时目录保存帧图片
+    temp_dir = tempfile.mkdtemp()
+    
+    # 尝试加载字体
+    try:
+        font = ImageFont.truetype("arial.ttf", 14)  # 稍微缩小字体
+        small_font = ImageFont.truetype("arial.ttf", 12)
+        ref_font = ImageFont.truetype("arial.ttf", 16)
+    except IOError:
+        font = ImageFont.load_default()
+        small_font = ImageFont.load_default()
+        ref_font = ImageFont.load_default()
+    
+    try:
+        # 对每一帧图片生成视频帧
+        for i in range(len(image_objects)):
+            # 创建一个空白画布
+            frame = Image.new('RGB', (frame_width, frame_height), color='white')
+            
+            # 如果有参考图片，先添加参考图片和Reference标签
+            if ref_images:
+                # 添加"Reference"文字标签
+                draw = ImageDraw.Draw(frame)
+                ref_text_y = (ref_height - 20) // 2
+                draw.text((10, ref_text_y), "Reference", fill="black", font=ref_font)
+                
+                # 绘制参考图片
+                start_x = reference_text_width
+                for j, ref_img in enumerate(ref_images):
+                    # 调整参考图片大小
+                    resized_ref = ref_img.resize((single_ref_width, ref_height), Image.LANCZOS)
+                    # 可以跨越到右侧区域
+                    paste_x = start_x + j * single_ref_width
+                    frame.paste(resized_ref, (paste_x, 0))
+            
+            # 粘贴当前图片
+            main_img_y = ref_height + 20 if ref_images else 0
+            frame.paste(image_objects[i], (0, main_img_y))
+            
+            # 创建绘图对象
+            draw = ImageDraw.Draw(frame)
+            
+            # 计算信息显示区域
+            info_x = img_width + 10
+            info_y = main_img_y + 10
+            
+            # 添加任务描述
+            task_lines = textwrap.wrap(f"Task: {task}", width=25)  # 缩短任务描述宽度
+            task_width = 0
+            for line_idx, line in enumerate(task_lines[:4]):  # 最多显示2行
+                draw.text((info_x-5, info_y + line_idx * 18), line, fill="black", font=font)
+                # 计算任务文本的实际宽度
+                bbox = draw.textbbox((0, 0), line, font=font)
+                line_width = bbox[2] - bbox[0]
+                task_width = max(task_width, line_width)
+            
+            # 在任务描述右侧横向排列状态信息
+            status_x = info_x + task_width + 30  # 任务文本右侧30px处开始
+            status_y = info_y
+            
+            # 计算当前帧在value_list中的对应索引 - 关键修改点
+            value_idx = i // skip
+            
+            # 横向排列当前帧状态信息
+            current_x = status_x
+            if done_list and value_idx < len(done_list):
+                done_status = done_list[value_idx]
+                done_color = "green" if done_status == "Yes" or done_status == True or done_status == 1 else "red"
+                done_text = f"Done: {done_status}"
+                draw.text((current_x, status_y), done_text, fill=done_color, font=font)
+                # 计算文本宽度并移动到下一个位置
+                bbox = draw.textbbox((0, 0), done_text, font=font)
+                current_x += (bbox[2] - bbox[0]) + 20
+            
+            if value_list and value_idx < len(value_list):
+                value = value_list[value_idx]
+                value_color = "green" if value > 0 else "red"
+                value_text = f"Value: {value:.4f}"
+                draw.text((current_x, status_y), value_text, fill=value_color, font=font)
+                # 计算文本宽度并移动到下一个位置
+                bbox = draw.textbbox((0, 0), value_text, font=font)
+                current_x += (bbox[2] - bbox[0]) + 20
+            
+            if critic_list and value_idx < len(critic_list):
+                critic = float(critic_list[value_idx])
+                critic_color = "green" if critic >= 0 else "red"
+                critic_text = f"Critic: {critic:.4f}"
+                draw.text((current_x, status_y), critic_text, fill=critic_color, font=font)
+            
+            # # 在第二行显示帧计数和value索引
+            # draw.text((status_x, status_y + 20), f"Frame: {i+1}/{len(image_objects)} (Value idx: {value_idx})", fill="black", font=small_font)
+            
+            # 如果有数据，创建曲线图 - 关键修改点
+            if curves_count > 0 and value_values:
+                # 固定字体大小
+                plt.rcParams.update({
+                    'font.size': 10,
+                    'axes.titlesize': 11,
+                    'axes.labelsize': 10,
+                    'xtick.labelsize': 8,
+                    'ytick.labelsize': 8
+                })
+                # 计算适当的高度，保持图表的可读性
+                plot_height = frame_height - status_y - 70  # 为上方信息留出更多空间
+                
+                # 根据可用空间确定图形尺寸
+                available_width = plot_width - 30  # 留出一些边距
+                fig_width = available_width / 100  # 转换为英寸
+                fig_height = plot_height/100
+                
+                fig = plt.figure(figsize=(fig_width, fig_height), dpi=100)
+                
+                # 调整子图布局
+                plt.subplots_adjust(hspace=0.4, left=0.15, right=0.95, bottom=0.12, top=0.9)
+                
+                subplot_idx = 1
+                
+                # 计算当前应该显示到哪个value点
+                current_value_idx = min(value_idx, len(value_values) - 1)
+
+                
+                # 绘制value曲线
+                if value_values is not None:
+                    ax = fig.add_subplot(curves_count, 1, subplot_idx)
+                    if current_value_idx >= 0:
+                        # 绘制value曲线，根据critic状态着色
+                        for j in range(current_value_idx):
+                            color = 'orange' if (critic_values and j < len(critic_values) and critic_values[j] < 0) else 'green'
+                            ax.plot([j, j+1], [value_values[j], value_values[j+1]], color=color, alpha=0.7)
+                            marker_color = 'orange' if (critic_values and j < len(critic_values) and critic_values[j] < 0) else 'green'
+                            ax.plot(j, value_values[j], marker='o', color=marker_color, markersize=2)
+                        
+                        # 当前点
+                        current_color = 'orange' if (critic_values and current_value_idx < len(critic_values) and critic_values[current_value_idx] < 0) else 'green'
+                        ax.plot(current_value_idx, value_values[current_value_idx], marker='o', color=current_color, markersize=4)
+                    
+                    ax.set_ylabel('Value')
+                    ax.grid(True, alpha=0.3)
+                    # 只在最后一个子图显示x轴标签
+                    if subplot_idx == curves_count:
+                        ax.set_xlabel('Step')
+                    else:
+                        ax.set_xticklabels([])  # 隐藏中间子图的x轴标签
+                    subplot_idx += 1
+                
+                # 绘制critic曲线
+                if critic_values is not None:
+                    ax = fig.add_subplot(curves_count, 1, subplot_idx)
+                    if current_value_idx >= 0:
+                        critic_data = np.array(critic_values[:current_value_idx+1])
+                        
+                        # 绘制线条
+                        ax.plot(range(current_value_idx+1), critic_data, 'r-', alpha=0.7)
+                        
+                        # 绘制点
+                        for j in range(current_value_idx+1):
+                            color = 'orange' if critic_values[j] < 0 else 'red'
+                            ax.plot(j, critic_data[j], marker='o', color=color, markersize=2)
+                        
+                        # 当前点
+                        current_color = 'orange' if critic_values[current_value_idx] < 0 else 'red'
+                        ax.plot(current_value_idx, critic_data[current_value_idx], marker='o', color=current_color, markersize=4, 
+                            markeredgecolor='black', markeredgewidth=0.5)
+                        
+                        # 设置坐标轴
+                        if critic_log_scale and len(critic_data) > 0:
+                            ax.set_yscale('symlog')
+                            ax.set_ylabel('Critic (log)')
+                        else:
+                            ax.set_ylabel('Critic')
+                    
+                    ax.grid(True, alpha=0.3)
+                    # 只在最后一个子图显示x轴标签
+                    if subplot_idx == curves_count:
+                        ax.set_xlabel('Step')
+                    else:
+                        ax.set_xticklabels([])  # 隐藏中间子图的x轴标签
+                    subplot_idx += 1
+                
+                # 绘制done曲线
+                if done_values is not None:
+                    ax = fig.add_subplot(curves_count, 1, subplot_idx)
+                    if current_value_idx >= 0:
+                        ax.plot(done_values[:current_value_idx+1], 'b-', marker='o', markersize=2, label='Done')
+                        ax.plot([current_value_idx], [done_values[current_value_idx]], 'ro', markersize=4)
+                    ax.set_ylim(-0.1, 1.1)
+                    ax.set_ylabel('Done')
+                    ax.grid(True, alpha=0.3)
+                    # 只在最后一个子图显示x轴标签
+                    if subplot_idx == curves_count:
+                        ax.set_xlabel('Step')
+                    else:
+                        ax.set_xticklabels([])  # 隐藏中间子图的x轴标签
+                    subplot_idx += 1
+                
+                # 将matplotlib图转换为PIL图像
+                fig.canvas.draw()
+                buf = fig.canvas.buffer_rgba()
+                w, h = fig.canvas.get_width_height()
+                plot_img = Image.frombuffer('RGBA', (w, h), buf, 'raw', 'RGBA', 0, 1).convert('RGB')
+                plt.close(fig)
+                
+                # 调整曲线图大小并粘贴到帧上
+                plot_img = plot_img.resize((available_width, plot_height), Image.LANCZOS)
+                paste_y = status_y + 50  # 在状态信息下方50px处开始绘制曲线
+                frame.paste(plot_img, (info_x, paste_y))
+            
+            # 保存帧为PNG文件
+            frame_path = os.path.join(temp_dir, f"{i:08d}.png")
+            frame.save(frame_path, "PNG")
+        
+        # 使用FFmpeg生成视频（更好的兼容性）
+        try:
+            # 检查FFmpeg是否可用
+            subprocess.run(["ffmpeg", "-version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+            
+            # 使用FFmpeg生成视频
+            ffmpeg_cmd = [
+                "ffmpeg",
+                "-y",  # 覆盖输出文件
+                "-framerate", str(fps),
+                "-i", os.path.join(temp_dir, "%08d.png"),
+                "-c:v", "libx264",  # 使用H.264编码
+                "-profile:v", "high",
+                "-pix_fmt", "yuv420p",  # 确保兼容性
+                "-crf", "23",  # 控制质量（0-51，数值越小质量越高）
+                "-movflags", "+faststart",  # 优化网络播放
+                video_path
+            ]
+            
+            print("正在使用FFmpeg生成视频...")
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+            
+            if result.returncode == 0:
+                print(f"视频已保存到 {video_path}")
+            else:
+                print(f"FFmpeg错误: {result.stderr}")
+                # 如果FFmpeg失败，回退到OpenCV方法
+                raise subprocess.CalledProcessError(result.returncode, ffmpeg_cmd)
+                
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print("FFmpeg不可用或失败，回退到OpenCV方法...")
+            
+            # 回退到OpenCV方法
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            video_writer = cv2.VideoWriter(video_path, fourcc, fps, (frame_width, frame_height))
+            
+            for i in range(len(image_objects)):
+                frame_path = os.path.join(temp_dir, f"{i:08d}.png")
+                frame_img = cv2.imread(frame_path)
+                if frame_img is not None:
+                    video_writer.write(frame_img)
+            
+            video_writer.release()
+            print(f"视频已保存到 {video_path}")
+    
+    finally:
+        # 清��临时目录
+        shutil.rmtree(temp_dir, ignore_errors=True)
+    
+    return video_path
+
+
+def visualize_le(image_objects, critic_list, value_list, task, id, output_path, resize_shape=(640, 480), fps=5,
+                 transparency=0.1, line_width=4, edge_width=2):
+    #### 只画value_list
+    import matplotlib
+    matplotlib.use('Agg')
+    import subprocess
+    temp_dir = tempfile.mkdtemp()
+    os.makedirs(output_path, exist_ok=True)
+    video_path = os.path.join(output_path, f"{task}_{id}_trajectory_legend.mp4")
+    skip = 1
+    skip_step = 0
+    if value_list and len(image_objects) > len(value_list):
+        skip = round(len(image_objects) / len(value_list))
+        print(f"计算得到的skip值: {skip}")
+        ### 计算跳帧数
+        skip_step = len(image_objects) - len(value_list)
+    if value_list is not None and len(value_list) > 0:
+        try:
+            value_values = [float(d) if d is not None else 0 for d in value_list]
+        except:
+            value_values = None
+    critic_values = None
+    if critic_list is not None and len(critic_list) > 0:
+        try:
+            critic_values = [float(d) if d is not None else 0 for d in critic_list]
+        except:
+            critic_values = None
+
+    ### 图片resize
+    ### 暂不考虑ref_images
+    frame_width, frame_height = resize_shape
+    resized_images = []
+    for img in image_objects:
+        resized_images.append(img.resize(resize_shape, Image.Resampling.LANCZOS))
+
+    ### 尝试加载字体
+    try:
+        font = ImageFont.truetype("arial.ttf", 14)  # 稍微缩小字体
+        small_font = ImageFont.truetype("arial.ttf", 12)
+        ref_font = ImageFont.truetype("arial.ttf", 16)
+    except IOError:
+        font = ImageFont.load_default()
+        small_font = ImageFont.load_default()
+        ref_font = ImageFont.load_default()
+
+    try:
+        # 对每一帧图片生成视频帧
+        for i in range(len(image_objects)):
+            # 创建一个空白画布并粘贴画面
+            frame = Image.new('RGB', (frame_width, frame_height), color='white')
+            frame.paste(resized_images[i], (0, 0))
+            draw = ImageDraw.Draw(frame)
+
+            # 计算当前帧在value_list中的对应索引 - 关键修改点
+            value_idx = i // skip - skip_step
+
+            # 如果有数据，创建曲线图 - 关键修改点
+            if value_idx >= 0:
+                fig = plt.figure(figsize=(frame_width / 100, frame_height / 100), dpi=100)
+                fig.patch.set_alpha(transparency)
+                ax = fig.add_axes([0, 0, 1, 1])
+                fig.patch.set_alpha(0.0)
+                ax.patch.set_alpha(0.0)
+                ax.axis('off')
+                plt.xlim(0, len(value_values)-1)
+                plt.ylim(min(value_values) - abs(max(value_values)) * 0.15, max(value_values) + abs(max(value_values)) * 0.15)
+                current_value_idx = min(value_idx, len(value_values) - 1)
+                if current_value_idx >= 0:
+                    for j in range(current_value_idx):
+                        ax.plot([j, j + 1], [value_values[j], value_values[j + 1]], color='white', alpha=0.3, linewidth=line_width+2*edge_width)
+                        color = '#4B0082' if (
+                                critic_values and j < len(critic_values) and critic_values[j] < 0) else '#FF4500'
+                        ax.plot([j, j + 1], [value_values[j], value_values[j + 1]], color=color, alpha=0.5, linewidth=line_width)
+                        marker_color = '#4B0082' if (
+                                critic_values and j < len(critic_values) and critic_values[j] < 0) else '#FF4500'
+                        ax.plot(j, value_values[j], marker='o', color='black', markersize=line_width + 2, alpha=0.5)
+                        ax.plot(j, value_values[j], marker='o', color=marker_color, markersize=line_width, alpha=0.5)
+
+
+                    # 将matplotlib图转换为PIL图像
+                    fig.canvas.draw()
+                    buf = fig.canvas.buffer_rgba()
+                    w, h = fig.canvas.get_width_height()
+                    plot_img = Image.frombuffer('RGBA', (w, h), buf, 'raw', 'RGBA', 0, 1)# .convert('RGB')
+                    plt.close(fig)
+                    # frame.paste(plot_img, (0, 0), mask=plot_img.convert("RGBA"))
+                    frame = Image.alpha_composite(frame.convert('RGBA'), plot_img).convert('RGB')
+
+            # 保存帧为PNG文件
+            frame_path = os.path.join(temp_dir, f"{i:08d}.png")
+            frame.save(frame_path, "PNG")
+
+        # 使用FFmpeg生成视频（更好的兼容性）
+        try:
+            # 检查FFmpeg是否可用
+            subprocess.run(["ffmpeg", "-version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+
+            # 使用FFmpeg生成视频
+            ffmpeg_cmd = [
+                "ffmpeg",
+                "-y",  # 覆盖输出文件
+                "-framerate", str(fps),
+                "-i", os.path.join(temp_dir, "%08d.png"),
+                "-c:v", "libx264",  # 使用H.264编码
+                "-profile:v", "high",
+                "-pix_fmt", "yuv420p",  # 确保兼容性
+                "-crf", "23",  # 控制质量（0-51，数值越小质量越高）
+                "-movflags", "+faststart",  # 优化网络播放
+                video_path
+            ]
+
+            print("正在使用FFmpeg生成视频...")
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+
+            if result.returncode == 0:
+                print(f"视频已保存到 {video_path}")
+            else:
+                print(f"FFmpeg错误: {result.stderr}")
+                # 如果FFmpeg失败，回退到OpenCV方法
+                raise subprocess.CalledProcessError(result.returncode, ffmpeg_cmd)
+
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print("FFmpeg不可用或失败，回退到OpenCV方法...")
+
+            # 回退到OpenCV方法
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            video_writer = cv2.VideoWriter(video_path, fourcc, fps, (frame_width, frame_height))
+
+            for i in range(len(image_objects)):
+                frame_path = os.path.join(temp_dir, f"{i:08d}.png")
+                frame_img = cv2.imread(frame_path)
+                if frame_img is not None:
+                    video_writer.write(frame_img)
+
+            video_writer.release()
+            print(f"视频已保存到 {video_path}")
+
+    finally:
+        # 清理临时目录
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+    return video_path
+
+
+def read_data_and_create_video(filename, camera_name=None, create_video=False, output_path=None, fps=30, start_frame=0, end_frame=None):
+    """
+    读取存储的压缩pickle文件，并可选地将其中的图片生成视频
+    
+    参数:
+        filename (str): 数据文件路径
+        camera_name (str, optional): 要处理的相机名称，如果为None则处理第一个找到的相机
+        create_video (bool, optional): 是否创建视频，默认为False
+        output_path (str, optional): 视频输出路径，如果为None且create_video=True，则使用与输入文件相同的名称
+        fps (int, optional): 视频帧率，默认为30
+        start_frame (int, optional): 起始帧索引，默认为0
+        end_frame (int, optional): 结束帧索引，默认为None表示处理到最后一帧
+        
+    返回:
+        list: PIL.Image对象列表
+    """
+    import gzip
+    import pickle
+    import base64
+    import numpy as np
+    import os
+    import cv2
+    import tempfile
+    import subprocess
+    from PIL import Image
+    import io
+    import shutil
+    
+    # 读取压缩的pickle文件
+    with gzip.open(filename, 'rb') as f:
+        data = pickle.load(f)
+    
+    # 确定处理的帧范围
+    if end_frame is None:
+        end_frame = len(data)
+    else:
+        end_frame = min(end_frame, len(data))
+    
+    # 确保起始帧有效
+    start_frame = max(0, min(start_frame, len(data) - 1))
+    
+    # 如果未指定相机名称，使用第一个可用的相机
+    print(data[0]['rgb'].keys())
+    if camera_name is None and len(data) > 0:
+        camera_name = list(data[0]['rgb'].keys())[0]
+    
+    # 存储解码后的图像
+    images = []
+    
+    # 创建临时目录用于存储视频帧
+    temp_dir = None
+    if create_video:
+        temp_dir = tempfile.mkdtemp()
+    
+    try:
+        # 处理每一帧
+        for i, frame_data in enumerate(data[start_frame:end_frame]):
+            if camera_name not in frame_data['rgb']:
+                print(f"警告: 帧 {i+start_frame} 中没有找到相机 {camera_name}")
+                continue
+            
+            # 解码图像
+            img_base64 = frame_data['rgb'][camera_name]
+            img_data = base64.b64decode(img_base64)
+            img_array = np.frombuffer(img_data, np.uint8)
+            img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+            
+            # BGR转RGB
+            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            pil_img = Image.fromarray(img_rgb)
+            images.append(pil_img)
+            
+            # 如果需要创建视频，保存帧到临时目录
+            if create_video:
+                frame_path = os.path.join(temp_dir, f"{i+start_frame:08d}.png")
+                pil_img.save(frame_path)
+        
+        # 创建视频
+        if create_video and images:
+            if output_path is None:
+                # 如果未指定输出路径，创建与输入文件同名的文件夹
+                base_name = os.path.splitext(os.path.basename(filename))[0]
+                output_dir = os.path.join(os.path.dirname(filename), base_name)
+                
+                # 确保输出目录存在
+                os.makedirs(output_dir, exist_ok=True)
+                
+                # 在该目录中创建视频文件
+                output_path = os.path.join(output_dir, f"{camera_name}_video.mp4")
+            
+            # 检查ffmpeg是否可用
+            try:
+                subprocess.run(["ffmpeg", "-version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+                
+                # 使用FFmpeg生成视频
+                ffmpeg_cmd = [
+                    "ffmpeg",
+                    "-y",  # 覆盖输出文件
+                    "-framerate", str(fps),
+                    "-i", os.path.join(temp_dir, "%08d.png"),
+                    "-c:v", "libx264",  # 使用H.264编码
+                    "-profile:v", "high",
+                    "-pix_fmt", "yuv420p",  # 确保兼容性
+                    "-crf", "23",  # 控制质量（0-51，数值越小质量越高）
+                    "-movflags", "+faststart",  # 优化网络播放
+                    output_path
+                ]
+                
+                subprocess.run(ffmpeg_cmd, check=True)
+                print(f"视频已保存至: {output_path}")
+            except subprocess.CalledProcessError:
+                print("错误: 无法运行FFmpeg，请确保它已正确安装")
+            except Exception as e:
+                print(f"创建视频时出错: {str(e)}")
+    
+    finally:
+        # 清理临时目录
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+    
+    return images
+
+# 视频压缩函数
+def compress_video(input_path, output_path, target_size=(448, 448), fps=5):
+    """
+    压缩视频到指定大小和帧率
+    如果原视频fps小于指定值则保持原帧率
+    """
+    cap = cv2.VideoCapture(input_path)
+    
+    # 获取原始视频的帧率和尺寸
+    original_fps = cap.get(cv2.CAP_PROP_FPS)
+    original_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    original_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    
+    # 如果原始帧率小于指定帧率，则使用原始帧率
+    output_fps = original_fps if original_fps < fps else fps
+    if target_size is None:
+        target_size = (original_width, original_height)
+    
+    sampling_interval = int(original_fps / output_fps) if output_fps < original_fps else 1
+    
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, output_fps, target_size)
+    frame_count = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        # # 处理宽高比
+        # if original_width > original_height * 1.5:
+        #     # 宽大于高的1.5倍，需要中心裁剪
+        #     target_width = int(original_height * 1.5)
+        #     # 计算裁剪的起始x坐标（居中裁剪）
+        #     start_x = int((original_width - target_width) / 2)
+        #     # 裁剪frame
+        #     frame = frame[:, start_x:start_x+target_width]
+        
+        # 只有当前帧是采样帧时才处理和写入
+        if frame_count % sampling_interval == 0:
+            # 缩放到目标尺寸
+            resized = cv2.resize(frame, target_size)
+            out.write(resized)
+        frame_count += 1
+    
+    cap.release()
+    out.release()
+    return output_path,output_fps
+
+# 图片压缩函数
+def compress_image(input_path, output_path, target_size=(448, 448)):
+    """压缩图片到指定大小"""
+    img = Image.open(input_path)
+    img = img.resize(target_size, Image.Resampling.LANCZOS)
+    img.save(output_path)
+    return output_path

VLAC/extract_hdf5.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""
+从单个 rollout 的 HDF5 中导出视频与逐帧图片。
+默认读取: root/agentview/video、root/eye_in_hand/video，形状 (1, T, 3, H, W) uint8。
+同时尽量导出 text prompt（常见 dataset / 组属性），写入 text_prompt.txt 与 text_fields.json。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+# 用于 text_prompt.txt：按顺序尝试这些 dataset 路径（第一个非空即采用）
+DEFAULT_PROMPT_DATASET_PRIORITY: tuple[str, ...] = (
+    "root/text_prompt",
+    "root/language_instruction",
+    "root/task_description",
+    "root/instruction",
+    "root/language",
+    "root/lang",
+    "language_instruction",
+    "task_description",
+    "text_prompt",
+    "instruction",
+)
+
+# 从这些 group 读取 HDF5 attributes（键名含语言/任务相关子串的会写入 json）
+ATTR_GROUP_PATHS: tuple[str, ...] = ("/", "root", "data")
+
+
+def video_chw_to_hwc(frames_chw: np.ndarray) -> np.ndarray:
+    """(T, 3, H, W) uint8 -> (T, H, W, 3)"""
+    return np.transpose(frames_chw, (0, 2, 3, 1))
+
+
+def _scalar_to_text(v: object) -> str | None:
+    if v is None:
+        return None
+    if isinstance(v, bytes):
+        s = v.decode("utf-8", errors="replace").strip()
+        return s or None
+    if isinstance(v, str):
+        s = v.strip()
+        return s or None
+    if isinstance(v, (np.str_, np.bytes_)):
+        if isinstance(v, np.bytes_):
+            s = v.tobytes().decode("utf-8", errors="replace").strip()
+        else:
+            s = str(v).strip()
+        return s or None
+    if isinstance(v, (np.floating, np.integer, np.bool_)):
+        return str(v.item())
+    s = str(v).strip()
+    return s or None
+
+
+def _decode_dataset_strings(ds: h5py.Dataset) -> list[str]:
+    """将字符串类 dataset 转为非空 str 列表。"""
+    try:
+        raw = ds.asstr()[()]
+    except Exception:
+        raw = ds[()]
+    arr = np.asarray(raw, dtype=object)
+    if arr.ndim == 0:
+        s = _scalar_to_text(arr.item())
+        return [s] if s else []
+    out: list[str] = []
+    for item in arr.reshape(-1):
+        s = _scalar_to_text(item)
+        if s:
+            out.append(s)
+    return out
+
+
+def _looks_like_text_dataset(ds: h5py.Dataset) -> bool:
+    dt = ds.dtype
+    if h5py.check_dtype(vlen=str, dtype=dt):
+        return True
+    kind = getattr(dt, "kind", None)
+    if kind in ("S", "U", "O"):
+        return True
+    return False
+
+
+def _attrs_to_text_map(f: h5py.File, group_paths: tuple[str, ...]) -> dict[str, str]:
+    """收集各 group 上「可能为任务/语言」的属性。"""
+    hint = re.compile(
+        r"(lang|language|instruction|prompt|task|text|desc|goal|command)",
+        re.I,
+    )
+    out: dict[str, str] = {}
+    for gp in group_paths:
+        if gp == "/":
+            g = f
+            prefix = "@"
+        elif gp not in f:
+            continue
+        else:
+            g = f[gp]
+            prefix = f"{gp}/@"
+        for ak, av in g.attrs.items():
+            if not hint.search(str(ak)):
+                continue
+            flat = np.asarray(av).reshape(-1)
+            s = _scalar_to_text(flat[0]) if flat.size else None
+            if s is None and isinstance(av, bytes):
+                s = _scalar_to_text(av)
+            if s:
+                out[f"{prefix}{ak}"] = s
+    return out
+
+
+def extract_text_fields(
+    f: h5py.File,
+    extra_dataset_paths: tuple[str, ...] = (),
+) -> tuple[dict[str, str | list[str]], str | None]:
+    """
+    返回 (fields, primary_prompt)。
+    fields: dataset 路径 -> 字符串或字符串列表；属性键为 ``group/@attr``。
+    """
+    fields: dict[str, str | list[str]] = {}
+    seen_paths: set[str] = set()
+
+    for path in (*DEFAULT_PROMPT_DATASET_PRIORITY, *extra_dataset_paths):
+        if path in seen_paths or path not in f:
+            continue
+        seen_paths.add(path)
+        obj = f[path]
+        if not isinstance(obj, h5py.Dataset):
+            continue
+        if not _looks_like_text_dataset(obj):
+            continue
+        lines = _decode_dataset_strings(obj)
+        if not lines:
+            continue
+        fields[path] = lines[0] if len(lines) == 1 else lines
+
+    fields.update(_attrs_to_text_map(f, ATTR_GROUP_PATHS))
+
+    primary: str | None = None
+    for path in (*DEFAULT_PROMPT_DATASET_PRIORITY, *extra_dataset_paths):
+        if path not in f or not isinstance(f[path], h5py.Dataset):
+            continue
+        if not _looks_like_text_dataset(f[path]):
+            continue
+        lines = _decode_dataset_strings(f[path])
+        if lines:
+            primary = lines[0]
+            break
+    if primary is None:
+        attr_items = [(k, v) for k, v in fields.items() if k.startswith("@") or "/@" in k]
+
+        def _attr_score(item: tuple[str, str | list[str]]) -> int:
+            kl = item[0].lower()
+            for i, sub in enumerate(
+                ("text_prompt", "language_instruction", "instruction", "task_desc", "task", "goal", "lang")
+            ):
+                if sub in kl:
+                    return i
+            return 99
+
+        attr_items.sort(key=_attr_score)
+        for _k, v in attr_items:
+            primary = v if isinstance(v, str) else v[0]
+            break
+    return fields, primary
+
+
+def write_text_exports(
+    out_dir: Path,
+    fields: dict[str, str | list[str]],
+    primary_prompt: str | None,
+) -> None:
+    json_path = out_dir / "text_fields.json"
+    with json_path.open("w", encoding="utf-8") as fp:
+        json.dump(fields, fp, ensure_ascii=False, indent=2)
+
+    txt_path = out_dir / "text_prompt.txt"
+    if primary_prompt is not None:
+        txt_path.write_text(primary_prompt + "\n", encoding="utf-8")
+        print(f"[ok] text prompt -> {txt_path} ({len(primary_prompt)} chars)")
+    else:
+        txt_path.write_text("", encoding="utf-8")
+        print("[warn] no text prompt found; wrote empty text_prompt.txt (see text_fields.json)")
+    print(f"[ok] all text fields -> {json_path}")
+
+
+def save_rollout(
+    hdf5_path: str | Path,
+    out_dir: str | Path | None = None,
+    fps: float = 20.0,
+    keys: tuple[str, ...] = ("root/agentview/video", "root/eye_in_hand/video"),
+    extra_prompt_paths: tuple[str, ...] = (),
+) -> Path:
+    hdf5_path = Path(hdf5_path).resolve()
+    if out_dir is None:
+        out_dir = hdf5_path.parent / f"{hdf5_path.stem}_export"
+    out_dir = Path(out_dir).resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    with h5py.File(hdf5_path, "r") as f:
+        fields, primary = extract_text_fields(f, extra_dataset_paths=extra_prompt_paths)
+        write_text_exports(out_dir, fields, primary)
+
+        for key in keys:
+            if key not in f:
+                print(f"[skip] missing dataset: {key}")
+                continue
+            ds = f[key]
+            arr = np.asarray(ds)
+            # (1, T, 3, H, W) or (T, 3, H, W)
+            if arr.ndim == 5 and arr.shape[0] == 1:
+                arr = arr[0]
+            if arr.ndim != 4 or arr.shape[1] != 3:
+                raise ValueError(f"{key}: expected (T,3,H,W), got {arr.shape}")
+
+            name = key.split("/")[-2]  # agentview / eye_in_hand
+            frames_hwc = video_chw_to_hwc(arr)
+
+            sub = out_dir / name
+            sub.mkdir(parents=True, exist_ok=True)
+
+            for i in range(frames_hwc.shape[0]):
+                out_png = sub / f"frame_{i:05d}.png"
+                try:
+                    from PIL import Image
+
+                    Image.fromarray(frames_hwc[i]).save(out_png)
+                except ImportError:
+                    import imageio.v2 as imageio
+
+                    imageio.imwrite(out_png, frames_hwc[i])
+
+            mp4_path = out_dir / f"{name}.mp4"
+            try:
+                import imageio.v2 as imageio
+
+                imageio.mimsave(mp4_path, list(frames_hwc), fps=fps)
+            except Exception:
+                import cv2
+
+                h, w = frames_hwc.shape[1:3]
+                fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+                writer = cv2.VideoWriter(str(mp4_path), fourcc, fps, (w, h))
+                for i in range(frames_hwc.shape[0]):
+                    bgr = cv2.cvtColor(frames_hwc[i], cv2.COLOR_RGB2BGR)
+                    writer.write(bgr)
+                writer.release()
+
+            print(f"[ok] {key} -> {sub}/ (frames), {mp4_path} ({frames_hwc.shape[0]} frames @ {fps} fps)")
+
+    return out_dir
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export rollout video + frames from HDF5.")
+    parser.add_argument(
+        "hdf5",
+        nargs="?",
+        default="/scratch1/home/zhicao/data/real/task_1/train/session_demo_1.hdf5",
+        help="Path to rollout .hdf5",
+    )
+    parser.add_argument(
+        "-o",
+        "--out-dir",
+        default=None,
+        help="Output directory (default: <stem>_export next to hdf5)",
+    )
+    parser.add_argument("--fps", type=float, default=20.0, help="Video FPS")
+    parser.add_argument(
+        "--prompt-path",
+        action="append",
+        default=[],
+        metavar="H5_PATH",
+        help="Extra HDF5 dataset path(s) for text (repeatable), e.g. root/my_prompt",
+    )
+    args = parser.parse_args()
+
+    extra = tuple(args.prompt_path) if args.prompt_path else ()
+    out = save_rollout(
+        args.hdf5,
+        out_dir=args.out_dir,
+        fps=args.fps,
+        extra_prompt_paths=extra,
+    )
+    print(f"Done. Output: {out}")
+
+
+if __name__ == "__main__":
+    main()

VLAC/model/VLAC-8b/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

VLAC/model/VLAC-8b/README.md

@@ -0,0 +1,191 @@
+---
+pipeline_tag: robotics
+library_name: transformers
+license: cc-by-nc-sa-4.0
+tags:
+  - vision-language-model
+  - manipulation
+  - robotics
+---
+
+
+# VLAC: A Vision-Language-Action-Critic Model for Robotic Real-World Reinforcement Learning
+<div align="center">
+
+[[paper]](https://arxiv.org/abs/2509.15937)
+[[code]](https://github.com/InternRobotics/VLAC)
+[[model]](https://huggingface.co/InternRobotics/VLAC-8b)
+
+</div>
+
+## 🚀 Interactive Demo & Homepage
+
+<div align="center">
+
+ [Try Interactive & Homepage](https://vlac.intern-ai.org.cn/)
+> **Online Demo is available now in Homepage, Try as you like!!!**
+
+</div>
+
+<!-- <div align="center">
+  <img src="https://github.com/InternRobotics/VLAC/tree/main/data/title_banner-2.gif" alt="VLAC banner" width="800"></img>
+</div> -->
+
+## VLAC-8B
+
+VLAC is a general-purpose pair-wise critic and manipulation model which designed for real world robot reinforcement learning and data refinement. 
+
+It provides robust evaluation capabilities for task progress prediction and task completion verification base one images and task description.
+
+VLAC trained on 3000h+ human egocentric data, 1200h+ comprehensive public robotic manipulation data, and 15h+ self-collected manipulation data.
+
+VLAC-8B is open new!
+
+## ✨ Key Features
+
+• **Pair-wise comparison mechanism** for improved progressing dense critic accuracy, better recognition of state changes, and each step can be the start of the trajectory.
+
+• **Multi-modal capabilities** - Supports process tracking, task completion judgment, task description estimation, visual question answering, and even embodied action output, equipped with VLA capabilities.
+
+• **Flexible zero-shot and one-shot** - in-context capabilities, maintaining excellent performance across entities, scenarios, and tasks.
+
+• **Human-task synesthesia** - Based on the ego4D human dataset, model understands common tasks and build synesthesia for real-world human tasks and embodied tasks.
+
+• **Trajectory quality screening** - VLAC can evaluate the collected trajectories and filters out low score trajectories based on the VOC value and mask the action with negative pair-wise score, that is, data with low fluency and quality, improving the effect and efficiency of imitation learning.
+
+<!-- ## Framework
+
+<div align="center">
+  <img src="https://github.com/InternRobotics/VLAC/blob/main/data/framework.png" alt="VLAC Framework" width="800"/>
+</div>
+
+*The VLAC model is trained on a combination of comprehensive public robotic manipulation datasets, human demonstration data, self-collected manipulation data, and various image understanding datasets. Video data is processed into pair-wise samples to learn the different task progress between any two frames, supplemented with task descriptions and task completion evaluation to enable task progress understanding and action generation, as illustrated in the bottom-left corner. As shown in the diagram on the right, the model demonstrates strong generalization capabilities to new robots, scenarios, and tasks not covered in the training dataset. It can predict task progress and distinguish failure action or trajectory, providing dense reward feedback for real-world reinforcement learning and offering guidance for data refinement. Additionally, the model can directly perform manipulation tasks, exhibiting zero-shot capabilities to handle different scenarios.* -->
+
+## Framework & Performance
+
+Details about the model's performance and evaluation metrics can be found in the [Homepage](https://vlac.intern-ai.org.cn/).
+
+## 🛠️ Installation
+
+To install from source:
+```shell
+git clone https://github.com/InternRobotics/VLAC.git
+cd VLAC
+pip install -e .
+```
+Running Environment:
+
+|              | Range        | Recommended | Notes                                     |
+| ------------ |--------------| ----------- | ----------------------------------------- |
+| python       | >=3.9        | 3.10        |                                           |
+| cuda         |              | cuda12      | No need to install if using CPU, NPU, MPS |
+| torch        | >=2.0        |             |                                           |
+| transformers | >=4.51       | 4.51.3      |                                           |
+| peft | >=0.15.2       |      |                                           |
+| ms-swift |        | 3.3      |                                           |
+
+
+## 🚀 Quick Start
+
+```python
+from evo_vlac import GAC_model
+from evo_vlac.utils.video_tool import compress_video
+import os
+#Consistent with the web interface, the value and citic rewards of video input can be evaluated.
+
+
+#assign local model path
+model_path="set to your local model path"
+#download model form https://huggingface.co/InternRobotics/VLAC-8b
+
+#assign video path and task description
+test_video='evo_vlac/examples/videos/pick-bowl-test.mp4'
+ref_video='evo_vlac/examples/videos/pick-bowl-ref.mov'
+task_description='Put up the bowl and place it back in the white storage box.'
+
+#init model
+Critic=GAC_model(tag='critic')
+Critic.init_model(model_path=model_path,model_type='internvl2',device_map=f'cuda:0')
+Critic.temperature=0.5
+Critic.top_k=1
+Critic.set_config()
+Critic.set_system_prompt()
+
+# transform video
+test_video_compressed = os.path.join(os.path.dirname(test_video),"test.mp4")
+_,output_fps=compress_video(test_video, test_video_compressed,fps=5)
+reference_video_compressed = None
+if ref_video:
+    reference_video_compressed = os.path.join(os.path.dirname(ref_video),"ref.mp4")
+    compress_video(ref_video, reference_video_compressed,fps=5)
+
+
+# generate Critic results
+result_path,value_list,critic_list,done_list = Critic.web_trajectory_critic(
+    task_description=task_description,
+    main_video_path=test_video_compressed,
+    reference_video_path=reference_video_compressed,#if None means no reference video, only use task_description to indicate the task
+    batch_num=10,#batch number
+    ref_num=6,#image number used in reference video
+    think=False,# whether to CoT
+    skip=5,#pair-wise step
+    rich=False,#whether to output decimal value
+    reverse_eval=False,#whether to reverse the evaluation(for VROC evaluation)
+    output_path="results",
+    fps=float(output_fps),
+    frame_skip=True,#whether to skip frames(if false, each frame while be evaluated, cost more time)
+    done_flag=False,#whether to out put done value
+    in_context_done=False,#whether use reference video to generate done value
+    done_threshold=0.9,#done threshold
+    video_output=True#whether to output video
+)
+
+
+print("=" * 100)
+print(">>>>>>>>>Critic results<<<<<<<<<<")
+print(" ")
+
+print(f"result path: {result_path}")
+print(f"task description: {task_description}")
+print("=" * 50)
+
+print("value_list:")
+print(value_list)
+print("=" * 50)
+
+print("critic_list:")
+print(critic_list)
+print("=" * 50)
+
+print("done_list:")
+print(done_list)
+print("=" * 100)
+```
+More examples  of 
+
+• pair-wise image inputs critic. Please check [this example](https://github.com/InternRobotics/VLAC/tree/main/evo_vlac/examples/image_pair-wise_critic_example.py)
+
+• vla action generation. Please check [this example](https://github.com/InternRobotics/VLAC/tree/main/evo_vlac/examples/vla_example.py)
+
+• data refinement. Please check [this example](https://github.com/InternRobotics/VLAC/tree/main/evo_vlac/examples/data_filtering_example.py)
+
+
+For training code, please refer to [InternVL2](https://huggingface.co/OpenGVLab/InternVL2-2B#quick-start).
+
+## 🔗 Citation
+
+If you find our work helpful, please cite:
+
+```bibtex
+@article{zhai2025vision,
+  title={A vision-language-action-critic model for robotic real-world reinforcement learning},
+  author={Zhai, Shaopeng and Zhang, Qi and Zhang, Tianyi and Huang, Fuxian and Zhang, Haoran and Zhou, Ming and Zhang, Shengzhe and Liu, Litao and Lin, Sixu and Pang, Jiangmiao},
+  journal={arXiv preprint arXiv:2509.15937},
+  year={2025}
+}
+```
+
+## 🙏 Acknowledgments
+
+- [SWIFT](https://github.com/modelscope/ms-swift)
+- [InternVL](https://github.com/OpenGVLab/InternVL)

VLAC/model/VLAC-8b/added_tokens.json

@@ -0,0 +1,11 @@
+{
+  "</box>": 92552,
+  "</img>": 92545,
+  "</quad>": 92548,
+  "</ref>": 92550,
+  "<IMG_CONTEXT>": 92546,
+  "<box>": 92551,
+  "<img>": 92544,
+  "<quad>": 92547,
+  "<ref>": 92549
+}

VLAC/model/VLAC-8b/args.json

@@ -0,0 +1,370 @@
+{
+  "model": "/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part10-14-resize-constant/v0-20250619-124555/checkpoint-3125",
+  "model_type": "internvl2",
+  "model_revision": null,
+  "task_type": "causal_lm",
+  "torch_dtype": "bfloat16",
+  "attn_impl": null,
+  "num_labels": null,
+  "problem_type": null,
+  "rope_scaling": null,
+  "device_map": null,
+  "max_memory": {},
+  "local_repo_path": null,
+  "template": "internvl2",
+  "system": "You are a visual-language assistant designed to interpret spatial and task-related information from images and text. Provide precise, context-aware responses and actionable guidance to assist in achieving task objectives.",
+  "max_length": 10240,
+  "truncation_strategy": "delete",
+  "max_pixels": null,
+  "tools_prompt": "react_en",
+  "norm_bbox": null,
+  "response_prefix": null,
+  "padding_side": "right",
+  "loss_scale": "default",
+  "sequence_parallel_size": 1,
+  "use_chat_template": true,
+  "template_backend": "swift",
+  "dataset": [
+    "/cpfs04/user/zhangqi/zhangqi/data/DI-dataset/VLACQA_mix_VLM/v7-1/part15-2000000-00i05-00t01-share.json",
+    "/cpfs04/user/zhangqi/zhangqi/data/DI-dataset/VLACQA_mix_VLM/v7-1/part16-2000000-00i05-00t01-share.json",
+    "/cpfs04/user/zhangqi/zhangqi/data/DI-dataset/VLACQA_mix_VLM/v7-1/part17-2000000-00i05-00t01-share.json",
+    "/cpfs04/user/zhangqi/zhangqi/data/DI-dataset/VLACQA_mix_VLM/v7-1/part18-2000000-00i05-00t01-share.json",
+    "/cpfs04/user/zhangqi/zhangqi/data/DI-dataset/VLACQA_mix_VLM/v7-1/part19-2000000-00i05-00t01-share.json"
+  ],
+  "val_dataset": [
+    "/cpfs04/user/zhangqi/zhangqi/data/DI-dataset/VLACQA_mix_VLM/v7-1/test0-20000-00i05-00t01-share.json"
+  ],
+  "split_dataset_ratio": 0.0,
+  "data_seed": 42,
+  "dataset_num_proc": 1,
+  "streaming": false,
+  "enable_cache": false,
+  "download_mode": "reuse_dataset_if_exists",
+  "columns": {},
+  "strict": false,
+  "remove_unused_columns": true,
+  "model_name": [
+    "InternVL2-8B"
+  ],
+  "model_author": [
+    "zq"
+  ],
+  "custom_dataset_info": [],
+  "quant_method": null,
+  "quant_bits": null,
+  "hqq_axis": null,
+  "bnb_4bit_compute_dtype": "bfloat16",
+  "bnb_4bit_quant_type": "nf4",
+  "bnb_4bit_use_double_quant": true,
+  "bnb_4bit_quant_storage": null,
+  "max_new_tokens": 64,
+  "temperature": 0.0,
+  "top_k": null,
+  "top_p": null,
+  "repetition_penalty": null,
+  "num_beams": 1,
+  "stream": false,
+  "stop_words": [],
+  "logprobs": false,
+  "top_logprobs": null,
+  "ckpt_dir": "/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part10-14-resize-constant/v0-20250619-124555/checkpoint-3125",
+  "load_dataset_config": null,
+  "lora_modules": [],
+  "tuner_backend": "peft",
+  "train_type": "full",
+  "adapters": [],
+  "external_plugins": [],
+  "seed": 42,
+  "model_kwargs": {},
+  "load_args": false,
+  "load_data_args": false,
+  "use_hf": false,
+  "hub_token": null,
+  "custom_register_path": [],
+  "ignore_args_error": false,
+  "use_swift_lora": false,
+  "output_dir": "/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part15-19-resize-decay/v1-20250624-140732",
+  "overwrite_output_dir": false,
+  "do_train": false,
+  "do_eval": false,
+  "do_predict": false,
+  "eval_strategy": "steps",
+  "prediction_loss_only": false,
+  "per_device_train_batch_size": 2,
+  "per_device_eval_batch_size": 1,
+  "per_gpu_train_batch_size": null,
+  "per_gpu_eval_batch_size": null,
+  "gradient_accumulation_steps": 8,
+  "eval_accumulation_steps": null,
+  "eval_delay": 0,
+  "torch_empty_cache_steps": null,
+  "learning_rate": 2e-05,
+  "weight_decay": 0.1,
+  "adam_beta1": 0.9,
+  "adam_beta2": 0.95,
+  "adam_epsilon": 1e-08,
+  "max_grad_norm": 1.0,
+  "num_train_epochs": 1.0,
+  "max_steps": -1,
+  "lr_scheduler_type": "cosine",
+  "lr_scheduler_kwargs": null,
+  "warmup_ratio": 0.0,
+  "warmup_steps": 100,
+  "log_level": "passive",
+  "log_level_replica": "warning",
+  "log_on_each_node": true,
+  "logging_dir": "/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part15-19-resize-decay/v1-20250624-140732/runs",
+  "logging_strategy": "steps",
+  "logging_first_step": true,
+  "logging_steps": 5,
+  "logging_nan_inf_filter": true,
+  "save_strategy": "steps",
+  "save_steps": 1000.0,
+  "save_total_limit": 1,
+  "save_safetensors": true,
+  "save_on_each_node": false,
+  "save_only_model": false,
+  "restore_callback_states_from_checkpoint": false,
+  "no_cuda": false,
+  "use_cpu": false,
+  "use_mps_device": false,
+  "jit_mode_eval": false,
+  "use_ipex": false,
+  "bf16": true,
+  "fp16": false,
+  "fp16_opt_level": "O1",
+  "half_precision_backend": "auto",
+  "bf16_full_eval": false,
+  "fp16_full_eval": false,
+  "tf32": null,
+  "local_rank": 0,
+  "ddp_backend": null,
+  "tpu_num_cores": null,
+  "tpu_metrics_debug": false,
+  "debug": null,
+  "dataloader_drop_last": false,
+  "eval_steps": 250.0,
+  "dataloader_num_workers": 4,
+  "dataloader_prefetch_factor": null,
+  "past_index": -1,
+  "run_name": null,
+  "disable_tqdm": null,
+  "label_names": null,
+  "load_best_model_at_end": false,
+  "metric_for_best_model": "loss",
+  "greater_is_better": false,
+  "ignore_data_skip": false,
+  "fsdp": "",
+  "fsdp_min_num_params": 0,
+  "fsdp_config": null,
+  "fsdp_transformer_layer_cls_to_wrap": null,
+  "accelerator_config": {
+    "dispatch_batches": false
+  },
+  "deepspeed": {
+    "fp16": {
+      "enabled": "auto",
+      "loss_scale": 0,
+      "loss_scale_window": 1000,
+      "initial_scale_power": 16,
+      "hysteresis": 2,
+      "min_loss_scale": 1
+    },
+    "bf16": {
+      "enabled": "auto"
+    },
+    "zero_optimization": {
+      "stage": 3,
+      "offload_optimizer": {
+        "device": "none",
+        "pin_memory": true
+      },
+      "offload_param": {
+        "device": "none",
+        "pin_memory": true
+      },
+      "overlap_comm": false,
+      "contiguous_gradients": true,
+      "sub_group_size": 1000000000.0,
+      "reduce_bucket_size": "auto",
+      "zero_quantized_weights": false,
+      "zero_quantized_gradients": false,
+      "stage3_prefetch_bucket_size": "auto",
+      "stage3_param_persistence_threshold": "auto",
+      "stage3_max_live_parameters": 1000000000.0,
+      "stage3_max_reuse_distance": 1000000000.0,
+      "stage3_gather_16bit_weights_on_model_save": true
+    },
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 2000,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+  },
+  "label_smoothing_factor": 0.0,
+  "optim": "adamw_torch",
+  "optim_args": null,
+  "adafactor": false,
+  "group_by_length": false,
+  "length_column_name": "length",
+  "report_to": [
+    "tensorboard"
+  ],
+  "ddp_find_unused_parameters": null,
+  "ddp_bucket_cap_mb": null,
+  "ddp_broadcast_buffers": null,
+  "dataloader_pin_memory": true,
+  "dataloader_persistent_workers": false,
+  "skip_memory_metrics": true,
+  "use_legacy_prediction_loop": false,
+  "push_to_hub": false,
+  "resume_from_checkpoint": null,
+  "hub_model_id": null,
+  "hub_strategy": "every_save",
+  "hub_private_repo": false,
+  "hub_always_push": false,
+  "gradient_checkpointing": true,
+  "gradient_checkpointing_kwargs": null,
+  "include_inputs_for_metrics": false,
+  "include_for_metrics": [],
+  "eval_do_concat_batches": true,
+  "fp16_backend": "auto",
+  "evaluation_strategy": "steps",
+  "push_to_hub_model_id": null,
+  "push_to_hub_organization": null,
+  "push_to_hub_token": null,
+  "mp_parameters": "",
+  "auto_find_batch_size": false,
+  "full_determinism": false,
+  "torchdynamo": null,
+  "ray_scope": "last",
+  "ddp_timeout": 1800,
+  "torch_compile": false,
+  "torch_compile_backend": null,
+  "torch_compile_mode": null,
+  "dispatch_batches": null,
+  "split_batches": null,
+  "include_tokens_per_second": false,
+  "include_num_input_tokens_seen": false,
+  "neftune_noise_alpha": null,
+  "optim_target_modules": null,
+  "batch_eval_metrics": false,
+  "eval_on_start": false,
+  "use_liger_kernel": false,
+  "eval_use_gather_object": false,
+  "average_tokens_across_devices": false,
+  "sortish_sampler": false,
+  "predict_with_generate": false,
+  "generation_max_length": null,
+  "generation_num_beams": null,
+  "generation_config": null,
+  "check_model": true,
+  "acc_strategy": "token",
+  "train_sampler_random": true,
+  "metric_warmup_step": 0,
+  "fsdp_num": 1,
+  "acc_steps": 1,
+  "eval_use_evalscope": false,
+  "eval_datasets": [],
+  "eval_limit": null,
+  "eval_datasets_args": null,
+  "eval_generation_config": null,
+  "freeze_parameters": [
+    "vision_model",
+    "mlp1"
+  ],
+  "freeze_parameters_ratio": 0.0,
+  "trainable_parameters": [],
+  "freeze_llm": false,
+  "freeze_vit": true,
+  "freeze_aligner": true,
+  "target_modules": [
+    "all-linear"
+  ],
+  "target_regex": null,
+  "modules_to_save": [],
+  "lora_rank": 8,
+  "lora_alpha": 32,
+  "lora_dropout": 0.05,
+  "lora_bias": "none",
+  "lora_dtype": null,
+  "lorap_lr_ratio": null,
+  "use_rslora": false,
+  "use_dora": false,
+  "lora_ga_batch_size": 2,
+  "lora_ga_iters": 2,
+  "lora_ga_max_length": 1024,
+  "lora_ga_direction": "ArB2r",
+  "lora_ga_scale": "stable",
+  "lora_ga_stable_gamma": 16,
+  "init_weights": true,
+  "fourier_n_frequency": 2000,
+  "fourier_scaling": 300.0,
+  "boft_block_size": 4,
+  "boft_block_num": 0,
+  "boft_n_butterfly_factor": 1,
+  "boft_dropout": 0.0,
+  "vera_rank": 256,
+  "vera_projection_prng_key": 0,
+  "vera_dropout": 0.0,
+  "vera_d_initial": 0.1,
+  "adapter_act": "gelu",
+  "adapter_length": 128,
+  "use_galore": false,
+  "galore_target_modules": null,
+  "galore_rank": 128,
+  "galore_update_proj_gap": 50,
+  "galore_scale": 1.0,
+  "galore_proj_type": "std",
+  "galore_optim_per_parameter": false,
+  "galore_with_embedding": false,
+  "galore_quantization": false,
+  "galore_proj_quant": false,
+  "galore_proj_bits": 4,
+  "galore_proj_group_size": 256,
+  "galore_cos_threshold": 0.4,
+  "galore_gamma_proj": 2,
+  "galore_queue_size": 5,
+  "adalora_target_r": 8,
+  "adalora_init_r": 12,
+  "adalora_tinit": 0,
+  "adalora_tfinal": 0,
+  "adalora_deltaT": 1,
+  "adalora_beta1": 0.85,
+  "adalora_beta2": 0.85,
+  "adalora_orth_reg_weight": 0.5,
+  "llamapro_num_new_blocks": 4,
+  "llamapro_num_groups": null,
+  "lisa_activated_layers": 0,
+  "lisa_step_interval": 20,
+  "reft_layer_key": null,
+  "reft_layers": null,
+  "reft_rank": 4,
+  "reft_intervention_type": "LoreftIntervention",
+  "reft_args": null,
+  "use_liger": false,
+  "swanlab_token": null,
+  "swanlab_project": null,
+  "swanlab_workspace": null,
+  "swanlab_exp_name": null,
+  "swanlab_mode": "cloud",
+  "add_version": true,
+  "resume_only_model": false,
+  "create_checkpoint_symlink": false,
+  "packing": false,
+  "lazy_tokenize": true,
+  "loss_type": null,
+  "optimizer": null,
+  "metric": null,
+  "zero_hpz_partition_size": null,
+  "rank": 0,
+  "global_world_size": 200,
+  "local_world_size": 8,
+  "model_suffix": "checkpoint-3125",
+  "model_info": "ModelInfo(model_type='internvl2', model_dir='/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part10-14-resize-constant/v0-20250619-124555/checkpoint-3125', torch_dtype=torch.bfloat16, max_model_len=32768, quant_method=None, quant_bits=None, rope_scaling={'factor': 2.0, 'type': 'dynamic'}, config=None, task_type='causal_lm', num_labels=None)",
+  "model_meta": "ModelMeta(model_type='internvl2', model_groups=[ModelGroup(models=[Model(ms_model_id='OpenGVLab/InternVL2-1B', hf_model_id='OpenGVLab/InternVL2-1B', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-2B', hf_model_id='OpenGVLab/InternVL2-2B', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-8B', hf_model_id='OpenGVLab/InternVL2-8B', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-26B', hf_model_id='OpenGVLab/InternVL2-26B', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-40B', hf_model_id='OpenGVLab/InternVL2-40B', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Llama3-76B', hf_model_id='OpenGVLab/InternVL2-Llama3-76B', model_path=None, ms_revision=None, hf_revision=None)], ignore_patterns=None, requires=None, tags=[]), ModelGroup(models=[Model(ms_model_id='OpenGVLab/InternVL2-2B-AWQ', hf_model_id='OpenGVLab/InternVL2-2B-AWQ', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-8B-AWQ', hf_model_id='OpenGVLab/InternVL2-8B-AWQ', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-26B-AWQ', hf_model_id='OpenGVLab/InternVL2-26B-AWQ', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-40B-AWQ', hf_model_id='OpenGVLab/InternVL2-40B-AWQ', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Llama3-76B-AWQ', hf_model_id='OpenGVLab/InternVL2-Llama3-76B-AWQ', model_path=None, ms_revision=None, hf_revision=None)], ignore_patterns=None, requires=None, tags=[]), ModelGroup(models=[Model(ms_model_id='OpenGVLab/InternVL2-8B-MPO', hf_model_id='OpenGVLab/InternVL2-8B-MPO', model_path=None, ms_revision=None, hf_revision=None)], ignore_patterns=None, requires=None, tags=[]), ModelGroup(models=[Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-1B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-1B-Pretrain', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-2B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-2B-Pretrain', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-4B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-4B-Pretrain', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-8B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-8B-Pretrain', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-26B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-26B-Pretrain', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-40B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-40B-Pretrain', model_path=None, ms_revision=None, hf_revision=None), Model(ms_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-Llama3-76B-Pretrain', hf_model_id='OpenGVLab/InternVL2-Pretrain-Models:InternVL2-Llama3-76B-Pretrain', model_path=None, ms_revision=None, hf_revision=None)], ignore_patterns=None, requires=None, tags=[])], template='internvl2', get_function=<function get_model_tokenizer_internvl at 0x7f9363136f80>, model_arch='internvl', architectures=['InternVLChatModel'], additional_saved_files=[], torch_dtype=None, is_multimodal=True, is_reward=False, task_type=None, ignore_patterns=[], requires=['transformers>=4.36', 'timm'], tags=['vision', 'video'])",
+  "model_dir": "/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part10-14-resize-constant/v0-20250619-124555/checkpoint-3125",
+  "hub": "<class 'swift.hub.hub.MSHub'>",
+  "training_args": "Seq2SeqTrainingArguments(output_dir='/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part15-19-resize-decay/v1-20250624-140732', overwrite_output_dir=False, do_train=False, do_eval=True, do_predict=False, eval_strategy=<IntervalStrategy.STEPS: 'steps'>, prediction_loss_only=False, per_device_train_batch_size=2, per_device_eval_batch_size=1, per_gpu_train_batch_size=None, per_gpu_eval_batch_size=None, gradient_accumulation_steps=8, eval_accumulation_steps=None, eval_delay=0, torch_empty_cache_steps=None, learning_rate=2e-05, weight_decay=0.1, adam_beta1=0.9, adam_beta2=0.95, adam_epsilon=1e-08, max_grad_norm=1.0, num_train_epochs=1.0, max_steps=-1, lr_scheduler_type=<SchedulerType.COSINE: 'cosine'>, lr_scheduler_kwargs=None, warmup_ratio=0.0, warmup_steps=100, log_level='passive', log_level_replica='warning', log_on_each_node=True, logging_dir='/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part15-19-resize-decay/v1-20250624-140732/runs', logging_strategy=<IntervalStrategy.STEPS: 'steps'>, logging_first_step=True, logging_steps=5, logging_nan_inf_filter=True, save_strategy=<IntervalStrategy.STEPS: 'steps'>, save_steps=1000, save_total_limit=1, save_safetensors=True, save_on_each_node=False, save_only_model=False, restore_callback_states_from_checkpoint=False, no_cuda=False, use_cpu=False, use_mps_device=False, seed=42, data_seed=42, jit_mode_eval=False, use_ipex=False, bf16=True, fp16=False, fp16_opt_level='O1', half_precision_backend='auto', bf16_full_eval=False, fp16_full_eval=False, tf32=None, local_rank=0, ddp_backend=None, tpu_num_cores=None, tpu_metrics_debug=False, debug=[], dataloader_drop_last=False, eval_steps=250, dataloader_num_workers=4, dataloader_prefetch_factor=None, past_index=-1, run_name='/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part15-19-resize-decay/v1-20250624-140732', disable_tqdm=False, remove_unused_columns=False, label_names=None, load_best_model_at_end=False, metric_for_best_model='loss', greater_is_better=False, ignore_data_skip=False, fsdp=[], fsdp_min_num_params=0, fsdp_config={'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}, fsdp_transformer_layer_cls_to_wrap=None, accelerator_config=AcceleratorConfig(split_batches=False, dispatch_batches=False, even_batches=True, use_seedable_sampler=True, non_blocking=False, gradient_accumulation_kwargs=None, use_configured_state=False), deepspeed={'fp16': {'enabled': 'auto', 'loss_scale': 0, 'loss_scale_window': 1000, 'initial_scale_power': 16, 'hysteresis': 2, 'min_loss_scale': 1}, 'bf16': {'enabled': 'auto'}, 'zero_optimization': {'stage': 3, 'offload_optimizer': {'device': 'none', 'pin_memory': True}, 'offload_param': {'device': 'none', 'pin_memory': True}, 'overlap_comm': False, 'contiguous_gradients': True, 'sub_group_size': 1000000000.0, 'reduce_bucket_size': 'auto', 'zero_quantized_weights': False, 'zero_quantized_gradients': False, 'stage3_prefetch_bucket_size': 'auto', 'stage3_param_persistence_threshold': 'auto', 'stage3_max_live_parameters': 1000000000.0, 'stage3_max_reuse_distance': 1000000000.0, 'stage3_gather_16bit_weights_on_model_save': True}, 'gradient_accumulation_steps': 'auto', 'gradient_clipping': 'auto', 'steps_per_print': 2000, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'wall_clock_breakdown': False}, label_smoothing_factor=0.0, optim=<OptimizerNames.ADAMW_TORCH: 'adamw_torch'>, optim_args=None, adafactor=False, group_by_length=False, length_column_name='length', report_to=['tensorboard'], ddp_find_unused_parameters=None, ddp_bucket_cap_mb=None, ddp_broadcast_buffers=None, dataloader_pin_memory=True, dataloader_persistent_workers=False, skip_memory_metrics=True, use_legacy_prediction_loop=False, push_to_hub=False, resume_from_checkpoint=None, hub_model_id=None, hub_strategy=<HubStrategy.EVERY_SAVE: 'every_save'>, hub_token=None, hub_private_repo=False, hub_always_push=False, gradient_checkpointing=True, gradient_checkpointing_kwargs=None, include_inputs_for_metrics=False, include_for_metrics=[], eval_do_concat_batches=True, fp16_backend='auto', evaluation_strategy='steps', push_to_hub_model_id=None, push_to_hub_organization=None, push_to_hub_token=None, mp_parameters='', auto_find_batch_size=False, full_determinism=False, torchdynamo=None, ray_scope='last', ddp_timeout=1800, torch_compile=False, torch_compile_backend=None, torch_compile_mode=None, dispatch_batches=None, split_batches=None, include_tokens_per_second=None, include_num_input_tokens_seen=None, neftune_noise_alpha=None, optim_target_modules=None, batch_eval_metrics=False, eval_on_start=False, use_liger_kernel=False, eval_use_gather_object=False, average_tokens_across_devices=None, sortish_sampler=False, predict_with_generate=False, generation_max_length=None, generation_num_beams=None, generation_config=None, check_model=True, acc_strategy='token', train_sampler_random=True, metric_warmup_step=0, fsdp_num=1, acc_steps=1, eval_use_evalscope=False, eval_datasets=[], eval_limit=None, eval_datasets_args=None, eval_generation_config=None, train_type='full', optimizer=None, local_repo_path=None, galore_config=None)"
+}

VLAC/model/VLAC-8b/config.json

@@ -0,0 +1,229 @@
+{
+  "_commit_hash": null,
+  "_name_or_path": "/cpfs04/user/zhangqi/zhangqi/data/model_garden/0619_intern8b_v7-1-part10-14-resize-constant/v0-20250619-124555/checkpoint-3125",
+  "architectures": [
+    "InternVLChatModel"
+  ],
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_internvl_chat.InternVLChatConfig",
+    "AutoModel": "modeling_internvl_chat.InternVLChatModel",
+    "AutoModelForCausalLM": "modeling_internvl_chat.InternVLChatModel"
+  },
+  "bias": false,
+  "bos_token_id": 1,
+  "downsample_ratio": 0.5,
+  "dynamic_image_size": true,
+  "eos_token_id": 2,
+  "force_image_size": 448,
+  "hidden_act": "silu",
+  "hidden_size": 4096,
+  "initializer_range": 0.02,
+  "intermediate_size": 14336,
+  "keys_to_ignore_at_inference": [
+    "past_key_values"
+  ],
+  "llm_config": {
+    "_attn_implementation_autoset": true,
+    "_name_or_path": "internlm/internlm2_5-7b-chat",
+    "add_cross_attention": false,
+    "architectures": [
+      "InternLM2ForCausalLM"
+    ],
+    "attn_implementation": "flash_attention_2",
+    "auto_map": {
+      "AutoConfig": "configuration_internlm2.InternLM2Config",
+      "AutoModel": "modeling_internlm2.InternLM2ForCausalLM",
+      "AutoModelForCausalLM": "modeling_internlm2.InternLM2ForCausalLM"
+    },
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bias": false,
+    "bos_token_id": 1,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 2,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "silu",
+    "hidden_size": 4096,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "intermediate_size": 14336,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "max_position_embeddings": 32768,
+    "min_length": 0,
+    "model_type": "internlm2",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 32,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 32,
+    "num_key_value_heads": 8,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 2,
+    "prefix": null,
+    "pretraining_tp": 1,
+    "problem_type": null,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "rms_norm_eps": 1e-05,
+    "rope_scaling": {
+      "factor": 2.0,
+      "type": "dynamic"
+    },
+    "rope_theta": 1000000,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": false,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": "bfloat16",
+    "torchscript": false,
+    "transformers_version": "4.46.2",
+    "typical_p": 1.0,
+    "use_bfloat16": true,
+    "use_cache": false,
+    "vocab_size": 92553
+  },
+  "max_dynamic_patch": 12,
+  "max_position_embeddings": 32768,
+  "min_dynamic_patch": 1,
+  "model_type": "internvl_chat",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 8,
+  "pad_token_id": 2,
+  "pretraining_tp": 1,
+  "ps_version": "v2",
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": {
+    "factor": 2.0,
+    "type": "dynamic"
+  },
+  "rope_theta": 1000000,
+  "select_layer": -1,
+  "template": "internlm2-chat",
+  "tie_word_embeddings": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.37.2",
+  "use_backbone_lora": 0,
+  "use_bfloat16": true,
+  "use_cache": false,
+  "use_llm_lora": 0,
+  "use_thumbnail": true,
+  "vision_config": {
+    "_attn_implementation_autoset": true,
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": [
+      "InternVisionModel"
+    ],
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "drop_path_rate": 0.0,
+    "dropout": 0.0,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_size": 1024,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_size": 448,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-06,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "intern_vit_6b",
+    "no_repeat_ngram_size": 0,
+    "norm_type": "layer_norm",
+    "num_attention_heads": 16,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_channels": 3,
+    "num_hidden_layers": 24,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 2,
+    "patch_size": 14,
+    "prefix": null,
+    "problem_type": null,
+    "pruned_heads": {},
+    "qk_normalization": false,
+    "qkv_bias": true,
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": "bfloat16",
+    "torchscript": false,
+    "transformers_version": "4.46.2",
+    "typical_p": 1.0,
+    "use_bfloat16": true,
+    "use_flash_attn": true
+  },
+  "vocab_size": 92553
+}

VLAC/model/VLAC-8b/configuration_intern_vit.py

@@ -0,0 +1,119 @@
+# --------------------------------------------------------
+# InternVL
+# Copyright (c) 2024 OpenGVLab
+# Licensed under The MIT License [see LICENSE for details]
+# --------------------------------------------------------
+import os
+from typing import Union
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class InternVisionConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`InternVisionModel`]. It is used to
+    instantiate a vision encoder according to the specified arguments, defining the model architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+    Args:
+        num_channels (`int`, *optional*, defaults to 3):
+            Number of color channels in the input images (e.g., 3 for RGB).
+        patch_size (`int`, *optional*, defaults to 14):
+            The size (resolution) of each patch.
+        image_size (`int`, *optional*, defaults to 224):
+            The size (resolution) of each image.
+        qkv_bias (`bool`, *optional*, defaults to `False`):
+            Whether to add a bias to the queries and values in the self-attention layers.
+        hidden_size (`int`, *optional*, defaults to 3200):
+            Dimensionality of the encoder layers and the pooler layer.
+        num_attention_heads (`int`, *optional*, defaults to 25):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        intermediate_size (`int`, *optional*, defaults to 12800):
+            Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
+        qk_normalization (`bool`, *optional*, defaults to `True`):
+            Whether to normalize the queries and keys in the self-attention layers.
+        num_hidden_layers (`int`, *optional*, defaults to 48):
+            Number of hidden layers in the Transformer encoder.
+        use_flash_attn (`bool`, *optional*, defaults to `True`):
+            Whether to use flash attention mechanism.
+        hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"selu"` and `"gelu_new"` ``"gelu"` are supported.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-6):
+            The epsilon used by the layer normalization layers.
+        dropout (`float`, *optional*, defaults to 0.0):
+            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+        drop_path_rate (`float`, *optional*, defaults to 0.0):
+            Dropout rate for stochastic depth.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        initializer_factor (`float`, *optional*, defaults to 0.1):
+            A factor for layer scale.
+    """
+
+    model_type = 'intern_vit_6b'
+
+    def __init__(
+            self,
+            num_channels=3,
+            patch_size=14,
+            image_size=224,
+            qkv_bias=False,
+            hidden_size=3200,
+            num_attention_heads=25,
+            intermediate_size=12800,
+            qk_normalization=True,
+            num_hidden_layers=48,
+            use_flash_attn=True,
+            hidden_act='gelu',
+            norm_type='rms_norm',
+            layer_norm_eps=1e-6,
+            dropout=0.0,
+            drop_path_rate=0.0,
+            attention_dropout=0.0,
+            initializer_range=0.02,
+            initializer_factor=0.1,
+            **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.dropout = dropout
+        self.drop_path_rate = drop_path_rate
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_channels = num_channels
+        self.patch_size = patch_size
+        self.image_size = image_size
+        self.initializer_range = initializer_range
+        self.initializer_factor = initializer_factor
+        self.attention_dropout = attention_dropout
+        self.layer_norm_eps = layer_norm_eps
+        self.hidden_act = hidden_act
+        self.norm_type = norm_type
+        self.qkv_bias = qkv_bias
+        self.qk_normalization = qk_normalization
+        self.use_flash_attn = use_flash_attn
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> 'PretrainedConfig':
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        if 'vision_config' in config_dict:
+            config_dict = config_dict['vision_config']
+
+        if 'model_type' in config_dict and hasattr(cls, 'model_type') and config_dict['model_type'] != cls.model_type:
+            logger.warning(
+                f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
+                f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'
+            )
+
+        return cls.from_dict(config_dict, **kwargs)

VLAC/model/VLAC-8b/configuration_internlm2.py

@@ -0,0 +1,150 @@
+# Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on transformers/src/transformers/models/llama/configuration_llama.py
+#
+# 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.
+""" InternLM2 model configuration"""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+INTERNLM2_PRETRAINED_CONFIG_ARCHIVE_MAP = {}
+
+
+# Modified from transformers.model.llama.configuration_llama.LlamaConfig
+class InternLM2Config(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`InternLM2Model`]. It is used to instantiate
+    an InternLM2 model according to the specified arguments, defining the model architecture. Instantiating a
+    configuration with the defaults will yield a similar configuration to that of the InternLM2-7B.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 32000):
+            Vocabulary size of the InternLM2 model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`InternLM2Model`]
+        hidden_size (`int`, *optional*, defaults to 4096):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 11008):
+            Dimension of the MLP representations.
+        num_hidden_layers (`int`, *optional*, defaults to 32):
+            Number of hidden layers in the Transformer encoder.
+        num_attention_heads (`int`, *optional*, defaults to 32):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        num_key_value_heads (`int`, *optional*):
+            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
+            `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
+            `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When
+            converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
+            by meanpooling all the original heads within that group. For more details checkout [this
+            paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to
+            `num_attention_heads`.
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            The non-linear activation function (function or string) in the decoder.
+        max_position_embeddings (`int`, *optional*, defaults to 2048):
+            The maximum sequence length that this model might ever be used with. Typically set this to something large
+            just in case (e.g., 512 or 1024 or 2048).
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-12):
+            The epsilon used by the rms normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether or not the model should return the last key/values attentions (not used by all models). Only
+            relevant if `config.is_decoder=True`.
+        tie_word_embeddings(`bool`, *optional*, defaults to `False`):
+            Whether to tie weight embeddings
+        Example:
+
+    """
+    model_type = 'internlm2'
+    _auto_class = 'AutoConfig'
+
+    def __init__(  # pylint: disable=W0102
+        self,
+        vocab_size=103168,
+        hidden_size=4096,
+        intermediate_size=11008,
+        num_hidden_layers=32,
+        num_attention_heads=32,
+        num_key_value_heads=None,
+        hidden_act='silu',
+        max_position_embeddings=2048,
+        initializer_range=0.02,
+        rms_norm_eps=1e-6,
+        use_cache=True,
+        pad_token_id=0,
+        bos_token_id=1,
+        eos_token_id=2,
+        tie_word_embeddings=False,
+        bias=True,
+        rope_theta=10000,
+        rope_scaling=None,
+        attn_implementation='eager',
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.bias = bias
+
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.use_cache = use_cache
+        self.rope_theta = rope_theta
+        self.rope_scaling = rope_scaling
+        self._rope_scaling_validation()
+
+        self.attn_implementation = attn_implementation
+        if self.attn_implementation is None:
+            self.attn_implementation = 'eager'
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+
+    def _rope_scaling_validation(self):
+        """
+        Validate the `rope_scaling` configuration.
+        """
+        if self.rope_scaling is None:
+            return
+
+        if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) != 2:
+            raise ValueError(
+                '`rope_scaling` must be a dictionary with with two fields, `type` and `factor`, '
+                f'got {self.rope_scaling}'
+            )
+        rope_scaling_type = self.rope_scaling.get('type', None)
+        rope_scaling_factor = self.rope_scaling.get('factor', None)
+        if rope_scaling_type is None or rope_scaling_type not in ['linear', 'dynamic']:
+            raise ValueError(
+                f"`rope_scaling`'s type field must be one of ['linear', 'dynamic'], got {rope_scaling_type}"
+            )
+        if rope_scaling_factor is None or not isinstance(rope_scaling_factor, float) or rope_scaling_factor < 1.0:
+            raise ValueError(f"`rope_scaling`'s factor field must be a float >= 1, got {rope_scaling_factor}")

VLAC/model/VLAC-8b/configuration_internvl_chat.py

@@ -0,0 +1,96 @@
+# --------------------------------------------------------
+# InternVL
+# Copyright (c) 2024 OpenGVLab
+# Licensed under The MIT License [see LICENSE for details]
+# --------------------------------------------------------
+
+import copy
+
+from transformers import AutoConfig, LlamaConfig
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+from .configuration_intern_vit import InternVisionConfig
+from .configuration_internlm2 import InternLM2Config
+
+logger = logging.get_logger(__name__)
+
+
+class InternVLChatConfig(PretrainedConfig):
+    model_type = 'internvl_chat'
+    is_composition = True
+
+    def __init__(
+            self,
+            vision_config=None,
+            llm_config=None,
+            use_backbone_lora=0,
+            use_llm_lora=0,
+            select_layer=-1,
+            force_image_size=None,
+            downsample_ratio=0.5,
+            template=None,
+            dynamic_image_size=False,
+            use_thumbnail=False,
+            ps_version='v1',
+            min_dynamic_patch=1,
+            max_dynamic_patch=6,
+            **kwargs):
+        super().__init__(**kwargs)
+
+        if vision_config is None:
+            vision_config = {}
+            logger.info('vision_config is None. Initializing the InternVisionConfig with default values.')
+
+        if llm_config is None:
+            llm_config = {}
+            logger.info('llm_config is None. Initializing the LlamaConfig config with default values (`LlamaConfig`).')
+
+        self.vision_config = InternVisionConfig(**vision_config)
+        # if llm_config['architectures'][0] == 'LlamaForCausalLM':
+        #     self.llm_config = LlamaConfig(**llm_config)
+        # elif llm_config['architectures'][0] == 'InternLM2ForCausalLM':
+        self.llm_config = InternLM2Config(**llm_config)
+        # else:
+            # raise ValueError('Unsupported architecture: {}'.format(llm_config['architectures'][0]))
+        self.use_backbone_lora = use_backbone_lora
+        self.use_llm_lora = use_llm_lora
+        self.select_layer = select_layer
+        self.force_image_size = force_image_size
+        self.downsample_ratio = downsample_ratio
+        self.template = template
+        self.dynamic_image_size = dynamic_image_size
+        self.use_thumbnail = use_thumbnail
+        self.ps_version = ps_version  # pixel shuffle version
+        self.min_dynamic_patch = min_dynamic_patch
+        self.max_dynamic_patch = max_dynamic_patch
+
+        logger.info(f'vision_select_layer: {self.select_layer}')
+        logger.info(f'ps_version: {self.ps_version}')
+        logger.info(f'min_dynamic_patch: {self.min_dynamic_patch}')
+        logger.info(f'max_dynamic_patch: {self.max_dynamic_patch}')
+
+    def to_dict(self):
+        """
+        Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
+
+        Returns:
+            `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
+        """
+        output = copy.deepcopy(self.__dict__)
+        output['vision_config'] = self.vision_config.to_dict()
+        output['llm_config'] = self.llm_config.to_dict()
+        output['model_type'] = self.__class__.model_type
+        output['use_backbone_lora'] = self.use_backbone_lora
+        output['use_llm_lora'] = self.use_llm_lora
+        output['select_layer'] = self.select_layer
+        output['force_image_size'] = self.force_image_size
+        output['downsample_ratio'] = self.downsample_ratio
+        output['template'] = self.template
+        output['dynamic_image_size'] = self.dynamic_image_size
+        output['use_thumbnail'] = self.use_thumbnail
+        output['ps_version'] = self.ps_version
+        output['min_dynamic_patch'] = self.min_dynamic_patch
+        output['max_dynamic_patch'] = self.max_dynamic_patch
+
+        return output

VLAC/model/VLAC-8b/conversation.py

@@ -0,0 +1,393 @@
+"""
+Conversation prompt templates.
+
+We kindly request that you import fastchat instead of copying this file if you wish to use it.
+If you have changes in mind, please contribute back so the community can benefit collectively and continue to maintain these valuable templates.
+"""
+
+import dataclasses
+from enum import IntEnum, auto
+from typing import Any, Dict, List, Tuple, Union
+
+
+class SeparatorStyle(IntEnum):
+    """Separator styles."""
+
+    ADD_COLON_SINGLE = auto()
+    ADD_COLON_TWO = auto()
+    ADD_COLON_SPACE_SINGLE = auto()
+    NO_COLON_SINGLE = auto()
+    NO_COLON_TWO = auto()
+    ADD_NEW_LINE_SINGLE = auto()
+    LLAMA2 = auto()
+    CHATGLM = auto()
+    CHATML = auto()
+    CHATINTERN = auto()
+    DOLLY = auto()
+    RWKV = auto()
+    PHOENIX = auto()
+    ROBIN = auto()
+    FALCON_CHAT = auto()
+    CHATGLM3 = auto()
+    INTERNVL_ZH = auto()
+    MPT = auto()
+
+
+@dataclasses.dataclass
+class Conversation:
+    """A class that manages prompt templates and keeps all conversation history."""
+
+    # The name of this template
+    name: str
+    # The template of the system prompt
+    system_template: str = '{system_message}'
+    # The system message
+    system_message: str = ''
+    # The names of two roles
+    roles: Tuple[str] = ('USER', 'ASSISTANT')
+    # All messages. Each item is (role, message).
+    messages: List[List[str]] = ()
+    # The number of few shot examples
+    offset: int = 0
+    # The separator style and configurations
+    sep_style: SeparatorStyle = SeparatorStyle.ADD_COLON_SINGLE
+    sep: str = '\n'
+    sep2: str = None
+    # Stop criteria (the default one is EOS token)
+    stop_str: Union[str, List[str]] = None
+    # Stops generation if meeting any token in this list
+    stop_token_ids: List[int] = None
+
+    def get_prompt(self) -> str:
+        """Get the prompt for generation."""
+        system_prompt = self.system_template.format(system_message=self.system_message)
+        if self.sep_style == SeparatorStyle.ADD_COLON_SINGLE:
+            ret = system_prompt + self.sep
+            for role, message in self.messages:
+                if message:
+                    ret += role + ': ' + message + self.sep
+                else:
+                    ret += role + ':'
+            return ret
+        elif self.sep_style == SeparatorStyle.ADD_COLON_TWO:
+            seps = [self.sep, self.sep2]
+            ret = system_prompt + seps[0]
+            for i, (role, message) in enumerate(self.messages):
+                if message:
+                    ret += role + ': ' + message + seps[i % 2]
+                else:
+                    ret += role + ':'
+            return ret
+        elif self.sep_style == SeparatorStyle.ADD_COLON_SPACE_SINGLE:
+            ret = system_prompt + self.sep
+            for role, message in self.messages:
+                if message:
+                    ret += role + ': ' + message + self.sep
+                else:
+                    ret += role + ': '  # must be end with a space
+            return ret
+        elif self.sep_style == SeparatorStyle.ADD_NEW_LINE_SINGLE:
+            ret = '' if system_prompt == '' else system_prompt + self.sep
+            for role, message in self.messages:
+                if message:
+                    ret += role + '\n' + message + self.sep
+                else:
+                    ret += role + '\n'
+            return ret
+        elif self.sep_style == SeparatorStyle.NO_COLON_SINGLE:
+            ret = system_prompt
+            for role, message in self.messages:
+                if message:
+                    ret += role + message + self.sep
+                else:
+                    ret += role
+            return ret
+        elif self.sep_style == SeparatorStyle.NO_COLON_TWO:
+            seps = [self.sep, self.sep2]
+            ret = system_prompt
+            for i, (role, message) in enumerate(self.messages):
+                if message:
+                    ret += role + message + seps[i % 2]
+                else:
+                    ret += role
+            return ret
+        elif self.sep_style == SeparatorStyle.RWKV:
+            ret = system_prompt
+            for i, (role, message) in enumerate(self.messages):
+                if message:
+                    ret += (
+                        role
+                        + ': '
+                        + message.replace('\r\n', '\n').replace('\n\n', '\n')
+                    )
+                    ret += '\n\n'
+                else:
+                    ret += role + ':'
+            return ret
+        elif self.sep_style == SeparatorStyle.LLAMA2:
+            seps = [self.sep, self.sep2]
+            if self.system_message:
+                ret = system_prompt
+            else:
+                ret = '[INST] '
+            for i, (role, message) in enumerate(self.messages):
+                tag = self.roles[i % 2]
+                if message:
+                    if i == 0:
+                        ret += message + ' '
+                    else:
+                        ret += tag + ' ' + message + seps[i % 2]
+                else:
+                    ret += tag
+            return ret
+        elif self.sep_style == SeparatorStyle.CHATGLM:
+            # source: https://huggingface.co/THUDM/chatglm-6b/blob/1d240ba371910e9282298d4592532d7f0f3e9f3e/modeling_chatglm.py#L1302-L1308
+            # source2: https://huggingface.co/THUDM/chatglm2-6b/blob/e186c891cf64310ac66ef10a87e6635fa6c2a579/modeling_chatglm.py#L926
+            round_add_n = 1 if self.name == 'chatglm2' else 0
+            if system_prompt:
+                ret = system_prompt + self.sep
+            else:
+                ret = ''
+
+            for i, (role, message) in enumerate(self.messages):
+                if i % 2 == 0:
+                    ret += f'[Round {i//2 + round_add_n}]{self.sep}'
+
+                if message:
+                    ret += f'{role}：{message}{self.sep}'
+                else:
+                    ret += f'{role}：'
+            return ret
+        elif self.sep_style == SeparatorStyle.CHATML:
+            ret = '' if system_prompt == '' else system_prompt + self.sep + '\n'
+            for role, message in self.messages:
+                if message:
+                    ret += role + '\n' + message + self.sep + '\n'
+                else:
+                    ret += role + '\n'
+            return ret
+        elif self.sep_style == SeparatorStyle.CHATGLM3:
+            ret = ''
+            if self.system_message:
+                ret += system_prompt
+            for role, message in self.messages:
+                if message:
+                    ret += role + '\n' + ' ' + message
+                else:
+                    ret += role
+            return ret
+        elif self.sep_style == SeparatorStyle.CHATINTERN:
+            # source: https://huggingface.co/internlm/internlm-chat-7b-8k/blob/bd546fa984b4b0b86958f56bf37f94aa75ab8831/modeling_internlm.py#L771
+            seps = [self.sep, self.sep2]
+            ret = system_prompt
+            for i, (role, message) in enumerate(self.messages):
+                # if i % 2 == 0:
+                #     ret += "<s>"
+                if message:
+                    ret += role + ':' + message + seps[i % 2] + '\n'
+                else:
+                    ret += role + ':'
+            return ret
+        elif self.sep_style == SeparatorStyle.DOLLY:
+            seps = [self.sep, self.sep2]
+            ret = system_prompt
+            for i, (role, message) in enumerate(self.messages):
+                if message:
+                    ret += role + ':\n' + message + seps[i % 2]
+                    if i % 2 == 1:
+                        ret += '\n\n'
+                else:
+                    ret += role + ':\n'
+            return ret
+        elif self.sep_style == SeparatorStyle.PHOENIX:
+            ret = system_prompt
+            for role, message in self.messages:
+                if message:
+                    ret += role + ': ' + '<s>' + message + '</s>'
+                else:
+                    ret += role + ': ' + '<s>'
+            return ret
+        elif self.sep_style == SeparatorStyle.ROBIN:
+            ret = system_prompt + self.sep
+            for role, message in self.messages:
+                if message:
+                    ret += role + ':\n' + message + self.sep
+                else:
+                    ret += role + ':\n'
+            return ret
+        elif self.sep_style == SeparatorStyle.FALCON_CHAT:
+            ret = ''
+            if self.system_message:
+                ret += system_prompt + self.sep
+            for role, message in self.messages:
+                if message:
+                    ret += role + ': ' + message + self.sep
+                else:
+                    ret += role + ':'
+
+            return ret
+        elif self.sep_style == SeparatorStyle.INTERNVL_ZH:
+            seps = [self.sep, self.sep2]
+            ret = self.system_message + seps[0]
+            for i, (role, message) in enumerate(self.messages):
+                if message:
+                    ret += role + ': ' + message + seps[i % 2]
+                else:
+                    ret += role + ':'
+            return ret
+        elif self.sep_style == SeparatorStyle.MPT:
+            ret = system_prompt + self.sep
+            for role, message in self.messages:
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + message + self.sep
+                else:
+                    ret += role
+            return ret
+        else:
+            raise ValueError(f'Invalid style: {self.sep_style}')
+
+    def set_system_message(self, system_message: str):
+        """Set the system message."""
+        self.system_message = system_message
+
+    def append_message(self, role: str, message: str):
+        """Append a new message."""
+        self.messages.append([role, message])
+
+    def update_last_message(self, message: str):
+        """Update the last output.
+
+        The last message is typically set to be None when constructing the prompt,
+        so we need to update it in-place after getting the response from a model.
+        """
+        self.messages[-1][1] = message
+
+    def to_gradio_chatbot(self):
+        """Convert the conversation to gradio chatbot format."""
+        ret = []
+        for i, (role, msg) in enumerate(self.messages[self.offset :]):
+            if i % 2 == 0:
+                ret.append([msg, None])
+            else:
+                ret[-1][-1] = msg
+        return ret
+
+    def to_openai_api_messages(self):
+        """Convert the conversation to OpenAI chat completion format."""
+        ret = [{'role': 'system', 'content': self.system_message}]
+
+        for i, (_, msg) in enumerate(self.messages[self.offset :]):
+            if i % 2 == 0:
+                ret.append({'role': 'user', 'content': msg})
+            else:
+                if msg is not None:
+                    ret.append({'role': 'assistant', 'content': msg})
+        return ret
+
+    def copy(self):
+        return Conversation(
+            name=self.name,
+            system_template=self.system_template,
+            system_message=self.system_message,
+            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,
+            stop_str=self.stop_str,
+            stop_token_ids=self.stop_token_ids,
+        )
+
+    def dict(self):
+        return {
+            'template_name': self.name,
+            'system_message': self.system_message,
+            'roles': self.roles,
+            'messages': self.messages,
+            'offset': self.offset,
+        }
+
+
+# A global registry for all conversation templates
+conv_templates: Dict[str, Conversation] = {}
+
+
+def register_conv_template(template: Conversation, override: bool = False):
+    """Register a new conversation template."""
+    if not override:
+        assert (
+            template.name not in conv_templates
+        ), f'{template.name} has been registered.'
+
+    conv_templates[template.name] = template
+
+
+def get_conv_template(name: str) -> Conversation:
+    """Get a conversation template."""
+    return conv_templates[name].copy()
+
+
+# Both Hermes-2 and internlm2-chat are chatml-format conversation templates. The difference
+# is that during training, the preprocessing function for the Hermes-2 template doesn't add
+# <s> at the beginning of the tokenized sequence, while the internlm2-chat template does.
+# Therefore, they are completely equivalent during inference.
+register_conv_template(
+    Conversation(
+        name='Hermes-2',
+        system_template='<|im_start|>system\n{system_message}',
+        # note: The new system prompt was not used here to avoid changes in benchmark performance.
+        # system_message='我是书生·万象，英文名是InternVL，是由上海人工智能实验室、清华大学及多家合作单位联合开发的多模态大语言模型。',
+        system_message='你是由上海人工智能实验室联合商汤科技开发的书生多模态大模型，英文名叫InternVL, 是一个有用无害的人工智能助手。',
+        roles=('<|im_start|>user\n', '<|im_start|>assistant\n'),
+        sep_style=SeparatorStyle.MPT,
+        sep='<|im_end|>',
+        stop_token_ids=[
+            2,
+            6,
+            7,
+            8,
+        ],
+        stop_str='<|endoftext|>',
+    )
+)
+
+
+register_conv_template(
+    Conversation(
+        name='internlm2-chat',
+        system_template='<|im_start|>system\n{system_message}',
+        # note: The new system prompt was not used here to avoid changes in benchmark performance.
+        # system_message='我是书生·万象，英文名是InternVL，是由上海人工智能实验室、清华大学及多家合作单位联合开发的多模态大语言模型。',
+        system_message='你是由上海人工智能实验室联合商汤科技开发的书生多模态大模型，英文名叫InternVL, 是一个有用无害的人工智能助手。',
+        roles=('<|im_start|>user\n', '<|im_start|>assistant\n'),
+        sep_style=SeparatorStyle.MPT,
+        sep='<|im_end|>',
+        stop_token_ids=[
+            2,
+            92543,
+            92542
+        ]
+    )
+)
+
+
+register_conv_template(
+    Conversation(
+        name='phi3-chat',
+        system_template='<|system|>\n{system_message}',
+        # note: The new system prompt was not used here to avoid changes in benchmark performance.
+        # system_message='我是书生·万象，英文名是InternVL，是由上海人工智能实验室、清华大学及多家合作单位联合开发的多模态大语言模型。',
+        system_message='你是由上海人工智能实验室联合商汤科技开发的书生多模态大模型，英文名叫InternVL, 是一个有用无害的人工智能助手。',
+        roles=('<|user|>\n', '<|assistant|>\n'),
+        sep_style=SeparatorStyle.MPT,
+        sep='<|end|>',
+        stop_token_ids=[
+            2,
+            32000,
+            32007
+        ]
+    )
+)

VLAC/model/VLAC-8b/generation_config.json

@@ -0,0 +1,8 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": [
+    92542,
+    92543
+  ],
+  "transformers_version": "4.46.2"
+}

VLAC/model/VLAC-8b/latest

@@ -0,0 +1 @@
+global_step3125

VLAC/model/VLAC-8b/model-00001-of-00004.safetensors

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

VLAC/model/VLAC-8b/model-00002-of-00004.safetensors

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