Add files using upload-large-folder tool

dataset_code/cp_high_motion.py

@@ -0,0 +1,171 @@
+import os
+import shutil
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+import threading
+
+def copy_single_file(pt_file, output_folder):
+    """
+    复制单个文件的函数
+    
+    Args:
+        pt_file: PT文件路径
+        output_folder: 输出文件夹路径
+    
+    Returns:
+        tuple: (是否成功, 文件名)
+    """
+    try:
+        pt_filename = pt_file.name
+        destination = Path(output_folder) / pt_filename
+        shutil.copy2(pt_file, destination)
+        return True, pt_filename
+    except Exception as e:
+        return False, f"复制 {pt_file.name} 失败: {str(e)}"
+
+def copy_matching_pt_files(json_folder, pt_folder, matched_output_folder, unmatched_output_folder, max_workers=4):
+    """
+    根据JSON文件的存在情况，多线程复制对应的PT文件到不同文件夹
+    
+    Args:
+        json_folder: JSON文件所在的文件夹路径
+        pt_folder: PT文件所在的文件夹路径
+        matched_output_folder: 匹配文件的输出文件夹路径
+        unmatched_output_folder: 不匹配文件的输出文件夹路径
+        max_workers: 最大线程数，默认为4
+    """
+    
+    # 创建输出文件夹（如果不存在）
+    os.makedirs(matched_output_folder, exist_ok=True)
+    os.makedirs(unmatched_output_folder, exist_ok=True)
+    
+    # 获取所有JSON文件的ID
+    print("正在扫描JSON文件...")
+    json_files = list(Path(json_folder).glob("*.json"))
+    json_ids = set()
+    
+    for json_file in tqdm(json_files, desc="扫描JSON文件"):
+        # 提取文件名（不含扩展名）作为ID
+        file_id = json_file.stem
+        json_ids.add(file_id)
+    
+    print(f"找到 {len(json_ids)} 个JSON文件")
+    
+    # 查找匹配和不匹配的PT文件
+    print("正在分类PT文件...")
+    pt_files = list(Path(pt_folder).glob("*.pt"))
+    matching_files = []
+    unmatching_files = []
+    
+    for pt_file in tqdm(pt_files, desc="分类PT文件"):
+        pt_filename = pt_file.name
+        
+        # 检查PT文件名是否以任何JSON ID开头
+        is_matched = False
+        for json_id in json_ids:
+            if pt_filename.startswith(json_id):
+                matching_files.append(pt_file)
+                is_matched = True
+                break  # 找到匹配后跳出内层循环
+        
+        if not is_matched:
+            unmatching_files.append(pt_file)
+    
+    print(f"找到 {len(matching_files)} 个匹配的PT文件")
+    print(f"找到 {len(unmatching_files)} 个不匹配的PT文件")
+    
+    # 使用线程锁保护计数器
+    copy_lock = threading.Lock()
+    matched_copied = 0
+    matched_failed = 0
+    unmatched_copied = 0
+    unmatched_failed = 0
+    
+    def process_files(files, output_folder, file_type):
+        nonlocal matched_copied, matched_failed, unmatched_copied, unmatched_failed
+        
+        if not files:
+            print(f"没有{file_type}文件需要复制")
+            return
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # 提交所有复制任务
+            future_to_file = {
+                executor.submit(copy_single_file, pt_file, output_folder): pt_file 
+                for pt_file in files
+            }
+            
+            # 使用tqdm显示进度
+            with tqdm(total=len(files), desc=f"复制{file_type}文件") as pbar:
+                for future in as_completed(future_to_file):
+                    success, result = future.result()
+                    
+                    with copy_lock:
+                        if success:
+                            if file_type == "匹配":
+                                matched_copied += 1
+                                pbar.set_postfix({
+                                    '已复制': matched_copied, 
+                                    '失败': matched_failed,
+                                    '当前': result
+                                })
+                            else:
+                                unmatched_copied += 1
+                                pbar.set_postfix({
+                                    '已复制': unmatched_copied, 
+                                    '失败': unmatched_failed,
+                                    '当前': result
+                                })
+                        else:
+                            if file_type == "匹配":
+                                matched_failed += 1
+                                pbar.set_postfix({
+                                    '已复制': matched_copied, 
+                                    '失败': matched_failed
+                                })
+                            else:
+                                unmatched_failed += 1
+                                pbar.set_postfix({
+                                    '已复制': unmatched_copied, 
+                                    '失败': unmatched_failed
+                                })
+                            print(f"\n错误: {result}")
+                    
+                    pbar.update(1)
+    
+    # 复制匹配的文件
+    if matching_files:
+        print("\n开始复制匹配的文件...")
+        process_files(matching_files, matched_output_folder, "匹配")
+    
+    # 复制不匹配的文件
+    if unmatching_files:
+        print("\n开始复制不匹配的文件...")
+        process_files(unmatching_files, unmatched_output_folder, "不匹配")
+    
+    # 输出最终统计
+    print(f"\n复制完成!")
+    print(f"匹配文件 - 成功复制: {matched_copied} 个, 失败: {matched_failed} 个")
+    print(f"不匹配文件 - 成功复制: {unmatched_copied} 个, 失败: {unmatched_failed} 个")
+    print(f"匹配文件输出目录: {matched_output_folder}")
+    print(f"不匹配文件输出目录: {unmatched_output_folder}")
+
+# 使用示例
+if __name__ == "__main__":
+    # 设置文件夹路径
+    json_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/new_metadata/high_motion"
+    pt_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents"
+    matched_output_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents/high_motion"
+    unmatched_output_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents/low_motion"
+    
+    os.makedirs(matched_output_folder, exist_ok=True)
+    os.makedirs(unmatched_output_folder, exist_ok=True)
+    # 执行复制操作（可以调整max_workers参数控制线程数）
+    copy_matching_pt_files(
+        json_folder, 
+        pt_folder, 
+        matched_output_folder, 
+        unmatched_output_folder, 
+        max_workers=32
+    )

dataset_code/get_length_num.py

@@ -0,0 +1,31 @@
+import os
+from collections import Counter
+from tqdm import tqdm
+
+def count_lengths(folder_path):
+    lengths = []
+    
+    for filename in os.listdir(folder_path):
+        if filename.endswith('.pt'):
+            parts = filename.split('_')
+            if len(parts) >= 4:
+                try:
+                    length = int(parts[-3])
+                    resolution = f"{length}"
+                    lengths.append(resolution)
+                except ValueError:
+                    print(f"无法解析文件: {filename}")
+    
+    counter = Counter(lengths)
+    
+    print("各长度统计：")
+    for length, count in sorted(counter.items(), key=lambda x: x[1], reverse=True):
+        print(f"{length}: {count}个文件")
+    
+    total_files = sum(counter.values())
+    print(f"\n总计: {total_files}个文件")
+    
+    return counter
+
+# 使用方法：
+count_lengths("/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents")

dataset_code/get_res_num.py

@@ -0,0 +1,29 @@
+import os
+from collections import Counter
+from tqdm import tqdm
+
+def count_resolutions(folder_path):
+    resolutions = []
+    
+    for filename in os.listdir(folder_path):
+        if filename.endswith('.pt'):
+            parts = filename.split('_')
+            if len(parts) >= 4:
+                try:
+                    height = int(parts[-2])
+                    width = int(parts[-1].split('.')[0])  # 去掉.pt后缀
+                    resolution = f"{width}×{height}"
+                    resolutions.append(resolution)
+                except ValueError:
+                    print(f"无法解析文件: {filename}")
+    
+    counter = Counter(resolutions)
+    
+    print("各分辨率统计：")
+    for resolution, count in sorted(counter.items()):
+        print(f"{resolution}: {count}个文件")
+    
+    return counter
+
+# 使用方法：
+count_resolutions("/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents")

dataset_code/move_bad_pt.py

@@ -0,0 +1,46 @@
+import os
+import shutil
+import torch
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+
+# 设置路径
+src_dirs = [
+    "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-drone",
+    "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-drone",
+    "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193",
+    "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386",
+    "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193",
+    "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386",
+]
+# src_dir = '/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents'
+bad_dir = '/mnt/bn/yufan-dev-my/ysh/Datasets/bad_pt'
+
+for src_dir in src_dirs:
+    # 创建 bad_pt 目录（如果不存在）
+    os.makedirs(bad_dir, exist_ok=True)
+
+    # 检查并移动损坏文件
+    def check_and_move(file):
+        file_path = os.path.join(src_dir, file)
+        try:
+            torch.load(file_path, map_location='cpu', weights_only=False)
+            return (file, True)  # 成功加载
+        except Exception:
+            shutil.move(file_path, os.path.join(bad_dir, file))
+            return (file, False)
+
+    # 获取所有 pt 文件
+    pt_files = [f for f in os.listdir(src_dir) if f.endswith('.pt')]
+
+    # 进度条包装器
+    results = []
+    with ThreadPoolExecutor(max_workers=8) as executor:
+        futures = {executor.submit(check_and_move, file): file for file in pt_files}
+        for future in tqdm(as_completed(futures), total=len(futures), desc="处理中"):
+            file, ok = future.result()
+            if not ok:
+                print(f"❌ 损坏：{file}")
+            # 可以注释掉下面这行减少控制台输出
+            # else:
+            #     print(f"✅ 正常：{file}")

dataset_code/move_bad_pt_mp4.py

@@ -0,0 +1,241 @@
+import os
+import shutil
+import torch
+import cv2
+from pathlib import Path
+import logging
+from tqdm import tqdm
+import concurrent.futures
+from threading import Lock
+import time
+
+class FileChecker:
+    def __init__(self, source_dir, corrupted_dir, max_workers=32):
+        self.source_dir = Path(source_dir)
+        self.corrupted_dir = Path(corrupted_dir)
+        self.max_workers = max_workers
+        self.lock = Lock()
+        
+        # 统计信息
+        self.stats = {
+            'total_pt': 0,
+            'total_mp4': 0,
+            'corrupted_pt': 0,
+            'corrupted_mp4': 0,
+            'moved_files': [],
+            'failed_moves': []
+        }
+        
+        self.setup_logging()
+        
+    def setup_logging(self):
+        """设置日志记录"""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler('file_check.log'),
+                logging.StreamHandler()
+            ]
+        )
+        self.logger = logging.getLogger(__name__)
+    
+    def check_pt_file(self, file_path):
+        """检查.pt文件是否损坏"""
+        try:
+            # 尝试加载torch文件
+            data = torch.load(file_path, map_location='cpu')
+            # 额外检查：确保数据不为空
+            if data is None:
+                return False
+            return True
+        except Exception as e:
+            return False
+    
+    def check_mp4_file(self, file_path):
+        """检查.mp4文件是否损坏"""
+        try:
+            # 尝试打开视频文件
+            cap = cv2.VideoCapture(str(file_path))
+            if not cap.isOpened():
+                return False
+            
+            # 检查视频属性
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            
+            # 基本属性检查
+            if frame_count <= 0 or fps <= 0 or width <= 0 or height <= 0:
+                cap.release()
+                return False
+            
+            # 尝试读取几帧来验证
+            frames_to_check = min(3, frame_count)
+            for i in range(frames_to_check):
+                ret, frame = cap.read()
+                if not ret or frame is None:
+                    cap.release()
+                    return False
+            
+            cap.release()
+            return True
+        except Exception as e:
+            return False
+    
+    def move_corrupted_file(self, file_path, file_type):
+        """移动损坏的文件"""
+        try:
+            # 保持原有的目录结构
+            relative_path = file_path.relative_to(self.source_dir)
+            new_path = self.corrupted_dir / relative_path
+            new_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # 移动文件
+            shutil.move(str(file_path), str(new_path))
+            
+            with self.lock:
+                self.stats['moved_files'].append(str(file_path))
+                if file_type == 'pt':
+                    self.stats['corrupted_pt'] += 1
+                else:
+                    self.stats['corrupted_mp4'] += 1
+            
+            self.logger.info(f"已移动损坏文件: {file_path} -> {new_path}")
+            return True
+            
+        except Exception as e:
+            with self.lock:
+                self.stats['failed_moves'].append(str(file_path))
+            self.logger.error(f"移动文件失败 {file_path}: {e}")
+            return False
+    
+    def process_pt_file(self, file_path):
+        """处理单个.pt文件"""
+        with self.lock:
+            self.stats['total_pt'] += 1
+        
+        if not self.check_pt_file(file_path):
+            self.logger.warning(f"发现损坏的 .pt 文件: {file_path}")
+            return self.move_corrupted_file(file_path, 'pt')
+        return True
+    
+    def process_mp4_file(self, file_path):
+        """处理单个.mp4文件"""
+        with self.lock:
+            self.stats['total_mp4'] += 1
+        
+        if not self.check_mp4_file(file_path):
+            self.logger.warning(f"发现损坏的 .mp4 文件: {file_path}")
+            return self.move_corrupted_file(file_path, 'mp4')
+        return True
+    
+    def process_files(self):
+        """多线程处理文件"""
+        # 创建损坏文件存储目录
+        self.corrupted_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 收集所有目标文件
+        pt_files = list(self.source_dir.rglob('*.pt'))
+        # mp4_files = list(self.source_dir.rglob('*.mp4'))
+        
+        self.logger.info(f"找到 {len(pt_files)} 个 .pt 文件")
+        # self.logger.info(f"找到 {len(mp4_files)} 个 .mp4 文件")
+        self.logger.info(f"使用 {self.max_workers} 个线程进行处理")
+        
+        start_time = time.time()
+        
+        # 处理.pt文件
+        if pt_files:
+            self.logger.info("开始多线程检查 .pt 文件...")
+            with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+                # 提交所有任务
+                future_to_file = {executor.submit(self.process_pt_file, file_path): file_path 
+                                 for file_path in pt_files}
+                
+                # 使用tqdm显示进度
+                for future in tqdm(concurrent.futures.as_completed(future_to_file), 
+                                 total=len(pt_files), desc="检查 .pt 文件"):
+                    file_path = future_to_file[future]
+                    try:
+                        future.result()
+                    except Exception as e:
+                        self.logger.error(f"处理文件 {file_path} 时出错: {e}")
+        
+        # # 处理.mp4文件
+        # if mp4_files:
+        #     self.logger.info("开始多线程检查 .mp4 文件...")
+        #     with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+        #         # 提交所有任务
+        #         future_to_file = {executor.submit(self.process_mp4_file, file_path): file_path 
+        #                          for file_path in mp4_files}
+                
+        #         # 使用tqdm显示进度
+        #         for future in tqdm(concurrent.futures.as_completed(future_to_file), 
+        #                          total=len(mp4_files), desc="检查 .mp4 文件"):
+        #             file_path = future_to_file[future]
+        #             try:
+        #                 future.result()
+        #             except Exception as e:
+        #                 self.logger.error(f"处理文件 {file_path} 时出错: {e}")
+        
+        end_time = time.time()
+        processing_time = end_time - start_time
+        
+        # 输出统计结果
+        self.print_statistics(processing_time)
+        
+        return self.stats
+    
+    def print_statistics(self, processing_time):
+        """输出统计结果"""
+        self.logger.info("=" * 60)
+        self.logger.info("检查完成！统计结果:")
+        self.logger.info(f"处理时间: {processing_time:.2f} 秒")
+        self.logger.info(f"使用线程数: {self.max_workers}")
+        self.logger.info(f"总 .pt 文件数: {self.stats['total_pt']}")
+        self.logger.info(f"损坏 .pt 文件数: {self.stats['corrupted_pt']}")
+        self.logger.info(f"总 .mp4 文件数: {self.stats['total_mp4']}")
+        self.logger.info(f"损坏 .mp4 文件数: {self.stats['corrupted_mp4']}")
+        self.logger.info(f"成功移动文件数: {len(self.stats['moved_files'])}")
+        self.logger.info(f"移动失败文件数: {len(self.stats['failed_moves'])}")
+        
+        if self.stats['total_pt'] + self.stats['total_mp4'] > 0:
+            total_files = self.stats['total_pt'] + self.stats['total_mp4']
+            files_per_second = total_files / processing_time
+            self.logger.info(f"平均处理速度: {files_per_second:.2f} 文件/秒")
+        
+        self.logger.info("=" * 60)
+
+def main():
+    # 配置参数
+    source_dir = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset"
+    corrupted_dir = "/mnt/bn/yufan-dev-my/ysh/Datasets/corrupted_files"
+    max_workers = 8
+    
+    print(f"源目录: {source_dir}")
+    print(f"损坏文件将移动到: {corrupted_dir}")
+    print(f"并发线程数: {max_workers}")
+    print("=" * 50)
+    
+    # 创建文件检查器并执行
+    checker = FileChecker(source_dir, corrupted_dir, max_workers)
+    stats = checker.process_files()
+    
+    # 保存移动文件列表
+    if stats['moved_files']:
+        with open('moved_files_list.txt', 'w') as f:
+            for file_path in stats['moved_files']:
+                f.write(f"{file_path}\n")
+        print(f"已将移动的文件列表保存到 moved_files_list.txt")
+    
+    # 保存失败文件列表
+    if stats['failed_moves']:
+        with open('failed_moves_list.txt', 'w') as f:
+            for file_path in stats['failed_moves']:
+                f.write(f"{file_path}\n")
+        print(f"已将移动失败的文件列表保存到 failed_moves_list.txt")
+
+if __name__ == "__main__":
+    main()

dataset_code/run.sh

@@ -0,0 +1,85 @@
+# export CUDA_VISIBLE_DEVICES=1,2,3,4,5,6
+
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+# GPUS_PER_NODE=5
+# NNODES=1
+# NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+
+#################################################################
+# 
+# torchrun $DISTRIBUTED_ARGS offoload_features_hv_official.py \
+#     --stride 2 \
+#     --batch_size 4 \
+#     --dataloader_num_workers 8 \
+#     --csv_file "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-drone_updated.csv" \
+#     --video_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-drone" \
+#     --output_latent_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-drone/latents_stride2"
+# torchrun $DISTRIBUTED_ARGS offoload_features_hv_official.py \
+#     --stride 2 \
+#     --batch_size 4 \
+#     --dataloader_num_workers 8 \
+#     --csv_file "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-drone_updated.csv" \
+#     --video_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-drone" \
+#     --output_latent_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-drone/latents_stride2"
+# 
+
+# 
+torchrun $DISTRIBUTED_ARGS offoload_features_hv_official.py \
+    --stride 1 \
+    --batch_size 4 \
+    --dataloader_num_workers 8 \
+    --csv_file "/mnt/bn/yufan-dev-my/ysh/Ckpts/SpatialVID/SpatialVID-HQ-Final/data/SpatialVID_HQ_step2_filtered.csv" \
+    --video_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/SpatialVID/SpatialVID-HQ-Final" \
+    --output_latent_folder "/mnt/bn/icvg/users/ysh/Ckpts/SpatialVID/SpatialVID-HQ-Final/latents_stride1_new"
+# 

dataset_code/sekai/offload/dummy_dataloader.py

@@ -0,0 +1,476 @@
+import os
+import pickle
+import random
+import numpy as np
+import pandas as pd
+from collections import defaultdict
+
+import torch
+import torchvision
+from torch.utils.data import DataLoader, Dataset, Sampler
+
+from video_reader import PyVideoReader
+
+from diffusers.utils import export_to_video
+from diffusers.training_utils import free_memory
+
+# 5:  (21, 41,  61,  81, 101)
+# 6:  (25, 49,  73,  97, 121)
+# 7:  (29, 57,  85, 113, 141)
+# 8:  (33, 65,  97, 129, 161)
+# 9:  (37, 73, 109, 145, 181)
+# 10: (41, 81, 121, 161, 201)
+# 11: (45, 89, 133, 177, 221)
+# 12: (49, 97, 145, 193, 241)
+
+# 1:  (21 - 1) * 4 + 1 = 81,  162
+# 2:  (22 - 1) * 4 + 1 = 85,  170
+# 3:  (23 - 1) * 4 + 1 = 89,  178
+# 4:  (24 - 1) * 4 + 1 = 93,  186
+# 5:  (25 - 1) * 4 + 1 = 97,  194
+# 6:  (26 - 1) * 4 + 1 = 101, 202
+# 7:  (27 - 1) * 4 + 1 = 105, 210
+# 8:  (28 - 1) * 4 + 1 = 109, 218
+# 9:  (29 - 1) * 4 + 1 = 113, 226
+# 10: (30 - 1) * 4 + 1 = 117, 234
+# 11: (31 - 1) * 4 + 1 = 121, 242
+# 12: (32 - 1) * 4 + 1 = 125, 250
+# 13: (33 - 1) * 4 + 1 = 129, 258
+# 14: (34 - 1) * 4 + 1 = 133, 266
+# 15: (35 - 1) * 4 + 1 = 137, 274
+# 16: (36 - 1) * 4 + 1 = 141, 282
+
+resolution_bucket_options = {
+    640: [
+        (768, 320),
+        (768, 384),
+        (640, 384),
+        (768, 512),
+        (576, 448),
+        (512, 512),
+        (448, 576),
+        (512, 768),
+        (384, 640),
+        (384, 768),
+        (320, 768),
+    ],
+}
+
+length_bucket_options = {
+    1: [321, 301, 281, 261, 241, 221, 193, 181, 161, 141, 121, 101, 81, 61, 41, 21],
+    2: [193, 177, 161, 156, 145, 133, 129, 121, 113, 109, 97, 85, 81, 73, 65, 61, 49, 37, 25],
+}
+
+def find_nearest_resolution_bucket(h, w, resolution=640):
+    min_metric = float('inf')
+    best_bucket = None
+    for (bucket_h, bucket_w) in resolution_bucket_options[resolution]:
+        metric = abs(h * bucket_w - w * bucket_h)
+        if metric <= min_metric:
+            min_metric = metric
+            best_bucket = (bucket_h, bucket_w)
+    return best_bucket
+
+def find_nearest_length_bucket(length, stride=1):
+    buckets = length_bucket_options[stride]
+    min_bucket = min(buckets)
+    if length < min_bucket:
+        return length
+    valid_buckets = [bucket for bucket in buckets if bucket <= length]
+    return max(valid_buckets)
+
+def read_cut_crop_and_resize(video_path, f_prime, h_prime, w_prime, stride=1):
+    vr = PyVideoReader(video_path, threads=0) # 0 means auto (let ffmpeg pick the optimal number)
+
+    filename = os.path.splitext(os.path.basename(video_path))[0]
+    parts = filename.split('_')
+    total_frames = int(parts[-1]) - int(parts[-2])
+
+    if stride != 1:
+        required_span = stride * (f_prime - 1)
+        try:
+            start_frame = max(0, total_frames - required_span - 1)
+            frame_indices = list(range(start_frame, total_frames, stride))
+            assert len(frame_indices) == f_prime
+            # frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+            frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=0, end_frame=total_frames))).float()
+            frames = frames[frame_indices]
+        except:
+            start_frame = max(0, total_frames - required_span - 2)
+            frame_indices = list(range(start_frame, total_frames, stride))
+            assert len(frame_indices) == f_prime
+            # frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+            frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=0, end_frame=total_frames))).float()
+            frames = frames[frame_indices]
+    else:
+        start_frame = max(0, total_frames - f_prime)
+        # frame_indices = list(range(start_frame, total_frames))
+        frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=start_frame, end_frame=total_frames))).float()
+
+    # total_frames = len(vr)
+    # start_frame = max(0, total_frames - f_prime)
+    # # frame_indices = list(range(start_frame, total_frames))
+    # # frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+    # frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=start_frame, end_frame=total_frames))).float()
+    
+    frames = (frames / 127.5) - 1
+    video = frames.permute(0, 3, 1, 2)
+
+    frames, channels, h, w = video.shape
+    aspect_ratio_original = h / w
+    aspect_ratio_target = h_prime / w_prime
+
+    if aspect_ratio_original >= aspect_ratio_target:
+        new_h = int(w * aspect_ratio_target)
+        top = (h - new_h) // 2
+        bottom = top + new_h
+        left = 0
+        right = w
+    else:
+        new_w = int(h / aspect_ratio_target)
+        left = (w - new_w) // 2
+        right = left + new_w
+        top = 0
+        bottom = h
+
+    # Crop the video
+    cropped_video = video[:, :, top:bottom, left:right]
+    # Resize the cropped video
+    resized_video = torchvision.transforms.functional.resize(cropped_video, (h_prime, w_prime))
+    return resized_video
+
+def save_frames(frame_raw, fps=24, video_path="1.mp4"):        
+    save_list = []
+    for frame in frame_raw:
+        frame = (frame + 1) / 2 * 255
+        frame = torchvision.transforms.transforms.ToPILImage()(frame.to(torch.uint8)).convert("RGB")
+        save_list.append(frame)
+        frame = None
+        del frame
+    export_to_video(save_list, video_path, fps=fps)
+    
+    save_list = None
+    del save_list
+    free_memory()
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(self, csv_file, video_folder, stride=1, cache_file=None, force_rebuild=True):
+        self.csv_file = csv_file
+        self.video_folder = video_folder
+        self.stride = stride
+
+        if cache_file is None:
+            cache_file = os.path.join(video_folder, f"dataset_cache_stride{stride}.pkl")
+
+        if force_rebuild or not os.path.exists(cache_file):
+            print("Building metadata cache...")
+            self._build_metadata()
+            self._save_cache(cache_file)
+        else:
+            print("Loading cached metadata...")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            if cached_data.get("stride", 1) != stride:
+                print(f"Stride mismatch in cache (cached: {cached_data.get('stride', 1)}, current: {stride}). Rebuilding...")
+                self._build_metadata()
+                self._save_cache(cache_file)
+            else:
+                self.samples = cached_data["samples"]
+                self.buckets = cached_data["buckets"]
+                print(f"Loaded {len(self.samples)} samples from cache")
+        
+
+    def _save_cache(self, cache_file):
+        print("Saving metadata cache...")
+        cached_data = {
+            "samples": self.samples, 
+            "buckets": self.buckets,
+            "stride": self.stride
+        }
+        with open(cache_file, "wb") as f:
+            pickle.dump(cached_data, f)
+        print(f"Cached {len(self.samples)} samples with stride={self.stride}")
+
+    # def _build_metadata(self):
+    #     self.feature_files = [f for f in os.listdir(self.video_folder) if f.endswith(".mp4")]
+    #     self.samples = []
+    #     self.buckets = defaultdict(list)
+    #     sample_idx = 0
+
+    #     print(f"Processing {len(self.feature_files)} files...")
+    #     for i, feature_file in enumerate(self.feature_files):
+    #         if i % 10000 == 0:
+    #             print(f"Processed {i}/{len(self.feature_files)} files")
+
+    #         video_path = os.path.join(self.video_folder, feature_file)
+
+    #         # Parse filename
+    #         parts = feature_file.split("_")[:4]
+    #         uttid = parts[0]
+    #         num_frame = int(parts[1])
+    #         height = int(parts[2])
+    #         width = int(parts[3].replace(".mp4", ""))
+
+    def _build_metadata(self):
+        self.df = pd.read_csv(self.csv_file)
+        
+        self.samples = []
+        self.buckets = defaultdict(list)
+        sample_idx = 0
+        
+        print(f"Processing {len(self.df)} records from CSV with stride={self.stride}...")
+        for i, row in self.df.iterrows():
+            if i % 10000 == 0:
+                print(f"Processed {i}/{len(self.df)} records")
+            
+            uttid = os.path.basename(row['videoFile']).replace(".mp4", "")
+            video_file = row['videoFile']
+            video_path = os.path.join(self.video_folder, video_file)
+            prompt = row["caption"]
+            # num_frame = row["num_frame"]
+
+            filename = os.path.splitext(os.path.basename(video_path))[0]
+            parts = filename.split('_')
+            num_frame = int(parts[-1]) - int(parts[-2])
+
+            height = row["height"]
+            width = row["width"]
+            fps = row["fps"]
+
+            # # keep length >= 121
+            # if num_frame < 121:
+            #     continue
+
+            effective_num_frame = (num_frame + self.stride - 1) // self.stride 
+            bucket_height, bucket_width = find_nearest_resolution_bucket(height, width, resolution=640)
+            bucket_num_frame = find_nearest_length_bucket(effective_num_frame, stride=self.stride)
+            bucket_key = (bucket_num_frame, bucket_height, bucket_width)
+
+            sample_info = {
+                "uttid": uttid,
+                "bucket_key": bucket_key,
+                "video_path": video_path,
+                "prompt": prompt,
+                "fps": fps,
+                "stride": self.stride,
+                "effective_num_frame": effective_num_frame,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+                "bucket_num_frame": bucket_num_frame,
+                "bucket_height": bucket_height,
+                "bucket_width": bucket_width,
+            }
+
+            self.samples.append(sample_info)
+            self.buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        sample_info = self.samples[idx]
+        video_data = read_cut_crop_and_resize(
+            video_path=sample_info["video_path"],
+            f_prime=sample_info["bucket_num_frame"],
+            h_prime=sample_info["bucket_height"],
+            w_prime=sample_info["bucket_width"],
+            stride=self.stride,
+        )
+        # while True:
+        #     sample_info = self.samples[idx]
+        #     try:
+        #         video_data = read_cut_crop_and_resize(
+        #             video_path=sample_info["video_path"],
+        #             f_prime=sample_info["bucket_num_frame"],
+        #             h_prime=sample_info["bucket_height"],
+        #             w_prime=sample_info["bucket_width"],
+        #             stride=self.stride,
+        #         )
+        #         break
+        #     except Exception:
+        #         idx = random.randint(0, len(self.samples) - 1)
+        #         print(f"Error loading {sample_info['video_path']}, retrying...")
+
+        return {
+            "uttid": sample_info["uttid"],
+            "bucket_key": sample_info["bucket_key"],
+            "video_metadata": {
+                "num_frames": sample_info["bucket_num_frame"],
+                "height": sample_info["bucket_height"],
+                "width": sample_info["bucket_width"],
+                "fps": sample_info["fps"],
+                "stride": self.stride,
+                "effective_num_frame": sample_info["effective_num_frame"],
+            },
+            "videos": video_data,
+            "prompts": sample_info["prompt"],
+            "first_frames_images": (video_data[0] + 1) / 2 * 255,
+        }
+
+class BucketedSampler(Sampler):
+    def __init__(self, dataset, batch_size, drop_last=False, shuffle=True, seed=42):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def __iter__(self):
+        if self.shuffle:
+            self.generator.manual_seed(self.seed + self._epoch)
+        else:
+            self.generator.manual_seed(self.seed)
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            indices = sample_indices.copy()
+            if self.shuffle:
+                indices = torch.randperm(len(indices), generator=self.generator).tolist()
+                indices = [sample_indices[i] for i in indices]
+
+            batches = []
+            for i in range(0, len(indices), self.batch_size):
+                batch = indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def __len__(self):
+        total_batches = 0
+        for sample_indices in self.buckets.values():
+            num_batches = len(sample_indices) // self.batch_size
+            if not self.drop_last and len(sample_indices) % self.batch_size != 0:
+                num_batches += 1
+            total_batches += num_batches
+        return total_batches
+
+
+def collate_fn(batch):
+    def collate_dict(data_list):
+        if isinstance(data_list[0], dict):
+            return {
+                key: collate_dict([d[key] for d in data_list])
+                for key in data_list[0]
+            }
+        elif isinstance(data_list[0], torch.Tensor):
+            return torch.stack(data_list)
+        else:
+            return data_list
+    
+    return {
+        key: collate_dict([d[key] for d in batch])
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    from accelerate import Accelerator
+
+    base_name = "sekai-game-drone"
+    csv_file = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls{base_name}_updated.csv"
+    video_folder = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/{base_name}"
+    stride = 2
+    batch_size = 2
+    num_train_epochs = 1
+    seed = 0
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset = BucketedFeatureDataset(csv_file=csv_file, video_folder=video_folder, stride=stride)
+    sampler = BucketedSampler(dataset, batch_size=2, drop_last=False, shuffle=True, seed=seed)
+    dataloader = DataLoader(dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=0)
+
+    print(len(dataset), len(dataloader))
+    accelerator = Accelerator()
+    dataloader = accelerator.prepare(dataloader)
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+    print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+
+    print("Testing dataloader...")
+    step = global_step
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        skip_steps = 0
+        printed_skip_log = False
+        for i, batch in enumerate(dataloader):
+            if epoch == first_epoch and skip_steps < (global_step % num_update_steps_per_epoch):
+                skip_steps += 1
+                continue
+            if epoch == first_epoch and not printed_skip_log:
+                print(f"Skip {skip_steps} steps in epoch {epoch}")
+                printed_skip_log = True
+
+            # Get metadata
+            uttid = batch["uttid"]
+            bucket_key = batch["bucket_key"]
+            num_frame = batch["video_metadata"]["num_frames"]
+            height = batch["video_metadata"]["height"]
+            width = batch["video_metadata"]["width"]
+
+            # Get feature
+            video_data = batch["videos"]
+            prompt = batch["prompts"]
+            first_frames_images = batch["first_frames_images"]
+            first_frames_images = [torchvision.transforms.ToPILImage()(x.to(torch.uint8)) for x in first_frames_images]
+
+            # save_frames(video_data[0].squeeze(0))
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  Videos shape: {video_data.shape}")
+                print(f"  Cpation: {prompt}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            step += 1

dataset_code/sekai/offload/dummy_dataloader_official.py

@@ -0,0 +1,472 @@
+import os
+import pickle
+import random
+import numpy as np
+import pandas as pd
+from collections import defaultdict
+
+import torch
+import torchvision
+from torch.utils.data import DataLoader, Dataset, Sampler
+
+from video_reader import PyVideoReader
+
+from diffusers.utils import export_to_video
+from diffusers.training_utils import free_memory
+
+# 5:  (21, 41,  61,  81, 101)
+# 6:  (25, 49,  73,  97, 121)
+# 7:  (29, 57,  85, 113, 141)
+# 8:  (33, 65,  97, 129, 161)
+# 9:  (37, 73, 109, 145, 181)
+# 10: (41, 81, 121, 161, 201)
+# 11: (45, 89, 133, 177, 221)
+# 12: (49, 97, 145, 193, 241)
+
+# 1:  (21 - 1) * 4 + 1 = 81,  162
+# 2:  (22 - 1) * 4 + 1 = 85,  170
+# 3:  (23 - 1) * 4 + 1 = 89,  178
+# 4:  (24 - 1) * 4 + 1 = 93,  186
+# 5:  (25 - 1) * 4 + 1 = 97,  194
+# 6:  (26 - 1) * 4 + 1 = 101, 202
+# 7:  (27 - 1) * 4 + 1 = 105, 210
+# 8:  (28 - 1) * 4 + 1 = 109, 218
+# 9:  (29 - 1) * 4 + 1 = 113, 226
+# 10: (30 - 1) * 4 + 1 = 117, 234
+# 11: (31 - 1) * 4 + 1 = 121, 242
+# 12: (32 - 1) * 4 + 1 = 125, 250
+# 13: (33 - 1) * 4 + 1 = 129, 258
+# 14: (34 - 1) * 4 + 1 = 133, 266
+# 15: (35 - 1) * 4 + 1 = 137, 274
+# 16: (36 - 1) * 4 + 1 = 141, 282
+
+resolution_bucket_options = {
+    640: [
+        (768, 320),
+        (768, 384),
+        (640, 384),
+        (768, 512),
+        (576, 448),
+        (512, 512),
+        (448, 576),
+        (512, 768),
+        (384, 640),
+        (384, 768),
+        (320, 768),
+    ],
+}
+
+length_bucket_options = {
+    1: [321, 301, 281, 261, 241, 221, 193, 181, 161, 141, 121, 101, 81, 61, 41, 21],
+    2: [193, 177, 161, 156, 145, 133, 129, 121, 113, 109, 97, 85, 81, 73, 65, 61, 49, 37, 25],
+}
+
+def find_nearest_resolution_bucket(h, w, resolution=640):
+    min_metric = float('inf')
+    best_bucket = None
+    for (bucket_h, bucket_w) in resolution_bucket_options[resolution]:
+        metric = abs(h * bucket_w - w * bucket_h)
+        if metric <= min_metric:
+            min_metric = metric
+            best_bucket = (bucket_h, bucket_w)
+    return best_bucket
+
+def find_nearest_length_bucket(length, stride=1):
+    buckets = length_bucket_options[stride]
+    min_bucket = min(buckets)
+    if length < min_bucket:
+        return length
+    valid_buckets = [bucket for bucket in buckets if bucket <= length]
+    return max(valid_buckets)
+
+def read_cut_crop_and_resize(video_path, f_prime, h_prime, w_prime, stride=1):
+    vr = PyVideoReader(video_path, threads=0) # 0 means auto (let ffmpeg pick the optimal number)
+    total_frames = len(vr)
+
+    if stride != 1:
+        required_span = stride * (f_prime - 1)
+        start_frame = max(0, total_frames - required_span - 1)
+    else:
+        start_frame = max(0, total_frames - f_prime)
+
+    frame_indices = list(range(start_frame, total_frames, stride))
+    assert len(frame_indices) == f_prime
+    frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+
+
+    # if stride != 1:
+    #     required_span = stride * (f_prime - 1)
+    #     start_frame = max(0, total_frames - required_span - 1)
+    #     frame_indices = list(range(start_frame, total_frames, stride))
+    #     assert len(frame_indices) == f_prime
+    #     frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=0, end_frame=total_frames))).float()
+    #     frames = frames[frame_indices]
+    # else:
+    #     start_frame = max(0, total_frames - f_prime)
+    #     frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=start_frame, end_frame=total_frames))).float()
+
+
+    # total_frames = len(vr)
+    # start_frame = max(0, total_frames - f_prime)
+    # # frame_indices = list(range(start_frame, total_frames))
+    # # frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+    # frames = torch.from_numpy(np.stack(vr.decode_fast(start_frame=start_frame, end_frame=total_frames))).float()
+
+
+    frames = (frames / 127.5) - 1
+    video = frames.permute(0, 3, 1, 2)
+
+    frames, channels, h, w = video.shape
+    aspect_ratio_original = h / w
+    aspect_ratio_target = h_prime / w_prime
+
+    if aspect_ratio_original >= aspect_ratio_target:
+        new_h = int(w * aspect_ratio_target)
+        top = (h - new_h) // 2
+        bottom = top + new_h
+        left = 0
+        right = w
+    else:
+        new_w = int(h / aspect_ratio_target)
+        left = (w - new_w) // 2
+        right = left + new_w
+        top = 0
+        bottom = h
+
+    # Crop the video
+    cropped_video = video[:, :, top:bottom, left:right]
+    # Resize the cropped video
+    resized_video = torchvision.transforms.functional.resize(cropped_video, (h_prime, w_prime))
+    return resized_video
+
+def save_frames(frame_raw, fps=24, video_path="1.mp4"):        
+    save_list = []
+    for frame in frame_raw:
+        frame = (frame + 1) / 2 * 255
+        frame = torchvision.transforms.transforms.ToPILImage()(frame.to(torch.uint8)).convert("RGB")
+        save_list.append(frame)
+        frame = None
+        del frame
+    export_to_video(save_list, video_path, fps=fps)
+    
+    save_list = None
+    del save_list
+    free_memory()
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(self, csv_file, video_folder, stride=1, cache_file=None, force_rebuild=False):
+        self.csv_file = csv_file
+        self.video_folder = video_folder
+        self.stride = stride
+        
+        if cache_file is None:
+            cache_file = os.path.join(video_folder, f"dataset_cache_stride{stride}.pkl")
+
+        if force_rebuild or not os.path.exists(cache_file):
+            print("Building metadata cache...")
+            self._build_metadata()
+            self._save_cache(cache_file)
+        else:
+            print("Loading cached metadata...")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            if cached_data.get("stride", 1) != stride:
+                print(f"Stride mismatch in cache (cached: {cached_data.get('stride', 1)}, current: {stride}). Rebuilding...")
+                self._build_metadata()
+                self._save_cache(cache_file)
+            else:
+                self.samples = cached_data["samples"]
+                self.buckets = cached_data["buckets"]
+                print(f"Loaded {len(self.samples)} samples from cache")
+        
+
+    def _save_cache(self, cache_file):
+        print("Saving metadata cache...")
+        cached_data = {
+            "samples": self.samples, 
+            "buckets": self.buckets,
+            "stride": self.stride
+        }
+        with open(cache_file, "wb") as f:
+            pickle.dump(cached_data, f)
+        print(f"Cached {len(self.samples)} samples with stride={self.stride}")
+
+    # def _build_metadata(self):
+    #     self.feature_files = [f for f in os.listdir(self.video_folder) if f.endswith(".mp4")]
+    #     self.samples = []
+    #     self.buckets = defaultdict(list)
+    #     sample_idx = 0
+
+    #     print(f"Processing {len(self.feature_files)} files...")
+    #     for i, feature_file in enumerate(self.feature_files):
+    #         if i % 10000 == 0:
+    #             print(f"Processed {i}/{len(self.feature_files)} files")
+
+    #         video_path = os.path.join(self.video_folder, feature_file)
+
+    #         # Parse filename
+    #         parts = feature_file.split("_")[:4]
+    #         uttid = parts[0]
+    #         num_frame = int(parts[1])
+    #         height = int(parts[2])
+    #         width = int(parts[3].replace(".mp4", ""))
+
+    def _build_metadata(self):
+        self.df = pd.read_csv(self.csv_file)
+        
+        self.samples = []
+        self.buckets = defaultdict(list)
+        sample_idx = 0
+        
+        print(f"Processing {len(self.df)} records from CSV with stride={self.stride}...")
+        for i, row in self.df.iterrows():
+            if i % 10000 == 0:
+                print(f"Processed {i}/{len(self.df)} records")
+            
+            uttid = os.path.basename(row['videoFile']).replace(".mp4", "")
+            video_file = row['videoFile']
+            video_path = os.path.join(self.video_folder, video_file)
+            prompt = row["caption"]
+            num_frame = row["num_frame"]
+            height = row["height"]
+            width = row["width"]
+            fps = row["fps"]
+
+            # # keep length >= 121
+            # if num_frame < 121:
+            #     continue
+
+            effective_num_frame = (num_frame + self.stride - 1) // self.stride
+            bucket_height, bucket_width = find_nearest_resolution_bucket(height, width, resolution=640)
+            bucket_num_frame = find_nearest_length_bucket(effective_num_frame, stride=self.stride)
+            bucket_key = (bucket_num_frame, bucket_height, bucket_width)
+
+            sample_info = {
+                "uttid": uttid,
+                "bucket_key": bucket_key,
+                "video_path": video_path,
+                "prompt": prompt,
+                "fps": fps,
+                "stride": self.stride,
+                "effective_num_frame": effective_num_frame,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+                "bucket_num_frame": bucket_num_frame,
+                "bucket_height": bucket_height,
+                "bucket_width": bucket_width,
+            }
+
+            self.samples.append(sample_info)
+            self.buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        # sample_info = self.samples[idx]
+        # video_data = read_cut_crop_and_resize(
+        #     video_path=sample_info["video_path"],
+        #     f_prime=sample_info["bucket_num_frame"],
+        #     h_prime=sample_info["bucket_height"],
+        #     w_prime=sample_info["bucket_width"],
+        #     stride=self.stride,
+        # )
+        while True:
+            sample_info = self.samples[idx]
+            try:
+                video_data = read_cut_crop_and_resize(
+                    video_path=sample_info["video_path"],
+                    f_prime=sample_info["bucket_num_frame"],
+                    h_prime=sample_info["bucket_height"],
+                    w_prime=sample_info["bucket_width"],
+                    stride=self.stride,
+                )
+                break
+            except Exception:
+                idx = random.randint(0, len(self.samples) - 1)
+                print(f"Error loading {sample_info['video_path']}, retrying...")
+
+        return {
+            "uttid": sample_info["uttid"],
+            "bucket_key": sample_info["bucket_key"],
+            "video_metadata": {
+                "num_frames": sample_info["bucket_num_frame"],
+                "height": sample_info["bucket_height"],
+                "width": sample_info["bucket_width"],
+                "fps": sample_info["fps"],
+                "stride": self.stride,
+                "effective_num_frame": sample_info["effective_num_frame"],
+            },
+            "videos": video_data,
+            "prompts": sample_info["prompt"],
+            "first_frames_images": (video_data[0] + 1) / 2 * 255,
+        }
+
+class BucketedSampler(Sampler):
+    def __init__(self, dataset, batch_size, drop_last=False, shuffle=False, seed=42):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def __iter__(self):
+        if self.shuffle:
+            self.generator.manual_seed(self.seed + self._epoch)
+        else:
+            self.generator.manual_seed(self.seed)
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            indices = sample_indices.copy()
+            if self.shuffle:
+                indices = torch.randperm(len(indices), generator=self.generator).tolist()
+                indices = [sample_indices[i] for i in indices]
+
+            batches = []
+            for i in range(0, len(indices), self.batch_size):
+                batch = indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def __len__(self):
+        total_batches = 0
+        for sample_indices in self.buckets.values():
+            num_batches = len(sample_indices) // self.batch_size
+            if not self.drop_last and len(sample_indices) % self.batch_size != 0:
+                num_batches += 1
+            total_batches += num_batches
+        return total_batches
+
+
+def collate_fn(batch):
+    def collate_dict(data_list):
+        if isinstance(data_list[0], dict):
+            return {
+                key: collate_dict([d[key] for d in data_list])
+                for key in data_list[0]
+            }
+        elif isinstance(data_list[0], torch.Tensor):
+            return torch.stack(data_list)
+        else:
+            return data_list
+    
+    return {
+        key: collate_dict([d[key] for d in batch])
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    from accelerate import Accelerator
+
+    base_name = "sekai-game-drone"
+    csv_file = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/{base_name}_updated.csv"
+    video_folder = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/{base_name}"
+    stride = 1
+    batch_size = 2
+    num_train_epochs = 1
+    seed = 0
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset = BucketedFeatureDataset(csv_file=csv_file, video_folder=video_folder, stride=stride)
+    sampler = BucketedSampler(dataset, batch_size=2, drop_last=False, shuffle=True, seed=seed)
+    dataloader = DataLoader(dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=8)
+
+    print(len(dataset), len(dataloader))
+    accelerator = Accelerator()
+    dataloader = accelerator.prepare(dataloader)
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+    print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+
+    print("Testing dataloader...")
+    step = global_step
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        skip_steps = 0
+        printed_skip_log = False
+        for i, batch in enumerate(dataloader):
+            if epoch == first_epoch and skip_steps < (global_step % num_update_steps_per_epoch):
+                skip_steps += 1
+                continue
+            if epoch == first_epoch and not printed_skip_log:
+                print(f"Skip {skip_steps} steps in epoch {epoch}")
+                printed_skip_log = True
+
+            # Get metadata
+            uttid = batch["uttid"]
+            bucket_key = batch["bucket_key"]
+            num_frame = batch["video_metadata"]["num_frames"]
+            height = batch["video_metadata"]["height"]
+            width = batch["video_metadata"]["width"]
+
+            # Get feature
+            video_data = batch["videos"]
+            prompt = batch["prompts"]
+            first_frames_images = batch["first_frames_images"]
+            first_frames_images = [torchvision.transforms.ToPILImage()(x.to(torch.uint8)) for x in first_frames_images]
+
+            # import pdb;pdb.set_trace()
+            # save_frames(video_data[0].squeeze(0), video_path="1.mp4")
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  Videos shape: {video_data.shape}")
+                print(f"  Cpation: {prompt}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            step += 1

dataset_code/sekai/offload/get_ffmpeg.sh

@@ -0,0 +1,4 @@
+
+ffprobe -v quiet -count_frames -select_streams v:0 -show_entries stream=nb_frames -of csv=p=0 /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/dummy_segments/00100200002_0021815_0022008.mp4
+
+ffprobe -v quiet -select_streams v:0 -show_entries stream=r_frame_rate -of csv=p=0 /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/dummy_segments/00100200002_0021815_0022008.mp4

dataset_code/sekai/offload/get_temp_csv.py

@@ -0,0 +1,118 @@
+import os
+import pandas as pd
+import argparse
+from tqdm import tqdm
+
+def extract_uttid_from_video_file(video_file):
+    """
+    从videoFile列中提取uttid（去掉.mp4后缀）
+    """
+    if video_file.endswith('.mp4'):
+        return video_file[:-4]  # 去掉.mp4
+    return video_file
+
+def create_filtered_csv(csv_file, output_latent_folder, output_csv_file):
+    """
+    创建一个过滤后的CSV文件，只包含需要处理的样本
+    只使用uttid匹配，不依赖其他元数据
+    """
+    # 读取原始CSV
+    df = pd.read_csv(csv_file)
+    print(f"Original dataset size: {len(df)}")
+    
+    # 获取已经存在的latent文件
+    existing_files = set()
+    if os.path.exists(output_latent_folder):
+        for filename in os.listdir(output_latent_folder):
+            if filename.endswith('.pt'):
+                parts = filename[:-3].split('_')
+                if len(parts) >= 4:  # 至少要有uttid + 3个元数据
+                    uttid_parts = parts[:-3]
+                    uttid = '_'.join(uttid_parts)
+                existing_files.add(uttid)
+    
+    print(f"Found {len(existing_files)} existing latent files")
+    
+    df_uttids = df['videoFile'].apply(extract_uttid_from_video_file)
+    mask = ~df_uttids.isin(existing_files)
+    filtered_df = df[mask]
+
+    # 保存到新的CSV文件
+    os.makedirs(os.path.dirname(output_csv_file), exist_ok=True)
+    filtered_df.to_csv(output_csv_file, index=False)
+    
+    print(f"Filtered dataset size: {len(filtered_df)}")
+    print(f"Filtered CSV saved to: {output_csv_file}")
+    
+    return len(filtered_df)
+
+def create_all_filtered_csvs():
+    """
+    为所有数据集创建过滤后的CSV文件
+    """
+    base_csv_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/"
+    base_output_latent_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/"
+
+    csv_paths = [
+        "sekai-game-walking-193_updated.csv", 
+        "sekai-real-walking-hq-193_updated.csv", 
+        "sekai-real-walking-hq-386_updated.csv", 
+        "sekai-game-walking-386_updated.csv"
+    ]
+    output_latent_paths = [
+        "sekai-game-walking-193/latents_stride1", 
+        "sekai-real-walking-hq-193/latents_stride1", 
+        "sekai-real-walking-hq-386/latents_stride2", 
+        "sekai-game-walking-386/latents_stride2"
+    ]
+
+    for csv_path, output_latent_path in zip(csv_paths, output_latent_paths):
+        original_csv = os.path.join(base_csv_path, csv_path)
+        output_latent_folder = os.path.join(base_output_latent_path, output_latent_path)
+        
+        # 创建过滤后的CSV文件名
+        filtered_csv_name = csv_path.replace('_updated.csv', '_filtered.csv')
+        filtered_csv_path = os.path.join(base_csv_path, filtered_csv_name)
+        
+        print(f"\nProcessing: {csv_path}")
+        
+        filtered_count = create_filtered_csv(
+            csv_file=original_csv,
+            output_latent_folder=output_latent_folder,
+            output_csv_file=filtered_csv_path
+        )
+        
+        print(f"Created filtered CSV: {filtered_csv_path} with {filtered_count} samples")
+
+def main():
+    parser = argparse.ArgumentParser(description="Create filtered CSV for processing")
+    # parser.add_argument("--csv_file", type=str, help="Original CSV file path")
+    # parser.add_argument("--output_latent_folder", type=str, help="Output latent folder path")
+    # parser.add_argument("--output_csv_file", type=str, help="Output filtered CSV file path")
+    parser.add_argument("--batch", action="store_true", help="Process all datasets in batch")
+    
+    args = parser.parse_args()
+    create_all_filtered_csvs()
+
+    # if args.batch:
+    #     # 批量处理所有数据集
+    #     create_all_filtered_csvs()
+    # else:
+    #     # 单个处理
+    #     if not all([args.csv_file, args.output_latent_folder, args.output_csv_file]):
+    #         print("Error: For single processing, --csv_file, --output_latent_folder, and --output_csv_file are required")
+    #         return
+            
+    #     filtered_count = create_filtered_csv(
+    #         csv_file=args.csv_file,
+    #         output_latent_folder=args.output_latent_folder,
+    #         output_csv_file=args.output_csv_file
+    #     )
+        
+    #     if filtered_count == 0:
+    #         print("No samples need processing!")
+    #     else:
+    #         print(f"Ready to process {filtered_count} samples")
+
+if __name__ == "__main__":
+    main()

dataset_code/sekai/offload/kill.sh

@@ -0,0 +1,3 @@
+pkill -9 -f run.sh
+pkill -9 -f offoload_features_hv.py
+pkill -9 -f offoload_features_hv_official.py

dataset_code/sekai/offload/offoload_features_hv.py

@@ -0,0 +1,326 @@
+import argparse
+import os
+from tqdm import tqdm
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import (
+    CLIPTextModel,
+    CLIPTokenizer,
+    LlamaModel,
+    LlamaTokenizerFast,
+    SiglipImageProcessor,
+    SiglipVisionModel,
+)
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video, load_image
+
+from dummy_dataloader import BucketedFeatureDataset, BucketedSampler, collate_fn
+from torch.utils.data import DataLoader
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.utils.data import Subset
+import torchvision.transforms as transforms
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output
+
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
+from diffusers.training_utils import free_memory
+
+from accelerate import Accelerator
+from utils_framepack import encode_image, encode_prompt
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+def main(rank, world_size, global_rank, stride, batch_size, dataloader_num_workers, csv_file, video_folder, output_latent_folder, pretrained_model_name_or_path, siglip_model_name_or_path):
+    weight_dtype = torch.bfloat16
+    device = rank
+    seed = 42
+
+    # Load the tokenizers
+    tokenizer_one = LlamaTokenizerFast.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer",
+    )
+    tokenizer_two = CLIPTokenizer.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer_2",
+    )
+    feature_extractor = SiglipImageProcessor.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="feature_extractor",
+
+    )
+
+    vae = AutoencoderKLHunyuanVideo.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    vae_scale_factor_spatial = vae.spatial_compression_ratio
+    video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    text_encoder_one = LlamaModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        torch_dtype=weight_dtype,
+    )
+    text_encoder_two = CLIPTextModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder_2",
+        torch_dtype=weight_dtype,
+    )
+    image_encoder = SiglipVisionModel.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="image_encoder",
+        torch_dtype=weight_dtype,
+    )
+
+    vae.requires_grad_(False)
+    text_encoder_one.requires_grad_(False)
+    text_encoder_two.requires_grad_(False)
+    image_encoder.requires_grad_(False)
+    vae.eval()
+    text_encoder_one.eval()
+    text_encoder_two.eval()
+    image_encoder.eval()
+
+    vae = vae.to(device)
+    text_encoder_one = text_encoder_one.to(device)
+    text_encoder_two = text_encoder_two.to(device)
+    image_encoder = image_encoder.to(device)
+
+    # dist.barrier()
+    dataset = BucketedFeatureDataset(csv_file=csv_file, video_folder=video_folder, stride=stride)
+    sampler = BucketedSampler(dataset, batch_size=batch_size, drop_last=True if batch_size != 1 else False, shuffle=False, seed=seed)
+    dataloader = DataLoader(
+        dataset, 
+        batch_sampler=sampler, 
+        collate_fn=collate_fn, 
+        num_workers=dataloader_num_workers,
+        # pin_memory=True,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        # persistent_workers=True if dataloader_num_workers > 0 else False,
+    )
+
+    print(len(dataset), len(dataloader))
+    accelerator = Accelerator()
+    dataloader = accelerator.prepare(dataloader)
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+    print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+    sampler.set_epoch(0)
+    if rank==0:
+        pbar = tqdm(total=len(dataloader), desc="Processing")
+    # dist.barrier()
+    for idx, batch in enumerate(dataloader):
+        free_memory()
+
+        valid_indices = []
+        valid_uttids = []
+        valid_num_frames = []
+        valid_heights = []
+        valid_widths = []
+        valid_videos = []
+        valid_prompts = []
+        valid_first_frames_images = []
+
+        for i, (uttid, num_frame, height, width) in enumerate(zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"])):
+            os.makedirs(output_latent_folder, exist_ok=True)
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            if not os.path.exists(output_path):
+                valid_indices.append(i)
+                valid_uttids.append(uttid)
+                valid_num_frames.append(num_frame)
+                valid_heights.append(height)
+                valid_widths.append(width)
+                valid_videos.append(batch["videos"][i])
+                valid_prompts.append(batch["prompts"][i])
+                valid_first_frames_images.append(batch["first_frames_images"][i])
+            else:
+                print(f"skipping {uttid}")
+        
+        if not valid_indices:
+            print("skipping entire batch!")
+            if rank==0:
+                pbar.update(1)
+                pbar.set_postfix({"batch": idx})
+            continue
+        
+        batch = None
+        del batch
+        free_memory()
+
+        batch = {
+            "uttid": valid_uttids,
+            "video_metadata": {
+                "num_frames": valid_num_frames,
+                "height": valid_heights,
+                "width": valid_widths
+            },
+            "videos": torch.stack(valid_videos),
+            "prompts": valid_prompts,
+            "first_frames_images": torch.stack(valid_first_frames_images),
+        }
+        
+        if len(batch["uttid"]) == 0:
+            print("All samples in this batch are already processed, skipping!")
+            continue
+
+        with torch.no_grad():
+            # Get Vae feature 1
+            pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+            vae_latents = vae.encode(pixel_values).latent_dist.sample()
+            vae_latents = vae_latents * vae.config.scaling_factor
+
+            # Encode prompts
+            prompts = batch["prompts"]
+            prompt_embeds, pooled_prompt_embeds, prompt_attention_mask = encode_prompt(
+                tokenizer=tokenizer_one,
+                text_encoder=text_encoder_one,
+                tokenizer_2=tokenizer_two,
+                text_encoder_2=text_encoder_two,
+                prompt=prompts,
+                device=device,
+            )
+
+            # Prepare images
+            image_tensor = batch["first_frames_images"]
+            images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+            image = video_processor.preprocess(image=images, height=batch["videos"].shape[-2], width=batch["videos"].shape[-1])
+            image_embeds = encode_image(
+                feature_extractor,
+                image_encoder,
+                image,
+                device=device,
+                dtype=weight_dtype,
+            )
+
+        for uttid, num_frame, height, width, cur_vae_latent, cur_prompt_embed, cur_pooled_prompt_embed, cur_prompt_attention_mask, cur_image_embed in zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"], vae_latents, prompt_embeds, pooled_prompt_embeds, prompt_attention_mask, image_embeds):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            temp_to_save = {
+                    "vae_latent": cur_vae_latent.cpu().detach(),
+                    "prompt_embed": cur_prompt_embed.cpu().detach(),
+                    "pooled_prompt_embeds": cur_pooled_prompt_embed.cpu().detach(),
+                    "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+                    "image_embeds": cur_image_embed.cpu().detach(),
+                }
+            torch.save(
+                temp_to_save,
+                output_path
+            )
+            print(f"save latent to: {output_path}")
+        
+        if rank==0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+
+
+        pixel_values = None
+        prompts = None
+        image_tensor = None
+        images = None
+        vae_latents = None
+        vae_latents_2 = None
+        image_embeds = None
+        prompt_embeds = None
+        pooled_prompt_embeds = None
+        prompt_attention_mask = None
+        batch = None
+        valid_indices = None
+        valid_uttids = None
+        valid_num_frames = None
+        valid_heights = None
+        valid_widths = None
+        valid_videos = None
+        valid_prompts = None
+        valid_first_frames_images = None
+        temp_to_save = None
+
+        del pixel_values
+        del prompts
+        del image_tensor
+        del images
+        del vae_latents
+        del vae_latents_2
+        del image_embeds
+        del batch
+        del valid_indices
+        del valid_uttids
+        del valid_num_frames
+        del valid_heights
+        del valid_widths
+        del valid_videos
+        del valid_prompts
+        del valid_first_frames_images
+        del temp_to_save
+
+        free_memory()
+
+    # dist.barrier()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--stride", type=int, default=2, help="Batch size for processing")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size for processing")
+    parser.add_argument("--dataloader_num_workers", type=int, default=0, help="Number of workers for data loading")
+    parser.add_argument("--csv_file", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/train/sekai-game-drone_updated.csv", help="Path to the config file")
+    parser.add_argument("--video_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/sekai-game-drone", help="Path to the config file")
+    parser.add_argument("--output_latent_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/sekai-game-drone/latents", help="Folder to store output latents")
+    parser.add_argument("--pretrained_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo", help="Pretrained model path")
+    parser.add_argument("--siglip_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl", help="Siglip model path")
+    args = parser.parse_args()
+
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    base_csv_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/"
+    base_video_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/"
+    base_output_latent_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/"
+
+    strides = [1, 1, 2, 2]
+    batch_sizes = [1, 1, 1, 1]
+    # csv_paths = ["sekai-game-walking-193_updated.csv", "sekai-real-walking-hq-193_updated.csv", "sekai-real-walking-hq-386_updated.csv", "sekai-game-walking-386_updated.csv"]
+    csv_paths = ["sekai-game-walking-193_filtered.csv", "sekai-real-walking-hq-193_filtered.csv", "sekai-real-walking-hq-386_filtered.csv", "sekai-game-walking-386_filtered.csv"]
+    video_paths = ["sekai-game-walking-193", "sekai-real-walking-hq-193", "sekai-real-walking-hq-386", "sekai-game-walking-386"]
+    output_latent_paths = ["sekai-game-walking-193/latents_stride1", "sekai-real-walking-hq-193/latents_stride1", "sekai-real-walking-hq-386/latents_stride2", "sekai-game-walking-386/latents_stride2"]
+
+    for stride, batch_size, csv_path, video_path, output_latent_path in zip(strides, batch_sizes, csv_paths, video_paths, output_latent_paths):
+        args.stride = stride
+        args.batch_sizes = batch_sizes
+        args.csv_file = os.path.join(base_csv_path, csv_path)
+        args.video_folder = os.path.join(base_video_path, video_path)
+        args.output_latent_folder =os.path.join(base_output_latent_path, output_latent_path)
+
+        main(
+            rank=device,
+            world_size=world_size,
+            global_rank=global_rank,
+            stride=args.stride,
+            batch_size=args.batch_size,
+            dataloader_num_workers=args.dataloader_num_workers,
+            csv_file=args.csv_file,
+            video_folder=args.video_folder,
+            output_latent_folder=args.output_latent_folder,
+            pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+            siglip_model_name_or_path=args.siglip_model_name_or_path,
+        )
+
+    dist.destroy_process_group()

dataset_code/sekai/offload/offoload_features_hv_official.py

@@ -0,0 +1,307 @@
+import argparse
+import os
+from tqdm import tqdm
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import (
+    CLIPTextModel,
+    CLIPTokenizer,
+    LlamaModel,
+    LlamaTokenizerFast,
+    SiglipImageProcessor,
+    SiglipVisionModel,
+)
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video, load_image
+
+from dummy_dataloader_official import BucketedFeatureDataset, BucketedSampler, collate_fn
+from torch.utils.data import DataLoader
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.utils.data import Subset
+import torchvision.transforms as transforms
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output
+
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
+from diffusers.training_utils import free_memory
+
+from accelerate import Accelerator
+from utils_framepack import encode_image, encode_prompt
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+def main(rank, world_size, global_rank, stride, batch_size, dataloader_num_workers, csv_file, video_folder, output_latent_folder, pretrained_model_name_or_path, siglip_model_name_or_path):
+    weight_dtype = torch.bfloat16
+    device = rank
+    seed = 42
+
+    # Load the tokenizers
+    tokenizer_one = LlamaTokenizerFast.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer",
+    )
+    tokenizer_two = CLIPTokenizer.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer_2",
+    )
+    feature_extractor = SiglipImageProcessor.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="feature_extractor",
+
+    )
+
+    vae = AutoencoderKLHunyuanVideo.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    vae_scale_factor_spatial = vae.spatial_compression_ratio
+    video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    text_encoder_one = LlamaModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        torch_dtype=weight_dtype,
+    )
+    text_encoder_two = CLIPTextModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder_2",
+        torch_dtype=weight_dtype,
+    )
+    image_encoder = SiglipVisionModel.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="image_encoder",
+        torch_dtype=weight_dtype,
+    )
+
+    vae.requires_grad_(False)
+    text_encoder_one.requires_grad_(False)
+    text_encoder_two.requires_grad_(False)
+    image_encoder.requires_grad_(False)
+    vae.eval()
+    text_encoder_one.eval()
+    text_encoder_two.eval()
+    image_encoder.eval()
+
+    vae = vae.to(device)
+    text_encoder_one = text_encoder_one.to(device)
+    text_encoder_two = text_encoder_two.to(device)
+    image_encoder = image_encoder.to(device)
+
+    dist.barrier()
+    dataset = BucketedFeatureDataset(csv_file=csv_file, video_folder=video_folder, stride=stride)
+    sampler = BucketedSampler(dataset, batch_size=batch_size, drop_last=False, shuffle=False, seed=seed)
+    dataloader = DataLoader(
+        dataset, 
+        batch_sampler=sampler, 
+        collate_fn=collate_fn, 
+        num_workers=dataloader_num_workers,
+        # pin_memory=True,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        # persistent_workers=True if dataloader_num_workers > 0 else False,
+    )
+
+    print(len(dataset), len(dataloader))
+    accelerator = Accelerator()
+    dataloader = accelerator.prepare(dataloader)
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+    print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+    sampler.set_epoch(0)
+    if rank==0:
+        pbar = tqdm(total=len(dataloader), desc="Processing")
+    dist.barrier()
+    for idx, batch in enumerate(dataloader):
+        free_memory()
+
+        valid_indices = []
+        valid_uttids = []
+        valid_num_frames = []
+        valid_heights = []
+        valid_widths = []
+        valid_videos = []
+        valid_prompts = []
+        valid_first_frames_images = []
+
+        for i, (uttid, num_frame, height, width) in enumerate(zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"])):
+            os.makedirs(output_latent_folder, exist_ok=True)
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            if not os.path.exists(output_path):
+                valid_indices.append(i)
+                valid_uttids.append(uttid)
+                valid_num_frames.append(num_frame)
+                valid_heights.append(height)
+                valid_widths.append(width)
+                valid_videos.append(batch["videos"][i])
+                valid_prompts.append(batch["prompts"][i])
+                valid_first_frames_images.append(batch["first_frames_images"][i])
+            else:
+                print(f"skipping {uttid}")
+        
+        if not valid_indices:
+            print("skipping entire batch!")
+            if rank==0:
+                pbar.update(1)
+                pbar.set_postfix({"batch": idx})
+            continue
+        
+        batch = None
+        del batch
+        free_memory()
+
+        batch = {
+            "uttid": valid_uttids,
+            "video_metadata": {
+                "num_frames": valid_num_frames,
+                "height": valid_heights,
+                "width": valid_widths
+            },
+            "videos": torch.stack(valid_videos),
+            "prompts": valid_prompts,
+            "first_frames_images": torch.stack(valid_first_frames_images),
+        }
+        
+        if len(batch["uttid"]) == 0:
+            print("All samples in this batch are already processed, skipping!")
+            continue
+
+        with torch.no_grad():
+            # Get Vae feature 1
+            pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+            vae_latents = vae.encode(pixel_values).latent_dist.sample()
+            vae_latents = vae_latents * vae.config.scaling_factor
+
+            # Encode prompts
+            prompts = batch["prompts"]
+            prompt_embeds, pooled_prompt_embeds, prompt_attention_mask = encode_prompt(
+                tokenizer=tokenizer_one,
+                text_encoder=text_encoder_one,
+                tokenizer_2=tokenizer_two,
+                text_encoder_2=text_encoder_two,
+                prompt=prompts,
+                device=device,
+            )
+
+            # Prepare images
+            image_tensor = batch["first_frames_images"]
+            images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+            image = video_processor.preprocess(image=images, height=batch["videos"].shape[-2], width=batch["videos"].shape[-1])
+            image_embeds = encode_image(
+                feature_extractor,
+                image_encoder,
+                image,
+                device=device,
+                dtype=weight_dtype,
+            )
+
+        for uttid, num_frame, height, width, cur_vae_latent, cur_prompt_embed, cur_pooled_prompt_embed, cur_prompt_attention_mask, cur_image_embed in zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"], vae_latents, prompt_embeds, pooled_prompt_embeds, prompt_attention_mask, image_embeds):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            temp_to_save = {
+                    "vae_latent": cur_vae_latent.cpu().detach(),
+                    "prompt_embed": cur_prompt_embed.cpu().detach(),
+                    "pooled_prompt_embeds": cur_pooled_prompt_embed.cpu().detach(),
+                    "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+                    "image_embeds": cur_image_embed.cpu().detach(),
+                }
+            torch.save(
+                temp_to_save,
+                output_path
+            )
+            print(f"save latent to: {output_path}")
+        
+        if rank==0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+
+
+        pixel_values = None
+        prompts = None
+        image_tensor = None
+        images = None
+        vae_latents = None
+        vae_latents_2 = None
+        image_embeds = None
+        prompt_embeds = None
+        pooled_prompt_embeds = None
+        prompt_attention_mask = None
+        batch = None
+        valid_indices = None
+        valid_uttids = None
+        valid_num_frames = None
+        valid_heights = None
+        valid_widths = None
+        valid_videos = None
+        valid_prompts = None
+        valid_first_frames_images = None
+        temp_to_save = None
+
+        del pixel_values
+        del prompts
+        del image_tensor
+        del images
+        del vae_latents
+        del vae_latents_2
+        del image_embeds
+        del batch
+        del valid_indices
+        del valid_uttids
+        del valid_num_frames
+        del valid_heights
+        del valid_widths
+        del valid_videos
+        del valid_prompts
+        del valid_first_frames_images
+        del temp_to_save
+
+        free_memory()
+        dist.barrier()
+    # dist.barrier()
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--stride", type=int, default=2, help="Batch size for processing")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size for processing")
+    parser.add_argument("--dataloader_num_workers", type=int, default=0, help="Number of workers for data loading")
+    parser.add_argument("--csv_file", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/train/sekai-game-drone_updated.csv", help="Path to the config file")
+    parser.add_argument("--video_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/sekai-game-drone", help="Path to the config file")
+    parser.add_argument("--output_latent_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/Sekai-Project/sekai-game-drone/latents", help="Folder to store output latents")
+    parser.add_argument("--pretrained_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo", help="Pretrained model path")
+    parser.add_argument("--siglip_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl", help="Siglip model path")
+    args = parser.parse_args()
+
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    main(
+        rank=device,
+        world_size=world_size,
+        global_rank=global_rank,
+        stride=args.stride,
+        batch_size=args.batch_size,
+        dataloader_num_workers=args.dataloader_num_workers,
+        csv_file=args.csv_file,
+        video_folder=args.video_folder,
+        output_latent_folder=args.output_latent_folder,
+        pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+        siglip_model_name_or_path=args.siglip_model_name_or_path,
+    )

dataset_code/sekai/offload/run.sh

@@ -0,0 +1,85 @@
+# export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6
+
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+GPUS_PER_NODE=1
+NNODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+
+#################################################################
+# 
+# torchrun $DISTRIBUTED_ARGS offoload_features_hv_official.py \
+#     --stride 2 \
+#     --batch_size 4 \
+#     --dataloader_num_workers 8 \
+#     --csv_file "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-drone_updated.csv" \
+#     --video_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-drone" \
+#     --output_latent_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-drone/latents_stride2"
+# torchrun $DISTRIBUTED_ARGS offoload_features_hv_official.py \
+#     --stride 2 \
+#     --batch_size 4 \
+#     --dataloader_num_workers 8 \
+#     --csv_file "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-drone_updated.csv" \
+#     --video_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-drone" \
+#     --output_latent_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-drone/latents_stride2"
+# 
+
+# 
+torchrun $DISTRIBUTED_ARGS offoload_features_hv.py \
+    --stride 1 \
+    --batch_size 1 \
+    --dataloader_num_workers 8 \
+    --csv_file "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193_updated.csv" \
+    --video_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_latent_folder "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking/latents_stride1"
+# 

dataset_code/sekai/offload/utils_framepack.py

@@ -0,0 +1,1229 @@
+import math
+import random
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from einops import rearrange, repeat
+
+from diffusers.training_utils import compute_density_for_timestep_sampling
+
+
+DEFAULT_PROMPT_TEMPLATE = {
+    "template": (
+        "<|start_header_id|>system<|end_header_id|>\n\nDescribe the video by detailing the following aspects: "
+        "1. The main content and theme of the video."
+        "2. The color, shape, size, texture, quantity, text, and spatial relationships of the objects."
+        "3. Actions, events, behaviors temporal relationships, physical movement changes of the objects."
+        "4. background environment, light, style and atmosphere."
+        "5. camera angles, movements, and transitions used in the video:<|eot_id|>"
+        "<|start_header_id|>user<|end_header_id|>\n\n{}<|eot_id|>"
+    ),
+    "crop_start": 95,
+}
+
+def get_config_value(args, name):
+    if hasattr(args, name):
+        return getattr(args, name)
+    elif hasattr(args, 'training_config') and hasattr(args.training_config, name):
+        return getattr(args.training_config, name)
+    else:
+        raise AttributeError(f"Neither args nor args.training_config has attribute '{name}'")
+
+# Copied from diffusers.pipelines.hunyuan_video.pipeline_hunyuan_video.HunyuanVideoPipeline._get_llama_prompt_embeds
+def _get_llama_prompt_embeds(
+    tokenizer,
+    text_encoder,
+    prompt: Union[str, List[str]],
+    prompt_template: Dict[str, Any],
+    num_videos_per_prompt: int = 1,
+    device: Optional[torch.device] = None,
+    dtype: Optional[torch.dtype] = None,
+    max_sequence_length: int = 256,
+    num_hidden_layers_to_skip: int = 2,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    device = device
+    dtype = dtype
+
+    prompt = [prompt] if isinstance(prompt, str) else prompt
+    batch_size = len(prompt)
+
+    prompt = [prompt_template["template"].format(p) for p in prompt]
+
+    crop_start = prompt_template.get("crop_start", None)
+    if crop_start is None:
+        prompt_template_input = tokenizer(
+            prompt_template["template"],
+            padding="max_length",
+            return_tensors="pt",
+            return_length=False,
+            return_overflowing_tokens=False,
+            return_attention_mask=False,
+        )
+        crop_start = prompt_template_input["input_ids"].shape[-1]
+        # Remove <|eot_id|> token and placeholder {}
+        crop_start -= 2
+
+    max_sequence_length += crop_start
+    text_inputs = tokenizer(
+        prompt,
+        max_length=max_sequence_length,
+        padding="max_length",
+        truncation=True,
+        return_tensors="pt",
+        return_length=False,
+        return_overflowing_tokens=False,
+        return_attention_mask=True,
+    )
+    text_input_ids = text_inputs.input_ids.to(device=device)
+    prompt_attention_mask = text_inputs.attention_mask.to(device=device)
+
+    prompt_embeds = text_encoder(
+        input_ids=text_input_ids,
+        attention_mask=prompt_attention_mask,
+        output_hidden_states=True,
+    ).hidden_states[-(num_hidden_layers_to_skip + 1)]
+    prompt_embeds = prompt_embeds.to(dtype=dtype)
+
+    if crop_start is not None and crop_start > 0:
+        prompt_embeds = prompt_embeds[:, crop_start:]
+        prompt_attention_mask = prompt_attention_mask[:, crop_start:]
+
+    # duplicate text embeddings for each generation per prompt, using mps friendly method
+    _, seq_len, _ = prompt_embeds.shape
+    prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+    prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
+    prompt_attention_mask = prompt_attention_mask.repeat(1, num_videos_per_prompt)
+    prompt_attention_mask = prompt_attention_mask.view(batch_size * num_videos_per_prompt, seq_len)
+
+    return prompt_embeds, prompt_attention_mask
+
+
+# Copied from diffusers.pipelines.hunyuan_video.pipeline_hunyuan_video.HunyuanVideoPipeline._get_clip_prompt_embeds
+def _get_clip_prompt_embeds(
+    tokenizer_2,
+    text_encoder_2,
+    prompt: Union[str, List[str]],
+    num_videos_per_prompt: int = 1,
+    device: Optional[torch.device] = None,
+    dtype: Optional[torch.dtype] = None,
+    max_sequence_length: int = 77,
+) -> torch.Tensor:
+    device = device
+    dtype = dtype
+
+    prompt = [prompt] if isinstance(prompt, str) else prompt
+    batch_size = len(prompt)
+
+    text_inputs = tokenizer_2(
+        prompt,
+        padding="max_length",
+        max_length=max_sequence_length,
+        truncation=True,
+        return_tensors="pt",
+    )
+
+    text_input_ids = text_inputs.input_ids
+    untruncated_ids = tokenizer_2(prompt, padding="longest", return_tensors="pt").input_ids
+    if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids):
+        _ = tokenizer_2.batch_decode(untruncated_ids[:, max_sequence_length - 1 : -1])
+
+    prompt_embeds = text_encoder_2(text_input_ids.to(device), output_hidden_states=False).pooler_output
+
+    # duplicate text embeddings for each generation per prompt, using mps friendly method
+    prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt)
+    prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, -1)
+
+    return prompt_embeds
+
+
+# Copied from diffusers.pipelines.hunyuan_video.pipeline_hunyuan_video.HunyuanVideoPipeline.encode_prompt
+def encode_prompt(
+    tokenizer,
+    text_encoder,
+    tokenizer_2,
+    text_encoder_2,
+    prompt: Union[str, List[str]],
+    prompt_2: Union[str, List[str]] = None,
+    prompt_template: Dict[str, Any] = DEFAULT_PROMPT_TEMPLATE,
+    num_videos_per_prompt: int = 1,
+    prompt_embeds: Optional[torch.Tensor] = None,
+    pooled_prompt_embeds: Optional[torch.Tensor] = None,
+    prompt_attention_mask: Optional[torch.Tensor] = None,
+    device: Optional[torch.device] = None,
+    dtype: Optional[torch.dtype] = None,
+    max_sequence_length: int = 256,
+):
+    if prompt_embeds is None:
+        prompt_embeds, prompt_attention_mask = _get_llama_prompt_embeds(
+            tokenizer,
+            text_encoder,
+            prompt,
+            prompt_template,
+            num_videos_per_prompt,
+            device=device,
+            dtype=dtype,
+            max_sequence_length=max_sequence_length,
+        )
+
+    if pooled_prompt_embeds is None:
+        if prompt_2 is None:
+            prompt_2 = prompt
+        pooled_prompt_embeds = _get_clip_prompt_embeds(
+            tokenizer_2,
+            text_encoder_2,
+            prompt,
+            num_videos_per_prompt,
+            device=device,
+            dtype=dtype,
+            max_sequence_length=77,
+        )
+
+    return prompt_embeds, pooled_prompt_embeds, prompt_attention_mask
+
+
+def encode_image(
+    feature_extractor,
+    image_encoder,
+    image: torch.Tensor,
+    device: Optional[torch.device] = None,
+    dtype: Optional[torch.dtype] = None,
+):
+    device = device
+    image = (image + 1) / 2.0  # [-1, 1] -> [0, 1]
+    image = feature_extractor(images=image, return_tensors="pt", do_rescale=False).to(
+        device=device, dtype=image_encoder.dtype
+    )
+    image_embeds = image_encoder(**image).last_hidden_state
+    return image_embeds.to(dtype=dtype)
+
+
+def get_framepack_input_t2v(
+    vae,
+    pixel_values,  # [-1, 1], (B, C, F, H, W)
+    latent_window_size: int = 9,
+    vanilla_sampling: bool = False,
+    dtype: Optional[torch.dtype] = None,
+    is_keep_x0=False,
+):
+    # calculate latent frame count from original frame count (4n+1)
+    latent_f = (pixel_values.shape[2] - 1) // 4 + 1
+    # assert latent_f % latent_window_size == 0
+
+    # calculate the total number of sections (excluding the first frame, divided by window size)
+    total_latent_sections = math.floor(latent_f / latent_window_size)  # 2.0
+    if total_latent_sections < 1:
+        min_frames_needed = latent_window_size * 4 + 1
+        raise ValueError(
+            f"Not enough frames for FramePack: {pixel_values.shape[2]} frames ({latent_f} latent frames), minimum required: {min_frames_needed} frames ({latent_window_size + 1} latent frames)"
+        )
+
+    # actual latent frame count (aligned to section boundaries)
+    latent_f_aligned = total_latent_sections * latent_window_size
+
+    # actual video frame count
+    frame_count_aligned = (latent_f_aligned - 1) * 4 + 1  # 73
+    if frame_count_aligned != pixel_values.shape[2]:  # 73 != 89
+        print(
+            f"Frame count mismatch: required={frame_count_aligned} != actual={pixel_values.shape[2]}, trimming to {frame_count_aligned}"
+        )
+        pixel_values = pixel_values[
+            :, :, :frame_count_aligned, :, :
+        ]  # torch.Size([1, 3, 89, 480, 832]) -> torch.Size([1, 3, 73, 480, 832])
+
+    latent_f = latent_f_aligned  # Update to the aligned value
+
+    # VAE encode
+    pixel_values = pixel_values.to(device=vae.device, dtype=vae.dtype)
+    latents = vae.encode(pixel_values).latent_dist.sample()
+    latents = latents * vae.config.scaling_factor
+    latents = latents.to(dtype=dtype)
+
+    all_target_latents = []
+    all_target_latent_indices = []
+    all_clean_latents = []
+    all_clean_latent_indices = []
+    all_clean_latents_2x = []
+    all_clean_latent_2x_indices = []
+    all_clean_latents_4x = []
+    all_clean_latent_4x_indices = []
+    section_to_video_idx = []
+
+    if vanilla_sampling:
+        # Vanilla Sampling Logic
+        if is_keep_x0:
+            for b in range(latents.shape[0]):
+                video_lat = latents[b : b + 1]  # Keep batch dim: 1, C, F_aligned, H, W
+
+                for section_index in range(total_latent_sections):
+                    target_start_f = section_index * latent_window_size
+                    target_end_f = target_start_f + latent_window_size
+                    start_latent = video_lat[:, :, 0:1, :, :]
+                    target_latents = video_lat[:, :, target_start_f:target_end_f, :, :]
+
+                    # Clean latents preparation (Vanilla)
+                    if section_index == 0:
+                        clean_latents_total_count = 2 + 2 + 16
+                    else:
+                        clean_latents_total_count = 1 + 2 + 16
+                    history_latents = torch.zeros(
+                        size=(
+                            1,
+                            16,
+                            clean_latents_total_count,
+                            video_lat.shape[-2],
+                            video_lat.shape[-1],
+                        ),
+                        device=video_lat.device,
+                        dtype=video_lat.dtype,
+                    )
+
+                    history_start_f = 0
+                    video_start_f = target_start_f - clean_latents_total_count
+                    copy_count = clean_latents_total_count
+
+                    if video_start_f < 0:
+                        history_start_f = -video_start_f
+                        copy_count = clean_latents_total_count - history_start_f
+                        video_start_f = 0
+                    if copy_count > 0:
+                        history_latents[:, :, history_start_f:] = video_lat[
+                            :, :, video_start_f : video_start_f + copy_count, :, :
+                        ]
+
+                    # indices generation (Vanilla): copy from FramePack-F1
+                    if section_index == 0:
+                        indices = torch.arange(0, sum([16, 2, 2, latent_window_size])).unsqueeze(0)
+                        (
+                            clean_latent_4x_indices,
+                            clean_latent_2x_indices,
+                            clean_latent_indices,
+                            latent_indices,
+                        ) = indices.split([16, 2, 2, latent_window_size], dim=1)
+                        clean_latents_4x, clean_latents_2x, clean_latents = history_latents.split([16, 2, 2], dim=2)
+                    else:
+                        indices = torch.arange(0, sum([1, 16, 2, 1, latent_window_size])).unsqueeze(0)
+                        (
+                            clean_latent_indices_start,
+                            clean_latent_4x_indices,
+                            clean_latent_2x_indices,
+                            clean_latent_1x_indices,
+                            latent_indices,
+                        ) = indices.split([1, 16, 2, 1, latent_window_size], dim=1)
+                        clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
+
+                        clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents.split([16, 2, 1], dim=2)
+                        clean_latents = torch.cat([start_latent, clean_latents_1x], dim=2)
+
+                    all_target_latents.append(target_latents)
+                    all_target_latent_indices.append(latent_indices)
+                    all_clean_latents.append(clean_latents)
+                    all_clean_latent_indices.append(clean_latent_indices)
+                    all_clean_latents_2x.append(clean_latents_2x)
+                    all_clean_latent_2x_indices.append(clean_latent_2x_indices)
+                    all_clean_latents_4x.append(clean_latents_4x)
+                    all_clean_latent_4x_indices.append(clean_latent_4x_indices)
+                    section_to_video_idx.append(b)
+        else:
+            for b in range(latents.shape[0]):
+                video_lat = latents[b : b + 1]  # Keep batch dim: 1, C, F_aligned, H, W
+
+                for section_index in range(total_latent_sections):
+                    target_start_f = section_index * latent_window_size
+                    target_end_f = target_start_f + latent_window_size
+                    target_latents = video_lat[:, :, target_start_f:target_end_f, :, :]
+
+                    # Clean latents preparation (Vanilla)
+                    clean_latents_total_count = 2 + 2 + 16
+                    history_latents = torch.zeros(
+                        size=(
+                            1,
+                            16,
+                            clean_latents_total_count,
+                            video_lat.shape[-2],
+                            video_lat.shape[-1],
+                        ),
+                        device=video_lat.device,
+                        dtype=video_lat.dtype,
+                    )
+
+                    history_start_f = 0
+                    video_start_f = target_start_f - clean_latents_total_count
+                    copy_count = clean_latents_total_count
+
+                    if video_start_f < 0:
+                        history_start_f = -video_start_f
+                        copy_count = clean_latents_total_count - history_start_f
+                        video_start_f = 0
+                    if copy_count > 0:
+                        history_latents[:, :, history_start_f:] = video_lat[
+                            :, :, video_start_f : video_start_f + copy_count, :, :
+                        ]
+
+                    # indices generation (Vanilla): copy from FramePack-F1
+                    indices = torch.arange(0, sum([16, 2, 2, latent_window_size])).unsqueeze(0)
+                    (
+                        clean_latent_4x_indices,
+                        clean_latent_2x_indices,
+                        clean_latent_indices,
+                        latent_indices,
+                    ) = indices.split([16, 2, 2, latent_window_size], dim=1)
+                    clean_latents_4x, clean_latents_2x, clean_latents = history_latents.split([16, 2, 2], dim=2)
+
+                    all_target_latents.append(target_latents)
+                    all_target_latent_indices.append(latent_indices)
+                    all_clean_latents.append(clean_latents)
+                    all_clean_latent_indices.append(clean_latent_indices)
+                    all_clean_latents_2x.append(clean_latents_2x)
+                    all_clean_latent_2x_indices.append(clean_latent_2x_indices)
+                    all_clean_latents_4x.append(clean_latents_4x)
+                    all_clean_latent_4x_indices.append(clean_latent_4x_indices)
+                    section_to_video_idx.append(b)
+    else:
+        pass
+
+    # Stack all sections into batches
+    batched_target_latents = torch.cat(all_target_latents, dim=0)
+    batched_target_latent_indices = torch.cat(all_target_latent_indices, dim=0)
+    batched_clean_latents = torch.cat(all_clean_latents, dim=0)
+    batched_clean_latent_indices = torch.cat(all_clean_latent_indices, dim=0)
+    batched_clean_latents_2x = torch.cat(all_clean_latents_2x, dim=0)
+    batched_clean_latent_2x_indices = torch.cat(all_clean_latent_2x_indices, dim=0)
+    batched_clean_latents_4x = torch.cat(all_clean_latents_4x, dim=0)
+    batched_clean_latent_4x_indices = torch.cat(all_clean_latent_4x_indices, dim=0)
+
+    return (
+        batched_target_latents,
+        batched_target_latent_indices,
+        batched_clean_latents,
+        batched_clean_latent_indices,
+        batched_clean_latents_2x,
+        batched_clean_latent_2x_indices,
+        batched_clean_latents_4x,
+        batched_clean_latent_4x_indices,
+        section_to_video_idx,
+    )
+
+
+def get_framepack_input_i2v(
+    vae,
+    pixel_values,  # [-1, 1], (B, C, F, H, W)
+    latent_window_size: int = 9,
+    vanilla_sampling: bool = False,
+    dtype: Optional[torch.dtype] = None,
+):
+    # calculate latent frame count from original frame count (4n+1)
+    latent_f = (pixel_values.shape[2] - 1) // 4 + 1
+
+    # calculate the total number of sections (excluding the first frame, divided by window size)
+    total_latent_sections = math.floor((latent_f - 1) / latent_window_size)  # 2.0
+    if total_latent_sections < 1:
+        min_frames_needed = latent_window_size * 4 + 1
+        raise ValueError(
+            f"Not enough frames for FramePack: {pixel_values.shape[2]} frames ({latent_f} latent frames), minimum required: {min_frames_needed} frames ({latent_window_size + 1} latent frames)"
+        )
+
+    # actual latent frame count (aligned to section boundaries)
+    latent_f_aligned = total_latent_sections * latent_window_size + 1
+
+    # actual video frame count
+    frame_count_aligned = (latent_f_aligned - 1) * 4 + 1  # 73
+    if frame_count_aligned != pixel_values.shape[2]:  # 73 != 89
+        print(
+            f"Frame count mismatch: required={frame_count_aligned} != actual={pixel_values.shape[2]}, trimming to {frame_count_aligned}"
+        )
+        pixel_values = pixel_values[
+            :, :, :frame_count_aligned, :, :
+        ]  # torch.Size([1, 3, 89, 480, 832]) -> torch.Size([1, 3, 73, 480, 832])
+
+    latent_f = latent_f_aligned  # Update to the aligned value
+
+    # VAE encode
+    pixel_values = pixel_values.to(device=vae.device, dtype=vae.dtype)
+    latents = vae.encode(pixel_values).latent_dist.sample()
+    latents = latents * vae.config.scaling_factor
+    latents = latents.to(dtype=dtype)
+
+    all_target_latents = []
+    all_target_latent_indices = []
+    all_clean_latents = []
+    all_clean_latent_indices = []
+    all_clean_latents_2x = []
+    all_clean_latent_2x_indices = []
+    all_clean_latents_4x = []
+    all_clean_latent_4x_indices = []
+    section_to_video_idx = []
+
+    if vanilla_sampling:
+        # Vanilla Sampling Logic
+        for b in range(latents.shape[0]):
+            video_lat = latents[b : b + 1]  # Keep batch dim: 1, C, F_aligned, H, W
+
+            for section_index in range(total_latent_sections):
+                target_start_f = section_index * latent_window_size + 1
+                target_end_f = target_start_f + latent_window_size
+                target_latents = video_lat[:, :, target_start_f:target_end_f, :, :]
+                start_latent = video_lat[:, :, 0:1, :, :]
+
+                # Clean latents preparation (Vanilla)
+                clean_latents_total_count = 1 + 2 + 16
+                history_latents = torch.zeros(
+                    size=(
+                        1,
+                        16,
+                        clean_latents_total_count,
+                        video_lat.shape[-2],
+                        video_lat.shape[-1],
+                    ),
+                    device=video_lat.device,
+                    dtype=video_lat.dtype,
+                )
+
+                history_start_f = 0
+                video_start_f = target_start_f - clean_latents_total_count
+                copy_count = clean_latents_total_count
+
+                if video_start_f < 0:
+                    history_start_f = -video_start_f
+                    copy_count = clean_latents_total_count - history_start_f
+                    video_start_f = 0
+                if copy_count > 0:
+                    history_latents[:, :, history_start_f:] = video_lat[
+                        :, :, video_start_f : video_start_f + copy_count, :, :
+                    ]
+
+                # indices generation (Vanilla): copy from FramePack-F1
+                indices = torch.arange(0, sum([1, 16, 2, 1, latent_window_size])).unsqueeze(0)
+                (
+                    clean_latent_indices_start,
+                    clean_latent_4x_indices,
+                    clean_latent_2x_indices,
+                    clean_latent_1x_indices,
+                    latent_indices,
+                ) = indices.split([1, 16, 2, 1, latent_window_size], dim=1)
+                clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
+
+                clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents.split([16, 2, 1], dim=2)
+                clean_latents = torch.cat([start_latent, clean_latents_1x], dim=2)
+
+                all_target_latents.append(target_latents)
+                all_target_latent_indices.append(latent_indices)
+                all_clean_latents.append(clean_latents)
+                all_clean_latent_indices.append(clean_latent_indices)
+                all_clean_latents_2x.append(clean_latents_2x)
+                all_clean_latent_2x_indices.append(clean_latent_2x_indices)
+                all_clean_latents_4x.append(clean_latents_4x)
+                all_clean_latent_4x_indices.append(clean_latent_4x_indices)
+                section_to_video_idx.append(b)
+    else:
+        # padding is reversed for inference (future to past)
+        latent_paddings = list(reversed(range(total_latent_sections)))  # [1, 0]
+        # Note: The padding trick for inference. See the paper for details.
+        if total_latent_sections > 4:
+            latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]
+
+        for b in range(latents.shape[0]):
+            video_lat = latents[
+                b : b + 1
+            ]  # keep batch dim, (1, C, F, H, W)           # torch.Size([1, 16, 19, 60, 104])
+
+            # emulate inference step (history latents)
+            # Note: In inference, history_latents stores *generated* future latents.
+            # Here, for caching, we just need its shape and type for clean_* tensors.
+            # The actual content doesn't matter much as clean_* will be overwritten.
+            history_latents = torch.zeros(
+                (
+                    1,
+                    video_lat.shape[1],
+                    1 + 2 + 16,
+                    video_lat.shape[3],
+                    video_lat.shape[4],
+                ),
+                dtype=video_lat.dtype,
+            ).to(video_lat.device)  # torch.Size([1, 16, 19, 60, 104])
+
+            latent_f_index = latent_f - latent_window_size  # Start from the last section     # 19 - 9 = 10
+            section_index = total_latent_sections - 1  # 2 - 1 = 1
+
+            for latent_padding in latent_paddings:
+                is_last_section = (
+                    section_index == 0
+                )  # the last section in inference order == the first section in time
+                latent_padding_size = latent_padding * latent_window_size
+                if is_last_section:
+                    assert latent_f_index == 1, "Last section should be starting from frame 1"
+
+                # indices generation (same as inference)
+                indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
+                (
+                    clean_latent_indices_pre,  # Index for start_latent
+                    blank_indices,  # Indices for padding (future context in inference)
+                    latent_indices,  # Indices for the target latents to predict
+                    clean_latent_indices_post,  # Index for the most recent history frame
+                    clean_latent_2x_indices,  # Indices for the next 2 history frames
+                    clean_latent_4x_indices,  # Indices for the next 16 history frames
+                ) = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
+
+                # Indices for clean_latents (start + recent history)
+                clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
+
+                # clean latents preparation (emulating inference)
+                clean_latents_pre = video_lat[:, :, 0:1, :, :]  # Always the first frame (start_latent)
+                clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[
+                    :, :, : 1 + 2 + 16, :, :
+                ].split([1, 2, 16], dim=2)
+                clean_latents = torch.cat(
+                    [clean_latents_pre, clean_latents_post], dim=2
+                )  # Combine start frame + placeholder
+
+                # Target latents for this section (ground truth)
+                target_latents = video_lat[:, :, latent_f_index : latent_f_index + latent_window_size, :, :]
+
+                all_target_latents.append(target_latents)
+                all_target_latent_indices.append(latent_indices)
+                all_clean_latents.append(clean_latents)
+                all_clean_latent_indices.append(clean_latent_indices)
+                all_clean_latents_2x.append(clean_latents_2x)
+                all_clean_latent_2x_indices.append(clean_latent_2x_indices)
+                all_clean_latents_4x.append(clean_latents_4x)
+                all_clean_latent_4x_indices.append(clean_latent_4x_indices)
+                section_to_video_idx.append(b)
+
+                if is_last_section:  # If this was the first section generated in inference (time=0)
+                    # History gets the start frame + the generated first section
+                    generated_latents_for_history = video_lat[:, :, : latent_window_size + 1, :, :]
+                else:
+                    # History gets the generated current section
+                    generated_latents_for_history = target_latents  # Use true latents as stand-in for generated
+
+                history_latents = torch.cat([generated_latents_for_history, history_latents], dim=2)
+
+                section_index -= 1
+                latent_f_index -= latent_window_size
+
+    # Stack all sections into batches
+    batched_target_latents = torch.cat(all_target_latents, dim=0)
+    batched_target_latent_indices = torch.cat(all_target_latent_indices, dim=0)
+    batched_clean_latents = torch.cat(all_clean_latents, dim=0)
+    batched_clean_latent_indices = torch.cat(all_clean_latent_indices, dim=0)
+    batched_clean_latents_2x = torch.cat(all_clean_latents_2x, dim=0)
+    batched_clean_latent_2x_indices = torch.cat(all_clean_latent_2x_indices, dim=0)
+    batched_clean_latents_4x = torch.cat(all_clean_latents_4x, dim=0)
+    batched_clean_latent_4x_indices = torch.cat(all_clean_latent_4x_indices, dim=0)
+
+    return (
+        batched_target_latents,
+        batched_target_latent_indices,
+        batched_clean_latents,
+        batched_clean_latent_indices,
+        batched_clean_latents_2x,
+        batched_clean_latent_2x_indices,
+        batched_clean_latents_4x,
+        batched_clean_latent_4x_indices,
+        section_to_video_idx,
+    )
+
+
+def get_pyramid_input(
+    args,
+    scheduler,
+    latents,  # [b c t h w]
+    pyramid_stage_num=3,
+    pyramid_sample_ratios=[1, 2, 1],
+    pyramid_sample_mode="efficient",  # ["efficient", "full", "diffusion_forcing", "stream_sample"]
+    pyramid_stream_inference_steps=[10, 10, 10],
+    stream_chunk_size=5,
+):
+    assert pyramid_stage_num == len(pyramid_sample_ratios)
+    if pyramid_sample_mode not in ["efficient", "full", "diffusion_forcing", "stream_sample"]:
+        raise ValueError(
+            f"Invalid pyramid_sample_mode: {pyramid_sample_mode}. Must be one of ['efficient', 'full', 'diffusion_forcing', 'dance_forcing']."
+        )
+
+    # Get clen pyramid latent list
+    pyramid_latent_list = []
+    pyramid_latent_list.append(latents)
+    num_frames, height, width = latents.shape[-3], latents.shape[-2], latents.shape[-1]
+    for _ in range(pyramid_stage_num - 1):
+        height //= 2
+        width //= 2
+        latents = rearrange(latents, "b c t h w -> (b t) c h w")
+        latents = torch.nn.functional.interpolate(latents, size=(height, width), mode="bilinear")
+        latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames)
+        pyramid_latent_list.append(latents)
+    pyramid_latent_list = list(reversed(pyramid_latent_list))
+
+    # Get pyramid noise list
+    noise = torch.randn_like(pyramid_latent_list[-1])
+    device = noise.device
+    dtype = pyramid_latent_list[-1].dtype
+    latent_frame_num = noise.shape[2]
+    input_video_num = noise.shape[0]
+
+    height, width = noise.shape[-2], noise.shape[-1]
+    noise_list = [noise]
+    cur_noise = noise
+    for i_s in range(pyramid_stage_num - 1):
+        height //= 2
+        width //= 2
+        cur_noise = rearrange(cur_noise, "b c t h w -> (b t) c h w")
+        cur_noise = F.interpolate(cur_noise, size=(height, width), mode="bilinear") * 2
+        cur_noise = rearrange(cur_noise, "(b t) c h w -> b c t h w", t=latent_frame_num)
+        noise_list.append(cur_noise)
+    noise_list = list(reversed(noise_list))  # make sure from low res to high res
+
+    # Get pyramid target list
+    if pyramid_sample_mode == "efficient":
+        assert input_video_num % (int(sum(pyramid_sample_ratios))) == 0
+        # To calculate the padding batchsize and column size
+        bsz = input_video_num // int(sum(pyramid_sample_ratios))
+        column_size = int(sum(pyramid_sample_ratios))
+        column_to_stage = {}
+        i_sum = 0
+        for i_s, column_num in enumerate(pyramid_sample_ratios):
+            for index in range(i_sum, i_sum + column_num):
+                column_to_stage[index] = i_s
+            i_sum += column_num
+
+        # from low resolution to high resolution
+        noisy_latents_list = []
+        sigmas_list = []
+        targets_list = []
+        timesteps_list = []
+        training_steps = scheduler.config.num_train_timesteps
+        for index in range(column_size):
+            i_s = column_to_stage[index]
+            clean_latent = pyramid_latent_list[i_s][index::column_size]  # [bs, c, t, h, w]
+            last_clean_latent = None if i_s == 0 else pyramid_latent_list[i_s - 1][index::column_size]
+            start_sigma = scheduler.start_sigmas[i_s]
+            end_sigma = scheduler.end_sigmas[i_s]
+
+            if i_s == 0:
+                start_point = noise_list[i_s][index::column_size]
+            else:
+                # Get the upsampled latent
+                last_clean_latent = rearrange(last_clean_latent, "b c t h w -> (b t) c h w")
+                last_clean_latent = F.interpolate(
+                    last_clean_latent,
+                    size=(
+                        last_clean_latent.shape[-2] * 2,
+                        last_clean_latent.shape[-1] * 2,
+                    ),
+                    mode="nearest",
+                )
+                last_clean_latent = rearrange(last_clean_latent, "(b t) c h w -> b c t h w", t=latent_frame_num)
+                start_point = start_sigma * noise_list[i_s][index::column_size] + (1 - start_sigma) * last_clean_latent
+
+            if i_s == pyramid_stage_num - 1:
+                end_point = clean_latent
+            else:
+                end_point = end_sigma * noise_list[i_s][index::column_size] + (1 - end_sigma) * clean_latent
+
+            # Sample a random timestep for each image
+            # for weighting schemes where we sample timesteps non-uniformly
+            u = compute_density_for_timestep_sampling(
+                weighting_scheme=get_config_value(args, 'weighting_scheme'),
+                batch_size=bsz,
+                logit_mean=get_config_value(args, 'logit_mean'),
+                logit_std=get_config_value(args, 'logit_std'),
+                mode_scale=get_config_value(args, 'mode_scale'),
+            )
+            indices = (u * training_steps).long()  # Totally 1000 training steps per stage
+            indices = indices.clamp(0, training_steps - 1)
+            timesteps = scheduler.timesteps_per_stage[i_s][indices].to(device=device)
+
+            # Add noise according to flow matching.
+            # zt = (1 - texp) * x + texp * z1
+            sigmas = scheduler.sigmas_per_stage[i_s][indices].to(device=device)
+            while len(sigmas.shape) < start_point.ndim:
+                sigmas = sigmas.unsqueeze(-1)
+
+            noisy_latents = sigmas * start_point + (1 - sigmas) * end_point
+
+            # [stage1_latent, stage2_latent, ..., stagen_latent], which will be concat after patching
+            noisy_latents_list.append([noisy_latents.to(dtype)])
+            sigmas_list.append(sigmas.to(dtype))
+            timesteps_list.append(timesteps.to(dtype))
+            targets_list.append(start_point - end_point)  # The standard rectified flow matching objective
+    elif pyramid_sample_mode == "full":
+        # To calculate the batchsize
+        bsz = input_video_num
+
+        # from low resolution to high resolution
+        noisy_latents_list = []
+        sigmas_list = []
+        targets_list = []
+        timesteps_list = []
+        training_steps = scheduler.config.num_train_timesteps
+        for i_s, cur_sample_ratio in zip(range(pyramid_stage_num), pyramid_sample_ratios):
+            clean_latent = pyramid_latent_list[i_s]  # [bs, c, t, h, w]
+            last_clean_latent = None if i_s == 0 else pyramid_latent_list[i_s - 1]
+            start_sigma = scheduler.start_sigmas[i_s]
+            end_sigma = scheduler.end_sigmas[i_s]
+
+            if i_s == 0:
+                start_point = noise_list[i_s]
+            else:
+                # Get the upsampled latent
+                last_clean_latent = rearrange(last_clean_latent, "b c t h w -> (b t) c h w")
+                last_clean_latent = F.interpolate(
+                    last_clean_latent,
+                    size=(
+                        last_clean_latent.shape[-2] * 2,
+                        last_clean_latent.shape[-1] * 2,
+                    ),
+                    mode="nearest",
+                )
+                last_clean_latent = rearrange(last_clean_latent, "(b t) c h w -> b c t h w", t=latent_frame_num)
+                start_point = start_sigma * noise_list[i_s] + (1 - start_sigma) * last_clean_latent
+
+            if i_s == pyramid_stage_num - 1:
+                end_point = clean_latent
+            else:
+                end_point = end_sigma * noise_list[i_s] + (1 - end_sigma) * clean_latent
+
+            for _ in range(cur_sample_ratio):
+                # Sample a random timestep for each image
+                # for weighting schemes where we sample timesteps non-uniformly
+                u = compute_density_for_timestep_sampling(
+                    weighting_scheme=get_config_value(args, 'weighting_scheme'),
+                    batch_size=bsz,
+                    logit_mean=get_config_value(args, 'logit_mean'),
+                    logit_std=get_config_value(args, 'logit_std'),
+                    mode_scale=get_config_value(args, 'mode_scale'),
+                )
+                indices = (u * training_steps).long()  # Totally 1000 training steps per stage
+                indices = indices.clamp(0, training_steps - 1)
+                timesteps = scheduler.timesteps_per_stage[i_s][indices].to(device=device)
+
+                # Add noise according to flow matching.
+                # zt = (1 - texp) * x + texp * z1
+                sigmas = scheduler.sigmas_per_stage[i_s][indices].to(device=device)
+                while len(sigmas.shape) < start_point.ndim:
+                    sigmas = sigmas.unsqueeze(-1)
+
+                noisy_latents = sigmas * start_point + (1 - sigmas) * end_point
+
+                # [stage1_latent, stage2_latent, ..., stagen_latent]
+                noisy_latents_list.append(noisy_latents.to(dtype))
+                sigmas_list.append(sigmas.to(dtype))
+                timesteps_list.append(timesteps.to(dtype))
+                targets_list.append(start_point - end_point)  # The standard rectified flow matching objective
+    elif pyramid_sample_mode == "diffusion_forcing":
+        # To calculate the batchsize
+        bsz = input_video_num
+        latent_chunk_num = latent_frame_num // stream_chunk_size
+        assert latent_frame_num % stream_chunk_size == 0
+
+        # from low resolution to high resolution
+        noisy_latents_list = []
+        sigmas_list = []
+        targets_list = []
+        timesteps_list = []
+        training_steps = scheduler.config.num_train_timesteps
+        for i_s, cur_sample_ratio in zip(range(pyramid_stage_num), pyramid_sample_ratios):
+            clean_latent = pyramid_latent_list[i_s]  # [bs, c, t, h, w]
+            last_clean_latent = None if i_s == 0 else pyramid_latent_list[i_s - 1]
+            start_sigma = scheduler.start_sigmas[i_s]
+            end_sigma = scheduler.end_sigmas[i_s]
+
+            if i_s == 0:
+                start_point = noise_list[i_s]
+            else:
+                # Get the upsampled latent
+                last_clean_latent = rearrange(last_clean_latent, "b c t h w -> (b t) c h w")
+                last_clean_latent = F.interpolate(
+                    last_clean_latent,
+                    size=(
+                        last_clean_latent.shape[-2] * 2,
+                        last_clean_latent.shape[-1] * 2,
+                    ),
+                    mode="nearest",
+                )
+                last_clean_latent = rearrange(last_clean_latent, "(b t) c h w -> b c t h w", t=latent_frame_num)
+                start_point = start_sigma * noise_list[i_s] + (1 - start_sigma) * last_clean_latent
+
+            if i_s == pyramid_stage_num - 1:
+                end_point = clean_latent
+            else:
+                end_point = end_sigma * noise_list[i_s] + (1 - end_sigma) * clean_latent
+
+            for _ in range(cur_sample_ratio):
+                # Sample a random timestep for each image
+                # for weighting schemes where we sample timesteps non-uniformly
+                u = compute_density_for_timestep_sampling(
+                    weighting_scheme=get_config_value(args, 'weighting_scheme'),
+                    batch_size=bsz * latent_chunk_num,
+                    logit_mean=get_config_value(args, 'logit_mean'),
+                    logit_std=get_config_value(args, 'logit_std'),
+                    mode_scale=get_config_value(args, 'mode_scale'),
+                )
+                indices = (u * training_steps).long()  # Totally 1000 training steps per stage
+                indices = indices.clamp(0, training_steps - 1)
+
+                timesteps = scheduler.timesteps_per_stage[i_s][indices].to(device=device)
+                timesteps = timesteps.view(bsz, latent_chunk_num)  # [bsz, latent_chunk_num]
+                sigmas = scheduler.sigmas_per_stage[i_s][indices].to(device=device)
+                sigmas = sigmas.view(bsz, latent_chunk_num)  # [bsz, latent_chunk_num]
+
+                chunk_index = (
+                    torch.arange(latent_frame_num, device=device).unsqueeze(0).expand(bsz, -1) // stream_chunk_size
+                )
+                chunk_index = chunk_index.clamp(max=latent_chunk_num - 1)
+                sigmas = torch.gather(sigmas, 1, chunk_index)  # [bsz, t]
+                timesteps = torch.gather(timesteps, 1, chunk_index)
+
+                # Add noise according to flow matching.
+                # zt = (1 - texp) * x + texp * z1
+                sigmas = (
+                    sigmas.unsqueeze(1).unsqueeze(-1).unsqueeze(-1)
+                )  # reshape to [bsz, 1, t, 1, 1] for broadcasting
+                noisy_latents = sigmas * start_point + (1 - sigmas) * end_point
+
+                # [stage1_latent, stage2_latent, ..., stagen_latent]
+                noisy_latents_list.append(noisy_latents.to(dtype))  # torch.Size([2, 16, 10, 12, 20])
+                sigmas_list.append(sigmas.to(dtype))  # torch.Size([2, 1, 10, 1, 1])
+                timesteps_list.append(timesteps.to(dtype))  # torch.Size([2, 10])
+                targets_list.append(start_point - end_point)  # The standard rectified flow matching objective
+    elif pyramid_sample_mode == "stream_sample":
+        # training_all_progressive_timesteps
+        # skip 0. (1, max_inference_steps):[1.3850,   44.1200,   86.8550,  129.5900,  172.3250,
+        #                                       215.0600,  257.7950,  300.5300,  343.2650,  386.0000,
+        #                                       386.3580,  426.0960,  465.8340,  505.5720,  545.3100,
+        #                                       585.0480,  624.7860,  664.5240,  704.2620,  744.0000,
+        #                                       744.2560,  772.6720,  801.0880,  829.5040,  857.9200,
+        #                                       886.3360,  914.7520,  943.1680,  971.5840, 1000.0000]
+
+        # progressive_timesteps_stages
+        # stream_chunk_size=3:
+        # [    386.,     386.,     386.,     744.,     744.,     744.,    1000.,    1000.,    1000.]  high, mid, low
+        # [343.2650, 343.2650, 343.2650, 704.2620, 704.2620, 704.2620, 971.5840, 971.5840, 971.5840]  high, mid, low
+        # [300.5300, 300.5300, 300.5300, 664.5240, 664.5240, 664.5240, 943.1680, 943.1680, 943.1680]  high, mid, low
+        # [257.7950, 257.7950, 257.7950, 624.7860, 624.7860, 624.7860, 914.7520, 914.7520, 914.7520]  high, mid, low
+        # [215.0600, 215.0600, 215.0600, 585.0480, 585.0480, 585.0480, 886.3360, 886.3360, 886.3360]  high, mid, low
+        # [172.3250, 172.3250, 172.3250, 545.3100, 545.3100, 545.3100, 857.9200, 857.9200, 857.9200]  high, mid, low
+        # [129.5900, 129.5900, 129.5900, 505.5720, 505.5720, 505.5720, 829.5040, 829.5040, 829.5040]  high, mid, low
+        # [ 86.8550,  86.8550,  86.8550, 465.8340, 465.8340, 465.8340, 801.0880, 801.0880, 801.0880]  high, mid, low
+        # [ 44.1200,  44.1200,  44.1200, 426.0960, 426.0960, 426.0960, 772.6720, 772.6720, 772.6720]  high, mid, low
+        # [  1.3850,   1.3850,   1.3850, 386.3580, 386.3580, 386.3580, 744.2560, 744.2560, 744.2560]  high, mid, low
+
+        # stream_chunk_size=5, shape = (training_num_steps_to_be_saved, latent_frame_num):
+        # [545.3100, 545.3100, 545.3100, 545.3100, 545.3100, 1000.0000, 1000.0000, 1000.0000, 1000.0000, 1000.0000]  mid,  low
+        # [505.5720, 505.5720, 505.5720, 505.5720, 505.5720,  971.5840,  971.5840,  971.5840,  971.5840,  971.5840]  mid,  low
+        # [465.8340, 465.8340, 465.8340, 465.8340, 465.8340,  943.1680,  943.1680,  943.1680,  943.1680,  943.1680]  mid,  low
+        # [426.0960, 426.0960, 426.0960, 426.0960, 426.0960,  914.7520,  914.7520,  914.7520,  914.7520,  914.7520]  mid,  low
+        # [386.3580, 386.3580, 386.3580, 386.3580, 386.3580,  886.3360,  886.3360,  886.3360,  886.3360,  886.3360]  mid,  low
+        # [386.0000, 386.0000, 386.0000, 386.0000, 386.0000,  857.9200,  857.9200,  857.9200,  857.9200,  857.9200]  high, low
+        # [343.2650, 343.2650, 343.2650, 343.2650, 343.2650,  829.5040,  829.5040,  829.5040,  829.5040,  829.5040]  high, low
+        # [300.5300, 300.5300, 300.5300, 300.5300, 300.5300,  801.0880,  801.0880,  801.0880,  801.0880,  801.0880]  high, low
+        # [257.7950, 257.7950, 257.7950, 257.7950, 257.7950,  772.6720,  772.6720,  772.6720,  772.6720,  772.6720]  high, low
+        # [215.0600, 215.0600, 215.0600, 215.0600, 215.0600,  744.2560,  744.2560,  744.2560,  744.2560,  744.2560]  high, low
+        # [172.3250, 172.3250, 172.3250, 172.3250, 172.3250,  744.0000,  744.0000,  744.0000,  744.0000,  744.0000]  high, mid
+        # [129.5900, 129.5900, 129.5900, 129.5900, 129.5900,  704.2620,  704.2620,  704.2620,  704.2620,  704.2620]  high, mid
+        # [ 86.8550,  86.8550,  86.8550,  86.8550,  86.8550,  664.5240,  664.5240,  664.5240,  664.5240,  664.5240]  high, mid
+        # [ 44.1200,  44.1200,  44.1200,  44.1200,  44.1200,  624.7860,  624.7860,  624.7860,  624.7860,  624.7860]  high, mid
+        # [  1.3850,   1.3850,   1.3850,   1.3850,   1.3850,  585.0480,  585.0480,  585.0480,  585.0480,  585.0480]  high, mid
+
+        # To calculate the batchsize
+        bsz = input_video_num
+
+        # Get multi stage timesteps for streamgen
+        (
+            training_num_steps_to_be_saved,
+            training_all_timesteps_stage_ids,
+            training_all_progressive_timesteps,
+            progressive_timesteps_stages,
+        ) = get_stream_sample(
+            scheduler=scheduler,
+            max_latent_frame_num=latent_frame_num,
+            stream_chunk_size=stream_chunk_size,
+            pyramid_stage_num=pyramid_stage_num,
+            pyramid_stream_inference_steps=pyramid_stream_inference_steps,
+        )
+        timestep_to_stage = {
+            float(t.item()): int(stage.item())
+            for t, stage in zip(training_all_progressive_timesteps[0], training_all_timesteps_stage_ids[0])
+        }
+
+        while True:
+            initialization = random.choice([True, False])
+            termination = random.choice([True, False])
+            if not (initialization and termination):  # Make sure not both are True
+                break
+
+        stage_i = random.randint(0, training_num_steps_to_be_saved - 1)
+        timesteps = progressive_timesteps_stages[stage_i].clone().repeat(bsz, 1)  # (b, f)
+        if initialization:  # get the ending timesteps, [999]x5 from [91, 192, ..., 999]x5
+            timesteps = timesteps[:, -latent_frame_num:]
+        elif termination:  # get the starting timesteps, [91]x5 from [91, ..., 999]x5
+            timesteps = timesteps[:, :latent_frame_num]
+
+        # For stage mapping / Get sigmas
+        sigmas, stage_latent_mapping = get_sigmas_from_pyramid_timesteps(scheduler, timesteps, timestep_to_stage)
+
+        # To device
+        timesteps = timesteps.to(device)
+        sigmas = sigmas.to(device)
+
+        # Get pyramid stage points
+        stage_point_list = []
+        for i_s in range(pyramid_stage_num):
+            clean_latent = pyramid_latent_list[i_s]  # [bs, c, t, h, w]
+            last_clean_latent = None if i_s == 0 else pyramid_latent_list[i_s - 1]
+            start_sigma = scheduler.start_sigmas[i_s]
+            end_sigma = scheduler.end_sigmas[i_s]
+
+            if i_s == 0:
+                start_point = noise_list[i_s]
+            else:
+                # Get the upsampled latent
+                last_clean_latent = rearrange(last_clean_latent, "b c t h w -> (b t) c h w")
+                last_clean_latent = F.interpolate(
+                    last_clean_latent,
+                    size=(
+                        last_clean_latent.shape[-2] * 2,
+                        last_clean_latent.shape[-1] * 2,
+                    ),
+                    mode="nearest",
+                )
+                last_clean_latent = rearrange(last_clean_latent, "(b t) c h w -> b c t h w", t=latent_frame_num)
+                start_point = start_sigma * noise_list[i_s] + (1 - start_sigma) * last_clean_latent
+
+            if i_s == pyramid_stage_num - 1:
+                end_point = clean_latent
+            else:
+                end_point = end_sigma * noise_list[i_s] + (1 - end_sigma) * clean_latent
+
+            stage_point_list.append((start_point, end_point))
+
+        noisy_latents_list = []  # torch.Size([2, 16, 10, 12, 20])
+        targets_list = []  # torch.Size([2, 16, 10, 12, 20])
+        sigmas_list = []  # torch.Size([2, 1, 10, 1, 1])
+        timesteps_list = []  # torch.Size([2, 10])
+        temp_noisy_latents_list = []
+        temp_targets_list = []
+
+        unique_elements = list(map(int, torch.unique(stage_latent_mapping)))
+        for cur_stage in reversed(unique_elements):
+            stage_indices = torch.nonzero(stage_latent_mapping == cur_stage, as_tuple=True)
+            start_index = stage_indices[1][0].item()
+            end_index = start_index + stream_chunk_size
+
+            start_point, end_point = stage_point_list[cur_stage]
+            start_point_slice = start_point[:, :, start_index:end_index, :, :]
+            end_point_slice = end_point[:, :, start_index:end_index, :, :]
+
+            sigmas_slice = sigmas[:, :, start_index:end_index, :, :]
+            noisy_latents = sigmas_slice * start_point_slice + (1 - sigmas_slice) * end_point_slice
+            target = start_point_slice - end_point_slice
+
+            temp_noisy_latents_list.append(noisy_latents.to(dtype))
+            temp_targets_list.append(target)
+
+        noisy_latents_list.append(temp_noisy_latents_list)
+        targets_list.append(temp_targets_list)
+        sigmas_list.append(sigmas.to(dtype))
+        timesteps_list.append(timesteps.to(dtype=dtype))
+
+    return noisy_latents_list, sigmas_list, timesteps_list, targets_list
+
+
+def get_sigmas_from_pyramid_timesteps(scheduler, timesteps, timestep_to_stage):
+    # For stage mapping
+    flat_timesteps = timesteps.flatten()
+    stage_latent_mapping = torch.tensor(
+        [timestep_to_stage.get(float(t.item()), -1) for t in flat_timesteps],
+        device=timesteps.device,
+    ).view(timesteps.shape)
+
+    # Get sigmas
+    sigmas = torch.full_like(timesteps, -1.0)
+    for i in range(timesteps.shape[0]):
+        for j in range(timesteps.shape[1]):
+            temp_stage_mapping = int(stage_latent_mapping[i, j])
+            target_value = timesteps[i, j]
+            temp_indice = (
+                (
+                    torch.isclose(
+                        scheduler.timesteps_per_stage[temp_stage_mapping],
+                        target_value.clone().detach().to(scheduler.timesteps_per_stage[temp_stage_mapping].dtype),
+                    )
+                )
+                .nonzero(as_tuple=True)[0]
+                .item()
+            )
+            sigmas[i, j] = scheduler.sigmas_per_stage[temp_stage_mapping][temp_indice]
+    sigmas = sigmas.unsqueeze(1).unsqueeze(-1).unsqueeze(-1)
+
+    return sigmas, stage_latent_mapping
+
+
+def get_stream_sample(
+    scheduler,
+    max_latent_frame_num,
+    stream_chunk_size,
+    pyramid_stage_num=3,
+    pyramid_stream_inference_steps=[10, 10, 10],
+):
+    max_inference_steps = sum(pyramid_stream_inference_steps)
+
+    # Set training all progressive timesteps and stage mapping
+    all_progressive_timesteps_list = []
+    timestep_stage_list = []
+    for stage_idx in range(pyramid_stage_num):
+        scheduler.set_timesteps(pyramid_stream_inference_steps[stage_idx], stage_idx)
+        temp_timesteps = scheduler.timesteps  # shape: (n_i,)
+        all_progressive_timesteps_list.append(temp_timesteps)
+        timestep_stage_list.append(
+            torch.full_like(temp_timesteps, fill_value=stage_idx)
+        )  # same shape, filled with stage_idx
+    all_progressive_timesteps = torch.cat(all_progressive_timesteps_list).unsqueeze(0).flip(1)  # (1, T)
+    all_timesteps_stage_ids = torch.cat(timestep_stage_list).unsqueeze(0).flip(1)
+
+    # Set training progressive timesteps stages
+    # every stream_chunk_size frames is treated as one, using the same noise level. f' = f / c
+    assert max_latent_frame_num % stream_chunk_size == 0, (
+        f"num_frames should be multiple of stream_chunk_size, {max_latent_frame_num} % {stream_chunk_size} != 0"
+    )
+    assert max_inference_steps % (max_latent_frame_num // stream_chunk_size) == 0, (
+        f"max_inference_steps should be multiple of max_latent_frame_num // stream_chunk_size, {max_inference_steps} % {max_latent_frame_num // stream_chunk_size} != 0"
+    )
+    num_steps_to_be_saved = max_inference_steps // (
+        max_latent_frame_num // stream_chunk_size
+    )  # every m steps, save stream_chunk_size frames. m = t / f' = t / (f / c) = c * (t / f)
+
+    # (b, t) -> [(b, t / m) in reverse range(m)] -> [(b, f) in reverse range(m)]
+    progressive_timesteps_stages = [
+        repeat(
+            all_progressive_timesteps[:, (num_steps_to_be_saved - 1) - s :: num_steps_to_be_saved],
+            "b f -> b f c",
+            c=stream_chunk_size,
+        ).flatten(1, 2)
+        for s in range(num_steps_to_be_saved)
+    ]
+
+    return num_steps_to_be_saved, all_timesteps_stage_ids, all_progressive_timesteps, progressive_timesteps_stages
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--weighting_scheme",
+        type=str,
+        default="logit_normal",
+        choices=["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"],
+        help=('We default to the "none" weighting scheme for uniform sampling and uniform loss'),
+    )
+    parser.add_argument(
+        "--logit_mean",
+        type=float,
+        default=0.0,
+        help="mean to use when using the `'logit_normal'` weighting scheme.",
+    )
+    parser.add_argument(
+        "--logit_std",
+        type=float,
+        default=1.0,
+        help="std to use when using the `'logit_normal'` weighting scheme.",
+    )
+    parser.add_argument(
+        "--mode_scale",
+        type=float,
+        default=1.29,
+        help="Scale of mode weighting scheme. Only effective when using the `'mode'` as the `weighting_scheme`.",
+    )
+    args = parser.parse_args()
+
+    device = "cuda"
+
+    import sys
+
+    sys.path.append("../")
+    from scheduler.scheduling_flow_matching_pyramid import PyramidFlowMatchEulerDiscreteScheduler
+
+    stages = [1, 2, 4]
+    timestep_shift = 1.0
+    stage_range = [0, 1 / 3, 2 / 3, 1]
+    scheduler_gamma = 1 / 3
+    scheduler = PyramidFlowMatchEulerDiscreteScheduler(
+        shift=timestep_shift,
+        stages=len(stages),
+        stage_range=stage_range,
+        gamma=scheduler_gamma,
+    )
+    print(
+        f"The start sigmas and end sigmas of each stage is Start: {scheduler.start_sigmas}, End: {scheduler.end_sigmas}, Ori_start: {scheduler.ori_start_sigmas}"
+    )
+
+    # Test get_framepack_input
+    from diffusers import AutoencoderKLHunyuanVideo
+
+    # 5:  (21, 41,  61,  81, 101)
+    # 6:  (25, 49,  73,  97, 121)
+    # 7:  (29, 57,  85, 113, 141)
+    # 8:  (33, 65,  97, 129, 161)
+    # 9:  (37, 73, 109, 145, 181)
+    # 10: (41, 81, 121, 161, 201)
+    # 11: (45, 89, 133, 177, 221)
+    # 12: (49, 97, 145, 193, 241)
+
+    pixel_values = torch.randn([2, 3, 241, 384, 640], device=device).clamp(-1, 1)
+    pixel_values = pixel_values.to(torch.bfloat16)
+    vae = AutoencoderKLHunyuanVideo.from_pretrained(
+        "/mnt/workspace/checkpoints/hunyuanvideo-community/HunyuanVideo/",
+        subfolder="vae",
+        weight_dtype=torch.bfloat16,
+    ).to(device)
+    vae.requires_grad_(False)
+    vae.eval()
+
+    (
+        model_input,  # torch.Size([2, 16, 9, 60, 104])
+        indices_latents,  # torch.Size([2, 9])
+        latents_clean,  # torch.Size([2, 16, 2, 60, 104])
+        indices_clean_latents,  # torch.Size([2, 2])
+        latents_history_2x,  # torch.Size([2, 16, 2, 60, 104])
+        indices_latents_history_2x,  # torch.Size([2, 2])
+        latents_history_4x,  # torch.Size([2, 16, 16, 60, 104])
+        indices_latents_history_4x,  # torch.Size([2, 16])
+        section_to_video_idx,
+    ) = get_framepack_input_i2v(
+        vae=vae,
+        pixel_values=pixel_values,  # torch.Size([1, 3, 73, 480, 832])
+        latent_window_size=12,
+        vanilla_sampling=False,
+        dtype=torch.bfloat16,
+    )
+
+    print(indices_latents, "\n", indices_clean_latents, "\n", indices_latents_history_2x, "\n", indices_latents_history_4x)
+
+    # print(
+    #     indices_latents,
+    #     "\n",
+    #     indices_clean_latents,
+    #     "\n",
+    #     indices_latents_history_2x,
+    #     "\n",
+    #     indices_latents_history_4x,
+    # )
+
+    # Test get_pyramid_input
+    # model_input = torch.randn([2, 16, 10, 48, 80], device=device)
+    # noisy_model_input_list, sigmas_list, timesteps_list, targets_list = get_pyramid_input(
+    #     args=args,
+    #     scheduler=scheduler,
+    #     latents=model_input,
+    #     pyramid_stage_num=3,
+    #     pyramid_sample_ratios=[1, 2, 1],
+    #     pyramid_sample_mode="stream_sample",
+    #     stream_chunk_size=3,
+    #     pyramid_stream_inference_steps=[10, 10, 10],
+    # )
+
+    # if isinstance(noisy_model_input_list[0], list):
+    #     total_sample_count = sum(y.shape[0] for x in noisy_model_input_list for y in x)
+    # else:
+    #     total_sample_count = sum(x.shape[0] for x in noisy_model_input_list)
+    # batch_size = model_input.shape[0]

dataset_code/sekai/preprocess/0.sh

@@ -0,0 +1,53 @@
+# CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+#     --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+#     --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+#     --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+#     --num_workers 8 \
+#     --part 0 \
+#     --total_part 1
+
+# CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+#     --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+#     --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+#     --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+#     --num_workers 8 \
+#     --part 0 \
+#     --total_part 1
+
+
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 0 \
+    --total_part 4 &
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 2 \
+    --total_part 4 &
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 2 \
+    --total_part 4 &
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 3 \
+    --total_part 4
+
+# CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+#     --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+#     --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+#     --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+#     --num_workers 8 \
+#     --part 0 \
+#     --total_part 1

dataset_code/sekai/preprocess/1.sh

@@ -0,0 +1,284 @@
+bash install.sh
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 1 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 1 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+# python get_caption.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 0 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 1 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 2 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 3 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 4 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 5 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 6 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 7 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 0 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 1 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 2 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 3 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 4 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 5 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 6 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 7 \
+    --total_part 32
+
+
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 0 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 1 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 2 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 3 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 4 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 5 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 6 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 7 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 0 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 1 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 2 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 3 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 4 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 5 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 6 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 7 \
+    --total_part 32

dataset_code/sekai/preprocess/2.sh

@@ -0,0 +1,282 @@
+bash install.sh
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 2 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 2 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+# python get_caption.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 8 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 9 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 10 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 11 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 12 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 13 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 14 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 15 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 8 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 9 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 10 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 11 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 12 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 13 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 14 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 15 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 8 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 9 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 10 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 11 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 12 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 13 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 14 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 15 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 8 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 9 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 10 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 11 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 12 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 13 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 14 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 15 \
+    --total_part 32

dataset_code/sekai/preprocess/3.sh

@@ -0,0 +1,282 @@
+bash install.sh
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 3 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 3 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+# python get_caption.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 16 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 17 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 18 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 19 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 20 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 21 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 22 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 23 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 16 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 17 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 18 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 19 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 20 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 21 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 22 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 23 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 16 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 17 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 18 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 19 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 20 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 21 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 22 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 23 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 16 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 17 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 18 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 19 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 20 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 21 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 22 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 23 \
+    --total_part 32

dataset_code/sekai/preprocess/4.sh

@@ -0,0 +1,282 @@
+bash install.sh
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 4 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 4 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+# python get_caption.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 24 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 25 \
+    --total_part 32 &
+sleep 20    
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 26 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 27 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 28 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 29 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 30 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 31 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 24 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 25 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 26 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 27 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 28 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 29 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 30 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 31 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 24 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 25 \
+    --total_part 32 &
+sleep 20    
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 26 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 27 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 28 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 29 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 30 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 31 \
+    --total_part 32
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 24 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 25 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 26 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 27 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 28 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 29 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 30 \
+    --total_part 32 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 31 \
+    --total_part 32

dataset_code/sekai/preprocess/5.sh

@@ -0,0 +1,282 @@
+bash install.sh
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 5 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 5 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+# python get_caption.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 32 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 33 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 34 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 35 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 36 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 37 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 38 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 39 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 32 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 33 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 34 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 35 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 36 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 37 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 38 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 39 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 32 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 33 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 34 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 35 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 36 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 37 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 38 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 39 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 32 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 33 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 34 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 35 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 36 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 37 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 38 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 39 \
+    --total_part 48

dataset_code/sekai/preprocess/6.sh

@@ -0,0 +1,282 @@
+bash install.sh
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 6 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 6 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+# python get_caption.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 40 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 41 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 42 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 43 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 44 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 45 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 46 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-193" \
+    --num_workers 8 \
+    --part 47 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 40 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 41 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 42 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 43 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 44 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 45 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 46 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-193.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-193" \
+    --num_workers 8 \
+    --part 47 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 40 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 41 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 42 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 43 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 44 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 45 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 46 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 47 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 40 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 41 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 42 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 43 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 44 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 45 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 46 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 47 \
+    --total_part 48

dataset_code/sekai/preprocess/add_config.py

@@ -0,0 +1,221 @@
+import pandas as pd
+import cv2
+import os
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from threading import Lock
+import time
+
+class VideoProcessor:
+    def __init__(self, max_workers=4):
+        self.max_workers = max_workers
+        self.progress_lock = Lock()
+        self.processed_count = 0
+        self.total_count = 0
+        
+    def get_video_properties(self, video_path):
+        """
+        获取视频的基本属性：高度、宽度、帧率
+        
+        Args:
+            video_path (str): 视频文件路径
+        
+        Returns:
+            tuple: (height, width, fps) 或 (None, None, None) 如果读取失败
+        """
+        try:
+            # 打开视频文件
+            cap = cv2.VideoCapture(video_path)
+            
+            if not cap.isOpened():
+                return None, None, None
+            
+            # 获取视频属性
+            filename = os.path.splitext(os.path.basename(video_path))[0]
+            parts = filename.split('_')
+            num_frame = int(parts[-1]) - int(parts[-2])
+
+            # num_frame = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            
+            # 释放视频捕获对象
+            cap.release()
+            
+            return num_frame, height, width, fps
+        
+        except Exception as e:
+            print(f"读取视频 {video_path} 时出错: {str(e)}")
+            return None, None, None
+    
+    def process_single_video(self, args):
+        """
+        处理单个视频文件
+        
+        Args:
+            args: (idx, video_file, video_dir)
+        
+        Returns:
+            tuple: (idx, num_frame, height, width, fps, success, message)
+        """
+        idx, video_file, video_dir = args
+        video_path = os.path.join(video_dir, video_file)
+        
+        # 检查视频文件是否存在
+        if not os.path.exists(video_path):
+            message = f"视频文件不存在: {video_path}"
+            return idx, None, None, None, False, message
+        
+        # 获取视频属性
+        num_frame, height, width, fps = self.get_video_properties(video_path)
+        
+        # 更新进度
+        with self.progress_lock:
+            self.processed_count += 1
+            progress = (self.processed_count / self.total_count) * 100
+            
+            if height is not None:
+                message = f"[{self.processed_count}/{self.total_count}] ({progress:.1f}%) {video_file} → {num_frame}, {width}x{height}, {fps:.2f}fps"
+                success = True
+                fps = round(fps, 2)
+            else:
+                message = f"[{self.processed_count}/{self.total_count}] ({progress:.1f}%) {video_file} → 获取信息失败"
+                success = False
+            
+            print(message)
+        
+        return idx, num_frame, height, width, fps, success, message
+    
+    def process_video_csv(self, csv_path, video_dir="./", output_csv_path=None, max_workers=None):
+        """
+        多线程处理CSV文件，添加视频的height、width、fps信息
+        
+        Args:
+            csv_path (str): 输入CSV文件路径
+            video_dir (str): 视频文件所在目录
+            output_csv_path (str): 输出CSV文件路径，如果为None则覆盖原文件
+            max_workers (int): 最大线程数，如果为None则使用初始化时的值
+        """
+        if max_workers is None:
+            max_workers = self.max_workers
+        
+        try:
+            # 读取CSV文件
+            df = pd.read_csv(csv_path)
+            self.total_count = len(df)
+            self.processed_count = 0
+            
+            print(f"成功读取CSV文件，共 {len(df)} 行数据")
+            print(f"使用 {max_workers} 个线程进行处理...")
+            
+            # 初始化新列
+            df['num_frame'] = None
+            df['height'] = None
+            df['width'] = None
+            df['fps'] = None
+            
+            # 准备任务列表
+            tasks = [(idx, row['videoFile'], video_dir) for idx, row in df.iterrows()]
+            
+            # 记录开始时间
+            start_time = time.time()
+            
+            # 使用线程池执行任务
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                # 提交所有任务
+                future_to_task = {executor.submit(self.process_single_video, task): task for task in tasks}
+                
+                # 处理完成的任务
+                for future in as_completed(future_to_task):
+                    idx, num_frame, height, width, fps, success, message = future.result()
+                    
+                    # 更新DataFrame
+                    if success and height is not None:                        
+                        df.at[idx, 'num_frame'] = num_frame
+                        df.at[idx, 'height'] = height
+                        df.at[idx, 'width'] = width
+                        df.at[idx, 'fps'] = fps
+            
+            # 计算处理时间
+            end_time = time.time()
+            processing_time = end_time - start_time
+            
+            # 保存结果
+            if output_csv_path is None:
+                output_csv_path = csv_path
+            
+            df.to_csv(output_csv_path, index=False)
+            
+            # 显示统计信息
+            valid_videos = df['height'].notna().sum()
+            print(f"\n{'='*60}")
+            print(f"处理完成！")
+            print(f"总处理时间: {processing_time:.2f}秒")
+            print(f"平均每个视频: {processing_time/len(df):.2f}秒")
+            print(f"成功处理视频数量: {valid_videos}/{len(df)}")
+            print(f"结果已保存到: {output_csv_path}")
+            print(f"{'='*60}")
+            
+            return df
+        
+        except Exception as e:
+            print(f"处理过程中出错: {str(e)}")
+            return None
+
+# 便捷函数
+def process_video_csv_multithread(csv_path, video_dir="./", output_csv_path=None, max_workers=4):
+    """
+    便捷的多线程视频处理函数
+    
+    Args:
+        csv_path (str): 输入CSV文件路径
+        video_dir (str): 视频文件所在目录
+        output_csv_path (str): 输出CSV文件路径
+        max_workers (int): 最大线程数
+    """
+    processor = VideoProcessor(max_workers=max_workers)
+    return processor.process_video_csv(csv_path, video_dir, output_csv_path, max_workers)
+
+# 使用示例
+if __name__ == "__main__":
+    # 配置参数
+    # base_names = ["sekai-real-walking-hq-193", "sekai-game-walking-193", "sekai-real-walking-hq-386", "sekai-game-walking-386"]
+    # base_names = ["sekai-real-walking-hq-193"]
+    # base_names = ["sekai-game-walking-193"]
+    # base_names = ["sekai-real-walking-hq-386"]
+    base_names = ["sekai-game-walking-386"]
+
+    for base_name in base_names:
+        csv_file_path = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/{base_name}.csv"
+        video_directory = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/{base_name}"
+        output_file_path = f"/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/{base_name}_updated.csv"
+        thread_count = 32
+        
+        # 方法1: 使用便捷函数
+        result_df = process_video_csv_multithread(
+            csv_path=csv_file_path,
+            video_dir=video_directory,
+            output_csv_path=output_file_path,
+            max_workers=thread_count
+        )
+        
+        # 方法2: 使用类的方式（更灵活）
+        """
+        processor = VideoProcessor(max_workers=thread_count)
+        result_df = processor.process_video_csv(
+            csv_path=csv_file_path,
+            video_dir=video_directory,
+            output_csv_path=output_file_path
+        )
+        """
+        
+        # 显示前几行结果
+        if result_df is not None:
+            print("\n处理后的数据预览:")
+            print(result_df[['videoFile', 'num_frame', 'height', 'width', 'fps']].head())
+            
+            # 显示一些统计信息
+            print(f"\n视频分辨率统计:")
+            resolution_stats = result_df.groupby(['width', 'height']).size().reset_index(name='count')
+            print(resolution_stats.head(10))

dataset_code/sekai/preprocess/cut_video.py

@@ -0,0 +1,292 @@
+import argparse
+import subprocess
+import os
+import glob
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+
+def extract_video_info_split(input_file):
+    filename = os.path.splitext(os.path.basename(input_file))[0]
+    parts = filename.split('_')
+    
+    start_frame = int(parts[-2])
+    end_frame = int(parts[-1])
+
+    # video_id = filename.replace(f"_{parts[-1]}", "").replace(f"_{parts[-2]}", "")
+    video_id = filename
+
+    return video_id, start_frame, end_frame
+
+    # if len(parts) == 3:
+        # video_id = parts[0]
+        # start_frame = int(parts[1])
+        # end_frame = int(parts[2])
+        # return video_id, start_frame, end_frame
+    # else:
+    #     raise ValueError(f"文件名格式不匹配，期望3个部分，实际得到{len(parts)}个: {filename}")
+
+def check_segments_exist(video_id, start_frame, total_frames, output_dir, frames_per_segment):
+    """
+    检查该视频的所有片段是否已存在
+    
+    Returns:
+        bool: True表示所有片段都存在，False表示有片段缺失
+        list: 缺失的片段文件名列表
+    """
+    missing_segments = []
+    current_frame = start_frame
+    
+    while current_frame < start_frame + total_frames:
+        segment_end_frame = min(current_frame + frames_per_segment - 1, start_frame + total_frames - 1)
+        output_filename = f"{video_id}_{current_frame:07d}_{(segment_end_frame+1):07d}.mp4"
+        output_file = os.path.join(output_dir, output_filename)
+        
+        if not os.path.exists(output_file):
+            missing_segments.append(output_filename)
+        
+        current_frame = segment_end_frame + 1
+    
+    return len(missing_segments) == 0, missing_segments
+
+def process_single_video(input_file, output_dir, frames_per_segment=386, skip_existing=True):
+    try:
+        video_id, start_frame, original_end_frame = extract_video_info_split(input_file)
+        
+        # 获取帧率
+        result = subprocess.run([
+            'ffprobe', '-v', 'quiet', '-select_streams', 'v:0',
+            '-show_entries', 'stream=r_frame_rate', '-of', 'csv=p=0', input_file
+        ], capture_output=True, text=True)
+        
+        frame_rate_str = result.stdout.strip()
+        if frame_rate_str and '/' in frame_rate_str:
+            frame_rate = eval(frame_rate_str)
+        else:
+            frame_rate = 30.0
+        
+        # 获取总帧数
+        result = subprocess.run([
+            'ffprobe', '-v', 'quiet', '-select_streams', 'v:0',
+            '-show_entries', 'stream=nb_frames', '-of', 'csv=p=0', input_file
+        ], capture_output=True, text=True)
+        
+        total_frames = int(result.stdout.strip())
+        
+        # 检查文件是否已存在
+        if skip_existing:
+            all_exist, missing_segments = check_segments_exist(
+                video_id, start_frame, total_frames, output_dir, frames_per_segment
+            )
+            
+            thread_id = threading.current_thread().name
+            
+            if all_exist:
+                # 计算应该有多少个片段
+                expected_segments = 0
+                current_frame = start_frame
+                while current_frame < start_frame + total_frames:
+                    expected_segments += 1
+                    segment_end_frame = min(current_frame + frames_per_segment - 1, start_frame + total_frames - 1)
+                    current_frame = segment_end_frame + 1
+                
+                print(f"[{thread_id}] 跳过文件: {os.path.basename(input_file)} - 所有{expected_segments}个片段已存在")
+                return True, expected_segments, os.path.basename(input_file), True  # 最后一个参数表示是否跳过
+            else:
+                print(f"[{thread_id}] 处理文件: {os.path.basename(input_file)} - 缺失{len(missing_segments)}个片段")
+        
+        current_frame = start_frame
+        
+        # 使用线程安全的打印
+        thread_id = threading.current_thread().name
+        if not skip_existing or not all_exist:
+            print(f"[{thread_id}] 原视频片段: 第{start_frame}帧 到 第{original_end_frame}帧")
+            print(f"[{thread_id}] 文件总帧数: {total_frames}")
+        
+        segment_index = 0
+        processed_segments = 0
+        
+        while current_frame < start_frame + total_frames:
+            segment_end_frame = min(current_frame + frames_per_segment - 1, start_frame + total_frames - 1)
+            
+            output_filename = f"{video_id}_{current_frame:07d}_{(segment_end_frame + 1):07d}.mp4"
+            output_file = os.path.join(output_dir, output_filename)
+            
+            if skip_existing and os.path.exists(output_file):
+                print(f"[{thread_id}]   跳过片段: {output_filename} (已存在)")
+                pass
+            else:
+                start_time = (current_frame - start_frame) / frame_rate
+                # 修改这里：直接使用帧数计算，确��精确
+                actual_frames = segment_end_frame - current_frame + 1
+                duration = actual_frames / frame_rate
+                
+                # 使用更精确的FFmpeg命令
+                # subprocess.run([
+                #     'ffmpeg', '-ss', str(start_time), '-i', input_file,
+                #     '-frames:v', str(actual_frames),
+                #     '-c:v', 'libx264', '-crf', '0',  # 无损编码
+                #     '-preset', 'ultrafast',  # 快速编码
+                #     '-c:a', 'copy',
+                #     output_file, '-y'
+                # ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                subprocess.run([
+                    'ffmpeg', '-ss', str(start_time), '-i', input_file,
+                    '-t', str(duration),
+                    '-c', 'copy',  # 直接拷贝，不重编码
+                    output_file, '-y'
+                ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                
+                print(f"[{thread_id}]   生成片段: {output_filename} ({actual_frames}帧)")
+                processed_segments += 1
+            
+            current_frame = segment_end_frame + 1
+            segment_index += 1
+        
+        if not skip_existing or not all_exist:
+            if processed_segments > 0:
+                print(f"[{thread_id}] 完成: {os.path.basename(input_file)} - 新生成{processed_segments}个片段")
+            else:
+                print(f"[{thread_id}] 完成: {os.path.basename(input_file)} - 所有片段都已存在")
+        
+        return True, segment_index, os.path.basename(input_file), False
+        
+    except Exception as e:
+        thread_id = threading.current_thread().name
+        print(f"[{thread_id}] 处理文件 {input_file} 时出错: {str(e)}")
+        return False, 0, os.path.basename(input_file), False
+
+def batch_process_videos(input_folder, output_dir, frames_per_segment=386, max_workers=4, 
+                        skip_existing=True, cur_part=None, total_part=None):
+    """
+    多线程批量处理视频
+    
+    Args:
+        input_folder: 输入文件夹路径
+        output_dir: 输出目录
+        frames_per_segment: 每个片段的帧数
+        max_workers: 最大线程数，建议设置为CPU核心数的1-2倍
+        skip_existing: 是否跳过已存在的文件
+        cur_part: 当前处理的部分 (1-based, 从1开始)
+        total_part: 总共分割的部分数
+    """
+    # 创建输出目录
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 查找所有mp4文件
+    video_files = glob.glob(os.path.join(input_folder, "*.mp4"))
+    
+    if not video_files:
+        print(f"在目录 {input_folder} 中未找到mp4文件")
+        return
+    
+    # 对视频文件进行排序，确保分割结果的一致性
+    video_files.sort()
+    
+    # 如果指定了分割参数，则对视频文件列表进行分割
+    if cur_part is not None and total_part is not None:
+        if not (1 <= cur_part <= total_part):
+            raise ValueError(f"cur_part ({cur_part}) 必须在 1 到 {total_part} 之间")
+        
+        total_videos = len(video_files)
+        videos_per_part = total_videos // total_part
+        remainder = total_videos % total_part
+        
+        # 计算当前部分的起始和结束索引
+        if cur_part <= remainder:
+            # 前remainder个部分每个多分配1个文件
+            start_idx = (cur_part - 1) * (videos_per_part + 1)
+            end_idx = start_idx + videos_per_part + 1
+        else:
+            # 后面的部分按标准数量分配
+            start_idx = remainder * (videos_per_part + 1) + (cur_part - remainder - 1) * videos_per_part
+            end_idx = start_idx + videos_per_part
+        
+        video_files = video_files[start_idx:end_idx]
+        
+        print(f"分割处理模式: 第 {cur_part} 部分 / 共 {total_part} 部分")
+        print(f"原始视频总数: {total_videos}")
+        print(f"当前部分处理: {len(video_files)} 个视频 (索引 {start_idx} 到 {end_idx-1})")
+    
+    if not video_files:
+        print("当前部分没有需要处理的视频文件")
+        return
+    
+    print(f"找到 {len(video_files)} 个视频文件")
+    print(f"输出目录: {output_dir}")
+    print(f"使用 {max_workers} 个线程进行处理")
+    print(f"跳过已存在文件: {'是' if skip_existing else '否'}")
+    
+    total_segments = 0
+    success_count = 0
+    skipped_count = 0
+    failed_files = []
+    
+    # 使用ThreadPoolExecutor进行多线程处理
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # 提交所有任务
+        future_to_file = {
+            executor.submit(process_single_video, video_file, output_dir, frames_per_segment, skip_existing): video_file
+            for video_file in video_files
+        }
+        
+        # 使用tqdm显示进度条
+        progress_desc = "处理进度"
+        if cur_part is not None and total_part is not None:
+            progress_desc = f"处理进度 ({cur_part}/{total_part})"
+        
+        with tqdm(total=len(video_files), desc=progress_desc) as pbar:
+            for future in as_completed(future_to_file):
+                video_file = future_to_file[future]
+                try:
+                    success, segments, filename, was_skipped = future.result()
+                    if success:
+                        success_count += 1
+                        total_segments += segments
+                        if was_skipped:
+                            skipped_count += 1
+                    else:
+                        failed_files.append(filename)
+                except Exception as exc:
+                    print(f'视频文件 {video_file} 处理时发生异常: {exc}')
+                    failed_files.append(os.path.basename(video_file))
+                finally:
+                    pbar.update(1)
+    
+    print(f"\n批量处理完成!")
+    if cur_part is not None and total_part is not None:
+        print(f"当前部分 ({cur_part}/{total_part}) 处理结果:")
+    print(f"成功处理: {success_count}/{len(video_files)} 个视频")
+    print(f"跳过文件: {skipped_count} 个视频 (所有片段已存在)")
+    print(f"实际处理: {success_count - skipped_count} 个视频")
+    print(f"总共生成: {total_segments} 个片段")
+    
+    if failed_files:
+        print(f"处理失败的文件: {failed_files}")
+
+def main():
+   parser = argparse.ArgumentParser(description='批量处理视频文件，提取帧并分段保存')
+   
+   parser.add_argument('--input_folder', type=str, default="./", help='输入文件夹路径')
+   parser.add_argument('--output_dir', type=str, default="./dummy_segments_33", help='输出目录路径')
+   parser.add_argument('--frames-per-segment', type=int, default=193, help='每段的帧数')
+   parser.add_argument('--max-workers', type=int, default=8, help='线程数')
+   parser.add_argument('--skip-existing', action='store_true', default=True, help='跳过已存在的文件')
+   parser.add_argument('--no-skip-existing', dest='skip_existing', action='store_false', help='强制重新处理')
+   parser.add_argument('--cur-part', type=int, default=1, help='当前处理的部分')
+   parser.add_argument('--total-part', type=int, default=1, help='总共分成几部分')
+   
+   args = parser.parse_args()
+   
+   batch_process_videos(
+       input_folder=args.input_folder,
+       output_dir=args.output_dir,
+       frames_per_segment=args.frames_per_segment,
+       max_workers=args.max_workers,
+       skip_existing=args.skip_existing,
+       cur_part=args.cur_part,
+       total_part=args.total_part
+   )
+
+if __name__ == "__main__":
+   main()

dataset_code/sekai/preprocess/get_caption.py

@@ -0,0 +1,281 @@
+from vllm import LLM, SamplingParams
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import DataLoader, Dataset
+
+import argparse
+import os
+from typing import Tuple
+
+import qwen_vl_utils
+from qwen_vl_utils import process_vision_info
+from tqdm import tqdm
+from transformers import AutoProcessor
+
+from video_reader import PyVideoReader
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+input_prompt = (
+    "Please generate a comprehensive caption for the following video, describing various aspects, including but not limited to: "
+    "1. The main theme and setting of the image (such as location, time of day, weather conditions, etc.) "
+    "2. Key objects and their characteristics (such as color, shape, size, etc.) "
+    "3. Relationships and interactions between objects (such as positioning, actions, etc.) "
+    "4. Any people present and their emotions or activities (such as expressions, postures, etc.) "
+    "5. Background and environmental details (such as architecture, natural scenery, etc.) "
+    "6. Motion of the Subject: The movement of people or objects in the video. Use verbs that describe movement. "
+    "7. Camera motion control: zoom in, zoom out, push in, pull out, pan right, pan left, truck right, truck left, tilt up, tilt down, pedestal up, pedestal down, arc shot,  tracking shot, static shot, and handheld shot. "
+    'Do not describe imagined content. Only describe what can be determined from the video. Avoid listing things. Do not use abstract concepts (love, hate, justice, infinity, joy) as subjects. Use concrete nouns (human, cup, dog, planet, headphones) for more accurate results. Use verbs to describe the movement and changes of the subject or people. Write your prompts in plain, conversational language. Start your description directly with the main subject, typically a noun. Without "\n", subheading and title. '
+    "For guidance on the expected output format and content length, refer to the provided examples:"
+    "The video begins with the viewer moving forward along a rocky path surrounded by dense greenery under a clear blue sky. The camera smoothly pans to reveal a signpost on the left, indicating a trailhead, before continuing along the uneven terrain dotted with shrubs and small trees. As the journey progresses, the path ascends slightly, leading to a set of wooden steps that navigate through the lush vegetation. The camera angle shifts subtly to capture the ascent, highlighting the natural textures of the rocks and foliage. Upon reaching the top, the scene opens up to a breathtaking view of Castle Rock Beach, with the vast ocean stretching out to the horizon and a prominent rock formation standing tall against the backdrop of the sea. The camera then pans back to the trail, showing more steps and the surrounding forested area, emphasizing the serene and untouched beauty of the location. The sunlight bathes the entire landscape in warm hues, casting sharp shadows and enhancing the vivid greens and earthy tones of the environment. The video concludes with the camera moving steadily along the trail, capturing the intricate details of the natural surroundings and the tranquil atmosphere of this remote coastal setting. "
+    "Attention: #######. Please describe the content of the video and the changes that occur, in chronological order:"
+)
+
+def _read_video_decord_cus(
+    ele: dict,
+) -> Tuple[torch.Tensor, float]:
+    vr = PyVideoReader(ele["video"], threads=0)
+    # crop video
+    # s_x, e_x, s_y, e_y = ele["crop"]
+    # sample video
+    # total_frames = ele["video_end"] - ele["video_start"]
+    # _, video_fps = len(vr), vr.get_avg_fps()
+    total_frames, video_fps = len(vr), vr.get_fps()
+    nframes = 32
+    # nframes = qwen_vl_utils.vision_process.smart_nframes(ele, total_frames=total_frames, video_fps=video_fps)
+    idx = np.linspace(0, total_frames - 1, nframes).round().astype(int).tolist()
+    # idx = [i + ele["video_start"] for i in idx]
+    video = vr.decode()[idx]
+    # video = vr.get_batch(idx).asnumpy()
+    video = torch.tensor(video).permute(0, 3, 1, 2)  # Convert to TCHW format
+    # video = video[:, :, s_y:e_y, s_x:e_x]
+    sample_fps = nframes / max(total_frames, 1e-6) * video_fps
+    vr = None
+    del vr
+    return video, sample_fps
+
+
+qwen_vl_utils.vision_process.VIDEO_READER_BACKENDS = {
+    "decord": _read_video_decord_cus,
+}
+
+
+class CaptionData(Dataset):
+    def __init__(self, video_data, input_video_root, output_json_folder, processor):
+        super().__init__()
+        self.input_video_root = input_video_root
+        self.output_json_folder = output_json_folder
+
+        vid_paths = [i["path"] for i in video_data]
+        video_keys = [i["video_key"] for i in video_data]
+        cameraFiles = [i["cameraFile"] for i in video_data]
+        locations = [i["location"] for i in video_data]
+        scenes = [i["scene"] for i in video_data]
+        crowdDensitys = [i["crowdDensity"] for i in video_data]
+        weathers = [i["weather"] for i in video_data]
+        timeOfDays = [i["timeOfDay"] for i in video_data]
+        save_paths = [
+            os.path.join(output_json_folder, (i["video_key"] + ".csv"))
+            for i in video_data
+        ]
+        print("part x origin num", len(save_paths))
+        self.paths = [
+            [save_path, vid_path, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay]
+            for save_path, vid_path, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay in zip(
+                save_paths, vid_paths, video_keys, cameraFiles, locations, scenes, crowdDensitys, weathers, timeOfDays
+            )
+        ]
+        print("part x need to process num", len(self.paths))
+
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.paths)
+
+    def load_video(self, path, location, scene, crowdDensity, weather, timeOfDay):
+        useful_message = f"here is some auxiliary information about the video, the location is {location}, the scene is {scene}, the crowdDensity is {crowdDensity}, the weather is {weather}, the timeOfDay is {timeOfDay}."
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "video",
+                        "video": path,
+                        # "total_pixels": 20480 * 28 * 28,
+                        "min_pixels": 16 * 28 * 28,
+                        # "max_pixels": 512 * 512,
+                        "fps": 1.0,
+                        # "video_start": cut[0],
+                        # "video_end": cut[1],
+                        # "crop": crop,
+                    },
+                    {"type": "text", "text": input_prompt.replace("#######", useful_message)},
+                ],
+            }
+        ]
+        # Preparation for inference
+        text = self.processor.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        image_inputs, video_inputs = process_vision_info(messages)
+
+        mm_data = {}
+        if image_inputs is not None:
+            mm_data["image"] = image_inputs
+        if video_inputs is not None:
+            mm_data["video"] = video_inputs
+
+        inputs = {
+            "prompt": text,
+            "multi_modal_data": mm_data,
+        }
+
+        return inputs
+
+    def wrapper(self, index):
+        save_path, video_path, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay = self.paths[index]
+        inputs = [self.load_video(video_path, location, scene, crowdDensity, weather, timeOfDay)]
+        return save_path, inputs, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay
+
+    def __getitem__(self, index):
+        try:
+            save_path, inputs, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay = self.wrapper(index)
+            return save_path, inputs, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay
+        except Exception as e:
+            print("error", e)
+            return False, False, False
+
+
+def collate_fn(batch):
+    save_paths, inputs, video_keys, cameraFiles, locations, scenes, crowdDensitys, weathers, timeOfDays = zip(*batch)
+    inputs = inputs[0]
+    if not inputs:
+        return False, False, False, False, False, False, False, False, False
+    return save_paths, inputs, video_keys, cameraFiles, locations, scenes, crowdDensitys, weathers, timeOfDays
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_id_or_path",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Qwen/Qwen2.5-VL-7B-Instruct/",
+    )
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument(
+        "--input_csv",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/test.csv",
+    )
+    parser.add_argument(
+        "--input_video_root", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-193"
+    )
+    parser.add_argument(
+        "--output_csv_path",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/test-193",
+    )
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--part", type=int, default=0)
+    parser.add_argument("--total_part", type=int, default=1)
+    args = parser.parse_args()
+    return args
+
+
+def main(args, llm):
+    assert args.batch_size == 1
+
+    model_id_or_path = args.model_id_or_path
+    processor = AutoProcessor.from_pretrained(model_id_or_path)
+
+    # 读取并预处理
+    df = pd.read_csv(args.input_csv)
+    keep_columns = ['videoFile', 'cameraFile', 'location', 'scene', 'crowdDensity', 'weather', 'timeOfDay']
+    df = df[keep_columns].copy()
+
+    # 批量构建路径和key
+    video_files = df['videoFile'].values
+    paths = np.array([os.path.join(args.input_video_root, f) for f in video_files])
+    video_keys = np.array([os.path.splitext(os.path.basename(f))[0] for f in video_files])
+
+    # 添加新列
+    df['path'] = paths
+    df['video_key'] = video_keys
+
+    # 转换为字典列表
+    video_data = df.to_dict('records')
+    print(f"总共构建了 {len(video_data)} 个视频数据项")
+    if len(video_data) == 0:
+        print("Finish: no data need to be processed!")
+        return
+
+    video_data = video_data[args.part :: args.total_part]
+    data = CaptionData(
+        video_data, args.input_video_root, args.output_csv_path, processor
+    )
+    loader = DataLoader(
+        data,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        pin_memory=False,
+        prefetch_factor=2 if args.num_workers > 0 else None,
+        shuffle=False,
+        drop_last=False,
+        collate_fn=collate_fn,
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.1,
+        top_p=0.001,
+        # top_k=1,
+        repetition_penalty=1.05,
+        max_tokens=512,
+    )
+
+    for save_paths, frames, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay in tqdm(loader):
+        if not save_paths:
+            print(f"{save_paths} is broking")
+            continue
+        if os.path.exists(save_paths[0]):
+            print(f"{save_paths} is already exists")
+            continue
+        if len(save_paths[0]) > 255:
+            print("Name too long, skipping :", save_paths[0])
+            continue
+
+        folder, filename = os.path.split(save_paths[0])
+        os.makedirs(folder, exist_ok=True)
+
+        try:
+            results = []
+            for inputs in frames:
+                with torch.inference_mode():
+                    outputs = llm.generate([inputs], sampling_params=sampling_params)
+                    generated_text = outputs[0].outputs[0].text
+                    results.append(generated_text)
+
+            df = pd.DataFrame({'videoFile': f"{video_key[0]}.mp4", 'cameraFile': cameraFile[0], 'caption': results[0].replace('\n', ' ').replace('\r', ' '), 'location': location[0], 'scene': scene[0], 'crowdDensity': crowdDensity[0], 'weather': weather[0], 'timeOfDay': timeOfDay[0]}, index=[0])
+            output_path = save_paths[0]
+            df.to_csv(f"{output_path}", index=False)
+
+        except Exception as e:
+            print(f"Error processing: {e}")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    # os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+    args = parse_args()
+
+    args.model_id_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Qwen/Qwen2.5-VL-7B-Instruct/"
+    llm = LLM(
+        args.model_id_or_path,
+        # max_model_len=32768 if process_vision_info is None else 4096,
+        # tensor_parallel_size=2,
+        # distributed_executor_backend="mp",
+        gpu_memory_utilization=0.95
+    )
+    main(args, llm)

dataset_code/sekai/preprocess/get_caption_keye.py

@@ -0,0 +1,326 @@
+from vllm import LLM, SamplingParams
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import DataLoader, Dataset
+
+import argparse
+import os
+from typing import Tuple
+
+import keye_vl_utils
+from keye_vl_utils import process_vision_info
+from tqdm import tqdm
+from transformers import AutoProcessor
+
+from video_reader import PyVideoReader
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+input_prompt = (
+    "Please generate a comprehensive caption for the following video, describing various aspects, including but not limited to: "
+    "1. The main theme and setting of the image (such as location, time of day, weather conditions, etc.) "
+    "2. Key objects and their characteristics (such as color, shape, size, etc.) "
+    "3. Relationships and interactions between objects (such as positioning, actions, etc.) "
+    "4. Any people present and their emotions or activities (such as expressions, postures, etc.) "
+    "5. Background and environmental details (such as architecture, natural scenery, etc.) "
+    "6. Motion of the Subject: The movement of people or objects in the video. Use verbs that describe movement. "
+    "7. Camera motion control: zoom in, zoom out, push in, pull out, pan right, pan left, truck right, truck left, tilt up, tilt down, pedestal up, pedestal down, arc shot,  tracking shot, static shot, and handheld shot. "
+    'Do not describe imagined content. Only describe what can be determined from the video. Avoid listing things. Do not use abstract concepts (love, hate, justice, infinity, joy) as subjects. Use concrete nouns (human, cup, dog, planet, headphones) for more accurate results. Use verbs to describe the movement and changes of the subject or people. Write your prompts in plain, conversational language. Start your description directly with the main subject, typically a noun. Without "\n", subheading and title. '
+    "For guidance on the expected output format and content length, refer to the provided examples:"
+    "The video begins with the viewer moving forward along a rocky path surrounded by dense greenery under a clear blue sky. The camera smoothly pans to reveal a signpost on the left, indicating a trailhead, before continuing along the uneven terrain dotted with shrubs and small trees. As the journey progresses, the path ascends slightly, leading to a set of wooden steps that navigate through the lush vegetation. The camera angle shifts subtly to capture the ascent, highlighting the natural textures of the rocks and foliage. Upon reaching the top, the scene opens up to a breathtaking view of Castle Rock Beach, with the vast ocean stretching out to the horizon and a prominent rock formation standing tall against the backdrop of the sea. The camera then pans back to the trail, showing more steps and the surrounding forested area, emphasizing the serene and untouched beauty of the location. The sunlight bathes the entire landscape in warm hues, casting sharp shadows and enhancing the vivid greens and earthy tones of the environment. The video concludes with the camera moving steadily along the trail, capturing the intricate details of the natural surroundings and the tranquil atmosphere of this remote coastal setting. "
+    "Attention: #######. Please describe the content of the video and the changes that occur, in chronological order:"
+)
+
+# def _read_video_decord_cus(
+#     ele: dict,
+# ) -> Tuple[torch.Tensor, float]:
+#     vr = PyVideoReader(ele["video"], threads=0)
+#     # crop video
+#     # s_x, e_x, s_y, e_y = ele["crop"]
+#     # sample video
+#     # total_frames = ele["video_end"] - ele["video_start"]
+#     # _, video_fps = len(vr), vr.get_avg_fps()
+#     total_frames, video_fps = len(vr), vr.get_fps()
+#     nframes = 32
+#     # nframes = keye_vl_utils.vision_process.smart_nframes(ele, total_frames=total_frames, video_fps=video_fps)
+#     idx = np.linspace(0, total_frames - 1, nframes).round().astype(int).tolist()
+#     # idx = [i + ele["video_start"] for i in idx]
+#     video = vr.decode()[idx]
+#     # video = vr.get_batch(idx).asnumpy()
+#     video = torch.tensor(video).permute(0, 3, 1, 2)  # Convert to TCHW format
+#     # video = video[:, :, s_y:e_y, s_x:e_x]
+#     sample_fps = nframes / max(total_frames, 1e-6) * video_fps
+#     vr = None
+#     del vr
+#     return video, sample_fps
+
+def _read_video_decord_cus(
+        ele: dict,
+) -> torch.Tensor:
+    """read video using decord.VideoReader
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    import decord
+    st = time.time()
+    if isinstance(ele["video"], bytes):
+        video_path = ""
+        fp = py_io.BytesIO(ele["video"])
+        vr = decord.VideoReader(fp)
+    else:
+        video_path = ele["video"]
+        vr = decord.VideoReader(video_path)
+    # TODO: support start_pts and end_pts
+    if 'video_start' in ele or 'video_end' in ele:
+        raise NotImplementedError("not support start_pts and end_pts in decord for now.")
+    nframes, video_fps = len(vr), vr.get_avg_fps()
+    # timestamp start from 0.0
+    timestamps = torch.FloatTensor([(1 / video_fps) * i for i in range(nframes)])
+
+    # final_nframes = smart_nframes(ele, total_frames=nframes, video_fps=video_fps)
+    # indices = torch.linspace(0, nframes - 1, final_nframes).round().long()
+
+    final_nframes = 32
+    idx = np.linspace(0, nframes - 1, final_nframes).round().astype(int).tolist()
+
+    frames = vr.get_batch(indices.tolist()).asnumpy()
+    frames = torch.tensor(frames).permute(0, 3, 1, 2)
+    logger.debug(f"Decord: {video_path=}, {nframes=}, {video_fps=}, time={time.time() - st:.3f}s")
+    timestamps = timestamps[indices]
+
+    ##### extract key frames start ######
+    threshold = ele.get("min_frame_similarity", MIN_FRAME_SIMILARITY)
+    frame_types = extract_slow_fast_frames(frames, threshold)
+    ##### extract key frames end ######
+    logger.debug(f"Read video:  {video_path=}, {nframes=}, {video_fps=}, time={time.time() - st:.3f}s")
+
+    return frames, timestamps, frame_types
+
+keye_vl_utils.vision_process.VIDEO_READER_BACKENDS = {
+    "decord": _read_video_decord_cus,
+}
+
+
+class CaptionData(Dataset):
+    def __init__(self, video_data, input_video_root, output_json_folder, processor):
+        super().__init__()
+        self.input_video_root = input_video_root
+        self.output_json_folder = output_json_folder
+
+        vid_paths = [i["path"] for i in video_data]
+        video_keys = [i["video_key"] for i in video_data]
+        cameraFiles = [i["cameraFile"] for i in video_data]
+        locations = [i["location"] for i in video_data]
+        scenes = [i["scene"] for i in video_data]
+        crowdDensitys = [i["crowdDensity"] for i in video_data]
+        weathers = [i["weather"] for i in video_data]
+        timeOfDays = [i["timeOfDay"] for i in video_data]
+        save_paths = [
+            os.path.join(output_json_folder, (i["video_key"] + ".csv"))
+            for i in video_data
+        ]
+        print("part x origin num", len(save_paths))
+        self.paths = [
+            [save_path, vid_path, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay]
+            for save_path, vid_path, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay in zip(
+                save_paths, vid_paths, video_keys, cameraFiles, locations, scenes, crowdDensitys, weathers, timeOfDays
+            )
+        ]
+        print("part x need to process num", len(self.paths))
+
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.paths)
+
+    def load_video(self, path, location, scene, crowdDensity, weather, timeOfDay):
+        useful_message = f"here is some auxiliary information about the video, the location is {location}, the scene is {scene}, the crowdDensity is {crowdDensity}, the weather is {weather}, the timeOfDay is {timeOfDay}."
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "video",
+                        "video": path,
+                        # "total_pixels": 20480 * 28 * 28,
+                        # "min_pixels": 16 * 28 * 28,
+                        # "max_pixels": 512 * 512,
+                        # "fps": 1.0,
+                        # "video_start": cut[0],
+                        # "video_end": cut[1],
+                        # "crop": crop,
+                    },
+                    {"type": "text", "text": input_prompt.replace("#######", useful_message)},
+                ],
+            }
+        ]
+        # Preparation for inference
+        text = self.processor.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        image_inputs, video_inputs, video_kwargs = process_vision_info(messages)
+
+        mm_data = {}
+        if image_inputs is not None:
+            mm_data["image"] = image_inputs
+        if video_inputs is not None:
+            mm_data["video"] = video_inputs
+
+        inputs = {
+            "prompt": text,
+            "multi_modal_data": mm_data,
+            # FPS will be returned in video_kwargs
+            "mm_processor_kwargs": video_kwargs,
+        }
+
+        return inputs
+
+    def wrapper(self, index):
+        save_path, video_path, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay = self.paths[index]
+        inputs = [self.load_video(video_path, location, scene, crowdDensity, weather, timeOfDay)]
+        return save_path, inputs, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay
+
+    def __getitem__(self, index):
+        try:
+            save_path, inputs, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay = self.wrapper(index)
+            return save_path, inputs, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay
+        except Exception as e:
+            print("error", e)
+            return False, False, False
+
+
+def collate_fn(batch):
+    save_paths, inputs, video_keys, cameraFiles, locations, scenes, crowdDensitys, weathers, timeOfDays = zip(*batch)
+    inputs = inputs[0]
+    if not inputs:
+        return False, False, False, False, False, False, False, False, False
+    return save_paths, inputs, video_keys, cameraFiles, locations, scenes, crowdDensitys, weathers, timeOfDays
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_id_or_path",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Qwen/Qwen2.5-VL-7B-Instruct/",
+    )
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument(
+        "--input_csv",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/test.csv",
+    )
+    parser.add_argument(
+        "--input_video_root", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193"
+    )
+    parser.add_argument(
+        "--output_csv_path",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/test-193",
+    )
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--part", type=int, default=0)
+    parser.add_argument("--total_part", type=int, default=1)
+    args = parser.parse_args()
+    return args
+
+
+def main(args, llm, sampling_params):
+    assert args.batch_size == 1
+
+    model_id_or_path = args.model_id_or_path
+    processor = AutoProcessor.from_pretrained(model_id_or_path, trust_remote_code=True)
+
+    # 读取并预处理
+    df = pd.read_csv(args.input_csv)
+    keep_columns = ['videoFile', 'cameraFile', 'location', 'scene', 'crowdDensity', 'weather', 'timeOfDay']
+    df = df[keep_columns].copy()
+
+    # 批量构建路径和key
+    video_files = df['videoFile'].values
+    paths = np.array([os.path.join(args.input_video_root, f) for f in video_files])
+    video_keys = np.array([os.path.splitext(os.path.basename(f))[0] for f in video_files])
+
+    # 添加新列
+    df['path'] = paths
+    df['video_key'] = video_keys
+
+    # 转换为字典列表
+    video_data = df.to_dict('records')
+    print(f"总共构建了 {len(video_data)} 个视频数据项")
+
+    video_data = video_data[args.part :: args.total_part]
+    data = CaptionData(
+        video_data, args.input_video_root, args.output_csv_path, processor
+    )
+    loader = DataLoader(
+        data,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        pin_memory=False,
+        prefetch_factor=2 if args.num_workers > 0 else None,
+        shuffle=False,
+        drop_last=False,
+        collate_fn=collate_fn,
+    )
+
+    for save_paths, frames, video_key, cameraFile, location, scene, crowdDensity, weather, timeOfDay in tqdm(loader):
+        if not save_paths:
+            print(f"{save_paths} is broking")
+            continue
+        if os.path.exists(save_paths[0]):
+            print(f"{save_paths} is already exists")
+            continue
+        if len(save_paths[0]) > 255:
+            print("Name too long, skipping :", save_paths[0])
+            continue
+
+        folder, filename = os.path.split(save_paths[0])
+        os.makedirs(folder, exist_ok=True)
+
+        try:
+            results = []
+            for inputs in frames:
+                with torch.inference_mode():
+                    outputs = llm.generate([inputs], sampling_params=sampling_params)
+                    generated_text = outputs[0].outputs[0].text
+                    results.append(generated_text)
+
+            df = pd.DataFrame({'videoFile': f"{video_key[0]}.mp4", 'cameraFile': cameraFile[0], 'caption': results[0].replace('\n', ' ').replace('\r', ' '), 'location': location[0], 'scene': scene[0], 'crowdDensity': crowdDensity[0], 'weather': weather[0], 'timeOfDay': timeOfDay[0]}, index=[0])
+            output_path = save_paths[0]
+            df.to_csv(f"{output_path}", index=False)
+
+        except Exception as e:
+            print(f"Error processing: {e}")
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    # os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+    args = parse_args()
+
+    args.model_id_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Kwai-Keye/Keye-VL-1_5-8B"
+    llm = LLM(
+        args.model_id_or_path,
+        # max_model_len=32768 if process_vision_info is None else 4096,
+        # tensor_parallel_size=2,
+        # distributed_executor_backend="mp",
+        gpu_memory_utilization=0.95,
+        trust_remote_code=True,
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.3,
+        max_tokens=512,
+    )
+    main(args, llm, sampling_params)

dataset_code/sekai/preprocess/get_temp_input_csv.py

@@ -0,0 +1,173 @@
+import os
+import argparse
+import pandas as pd
+from tqdm import tqdm
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+
+# 添加线程锁保护共享资源
+video_data_lock = threading.Lock()
+matched_count_lock = threading.Lock()
+
+def process_video_file(video_file, args, csv_video_mapping):
+    """处理单个视频文件的函数"""
+    video_path = os.path.join(args.input_video_root, video_file)
+    video_filename = os.path.splitext(video_file)[0]
+    
+    matched_row = None
+    for csv_prefix, row in csv_video_mapping.items():
+        if video_filename.startswith(csv_prefix):
+            matched_row = row
+            break
+
+    result = None
+    if matched_row is not None:
+        final_csv_path = os.path.join(args.output_csv_path, (video_filename + ".csv"))
+        
+        if os.path.exists(final_csv_path):
+            # 检查CSV文件是否损坏
+            try:
+                import pandas as pd
+                # 尝试读取CSV文件来验证其完整性
+                pd.read_csv(final_csv_path)
+                return None  # 文件存在且有效，不需要重新处理
+            except (pd.errors.EmptyDataError, pd.errors.ParserError, UnicodeDecodeError, FileNotFoundError) as e:
+                # CSV文件损坏，删除它
+                print(f"Warning: CSV file {final_csv_path} is corrupted ({e}). Deleting and will recreate.")
+                os.remove(final_csv_path)
+
+        result = {
+            'videoFile': video_filename + ".mp4",
+            'cameraFile': matched_row['cameraFile'],
+            'location': matched_row['location'],  
+            'scene': matched_row['scene'], 
+            'crowdDensity': matched_row['crowdDensity'], 
+            'weather': matched_row['weather'], 
+            'timeOfDay': matched_row['timeOfDay'],
+        }
+    else:
+        print(f"Warning: No CSV record found for video file: {video_file}")
+    
+    return result
+
+# 多线程处理主代码
+def process_videos_multithreaded(video_files, args, csv_video_mapping, max_workers=4):
+    video_data = []
+    matched_count = 0
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # 提交所有任务
+        future_to_video = {
+            executor.submit(process_video_file, video_file, args, csv_video_mapping): video_file 
+            for video_file in video_files
+        }
+        
+        # 处理完成的任务
+        for future in tqdm(as_completed(future_to_video), total=len(video_files), desc="Processing videos"):
+            video_file = future_to_video[future]
+            try:
+                result = future.result()
+                if result is not None:
+                    with video_data_lock:
+                        video_data.append(result)
+                    with matched_count_lock:
+                        matched_count += 1
+            except Exception as exc:
+                print(f'Video {video_file} generated an exception: {exc}')
+    
+    return video_data, matched_count
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--input_csv",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking_updated.csv",
+    )
+    parser.add_argument(
+        "--input_video_root", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386"
+    )
+    parser.add_argument(
+        "--output_csv_path",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386",
+    )
+    parser.add_argument(
+        "--output_csv_file",
+        type=str,
+        default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv",
+    )
+    parser.add_argument("--num_workers", type=int, default=16)
+    args = parser.parse_args()
+    return args
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # 读取CSV文件
+    df = pd.read_csv(args.input_csv)
+
+    # 保留需要的字段，过滤掉不需要的字段
+    keep_columns = ['videoFile', 'cameraFile', 'caption', 'location', 'scene', 'crowdDensity', 'weather', 'timeOfDay']
+    df = df[keep_columns].copy()
+
+    # 创建CSV中视频文件名前缀到记录的映射
+    csv_video_mapping = {}
+    for idx, row in df.iterrows():
+        video_prefix = os.path.splitext(os.path.basename(row['videoFile']))[0]
+        csv_video_mapping[video_prefix] = row
+
+    # 获取视频文件夹中的所有视频文件
+    video_files = []
+    for file in os.listdir(args.input_video_root):
+        if file.lower().endswith(('.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv')):  # 添加更多视频格式
+            video_files.append(file)
+
+    # # 准备视频数据
+    # video_data = []
+    # matched_count = 0
+    
+    # for video_file in tqdm(video_files):
+    #     video_path = os.path.join(args.input_video_root, video_file)
+    #     video_filename = os.path.splitext(video_file)[0]
+        
+    #     matched_row = None
+    #     for csv_prefix, row in csv_video_mapping.items():
+    #         if video_filename.startswith(csv_prefix):
+    #             matched_row = row
+    #             break
+
+    #     if matched_row is not None:
+    #         final_csv_path = os.path.join(args.output_csv_path, (video_filename + ".csv"))
+    #         if not os.path.exists(final_csv_path):
+    #             video_data.append({
+    #                 "video_key": video_filename,
+    #                 'videoFile': video_filename + ".mp4",
+    #                 'cameraFile': matched_row['cameraFile'],
+    #                 'location': matched_row['location'],  
+    #                 'scene': matched_row['scene'], 
+    #                 'crowdDensity': matched_row['crowdDensity'], 
+    #                 'weather': matched_row['weather'], 
+    #                 'timeOfDay': matched_row['timeOfDay'],
+    #             })
+    #             matched_count += 1
+    #     else:
+    #         print(f"Warning: No CSV record found for video file: {video_file}")
+    video_data, matched_count = process_videos_multithreaded(video_files, args, csv_video_mapping, max_workers=args.num_workers)
+    
+    print(f"Successfully matched {matched_count} videos with CSV records")
+    print(f"Total video data to process: {len(video_data)}")
+
+    if video_data:
+        output_df = pd.DataFrame(video_data)
+        output_csv_file = args.output_csv_file
+        output_df.to_csv(output_csv_file, index=False)
+        print(f"Video data saved to: {output_csv_file}")
+        print(f"Saved {len(video_data)} video records")
+    else:
+        output_df = pd.DataFrame()
+        output_csv_file = args.output_csv_file
+        output_df.to_csv(output_csv_file, index=False)
+        print(f"Empty video data saved to: {output_csv_file}")
+        print("No video data to save - created empty CSV file")

dataset_code/sekai/preprocess/install.sh

@@ -0,0 +1,15 @@
+# pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu124
+# pip install flashinfer-python==0.2.2.post1 -i https://flashinfer.ai/whl/cu124/torch2.6
+# pip install vllm==0.8.4 qwen_vl_utils keye_vl_utils opencv-python-headless==4.11.0.86 numpy==1.26.4 video-reader-rs
+# sudo pip install flash-attn==2.7.4.post1 --no-build-isolation
+
+# cp -r /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/flash-attention /opt/tiger
+# cd /opt/tiger/flash-attention/hopper
+# pip install ninja==1.11.1.3
+# sudo python setup.py install
+
+# pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu126
+# pip install flashinfer-python==0.2.2.post1 -i https://flashinfer.ai/whl/cu124/torch2.6
+# pip install qwen_vl_utils keye_vl_utils opencv-python-headless==4.11.0.86 numpy==1.26.4 video-reader-rs
+# pip install flash-attn==2.8.3 --no-build-isolation
+# pip install git+https://github.com/vllm-project/vllm.git

dataset_code/sekai/preprocess/kill.sh

@@ -0,0 +1,8 @@
+pkill -9 -f 1.sh
+pkill -9 -f 2.sh
+pkill -9 -f 3.sh
+pkill -9 -f 4.sh
+pkill -9 -f 5.sh
+pkill -9 -f 6.sh
+pkill -9 -f get_caption.py
+pkill -f "multiprocessing.spawn"

dataset_code/sekai/preprocess/merge_csv.py

@@ -0,0 +1,217 @@
+import pandas as pd
+import os
+import glob
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+import threading
+from functools import partial
+
+def read_single_csv(file_path, expected_columns=None):
+    """
+    读取单个CSV文件的辅助函数
+    
+    Args:
+        file_path (str): CSV文件路径
+        expected_columns (list): 期望的列名列表
+        
+    Returns:
+        tuple: (DataFrame或None, 文件名, 错误信息或None)
+    """
+    try:
+        df = pd.read_csv(file_path)
+        
+        # 检查列是否一致
+        if expected_columns and df.columns.tolist() != expected_columns:
+            return None, os.path.basename(file_path), f"列结构不一致"
+        
+        return df, os.path.basename(file_path), None
+        
+    except Exception as e:
+        return None, os.path.basename(file_path), str(e)
+
+def merge_single_row_csvs(folder_path, output_file='merged_data.csv', max_workers=None):
+    """
+    使用多线程合并文件夹中所有单行CSV文件为一个大的CSV文件
+    
+    Args:
+        folder_path (str): 包含CSV文件的文件夹路径
+        output_file (str): 输出文件名
+        max_workers (int): 最大线程数，默认为None（使用系统默认值）
+    """
+    # 获取文件夹中所有CSV文件
+    csv_files = glob.glob(os.path.join(folder_path, "*.csv"))
+    
+    if not csv_files:
+        print("文件夹中没有找到CSV文件")
+        return
+    
+    print(f"找到 {len(csv_files)} 个CSV文件")
+    
+    # 读取第一个文件获取列名
+    try:
+        first_df = pd.read_csv(csv_files[0])
+        expected_columns = first_df.columns.tolist()
+        print(f"期望的列结构: {expected_columns}")
+    except Exception as e:
+        print(f"无法读取第一个文件: {str(e)}")
+        return
+    
+    # 存储所有数据的列表
+    all_data = []
+    failed_files = []
+    
+    # 创建部分函数，预设expected_columns参数
+    read_csv_partial = partial(read_single_csv, expected_columns=expected_columns)
+    
+    # 使用ThreadPoolExecutor进行多线程处理
+    print("开始多线程读取文件...")
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # 提交所有任务
+        future_to_file = {executor.submit(read_csv_partial, file_path): file_path 
+                         for file_path in csv_files}
+        
+        # 使用tqdm显示进度并收集结果
+        with tqdm(total=len(csv_files), desc="读取CSV文件") as pbar:
+            for future in as_completed(future_to_file):
+                df, filename, error = future.result()
+                
+                if df is not None:
+                    all_data.append(df)
+                else:
+                    failed_files.append((filename, error))
+                
+                pbar.update(1)
+                # 在进度条描述中显示成功/失败统计
+                pbar.set_postfix({
+                    '成功': len(all_data), 
+                    '失败': len(failed_files)
+                })
+    
+    # 显示处理结果
+    print(f"\n处理完成:")
+    print(f"成功读取: {len(all_data)} 个文件")
+    print(f"失败: {len(failed_files)} 个文件")
+    
+    if failed_files:
+        print("\n失败的文件:")
+        for filename, error in failed_files[:10]:  # 只显示前10个错误
+            print(f"  {filename}: {error}")
+        if len(failed_files) > 10:
+            print(f"  ... 还有 {len(failed_files) - 10} 个失败的文件")
+    
+    if not all_data:
+        print("没有成功读取任何数据")
+        return
+    
+    # 合并所有数据
+    print("\n正在合并数据...")
+    with tqdm(desc="合并数据") as pbar:
+        merged_df = pd.concat(all_data, ignore_index=True)
+        pbar.update(1)
+    
+    # 保存合并后的数据
+    print("正在保存文件...")
+    with tqdm(desc="保存文件") as pbar:
+        merged_df.to_csv(output_file, index=False)
+        pbar.update(1)
+    
+    print(f"\n✅ 合并完成！")
+    print(f"共 {len(merged_df)} 行数据已保存到 {output_file}")
+    
+    # 显示数据概览
+    print(f"\n📊 数据概览:")
+    print(f"总行数: {len(merged_df):,}")
+    print(f"总列数: {len(merged_df.columns)}")
+    print(f"文件大小: {os.path.getsize(output_file) / 1024 / 1024:.2f} MB")
+    print(f"列名: {list(merged_df.columns)}")
+    
+    # 显示前几行数据
+    print(f"\n📝 数据预览:")
+    print(merged_df.head())
+
+def merge_with_batch_processing(folder_path, output_file='merged_data.csv', 
+                               batch_size=1000, max_workers=None):
+    """
+    使用批处理的方式合并大量CSV文件，减少内存占用
+    
+    Args:
+        folder_path (str): 包含CSV文件的文件夹路径
+        output_file (str): 输出文件名
+        batch_size (int): 每批处理的文件数量
+        max_workers (int): 最大线程数
+    """
+    csv_files = glob.glob(os.path.join(folder_path, "*.csv"))
+    
+    if not csv_files:
+        print("文件夹中没有找到CSV文件")
+        return
+    
+    print(f"找到 {len(csv_files)} 个CSV文件，将分批处理")
+    
+    # 读取第一个文件获取列名
+    try:
+        first_df = pd.read_csv(csv_files[0])
+        expected_columns = first_df.columns.tolist()
+    except Exception as e:
+        print(f"无法读取第一个文件: {str(e)}")
+        return
+    
+    # 分批处理文件
+    total_rows = 0
+    is_first_batch = True
+    
+    with tqdm(total=len(csv_files), desc="总进度") as main_pbar:
+        for i in range(0, len(csv_files), batch_size):
+            batch_files = csv_files[i:i + batch_size]
+            batch_data = []
+            
+            # 处理当前批次
+            read_csv_partial = partial(read_single_csv, expected_columns=expected_columns)
+            
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                future_to_file = {executor.submit(read_csv_partial, file_path): file_path 
+                                 for file_path in batch_files}
+                
+                for future in as_completed(future_to_file):
+                    df, filename, error = future.result()
+                    if df is not None:
+                        batch_data.append(df)
+                    main_pbar.update(1)
+            
+            # 合并当前批次数据
+            if batch_data:
+                batch_df = pd.concat(batch_data, ignore_index=True)
+                
+                # 保存到文件（追加模式）
+                mode = 'w' if is_first_batch else 'a'
+                header = is_first_batch
+                batch_df.to_csv(output_file, mode=mode, header=header, index=False)
+                
+                total_rows += len(batch_df)
+                is_first_batch = False
+                
+                print(f"\n批次 {i//batch_size + 1} 完成，添加了 {len(batch_df)} 行")
+    
+    print(f"\n✅ 所有批次处理完成！总共 {total_rows} 行数据保存到 {output_file}")
+
+# 使用示例
+if __name__ == "__main__":
+    folder_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386"
+    output_file = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386.csv"
+    
+    # 方法1: 标准多线程合并（推荐用于中等大小的数据集）
+    merge_single_row_csvs(
+        folder_path=folder_path, 
+        output_file=output_file,
+        max_workers=8  # 可以根据你的CPU核心数调整
+    )
+    
+    # 方法2: 批处理合并（推荐用于大型数据集，节省内存）
+    # merge_with_batch_processing(
+    #     folder_path=folder_path,
+    #     output_file=output_file,
+    #     batch_size=1000,
+    #     max_workers=8
+    # )

dataset_code/sekai/preprocess/temp.py

@@ -0,0 +1,25 @@
+import pandas as pd
+import numpy as np
+import os
+
+input_csv = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-193.csv"
+input_video_root = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-193"
+
+# 读取并预处理
+df = pd.read_csv(input_csv)
+keep_columns = ['videoFile', 'cameraFile', 'location', 'scene', 'crowdDensity', 'weather', 'timeOfDay']
+df = df[keep_columns].copy()
+
+# 批量构建路径和key
+video_files = df['videoFile'].values
+paths = np.array([os.path.join(input_video_root, f) for f in video_files])
+video_keys = np.array([os.path.splitext(os.path.basename(f))[0] for f in video_files])
+
+# 添加新列
+df['path'] = paths
+df['video_key'] = video_keys
+
+# 转换为字典列表
+video_data = df.to_dict('records')
+
+import pdb;pdb.set_trace()

dataset_code/sekai/preprocess/temp.sh

@@ -0,0 +1,155 @@
+pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu124
+pip install vllm==0.8.4 qwen_vl_utils
+pip install flashinfer-python==0.2.2.post1 -i https://flashinfer.ai/whl/cu124/torch2.6
+pip install opencv-python-headless==4.11.0.86 numpy==1.26.4 video-reader-rs
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 193 \
+#     --max-workers 32 \
+#     --cur-part 6 \
+#     --total-part 6 \
+
+
+# python cut_video.py \
+#     --input_folder /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq \
+#     --output_dir /mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386 \
+#     --frames-per-segment 386 \
+#     --max-workers 32 \
+#     --cur-part 6 \
+#     --total-part 6 \
+
+export PYTHONMULTIPROCESSING_START_METHOD=fork
+export VLLM_WORKER_MULTIPROC_METHO=spawn
+
+python warm_up_model.py
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 40 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 41 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 42 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 43 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 44 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 45 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 46 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-real-walking-hq-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-walking-hq-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-real-walking-hq-386" \
+    --num_workers 8 \
+    --part 47 \
+    --total_part 48
+
+
+CUDA_VISIBLE_DEVICES=0 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 40 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=1 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 41 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=2 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 42 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=3 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 43 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=4 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 44 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=5 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 45 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=6 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 46 \
+    --total_part 48 &
+sleep 20
+CUDA_VISIBLE_DEVICES=7 python get_caption.py \
+    --input_csv "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/temp_input_csv/sekai-game-walking-386.csv" \
+    --input_video_root "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-game-walking-386" \
+    --output_csv_path "/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/yamls/sekai-game-walking-386" \
+    --num_workers 8 \
+    --part 47 \
+    --total_part 48

dataset_code/sft_sftnews/offload/app.py

@@ -0,0 +1,32 @@
+from dataset_tool import CollectionDataset, collate_fn_map
+from omegaconf import OmegaConf
+from torch.utils.data import DataLoader
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output  # 用于清理历史输出
+
+from torch.utils.data import Subset
+
+configs = OmegaConf.load("512_collection_config_vae1011_aligned_full_dump.yaml")
+dataset = CollectionDataset.create_dataset_function(configs['train_data'],
+                                                        configs['train_data_weights'],
+                                                        **configs['data']['params'])
+
+dataloader = DataLoader(
+    dataset,
+    batch_size=2,
+    num_workers=0,
+    collate_fn=collate_fn_map,
+    pin_memory=True,
+    # prefetch_factor=2,
+    # persistent_workers=True,
+)
+
+print(len(dataloader))
+
+for idx, batch in enumerate(dataloader):
+    print(batch["videos"].shape)

dataset_code/sft_sftnews/offload/example_run.sh

@@ -0,0 +1,153 @@
+set -x
+sudo apt-get update && sudo apt-get install -y libgl1-mesa-glx
+bash ./config/shell_scripts/cogvideo_i2v/train_wan_prepare.sh
+git --no-pager log --decorate=short --pretty=oneline -n5
+
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## WANDB
+#################################################################
+export WANDB__SERVICE_WAIT=6000
+export WANDB_MODE=online
+export WANDB_DISABLE_SERVICE=True
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+# GPUS_PER_NODE=1
+# NNODES=1
+# NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+region=$RUNTIME_IDC_NAME
+if [ $region == 'maliva' ]; then
+    hdfs_prefix=hdfs://harunava/home/byte_icaip_nebudata
+    export ARNOLD_BASE_DIR=hdfs://harunava
+else
+    hdfs_prefix=hdfs://harunasg/home/byte_icaip_nebudata_sg
+    export RUNTIME_IDC_NAME=my2
+    export ARNOLD_BASE_DIR=hdfs://harunasg
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+echo -e "\033[31mPERSISTENCE_PATH: ${hdfs_prefix}\033[0m"
+
+#################################################################
+
+#################################################################
+## Training
+#################################################################
+learning_rate="1e-5"
+lr_schedule="cosine_with_restarts"
+optimizer="adamw"
+steps="2000000"
+version="v0.4"
+DATASET_CONFIG="config/dataset_config/512_collection_config_vae1011_aligned_full_dump.yaml"
+
+CKPT="/mnt/bn/icvg/users/yangxiao.0/Wan-AI/Wan2.1-I2V-14B-720P-patchsize1"
+# CKPT="./models/Wan2.1-I2V-14B-720P"
+output_dir="hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/dali/dit_ckpt/i2v_wan_imageonly_lime_official_rl_1e-5_rm_with_1st_frame_round_4_2fps_rm_0812_color_VQ_MQ_MPS_0_cc_0814"
+#output_dir="hdfs://harunasg/home/byte_icaip_nebudata_sg/fuwen/results/wan"
+logging_dir="/mnt/bn/icvg/users/xinwei.huang/video_refl_new/log"
+#logging_dir="./results/wan"
+#################################################################
+
+#TODO: prefetching
+export WANDB_PROJECT=dc_ae_dit
+export EXP_NAME=refl_2e-5_no_flowmatching_overall_fps6_rm_with_1st_frame_round_3_2fps_0812_RM_color_VQ_MQ_MPS_0_cc_loss
+python3 -m torch.distributed.launch $DISTRIBUTED_ARGS  ./training/train_wan_i2v_dc_ae.py \
+  --dataset_config $DATASET_CONFIG \
+  --frame_buckets 49 \
+  --dataloader_num_workers 1 \
+  --prefetch_factor 2 \
+  --pin_memory \
+  --seed 42 \
+  --mixed_precision bf16 \
+  --output_dir $output_dir \
+  --train_batch_size 1 \
+  --max_train_steps $steps \
+  --checkpointing_steps 50 \
+  --gradient_accumulation_steps 1 \
+  --learning_rate $learning_rate \
+  --lr_scheduler $lr_schedule \
+  --lr_warmup_steps 1 \
+  --lr_num_cycles 1 \
+  --optimizer $optimizer \
+  --beta1 0.9 \
+  --beta2 0.95 \
+  --weight_decay 0.001 \
+  --max_grad_norm 1.0 \
+  --allow_tf32 \
+  --report_to wandb \
+  --nccl_timeout 1800 \
+  --resume_from_checkpoint latest \
+  --wandb_project ${WANDB_PROJECT} \
+  --wandb_name ${EXP_NAME} \
+  --pretrained_model_name_or_path $CKPT \
+  --use_robust_loss \
+  --drop_first_frame_condition_threshold 0.00 \
+  --drop_last_frame_condition_threshold 0.0 \
+  --logging_dir $logging_dir \
+  --video_logging_interval 1000000 \
+  --scalar_logging_interval 1 \
+  --tp_size 8 \
+  --gradient_checkpointing \
+  --ema \
+  --ema_decay 0.99 \
+  --ema_interval 1 \
+  --sampling_steps 30  \
+  --max_turn_step 29 \
+  --min_turn_step 6 \
+  --optimizing_objective "VQ, MQ" \
+  --selected_frames 0 12 24 36 48 60 \
+  --half_input \
+  --use_cfg \
+  --rm_model_path "/mnt/bn/icvg/users/xinwei.huang/VideoAlign/rm_output_0801_first_color" \
+  --transformer_model_path "/mnt/bn/icvg/users/xinwei.huang/video_models/rm0806_round3_mps0.13000.pth/model.pt" \
+  --frame_reward_loss_weight 0

dataset_code/sft_sftnews/offload/install.sh

@@ -0,0 +1,119 @@
+sudo apt update
+sudo apt install -y libavformat-dev libavcodec-dev libavdevice-dev libavutil-dev libavfilter-dev libswscale-dev libswresample-dev gfortran htop screen
+sudo apt-get update
+sudo apt-get install -y build-essential python3-dev python3-setuptools make cmake
+sudo apt-get install -y ffmpeg libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev libssl-dev screen
+
+# install the dependencies
+pip install -r requirements.txt 
+pip install --upgrade diffusers transformers accelerate deepspeed nvitop
+pip install git+https://github.com/huggingface/diffusers
+
+# ## for AIP dataset
+git clone git@code.byted.org:us-cv/mininova.git /tmp/mininova
+pip install /tmp/mininova/py_pkg/byted/nebudata/
+pip install /tmp/mininova/py_pkg/byted/aipcommon/
+
+# for decord
+# git clone -b v0.3 https://github.com/dmlc/dlpack.git
+cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/dlpack
+mkdir build
+cd build
+cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
+make
+sudo make install
+
+cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/dmlc-core
+mkdir build
+cd build
+cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
+make
+sudo make install
+
+cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/decord
+mkdir build
+cd build
+cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
+make
+cd ../python 
+pwd=$PWD 
+echo "PYTHONPATH=$PYTHONPATH:$pwd" >> ~/.bashrc 
+source ~/.bashrc 
+sudo python3 setup.py install --user
+
+# for flash-attn
+pip install flash-attn==2.7.4.post1 --no-build-isolation
+cp -r /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/flash-attention /opt/tiger
+cd /opt/tiger/flash-attention/hopper
+pip install ninja==1.11.1.3
+sudo python setup.py install
+
+# for github
+# git remote set-url origin https://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@github.com/SHYuanBest/fp_train.git
+git config --global user.name SHYuanBest
+git config --global user.email shyuan-cs@hotmail.com
+
+pip uninstall torchao -y
+
+
+# sudo apt update
+# sudo apt install -y libavformat-dev libavcodec-dev libavdevice-dev libavutil-dev libavfilter-dev libswscale-dev libswresample-dev gfortran htop screen
+# sudo apt-get update
+# sudo apt-get install -y build-essential python3-dev python3-setuptools make cmake
+# sudo apt-get install -y ffmpeg libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev libssl-dev screen
+
+# # install the dependencies
+# pip install -r requirements.txt 
+# pip install --upgrade diffusers transformers accelerate deepspeed nvitop
+# pip install git+https://github.com/huggingface/diffusers
+
+# # ## for AIP dataset
+# git clone git@code.byted.org:us-cv/mininova.git /tmp/mininova
+# pip install /tmp/mininova/py_pkg/byted/nebudata/
+# pip install /tmp/mininova/py_pkg/byted/aipcommon/
+
+# # for decord
+# # git clone -b v0.3 https://github.com/dmlc/dlpack.git
+# cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/dlpack
+# mkdir build
+# cd build
+# cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
+# make
+# sudo make install
+
+# cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/dmlc-core
+# mkdir build
+# cd build
+# cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
+# make
+# sudo make install
+
+# cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/decord
+# mkdir build
+# cd build
+# cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
+# make
+# cd ../python 
+# pwd=$PWD 
+# echo "PYTHONPATH=$PYTHONPATH:$pwd" >> ~/.bashrc 
+# source ~/.bashrc 
+# sudo python3 setup.py install --user
+
+# # for flash-attn
+# pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu126
+# pip install flashinfer-python==0.3.1 vllm==0.10.1.1 qwen_vl_utils keye_vl_utils opencv-python-headless==4.11.0.86 numpy==1.26.4 video-reader-rs
+# cd /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/flash-attention-new
+# sudo python setup.py install
+
+# cp -r /mnt/bn/yufan-dev-my/ysh/Codes/dummy_dataloader/decord_temp/flash-attention /opt/tiger
+# cd /opt/tiger/flash-attention/hopper
+# pip install ninja==1.11.1.3
+# sudo python setup.py install
+
+# # for github
+# # git remote set-url origin https://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@github.com/SHYuanBest/fp_train.git
+# git config --global user.name SHYuanBest
+# git config --global user.email shyuan-cs@hotmail.com
+
+# pip uninstall torchao
+# pip uninstall pynvml

dataset_code/sft_sftnews/offload/kill.sh

@@ -0,0 +1,11 @@
+pkill -9 -f run_hv_save_videos.sh
+pkill -9 -f run_hv.sh
+pkill -9 -f run_hv_0.sh
+pkill -9 -f run_hv_1.sh
+pkill -9 -f run_hv_2.sh
+pkill -9 -f run_hv_3.sh
+pkill -9 -f run_hv_4.sh
+pkill -9 -f run_hv_5.sh
+
+pkill -9 -f offoload_features_hv_save_videos.py
+pkill -9 -f offoload_features_hv.py

dataset_code/sft_sftnews/offload/offoload_features_backup.py

@@ -0,0 +1,185 @@
+import os
+from tqdm import tqdm
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import (
+    CLIPTextModel,
+    CLIPTokenizer,
+    LlamaModel,
+    LlamaTokenizerFast,
+    SiglipImageProcessor,
+    SiglipVisionModel,
+)
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video, load_image
+
+from dataset_tool import CollectionDataset, collate_fn_map
+from omegaconf import OmegaConf
+from torch.utils.data import DataLoader
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+import torchvision.transforms as transforms
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output  # 用于清理历史输出
+
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
+
+from utils_framepack import encode_image, encode_prompt
+
+def main(rank, world_size):
+    weight_dtype = torch.bfloat16
+    batch_size = 2
+    dataloader_num_workers = 0
+    output_latent_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents"
+    pretrained_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo"
+    siglip_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl"
+    os.makedirs(output_latent_folder, exist_ok=True)
+
+    device = "cuda"
+
+    # Load the tokenizers
+    tokenizer_one = LlamaTokenizerFast.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer",
+    )
+    tokenizer_two = CLIPTokenizer.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer_2",
+    )
+    feature_extractor = SiglipImageProcessor.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="feature_extractor",
+
+    )
+
+    vae = AutoencoderKLHunyuanVideo.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    vae_scale_factor_spatial = vae.spatial_compression_ratio
+    video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    text_encoder_one = LlamaModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        torch_dtype=weight_dtype,
+    )
+    text_encoder_two = CLIPTextModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder_2",
+        torch_dtype=weight_dtype,
+    )
+    image_encoder = SiglipVisionModel.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="image_encoder",
+        torch_dtype=weight_dtype,
+    )
+
+    vae.requires_grad_(False)
+    text_encoder_one.requires_grad_(False)
+    text_encoder_two.requires_grad_(False)
+    image_encoder.requires_grad_(False)
+    vae.eval()
+    text_encoder_one.eval()
+    text_encoder_two.eval()
+    image_encoder.eval()
+
+    vae = vae.to(device)
+    text_encoder_one = text_encoder_one.to(device)
+    text_encoder_two = text_encoder_two.to(device)
+    image_encoder = image_encoder.to(device)
+
+    configs = OmegaConf.load("512_collection_config_vae1011_aligned_full_dump.yaml")
+    dataset = CollectionDataset.create_dataset_function(configs['train_data'],
+                                                            configs['train_data_weights'],
+                                                            **configs['data']['params'])
+    dataloader = DataLoader(
+        dataset,
+        shuffle=False,
+        batch_size=batch_size,
+        num_workers=dataloader_num_workers,
+        collate_fn=collate_fn_map,
+        pin_memory=True,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        persistent_workers=True if dataloader_num_workers != 0 else False,
+    )
+
+    for idx, batch in tqdm(enumerate(dataloader), total=len(dataloader), desc="Processing batches"):
+        exis_flag = True
+        num_frames = batch["video_metadata"]["num_frames"]
+        for uttid, num_frame in batch["uttid"], num_frames:
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}.pt")
+            if not os.path.exists(output_path):
+                exis_flag = False
+                break
+        if exis_flag:
+            print("skipping!")
+            continue
+
+        with torch.no_grad():
+            # Get Vae feature
+            pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+            vae_latents = vae.encode(pixel_values).latent_dist.sample()
+            vae_latents = vae_latents * vae.config.scaling_factor
+
+            # Encode prompts
+            prompts = batch["prompts"]
+            prompt_embeds, pooled_prompt_embeds, prompt_attention_mask = encode_prompt(
+                tokenizer=tokenizer_one,
+                text_encoder=text_encoder_one,
+                tokenizer_2=tokenizer_two,
+                text_encoder_2=text_encoder_two,
+                prompt=prompts,
+                device=device,
+            )
+
+            # Prepare images
+            image_tensor = batch["first_frames_images"]
+            images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+            image = video_processor.preprocess(image=images, height=batch["videos"].shape[-2], width=batch["videos"].shape[-1])
+            image_embeds = encode_image(
+                feature_extractor,
+                image_encoder,
+                image,
+                device=device,
+                dtype=weight_dtype,
+            )
+
+        for uttid, cur_vae_latent, cur_prompt_embed, cur_pooled_prompt_embed, cur_prompt_attention_mask, cur_image_embed in zip(batch["uttid"], vae_latents, prompt_embeds, pooled_prompt_embeds, prompt_attention_mask, image_embeds):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{pixel_values.shape[2]}.pt")
+            torch.save(
+                {
+                    "vae_latent": cur_vae_latent.cpu().detach(),
+                    "prompt_embed": cur_prompt_embed.cpu().detach(),
+                    "pooled_prompt_embeds": cur_pooled_prompt_embed.cpu().detach(),
+                    "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+                    "image_embeds": cur_image_embed.cpu().detach(),
+                },
+                output_path
+            )
+            print(f"save to: {output_path}")
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    main(world_size=world_size, rank = device)

dataset_code/sft_sftnews/offload/offoload_features_hv.py

@@ -0,0 +1,352 @@
+import json
+import argparse
+import os
+from tqdm import tqdm
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import (
+    CLIPTextModel,
+    CLIPTokenizer,
+    LlamaModel,
+    LlamaTokenizerFast,
+    SiglipImageProcessor,
+    SiglipVisionModel,
+)
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video, load_image
+
+from dataset_tool import CollectionDataset, collate_fn_map
+from omegaconf import OmegaConf
+from torch.utils.data import DataLoader
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.utils.data import Subset
+import torchvision.transforms as transforms
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output  # 用于清理历史输出
+
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
+from diffusers.training_utils import free_memory
+
+from utils_framepack import encode_image, encode_prompt
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+def main(rank, world_size, global_rank, batch_size, dataloader_num_workers, config_path, output_latent_folder, pretrained_model_name_or_path, siglip_model_name_or_path):
+    weight_dtype = torch.bfloat16
+    # batch_size = 2
+    # dataloader_num_workers = 8
+    # config_path = "512_collection_config_vae1011_aligned_full_dump.yaml"
+    # output_latent_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents"
+    # pretrained_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo"
+    # siglip_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl"
+
+    base_folder = output_latent_folder
+    device = rank
+
+    # Load the tokenizers
+    # tokenizer_one = LlamaTokenizerFast.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="tokenizer",
+    # )
+    # tokenizer_two = CLIPTokenizer.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="tokenizer_2",
+    # )
+    # feature_extractor = SiglipImageProcessor.from_pretrained(
+    #     siglip_model_name_or_path,
+    #     subfolder="feature_extractor",
+
+    # )
+
+    # vae = AutoencoderKLHunyuanVideo.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="vae",
+    #     torch_dtype=torch.float32,
+    # )
+    # vae_scale_factor_spatial = vae.spatial_compression_ratio
+    # video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    # text_encoder_one = LlamaModel.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="text_encoder",
+    #     torch_dtype=weight_dtype,
+    # )
+    # text_encoder_two = CLIPTextModel.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="text_encoder_2",
+    #     torch_dtype=weight_dtype,
+    # )
+    # image_encoder = SiglipVisionModel.from_pretrained(
+    #     siglip_model_name_or_path,
+    #     subfolder="image_encoder",
+    #     torch_dtype=weight_dtype,
+    # )
+
+    # vae.requires_grad_(False)
+    # text_encoder_one.requires_grad_(False)
+    # text_encoder_two.requires_grad_(False)
+    # image_encoder.requires_grad_(False)
+    # vae.eval()
+    # text_encoder_one.eval()
+    # text_encoder_two.eval()
+    # image_encoder.eval()
+
+    # vae = vae.to(device)
+    # text_encoder_one = text_encoder_one.to(device)
+    # text_encoder_two = text_encoder_two.to(device)
+    # image_encoder = image_encoder.to(device)
+
+    dist.barrier()
+    configs = OmegaConf.load(config_path)
+    dataset = CollectionDataset.create_dataset_function(configs['train_data'],
+                                                            configs['train_data_weights'],
+                                                            **configs['data']['params'])
+    print(len(dataset))
+
+    sampler = DistributedSampler(dataset, rank=rank, num_replicas=world_size,)
+    dataloader = DataLoader(
+        dataset,
+        shuffle=False,
+        batch_size=batch_size,
+        collate_fn=collate_fn_map,
+        num_workers=dataloader_num_workers,
+        pin_memory=False,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        persistent_workers=False,
+    )
+
+    sampler.set_epoch(0)
+    if global_rank == 0:
+        pbar = tqdm(total=len(dataloader), desc="Processing")
+    dist.barrier()
+    for idx, batch in enumerate(dataloader):
+        dist.barrier()
+        free_memory()
+
+        output_json = {
+            "uttid": batch["uttid"][0],
+            "topk_avg_motion_scores_t": batch["topk_avg_motion_scores_t"].item(),
+        }
+
+        if batch["topk_avg_motion_scores_t"].item() >= 400:
+            base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/new_metadata/high_motion"
+        else:
+            base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/new_metadata/low_motion"
+
+        os.makedirs(base_path, exist_ok=True)
+        
+        output_path = os.path.join(base_path, f"{batch['uttid'][0]}.json")
+
+        if os.path.exists(output_path):
+            print(f"skipping: {output_path}")
+            continue
+
+        with open(output_path, 'w',) as f:
+            json.dump(output_json, f, indent=2)
+        print(f"save json to {output_path}")
+
+        batch = None
+        output_json = None
+        del batch
+        del output_json
+        free_memory()
+
+        # valid_indices = []
+        # valid_uttids = []
+        # valid_num_frames = []
+        # valid_heights = []
+        # valid_widths = []
+        # valid_videos = []
+        # valid_prompts = []
+        # valid_first_frames_images = []
+        # valid_stride_videos = []
+
+        # for i, (uttid, num_frame, height, width, topk_avg_motion_scores_t) in enumerate(zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"], batch["topk_avg_motion_scores_t"])):
+        #     if topk_avg_motion_scores_t != -1:
+        #         output_latent_folder = os.path.join(base_folder, "latents/high_motion")
+        #     else:
+        #         output_latent_folder = os.path.join(base_folder, "latents/low_motion")
+            
+        #     os.makedirs(output_latent_folder, exist_ok=True)
+        #     output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+        #     if not os.path.exists(output_path):
+        #         valid_indices.append(i)
+        #         valid_uttids.append(uttid)
+        #         valid_num_frames.append(num_frame)
+        #         valid_heights.append(height)
+        #         valid_widths.append(width)
+        #         valid_videos.append(batch["videos"][i])
+        #         valid_prompts.append(batch["prompts"][i])
+        #         valid_first_frames_images.append(batch["first_frames_images"][i])
+        #         valid_stride_videos.append(batch["stride_videos"][i])
+        #     else:
+        #         print(f"skipping {uttid}")
+        
+        # if not valid_indices:
+        #     print("skipping entire batch!")
+        #     continue
+        
+        # batch = None
+        # del batch
+        # free_memory()
+
+        # batch = {
+        #     "uttid": valid_uttids,
+        #     "video_metadata": {
+        #         "num_frames": valid_num_frames,
+        #         "height": valid_heights,
+        #         "width": valid_widths
+        #     },
+        #     "videos": torch.stack(valid_videos),
+        #     "prompts": valid_prompts,
+        #     "first_frames_images": torch.stack(valid_first_frames_images),
+        #     "stride_videos": torch.stack(valid_stride_videos),
+        # }
+        
+        # if len(batch["uttid"]) == 0:
+        #     print("All samples in this batch are already processed, skipping!")
+        #     continue
+
+        # with torch.no_grad():
+        #     # Get Vae feature 1
+        #     pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+        #     vae_latents = vae.encode(pixel_values).latent_dist.sample()
+        #     vae_latents = vae_latents * vae.config.scaling_factor
+
+        #     # Get Vae feature 2
+        #     pixel_values_2 = batch["stride_videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+        #     vae_latents_2 = vae.encode(pixel_values_2).latent_dist.sample()
+        #     vae_latents_2 = vae_latents_2 * vae.config.scaling_factor
+
+        #     # Encode prompts
+        #     prompts = batch["prompts"]
+        #     prompt_embeds, pooled_prompt_embeds, prompt_attention_mask = encode_prompt(
+        #         tokenizer=tokenizer_one,
+        #         text_encoder=text_encoder_one,
+        #         tokenizer_2=tokenizer_two,
+        #         text_encoder_2=text_encoder_two,
+        #         prompt=prompts,
+        #         device=device,
+        #     )
+
+        #     # Prepare images
+        #     image_tensor = batch["first_frames_images"]
+        #     images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+        #     image = video_processor.preprocess(image=images, height=batch["videos"].shape[-2], width=batch["videos"].shape[-1])
+        #     image_embeds = encode_image(
+        #         feature_extractor,
+        #         image_encoder,
+        #         image,
+        #         device=device,
+        #         dtype=weight_dtype,
+        #     )
+
+        # for uttid, num_frame, height, width, cur_vae_latent, cur_prompt_embed, cur_pooled_prompt_embed, cur_prompt_attention_mask, cur_image_embed, cur_vae_latents_2 in zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"], vae_latents, prompt_embeds, pooled_prompt_embeds, prompt_attention_mask, image_embeds, vae_latents_2):
+        #     output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+        #     temp_to_save = {
+        #             "vae_latent": cur_vae_latent.cpu().detach(),
+        #             "prompt_embed": cur_prompt_embed.cpu().detach(),
+        #             "pooled_prompt_embeds": cur_pooled_prompt_embed.cpu().detach(),
+        #             "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+        #             "image_embeds": cur_image_embed.cpu().detach(),
+        #             "vae_latents_2": cur_vae_latents_2.cpu().detach(),
+        #         }
+        #     torch.save(
+        #         temp_to_save,
+        #         output_path
+        #     )
+        #     print(f"save latent to: {output_path}")
+        
+        if global_rank == 0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+
+
+        pixel_values = None
+        pixel_values_2 = None
+        prompts = None
+        image_tensor = None
+        images = None
+        vae_latents = None
+        vae_latents_2 = None
+        image_embeds = None
+        prompt_embeds = None
+        pooled_prompt_embeds = None
+        prompt_attention_mask = None
+        batch = None
+        valid_indices = None
+        valid_uttids = None
+        valid_num_frames = None
+        valid_heights = None
+        valid_widths = None
+        valid_videos = None
+        valid_prompts = None
+        valid_first_frames_images = None
+        valid_stride_videos = None
+        temp_to_save = None
+
+        del pixel_values
+        del pixel_values_2
+        del prompts
+        del image_tensor
+        del images
+        del vae_latents
+        del vae_latents_2
+        del image_embeds
+        del batch
+        del valid_indices
+        del valid_uttids
+        del valid_num_frames
+        del valid_heights
+        del valid_widths
+        del valid_videos
+        del valid_prompts
+        del valid_first_frames_images
+        del valid_stride_videos
+        del temp_to_save
+
+        free_memory()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size for processing")
+    parser.add_argument("--dataloader_num_workers", type=int, default=0, help="Number of workers for data loading")
+    parser.add_argument("--config_path", type=str, default="part1.yaml", help="Path to the config file")
+    parser.add_argument("--output_latent_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos", help="Folder to store output latents")
+    parser.add_argument("--pretrained_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo", help="Pretrained model path")
+    parser.add_argument("--siglip_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl", help="Siglip model path")
+    args = parser.parse_args()
+
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    main(
+        world_size=world_size, 
+        rank=device, 
+        global_rank=global_rank,
+        batch_size=args.batch_size,
+        dataloader_num_workers=args.dataloader_num_workers,
+        config_path=args.config_path,
+        output_latent_folder=args.output_latent_folder,
+        pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+        siglip_model_name_or_path=args.siglip_model_name_or_path
+    )

dataset_code/sft_sftnews/offload/offoload_features_hv_save_videos.py

@@ -0,0 +1,255 @@
+import argparse
+import os
+from tqdm import tqdm
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import (
+    CLIPTextModel,
+    CLIPTokenizer,
+    LlamaModel,
+    LlamaTokenizerFast,
+    SiglipImageProcessor,
+    SiglipVisionModel,
+)
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video, load_image
+
+from dataset_tool import CollectionDataset, collate_fn_map
+from omegaconf import OmegaConf
+from torch.utils.data import DataLoader
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.utils.data import Subset
+import torchvision.transforms as transforms
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output  # 用于清理历史输出
+
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
+from diffusers.training_utils import free_memory
+
+from utils_framepack import encode_image, encode_prompt
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+def main(rank, world_size, global_rank, batch_size, dataloader_num_workers, config_path, output_latent_folder, pretrained_model_name_or_path, siglip_model_name_or_path):
+    weight_dtype = torch.bfloat16
+    # batch_size = 2
+    # dataloader_num_workers = 8
+    # config_path = "512_collection_config_vae1011_aligned_full_dump.yaml"
+    # output_latent_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents"
+    # pretrained_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo"
+    # siglip_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl"
+    os.makedirs(output_latent_folder, exist_ok=True)
+
+    device = rank
+
+    # # Load the tokenizers
+    # tokenizer_one = LlamaTokenizerFast.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="tokenizer",
+    # )
+    # tokenizer_two = CLIPTokenizer.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="tokenizer_2",
+    # )
+    # feature_extractor = SiglipImageProcessor.from_pretrained(
+    #     siglip_model_name_or_path,
+    #     subfolder="feature_extractor",
+
+    # )
+
+    # vae = AutoencoderKLHunyuanVideo.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="vae",
+    #     torch_dtype=torch.float32,
+    # )
+    # vae_scale_factor_spatial = vae.spatial_compression_ratio
+    # video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    # text_encoder_one = LlamaModel.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="text_encoder",
+    #     torch_dtype=weight_dtype,
+    # )
+    # text_encoder_two = CLIPTextModel.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="text_encoder_2",
+    #     torch_dtype=weight_dtype,
+    # )
+    # image_encoder = SiglipVisionModel.from_pretrained(
+    #     siglip_model_name_or_path,
+    #     subfolder="image_encoder",
+    #     torch_dtype=weight_dtype,
+    # )
+
+    # vae.requires_grad_(False)
+    # text_encoder_one.requires_grad_(False)
+    # text_encoder_two.requires_grad_(False)
+    # image_encoder.requires_grad_(False)
+    # vae.eval()
+    # text_encoder_one.eval()
+    # text_encoder_two.eval()
+    # image_encoder.eval()
+
+    # vae = vae.to(device)
+    # text_encoder_one = text_encoder_one.to(device)
+    # text_encoder_two = text_encoder_two.to(device)
+    # image_encoder = image_encoder.to(device)
+
+    dist.barrier()
+    configs = OmegaConf.load(config_path)
+    dataset = CollectionDataset.create_dataset_function(configs['train_data'],
+                                                            configs['train_data_weights'],
+                                                            **configs['data']['params'])
+    print(len(dataset))
+
+    sampler = DistributedSampler(dataset, rank=rank, num_replicas=world_size,)
+    dataloader = DataLoader(
+        dataset,
+        shuffle=False,
+        batch_size=batch_size,
+        collate_fn=collate_fn_map,
+        num_workers=dataloader_num_workers,
+        pin_memory=False,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        persistent_workers=False,
+    )
+
+    sampler.set_epoch(0)
+    if global_rank == 0:
+        pbar = tqdm(total=len(dataloader), desc="Processing")
+    dist.barrier()
+    for idx, batch in enumerate(dataloader):
+        valid_indices = []
+        valid_uttids = []
+        valid_num_frames = []
+        valid_heights = []
+        valid_widths = []
+        valid_videos = []
+        valid_prompts = []
+        valid_first_frames_images = []
+        
+        # for i, (uttid, num_frame, height, width) in enumerate(zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"])):
+        #     output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+        #     if not os.path.exists(output_path):
+        #         valid_indices.append(i)
+        #         valid_uttids.append(uttid)
+        #         valid_num_frames.append(num_frame)
+        #         valid_heights.append(height)
+        #         valid_widths.append(width)
+        #         valid_videos.append(batch["videos"][i])
+        #         valid_prompts.append(batch["prompts"][i])
+        #         valid_first_frames_images.append(batch["first_frames_images"][i])
+        #     else:
+        #         print(f"skipping {uttid}")
+        
+        # if not valid_indices:
+        #     print("skipping entire batch!")
+        #     continue
+        
+        # batch = {
+        #     "uttid": valid_uttids,
+        #     "video_metadata": {
+        #         "num_frames": valid_num_frames,
+        #         "height": valid_heights,
+        #         "width": valid_widths
+        #     },
+        #     "videos": torch.stack(valid_videos),
+        #     "prompts": valid_prompts,
+        #     "first_frames_images": torch.stack(valid_first_frames_images)
+        # }
+        
+        # if len(batch["uttid"]) == 0:
+        #     print("All samples in this batch are already processed, skipping!")
+        #     continue
+
+        # with torch.no_grad():
+        #     # Get Vae feature
+        #     pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+        #     vae_latents = vae.encode(pixel_values).latent_dist.sample()
+        #     vae_latents = vae_latents * vae.config.scaling_factor
+
+        #     # Encode prompts
+        #     prompts = batch["prompts"]
+        #     prompt_embeds, pooled_prompt_embeds, prompt_attention_mask = encode_prompt(
+        #         tokenizer=tokenizer_one,
+        #         text_encoder=text_encoder_one,
+        #         tokenizer_2=tokenizer_two,
+        #         text_encoder_2=text_encoder_two,
+        #         prompt=prompts,
+        #         device=device,
+        #     )
+
+        #     # Prepare images
+        #     image_tensor = batch["first_frames_images"]
+        #     images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+        #     image = video_processor.preprocess(image=images, height=batch["videos"].shape[-2], width=batch["videos"].shape[-1])
+        #     image_embeds = encode_image(
+        #         feature_extractor,
+        #         image_encoder,
+        #         image,
+        #         device=device,
+        #         dtype=weight_dtype,
+        #     )
+
+        # for uttid, num_frame, height, width, cur_vae_latent, cur_prompt_embed, cur_pooled_prompt_embed, cur_prompt_attention_mask, cur_image_embed in zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"], vae_latents, prompt_embeds, pooled_prompt_embeds, prompt_attention_mask, image_embeds):
+        #     output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+        #     torch.save(
+        #         {
+        #             "vae_latent": cur_vae_latent.cpu().detach(),
+        #             "prompt_embed": cur_prompt_embed.cpu().detach(),
+        #             "pooled_prompt_embeds": cur_pooled_prompt_embed.cpu().detach(),
+        #             "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+        #             "image_embeds": cur_image_embed.cpu().detach(),
+        #         },
+        #         output_path
+        #     )
+        #     print(f"save to: {output_path}")
+        
+        if global_rank == 0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+        free_memory()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size for processing")
+    parser.add_argument("--dataloader_num_workers", type=int, default=12, help="Number of workers for data loading")
+    parser.add_argument("--config_path", type=str, default="part1.yaml", help="Path to the config file")
+    parser.add_argument("--output_latent_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents", help="Folder to store output latents")
+    parser.add_argument("--pretrained_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo", help="Pretrained model path")
+    parser.add_argument("--siglip_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl", help="Siglip model path")
+    args = parser.parse_args()
+
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    main(
+        world_size=world_size, 
+        rank=device, 
+        global_rank=global_rank,
+        batch_size=args.batch_size,
+        dataloader_num_workers=args.dataloader_num_workers,
+        config_path=args.config_path,
+        output_latent_folder=args.output_latent_folder,
+        pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+        siglip_model_name_or_path=args.siglip_model_name_or_path
+    )

dataset_code/sft_sftnews/offload/offoload_features_wan.py

@@ -0,0 +1,417 @@
+import math
+import html
+import ftfy
+import regex as re
+import random
+from typing import Any, Dict, List, Optional, Tuple, Union
+import argparse
+import os
+from tqdm import tqdm
+from diffusers import AutoencoderKLWan
+from transformers import (
+    AutoTokenizer, 
+    CLIPImageProcessor, 
+    CLIPVisionModel,  
+    UMT5EncoderModel,
+    SiglipImageProcessor,
+    SiglipVisionModel
+)
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video, load_image
+
+from dataset_tool import CollectionDataset, collate_fn_map
+from omegaconf import OmegaConf
+from torch.utils.data import DataLoader
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.utils.data import Subset
+import torchvision.transforms as transforms
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML, display
+from IPython.display import clear_output  # 用于清理历史输出
+
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
+from diffusers.training_utils import free_memory
+
+from utils_framepack import encode_image
+
+def encode_image_1(
+    image_processor,
+    image_encoder,
+    image,
+    device: Optional[torch.device] = "cuda",
+):
+    device = device
+    image = image_processor(images=image, return_tensors="pt").to(device)
+    image_embeds = image_encoder(**image, output_hidden_states=True)
+    return image_embeds.hidden_states[-2]
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def prompt_clean(text):
+    text = whitespace_clean(basic_clean(text))
+    return text
+
+
+def _get_t5_prompt_embeds(
+    tokenizer,
+    text_encoder,
+    prompt: Union[str, List[str]] = None,
+    num_videos_per_prompt: int = 1,
+    max_sequence_length: int = 512,
+    caption_dropout_p: float = 0.0,
+    device: Optional[torch.device] = "cuda",
+    dtype: Optional[torch.dtype] = torch.bfloat16,
+):
+    device = device
+    dtype = dtype
+
+    prompt = [prompt] if isinstance(prompt, str) else prompt
+    prompt = [prompt_clean(u) for u in prompt]
+    batch_size = len(prompt)
+
+    text_inputs = tokenizer(
+        prompt,
+        padding="max_length",
+        max_length=max_sequence_length,
+        truncation=True,
+        add_special_tokens=True,
+        return_attention_mask=True,
+        return_tensors="pt",
+    )
+    text_input_ids, mask = text_inputs.input_ids, text_inputs.attention_mask
+
+    prompt_embeds = text_encoder(text_input_ids.to(device), mask.to(device)).last_hidden_state
+    prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+
+    if random.random() < caption_dropout_p:
+        prompt_embeds.fill_(0)
+        mask.fill_(False)
+    seq_lens = mask.gt(0).sum(dim=1).long()
+
+    prompt_embeds = [u[:v] for u, v in zip(prompt_embeds, seq_lens)]
+    prompt_embeds = torch.stack([
+        torch.cat([u,
+                   u.new_zeros(max_sequence_length - u.size(0), u.size(1))])
+        for u in prompt_embeds
+    ],
+                                dim=0)
+
+    # duplicate text embeddings for each generation per prompt, using mps friendly method
+    _, seq_len, _ = prompt_embeds.shape
+    prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+    prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt,
+                                       seq_len, -1)
+
+    return prompt_embeds
+
+
+# Copied from diffusers.pipelines.wan.pipeline_wan.WanPipeline.encode_prompt
+def encode_prompt(
+    tokenizer,
+    text_encoder,
+    prompt: Union[str, List[str]],
+    num_videos_per_prompt: int = 1,
+    prompt_embeds: Optional[torch.Tensor] = None,
+    max_sequence_length: int = 512,
+    caption_dropout_p: float = 0.0,
+    device: Optional[torch.device] = "cuda",
+    dtype: Optional[torch.dtype] = torch.bfloat16,
+):
+    device = device
+
+    prompt = [prompt] if isinstance(prompt, str) else prompt
+    if prompt is not None:
+        batch_size = len(prompt)
+    else:
+        batch_size = prompt_embeds.shape[0]
+
+    if prompt_embeds is None:
+        prompt_embeds = _get_t5_prompt_embeds(
+            tokenizer,
+            text_encoder,
+            prompt=prompt,
+            num_videos_per_prompt=num_videos_per_prompt,
+            max_sequence_length=max_sequence_length,
+            caption_dropout_p=caption_dropout_p,
+            device=device,
+            dtype=dtype,
+        )
+
+    return prompt_embeds
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+def main(rank, world_size, global_rank, batch_size, dataloader_num_workers, config_path, output_latent_folder, pretrained_model_name_or_path, siglip_model_name_or_path):
+    weight_dtype = torch.bfloat16
+    # batch_size = 2
+    # dataloader_num_workers = 8
+    # config_path = "512_collection_config_vae1011_aligned_full_dump.yaml"
+    # output_latent_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents"
+    # pretrained_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo"
+    # siglip_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl"
+    os.makedirs(output_latent_folder, exist_ok=True)
+
+    device = rank
+
+    # load tokenizers
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="tokenizer",
+    )
+    clip_image_processor = CLIPImageProcessor.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="image_processor",
+    )
+    feature_extractor = SiglipImageProcessor.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="feature_extractor",
+    )
+
+    # load encoders
+    text_encoder = UMT5EncoderModel.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        torch_dtype=torch.float16,
+    )
+    clip_image_encoder = CLIPVisionModel.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="image_encoder",
+        torch_dtype=torch.float16,
+    )
+    image_encoder = SiglipVisionModel.from_pretrained(
+        siglip_model_name_or_path,
+        subfolder="image_encoder",
+        torch_dtype=weight_dtype,
+    )
+    
+
+    vae = AutoencoderKLWan.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    vae_scale_factor_spatial = vae.spatial_compression_ratio
+    video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    vae.requires_grad_(False)
+    text_encoder.requires_grad_(False)
+    clip_image_encoder.requires_grad_(False)
+    image_encoder.requires_grad_(False)
+    vae.eval()
+    text_encoder.eval()
+    clip_image_encoder.eval()
+    image_encoder.eval()
+
+    vae = vae.to(device)
+    text_encoder = text_encoder.to(device)
+    image_encoder = image_encoder.to(device)
+    clip_image_encoder = clip_image_encoder.to(device)
+
+    dist.barrier()
+    configs = OmegaConf.load(config_path)
+    dataset = CollectionDataset.create_dataset_function(configs['train_data'],
+                                                            configs['train_data_weights'],
+                                                            **configs['data']['params'])
+    print(len(dataset))
+
+    if global_rank == 0:
+        pbar = tqdm(total=len(dataset) // world_size, desc="Processing")
+    dist.barrier()
+
+    # dataloader = DataLoader(
+    #     dataset,
+    #     shuffle=False,
+    #     batch_size=batch_size,
+    #     collate_fn=collate_fn_map,
+    #     num_workers=dataloader_num_workers,
+    #     pin_memory=True,
+    #     prefetch_factor=2 if dataloader_num_workers != 0 else None,
+    #     persistent_workers=True if dataloader_num_workers != 0 else False,
+    # )
+
+    # def distributed_iterate_dataloader(dataloader, world_size, rank):
+    #     sample_count = 0
+    #     for idx, batch in enumerate(dataloader):
+    #         if sample_count % world_size == rank:
+    #             # No need to call collate_fn_map again as it's already done by DataLoader
+    #             yield batch  # Yield the batch directly
+    #         sample_count += 1
+
+    # for idx, batch in enumerate(distributed_iterate_dataloader(dataloader, dist.get_world_size(), dist.get_rank())):
+
+
+    def distributed_iterate_dataset(dataset, world_size, rank):
+        iterator = iter(dataset)
+        sample_count = 0
+        
+        while True:
+            try:
+                batch = next(iterator)
+                
+                if sample_count % world_size == rank:
+                    processed_batch = collate_fn_map(batch)
+                    yield processed_batch
+                
+                sample_count += 1
+                
+            except StopIteration:
+                break
+
+    for idx, batch in enumerate(distributed_iterate_dataset(dataset, dist.get_world_size(), dist.get_rank())):
+        valid_indices = []
+        valid_uttids = []
+        valid_num_frames = []
+        valid_heights = []
+        valid_widths = []
+        valid_videos = []
+        valid_prompts = []
+        valid_first_frames_images = []
+        
+        for i, (uttid, num_frame, height, width) in enumerate(zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"])):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            if not os.path.exists(output_path):
+                valid_indices.append(i)
+                valid_uttids.append(uttid)
+                valid_num_frames.append(num_frame)
+                valid_heights.append(height)
+                valid_widths.append(width)
+                valid_videos.append(batch["videos"][i])
+                valid_prompts.append(batch["prompts"][i])
+                valid_first_frames_images.append(batch["first_frames_images"][i])
+            else:
+                print(f"skipping {uttid}")
+        
+        if not valid_indices:
+            print("skipping entire batch!")
+            continue
+
+        batch = {
+            "uttid": valid_uttids,
+            "video_metadata": {
+                "num_frames": valid_num_frames,
+                "height": valid_heights,
+                "width": valid_widths
+            },
+            "videos": torch.stack(valid_videos),
+            "prompts": valid_prompts,
+            "first_frames_images": torch.stack(valid_first_frames_images)
+        }
+        
+        if len(batch["uttid"]) == 0:
+            print("All samples in this batch are already processed, skipping!")
+            continue
+
+        with torch.no_grad():
+            # Get Vae feature
+            latents_mean = torch.tensor(
+               vae.config.latents_mean).view(
+                   1, vae.config.z_dim, 1, 1,
+                   1).to(vae.device, vae.dtype)
+            latents_std = 1.0 / torch.tensor(
+               vae.config.latents_std).view(
+                   1, vae.config.z_dim, 1, 1, 1).to(
+                       vae.device, vae.dtype)
+            pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+            vae_latents = vae.encode(pixel_values).latent_dist.sample()
+            vae_latents = (vae_latents - latents_mean) * latents_std
+
+            # Encode prompts
+            prompts = batch["prompts"]
+            prompt_embeds = encode_prompt(
+                tokenizer=tokenizer,
+                text_encoder=text_encoder,
+                prompt=prompts,
+                device=device,
+            )
+
+            # Prepare images
+            image_tensor = batch["first_frames_images"]
+            images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+
+            clip_image_embeds = encode_image_1(
+                image_processor=clip_image_processor,
+                image_encoder=clip_image_encoder,
+                image=images,
+                device=device
+            )
+
+            image = video_processor.preprocess(image=images, height=batch["videos"].shape[-2], width=batch["videos"].shape[-1])
+            image_embeds = encode_image(
+                feature_extractor,
+                image_encoder,
+                image,
+                device=device,
+                dtype=weight_dtype,
+            )
+
+        for uttid, num_frame, height, width, cur_vae_latent, cur_prompt_embed, cur_clip_image_embed, cur_image_embed in zip(batch["uttid"], batch["video_metadata"]["num_frames"], batch["video_metadata"]["height"], batch["video_metadata"]["width"], vae_latents, prompt_embeds, clip_image_embeds, image_embeds):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            torch.save(
+                {
+                    "vae_latent": cur_vae_latent.cpu().detach(),
+                    "prompt_embed": cur_prompt_embed.cpu().detach(),
+                    "clip_image_embeds": cur_clip_image_embed.cpu().detach(),
+                    "image_embeds": cur_image_embed.cpu().detach(),
+                },
+                output_path
+            )
+            print(f"save to: {output_path}")
+        
+        if global_rank == 0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+        free_memory()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size for processing")
+    parser.add_argument("--dataloader_num_workers", type=int, default=8, help="Number of workers for data loading")
+    parser.add_argument("--config_path", type=str, default="part1.yaml", help="Path to the config file")
+    parser.add_argument("--output_latent_folder", type=str, default="/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents_wan", help="Folder to store output latents")
+    parser.add_argument("--pretrained_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/Wan-AI/Wan2.1-I2V-14B-720P-Diffusers/", help="Pretrained model path")
+    parser.add_argument("--siglip_model_name_or_path", type=str, default="/mnt/bn/yufan-dev-my/ysh/Ckpts/lllyasviel/flux_redux_bfl", help="Siglip model path")
+    args = parser.parse_args()
+
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    main(
+        world_size=world_size, 
+        rank=device, 
+        global_rank=global_rank,
+        batch_size=args.batch_size,
+        dataloader_num_workers=args.dataloader_num_workers,
+        config_path=args.config_path,
+        output_latent_folder=args.output_latent_folder,
+        pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+        siglip_model_name_or_path=args.siglip_model_name_or_path
+    )

dataset_code/sft_sftnews/offload/part0.yaml

@@ -0,0 +1,101 @@
+# vae1011-98022219
+# train_data: ['albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [68859, 1192, 15856, 203755, 1384503, 78671, 26307, 343789, 514339, 152912, 1762929, 6288112, 594676, 34082, 16263, 49979, 62714, 447823, 19018149, 7013003, 16887569, 3790563, 584691, 477319, 10022018, 9587751, 8486291, 7210, 10100894]
+
+
+#high quality data-30372699
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018]
+
+#high quality data : vae1011 = 1:1
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p',  'albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018,  22953, 397, 5285, 67918, 461501, 26223, 8769, 114596, 171446, 50970, 587643, 2096037, 198225, 11360, 5421, 16659, 20904, 149274, 6339383, 2337667, 5629189, 1263521, 194897, 159106, 3340672, 3195917, 2828763, 2403, 3366964]
+
+# train_data: ['flow_test']
+# train_data_weights: [1]
+# train_data: ['sft','sft_hq']
+# train_data_weights: [1,10]
+# train_data: ['eval']
+# train_data_weights: [1]
+train_data: ['sft_new','sft_new_1']
+train_data_weights: [536463, 135600]
+# train_data: ['sft']
+# train_data_weights: [1]
+
+data:
+  params:
+    batch_size: 1 # the real batch size
+    image_batch_size: 16 # real image batch size
+    enable_bucket: True
+    dataset_collections: # list all available datasets
+      sft_new:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en_new/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]   # 245760
+          "384p-2.0": [768, 384]   # 294912
+          "512p-1.6": [640, 384]   # 245760
+          "512p-1.5": [768, 512]   # 393216
+          "448p-1.29": [576, 448]  # 258048
+          "512p-1.0": [512, 512]   # 262144
+          "448p-0.78": [448, 576]  # 258048
+          "512p-0.67": [512, 768]  # 393216
+          "512p-0.6": [384, 640]   # 245760
+          "384p-0.5": [384, 768]   # 294912
+          "320p-0.42": [320, 768]  # 245760
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 0
+
+      sft_new_1:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 0

dataset_code/sft_sftnews/offload/part1.yaml

@@ -0,0 +1,101 @@
+# vae1011-98022219
+# train_data: ['albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [68859, 1192, 15856, 203755, 1384503, 78671, 26307, 343789, 514339, 152912, 1762929, 6288112, 594676, 34082, 16263, 49979, 62714, 447823, 19018149, 7013003, 16887569, 3790563, 584691, 477319, 10022018, 9587751, 8486291, 7210, 10100894]
+
+
+#high quality data-30372699
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018]
+
+#high quality data : vae1011 = 1:1
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p',  'albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018,  22953, 397, 5285, 67918, 461501, 26223, 8769, 114596, 171446, 50970, 587643, 2096037, 198225, 11360, 5421, 16659, 20904, 149274, 6339383, 2337667, 5629189, 1263521, 194897, 159106, 3340672, 3195917, 2828763, 2403, 3366964]
+
+# train_data: ['flow_test']
+# train_data_weights: [1]
+# train_data: ['sft','sft_hq']
+# train_data_weights: [1,10]
+# train_data: ['eval']
+# train_data_weights: [1]
+train_data: ['sft_new','sft_new_1']
+train_data_weights: [536463, 135600]
+# train_data: ['sft']
+# train_data_weights: [1]
+
+data:
+  params:
+    batch_size: 1 # the real batch size
+    image_batch_size: 16 # real image batch size
+    enable_bucket: True
+    dataset_collections: # list all available datasets
+      sft_new:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en_new/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 1
+
+      sft_new_1:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 1

dataset_code/sft_sftnews/offload/part2.yaml

@@ -0,0 +1,101 @@
+# vae1011-98022219
+# train_data: ['albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [68859, 1192, 15856, 203755, 1384503, 78671, 26307, 343789, 514339, 152912, 1762929, 6288112, 594676, 34082, 16263, 49979, 62714, 447823, 19018149, 7013003, 16887569, 3790563, 584691, 477319, 10022018, 9587751, 8486291, 7210, 10100894]
+
+
+#high quality data-30372699
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018]
+
+#high quality data : vae1011 = 1:1
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p',  'albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018,  22953, 397, 5285, 67918, 461501, 26223, 8769, 114596, 171446, 50970, 587643, 2096037, 198225, 11360, 5421, 16659, 20904, 149274, 6339383, 2337667, 5629189, 1263521, 194897, 159106, 3340672, 3195917, 2828763, 2403, 3366964]
+
+# train_data: ['flow_test']
+# train_data_weights: [1]
+# train_data: ['sft','sft_hq']
+# train_data_weights: [1,10]
+# train_data: ['eval']
+# train_data_weights: [1]
+train_data: ['sft_new','sft_new_1']
+train_data_weights: [536463, 135600]
+# train_data: ['sft']
+# train_data_weights: [1]
+
+data:
+  params:
+    batch_size: 1 # the real batch size
+    image_batch_size: 16 # real image batch size
+    enable_bucket: True
+    dataset_collections: # list all available datasets
+      sft_new:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en_new/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 2
+
+      sft_new_1:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 2

dataset_code/sft_sftnews/offload/part3.yaml

@@ -0,0 +1,101 @@
+# vae1011-98022219
+# train_data: ['albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [68859, 1192, 15856, 203755, 1384503, 78671, 26307, 343789, 514339, 152912, 1762929, 6288112, 594676, 34082, 16263, 49979, 62714, 447823, 19018149, 7013003, 16887569, 3790563, 584691, 477319, 10022018, 9587751, 8486291, 7210, 10100894]
+
+
+#high quality data-30372699
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018]
+
+#high quality data : vae1011 = 1:1
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p',  'albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018,  22953, 397, 5285, 67918, 461501, 26223, 8769, 114596, 171446, 50970, 587643, 2096037, 198225, 11360, 5421, 16659, 20904, 149274, 6339383, 2337667, 5629189, 1263521, 194897, 159106, 3340672, 3195917, 2828763, 2403, 3366964]
+
+# train_data: ['flow_test']
+# train_data_weights: [1]
+# train_data: ['sft','sft_hq']
+# train_data_weights: [1,10]
+# train_data: ['eval']
+# train_data_weights: [1]
+train_data: ['sft_new','sft_new_1']
+train_data_weights: [536463, 135600]
+# train_data: ['sft']
+# train_data_weights: [1]
+
+data:
+  params:
+    batch_size: 1 # the real batch size
+    image_batch_size: 16 # real image batch size
+    enable_bucket: True
+    dataset_collections: # list all available datasets
+      sft_new:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en_new/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 3
+
+      sft_new_1:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 3

dataset_code/sft_sftnews/offload/part4.yaml

@@ -0,0 +1,101 @@
+# vae1011-98022219
+# train_data: ['albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [68859, 1192, 15856, 203755, 1384503, 78671, 26307, 343789, 514339, 152912, 1762929, 6288112, 594676, 34082, 16263, 49979, 62714, 447823, 19018149, 7013003, 16887569, 3790563, 584691, 477319, 10022018, 9587751, 8486291, 7210, 10100894]
+
+
+#high quality data-30372699
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018]
+
+#high quality data : vae1011 = 1:1
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p',  'albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018,  22953, 397, 5285, 67918, 461501, 26223, 8769, 114596, 171446, 50970, 587643, 2096037, 198225, 11360, 5421, 16659, 20904, 149274, 6339383, 2337667, 5629189, 1263521, 194897, 159106, 3340672, 3195917, 2828763, 2403, 3366964]
+
+# train_data: ['flow_test']
+# train_data_weights: [1]
+# train_data: ['sft','sft_hq']
+# train_data_weights: [1,10]
+# train_data: ['eval']
+# train_data_weights: [1]
+train_data: ['sft_new','sft_new_1']
+train_data_weights: [536463, 135600]
+# train_data: ['sft']
+# train_data_weights: [1]
+
+data:
+  params:
+    batch_size: 1 # the real batch size
+    image_batch_size: 16 # real image batch size
+    enable_bucket: True
+    dataset_collections: # list all available datasets
+      sft_new:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en_new/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 4
+
+      sft_new_1:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 4

dataset_code/sft_sftnews/offload/part5.yaml

@@ -0,0 +1,101 @@
+# vae1011-98022219
+# train_data: ['albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [68859, 1192, 15856, 203755, 1384503, 78671, 26307, 343789, 514339, 152912, 1762929, 6288112, 594676, 34082, 16263, 49979, 62714, 447823, 19018149, 7013003, 16887569, 3790563, 584691, 477319, 10022018, 9587751, 8486291, 7210, 10100894]
+
+
+#high quality data-30372699
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018]
+
+#high quality data : vae1011 = 1:1
+# train_data: ['Istock_sports_videos','abaka_short','malayan','movie_v0_1','nexdata','rf123_1080p',  'albatross_2_dump', 'budgie_1_dump', 'budgie_2_dump', 'canary_2_dump', 'condor_2_dump', 'falcon_dump', 'filmsupply_highres_dump', 'guillemot_2_dump', 'guillemot_4_dump', 'gull_2_dump', 'harrier_2_dump', 'hdvg_dump', 'hornbill_2_dump', 'hummingbird_2_dump', 'kingfisher_dump', 'lovebird_dump', 'macaw_2_dump', 'movie_2_dump', 'panda70m_dump', 'partridge_2_dump', 'partridge_4_dump', 'petrel_2_dump', 'pigeon_2_dump', 'puffin_2_dump', 'swallow_2_dump', 'vimeo_2_dump', 'vimeo_4_dump', 'warbler_2_dump', 'wren_2_dump']
+# train_data_weights: [3431837,742656,5699324,14771089,1502775,4225018,  22953, 397, 5285, 67918, 461501, 26223, 8769, 114596, 171446, 50970, 587643, 2096037, 198225, 11360, 5421, 16659, 20904, 149274, 6339383, 2337667, 5629189, 1263521, 194897, 159106, 3340672, 3195917, 2828763, 2403, 3366964]
+
+# train_data: ['flow_test']
+# train_data_weights: [1]
+# train_data: ['sft','sft_hq']
+# train_data_weights: [1,10]
+# train_data: ['eval']
+# train_data_weights: [1]
+train_data: ['sft_new','sft_new_1']
+train_data_weights: [536463, 135600]
+# train_data: ['sft']
+# train_data_weights: [1]
+
+data:
+  params:
+    batch_size: 1 # the real batch size
+    image_batch_size: 16 # real image batch size
+    enable_bucket: True
+    dataset_collections: # list all available datasets
+      sft_new:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en_new/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 5
+
+      sft_new_1:
+        target: dataset_tool.SeedV1Dataset
+        path: "hdfs://harunasg/home/byte_icvg_aigc_cp/user/video/temp/19900101/v2_en/2025-02-13-05-39-30/data"
+        resolution: 512
+        aspect_ratios:
+          "320p-2.4": [768, 320]
+          "384p-2.0": [768, 384]
+          "512p-1.6": [640, 384]
+          "512p-1.5": [768, 512]
+          "448p-1.29": [576, 448]
+          "512p-1.0": [512, 512]
+          "448p-0.78": [448, 576]
+          "512p-0.67": [512, 768]
+          "512p-0.6": [384, 640]
+          "384p-0.5": [384, 768]
+          "320p-0.42": [320, 768]
+        ratio_strategy: closest
+        params:
+          sample_size: -1 # set to -1 to keep the original resolution
+          fps: 24
+          num_parallel_files: 1
+          video_frame_sampler:
+            type: 'adaptive_advanced'
+            strategies:
+              - stride: 1
+                stride_prob: 1.0
+                frame_lengths: [ 121 ]
+                frame_lengths_prob: 'harmonic'
+            clip: 'simple'
+          text_sampler:
+            type: 'frequency'
+            frequency:
+              recaption_7B_: 1.0
+              origin_title: 0.0
+          part_idx: 5

dataset_code/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+input_file="/mnt/bn/yufan-dev-my/ysh/Ckpts/SpatialVID/e6d91e1b-e366-5fa9-aef4-9769eb0bf631.mp4"
+output_file="output_trimmed.mp4"
+
+# 获取总帧数
+total_frames=$(ffprobe -v quiet -select_streams v:0 -count_frames -show_entries stream=nb_frames -of csv=p=0 "$input_file")
+
+# 计算要保留的帧数
+keep_frames=$((total_frames - 19))
+
+# 执行裁剪
+ffmpeg -i "$input_file" -vf "select='lt(n,$keep_frames)'" -vsync 0 -c:a copy "$output_file"
+
+echo "处理完成: $output_file"
+echo "原始帧数: $total_frames"
+echo "保留帧数: $keep_frames"

dataset_code/vae_decode_hv.py

@@ -0,0 +1,92 @@
+import os
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+
+import torch
+from diffusers import AutoencoderKLHunyuanVideo
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video
+
+device = "cuda"
+pretrained_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo"
+vae = AutoencoderKLHunyuanVideo.from_pretrained(
+    pretrained_model_name_or_path,
+    subfolder="vae",
+    torch_dtype=torch.float32,
+).to(device)
+vae.eval()
+vae.requires_grad_(False)
+vae.enable_tiling()
+
+vae_scale_factor_spatial = vae.spatial_compression_ratio
+video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+latents = torch.load('/mnt/bn/yufan-dev-my/ysh/Ckpts/Lixsp11/0_final_sekai_dataset/sekai-real-drone/latents_stride1/9F82nRgRthI_0046499_0046799_281_384_640.pt', map_location='cpu', weights_only=False)
+vae_latents = latents['vae_latent'] / vae.config.scaling_factor
+# vae_latents = vae_latents.to(device=device, dtype=vae.dtype)[:, :9, :, :]
+
+video = vae.decode(vae_latents.unsqueeze(0).to(vae.device), return_dict=False)[0]
+video = video_processor.postprocess_video(video, output_type="pil")
+export_to_video(video[0], "output_fp_hv_33.mp4", fps=30)
+
+# video[0][0].save("1_0.png")
+# video[0][-1].save("2_0.png")
+
+# first_vae_latents = latents['vae_latent'][:, 0, :, :].unsqueeze(1) / vae.config.scaling_factor
+# first_vae_latents = first_vae_latents.to(device=device, dtype=vae.dtype)
+# first_image = vae.decode(first_vae_latents.unsqueeze(0), return_dict=False)[0]
+# first_image = video_processor.postprocess_video(first_image, output_type="pil")[0][0]
+# first_image.save("1_1.png")
+
+# last_vae_latents = latents['vae_latent'][:, -1, :, :].unsqueeze(1) / vae.config.scaling_factor
+# last_vae_latents = last_vae_latents.to(device=device, dtype=vae.dtype)
+# last_image = vae.decode(last_vae_latents.unsqueeze(0), return_dict=False)[0]
+# last_image = video_processor.postprocess_video(last_image, output_type="pil")[0][0]
+# last_image.save("2_1.png")
+
+# print(f"Max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+
+# import sys
+# sys.path.append("/mnt/bn/yufan-dev-my/ysh/Codes/Efficient/fp_train/dance_forcing/utils")
+
+# from utils_framepack import get_framepack_input_i2v
+
+# (
+#     model_input,  # torch.Size([2, 16, 9, 60, 104])
+#     indices_latents,  # torch.Size([2, 9])
+#     latents_clean,  # torch.Size([2, 16, 2, 60, 104])
+#     indices_clean_latents,  # torch.Size([2, 2])
+#     latents_history_2x,  # torch.Size([2, 16, 2, 60, 104])
+#     indices_latents_history_2x,  # torch.Size([2, 2])
+#     latents_history_4x,  # torch.Size([2, 16, 16, 60, 104])
+#     indices_latents_history_4x,  # torch.Size([2, 16])
+#     section_to_video_idx,
+# ) = get_framepack_input_i2v(
+#     vae_latents=latents['vae_latent'].unsqueeze(0),
+#     latent_window_size=9,
+#     vanilla_sampling=True,
+#     is_local_flf2v=True,
+#     dtype=torch.bfloat16,
+# )
+
+# vae_latents_1 = torch.cat([model_input[0:1], model_input[-1:]], dim = 2)
+# vae_latents_1 = vae_latents_1.to(vae.device, dtype=vae.dtype) / vae.config.scaling_factor
+# video = vae.decode(vae_latents_1, return_dict=False)[0]
+# video = video_processor.postprocess_video(video, output_type="pil")
+# export_to_video(video[0], "output_fp_f1_test_1.mp4", fps=30)
+
+
+# def remove_front_padding(tensor, dim=1):
+#     non_zero_indices = torch.any(tensor != 0, dim=tuple(i for i in range(tensor.ndim) if i != dim))
+#     first_non_zero = torch.argmax(non_zero_indices.float())
+#     slices = [slice(None)] * tensor.ndim
+#     slices[dim] = slice(first_non_zero.item(), None)
+#     return tensor[tuple(slices)]
+
+# vae_latents_1 = remove_front_padding(torch.cat([latents_history_4x[-1:], latents_history_2x[-1:], latents_clean[-1:][:, :, 0:1,], model_input[-1:], latents_clean[-1:][:, :, 1:,]], dim = 2), dim = 2)
+# vae_latents_1 = vae_latents_1.to(vae.device, dtype=vae.dtype) / vae.config.scaling_factor
+# video = vae.decode(vae_latents_1, return_dict=False)[0]
+# video = video_processor.postprocess_video(video, output_type="pil")
+# export_to_video(video[0], "output_fp_f1_test_2.mp4", fps=30)
+
+# import pdb;pdb.set_trace()

dataset_code/vae_decode_hv_batch.py

@@ -0,0 +1,118 @@
+import os
+import glob
+import torch
+import torch.multiprocessing as mp
+from diffusers import AutoencoderKLHunyuanVideo
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video
+from concurrent.futures import ProcessPoolExecutor
+import time
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+
+def process_files_on_gpu(gpu_id, file_list, pretrained_model_path, output_folder):
+    """在指定GPU上处理文件列表"""
+    device = f"cuda:{gpu_id}"
+    
+    # 初始化VAE模型
+    vae = AutoencoderKLHunyuanVideo.from_pretrained(
+        pretrained_model_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    ).to(device)
+    vae.eval()
+    vae.requires_grad_(False)
+    vae.enable_tiling()
+
+    vae_scale_factor_spatial = vae.spatial_compression_ratio
+    video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+    for i, pt_file in enumerate(file_list):
+        try:
+            print(f"GPU {gpu_id} - 正在处理 ({i+1}/{len(file_list)}): {os.path.basename(pt_file)}")
+            
+            # 加载latents
+            latents = torch.load(pt_file, map_location='cpu', weights_only=False)
+            vae_latents = latents['vae_latent'] / vae.config.scaling_factor
+            vae_latents = vae_latents.to(device=device, dtype=vae.dtype)
+            
+            # 解码视频
+            video = vae.decode(vae_latents.unsqueeze(0), return_dict=False)[0]
+            video = video_processor.postprocess_video(video, output_type="pil")
+            
+            # 生成输出文件名
+            base_name = os.path.splitext(os.path.basename(pt_file))[0]
+            output_path = os.path.join(output_folder, f"{base_name}.mp4")
+            
+            # 导出视频
+            export_to_video(video[0], output_path, fps=30)
+            print(f"GPU {gpu_id} - 成功保存: {output_path}")
+            
+            # 清理GPU内存
+            del latents, vae_latents, video
+            torch.cuda.empty_cache()
+            
+        except Exception as e:
+            print(f"GPU {gpu_id} - 处理文件 {pt_file} 时出错: {str(e)}")
+            continue
+    
+    print(f"GPU {gpu_id} - 完成所有分配的文件处理！")
+
+def main():
+    # 设置路径
+    pretrained_model_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/hunyuanvideo-community/HunyuanVideo"
+    input_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/dummy_fp_offload_latents"
+    output_folder = "/mnt/bn/yufan-dev-my/ysh/Datasets/dummy_fp_offload_latents/decoded_videos"
+    
+    # 创建输出文件夹
+    os.makedirs(output_folder, exist_ok=True)
+    
+    # 获取所有.pt文件
+    pt_files = glob.glob(os.path.join(input_folder, "*.pt"))
+    print(f"找到 {len(pt_files)} 个.pt文件")
+    
+    if len(pt_files) == 0:
+        print("没有找到.pt文件！")
+        return
+    
+    # 检查可用GPU数量
+    num_gpus = min(8, torch.cuda.device_count())
+    print(f"使用 {num_gpus} 个GPU进行并行处理")
+    
+    # 将文件分配到不同的GPU
+    files_per_gpu = len(pt_files) // num_gpus
+    file_chunks = []
+    
+    for i in range(num_gpus):
+        start_idx = i * files_per_gpu
+        if i == num_gpus - 1:  # 最后一个GPU处理剩余的所有文件
+            end_idx = len(pt_files)
+        else:
+            end_idx = (i + 1) * files_per_gpu
+        
+        file_chunks.append(pt_files[start_idx:end_idx])
+        print(f"GPU {i} 将处理 {len(file_chunks[i])} 个文件")
+    
+    # 使用多进程并行处理
+    start_time = time.time()
+    
+    processes = []
+    for gpu_id in range(num_gpus):
+        if len(file_chunks[gpu_id]) > 0:  # 只为有文件的GPU创建进程
+            p = mp.Process(
+                target=process_files_on_gpu,
+                args=(gpu_id, file_chunks[gpu_id], pretrained_model_path, output_folder)
+            )
+            p.start()
+            processes.append(p)
+    
+    # 等待所有进程完成
+    for p in processes:
+        p.join()
+    
+    end_time = time.time()
+    print(f"\n所有文件处理完成！总耗时: {end_time - start_time:.2f} 秒")
+
+if __name__ == "__main__":
+    mp.set_start_method('spawn', force=True)  # 确保多进程兼容性
+    main()

dataset_code/vae_decode_wan.py

@@ -0,0 +1,32 @@
+import os
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+
+import torch
+from diffusers import AutoencoderKLWan
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video
+
+device = "cuda"
+pretrained_model_name_or_path = "/mnt/bn/yufan-dev-my/ysh/Ckpts/Wan-AI/Wan2.1-I2V-14B-720P-Diffusers/"
+vae = AutoencoderKLWan.from_pretrained(
+    pretrained_model_name_or_path,
+    subfolder="vae",
+    torch_dtype=torch.float32,
+).to(device)
+vae.eval()
+vae.requires_grad_(False)
+vae.enable_tiling()
+
+vae_scale_factor_spatial = vae.spatial_compression_ratio
+video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+
+latents = torch.load('/mnt/bn/yufan-dev-my/ysh/Datasets/fp_offload_latents_wan/6ad434bc-df9b-40be-9632-c8f9508f1ccc_121_768_384.pt', map_location='cpu', weights_only=False)
+latents_mean = torch.tensor(vae.config.latents_mean).view(1, vae.config.z_dim, 1, 1, 1)
+latents_std = 1.0 / torch.tensor(vae.config.latents_std).view(1, vae.config.z_dim, 1, 1, 1)
+vae_latents = latents['vae_latent'] / latents_std + latents_mean
+vae_latents = vae_latents.to(device=device, dtype=vae.dtype)
+
+video = vae.decode(vae_latents, return_dict=False)[0]
+video = video_processor.postprocess_video(video, output_type="pil")
+export_to_video(video[0], "output_wan.mp4", fps=30)