Add files using upload-large-folder tool

spatial-model/GeoThinker/scripts/evaluation/eval.sh

@@ -0,0 +1,16 @@
+set -e
+export LMMS_EVAL_LAUNCHER="accelerate"
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+export NCCL_NVLS_ENABLE=0
+
+output_path=logs/$(TZ="Asia/Shanghai" date "+%Y%m%d")
+model_path=GeoThinker-8B
+
+benchmark=vsibench
+
+accelerate launch --num_processes=8 --main_process_port 29505 -m lmms_eval \
+    --model geothinker \
+    --model_args pretrained=$model_path,use_flash_attention_2=true,max_num_frames=32,max_length=12800,max_pixels=451584,min_pixels=12544 \
+    --tasks ${benchmark} \
+    --batch_size 1 \
+    --output_path $output_path

spatial-model/GeoThinker/scripts/train/train_sr_qwen25vl.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# Complete QwenVL Training Launch Script with Full Parameter Documentation
+
+# Qwen2.5VL works on transformers=4.50.0, and may not work on transformers=4.57.0
+pip install transformers==4.50.0
+
+# ======================
+# Distributed Configuration
+# ======================
+MASTER_ADDR="127.0.0.1"                     # [Required] Master node IP for multi-GPU training
+MASTER_PORT=$(shuf -i 20000-29999 -n 1)     # Random port to avoid conflicts
+NPROC_PER_NODE=8  # Automatically detects available GPUs
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+
+# ======================
+# Path Configuration
+# ======================
+MODEL_PATH="Qwen/Qwen2.5-VL-7B-Instruct/"  # [ModelArguments] Pretrained model path
+GEOMETRY_ENCODER_TYPE="vggt"
+GEOMETRY_ENCODER_PATH="facebook/VGGT-1B"
+OUTPUT_DIR="PATH_TO_OUTPUT_DIR"                   # Directory for saving checkpoints
+CACHE_DIR="./cache"                        # [TrainingArguments] Cache directory for models
+mkdir -p $OUTPUT_DIR
+
+# ======================
+# Model Configuration
+# ======================
+DATASETS="llava_hound_64k_32frame,spar_234k,vsi_590k_32frame,vlm3r_vsi_205k_32frames,vlm3r_vst_132k_32frames,phygames_140k,mindcube_10k,cambrian_s_3m_subset_32frame"
+
+# ======================
+# Training Hyperparameters
+# ======================
+LR=1e-5
+total_batch_size=64
+GRADIENT_ACCUMULATION_STEPS=$(($total_batch_size / $NPROC_PER_NODE))
+
+torchrun --nproc_per_node=$NPROC_PER_NODE \
+            --master_addr=$MASTER_ADDR \
+            --master_port=$MASTER_PORT \
+            src/qwen_vl/train/train_qwen.py \
+            --model_name_or_path $MODEL_PATH \
+            --tune_mm_llm True \
+            --tune_mm_vision False \
+            --tune_mm_mlp False \
+            --dataset_use $DATASETS \
+            --output_dir $OUTPUT_DIR \
+            --cache_dir $CACHE_DIR \
+            --bf16 \
+            --per_device_train_batch_size 1 \
+            --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+            --learning_rate $LR \
+            --mm_projector_lr 1e-5 \
+            --vision_tower_lr 1e-6 \
+            --optim adamw_torch \
+            --model_max_length 12800 \
+            --data_flatten False \
+            --max_pixels $((576*28*28)) \
+            --min_pixels $((16*28*28)) \
+            --base_interval 2 \
+            --video_max_frames 8 \
+            --video_min_frames 4 \
+            --video_max_frame_pixels $((1664*28*28)) \
+            --video_min_frame_pixels $((256*28*28)) \
+            --num_train_epochs 1 \
+            --warmup_ratio 0.03 \
+            --lr_scheduler_type "cosine" \
+            --weight_decay 0.01 \
+            --logging_steps 50 \
+            --save_steps 1000 \
+            --save_total_limit 1 \
+            --deepspeed "scripts/zero2_opt.json" \
+            --gradient_checkpointing \
+            --dataloader_num_workers 4 \
+            --group_by_modality_length true \
+            --seed 0 \
+            --report_to "none" \
+            --use_geometry_encoder true \
+            --geometry_encoder_type $GEOMETRY_ENCODER_TYPE \
+            --geometry_encoder_path $GEOMETRY_ENCODER_PATH \
+            --feature_fusion_method "zero" \
+            --geo_cross_attn True \
+            --geo_importance_gate True \
+            --depart_smi_token True \
+            > ${OUTPUT_DIR}/train.log 2>&1

spatial-model/GeoThinker/scripts/train/train_sr_qwen3vl.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# Complete QwenVL Training Launch Script with Full Parameter Documentation
+
+# Qwen3VL works on transformers=4.57.0
+pip install transformers==4.57.0
+
+# ======================
+# Distributed Configuration
+# ======================
+MASTER_ADDR="127.0.0.1"                     # [Required] Master node IP for multi-GPU training
+MASTER_PORT=$(shuf -i 20000-29999 -n 1)     # Random port to avoid conflicts
+NPROC_PER_NODE=8  # Automatically detects available GPUs
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+
+# ======================
+# Path Configuration
+# ======================
+MODEL_PATH="Qwen/Qwen3-VL-8B-Instruct/"  # [ModelArguments] Pretrained model path
+GEOMETRY_ENCODER_TYPE="vggt"
+GEOMETRY_ENCODER_PATH="facebook/VGGT-1B"
+OUTPUT_DIR="PATH_TO_OUTPUT_DIR"                   # Directory for saving checkpoints
+CACHE_DIR="./cache"                        # [TrainingArguments] Cache directory for models
+mkdir -p $OUTPUT_DIR
+
+# ======================
+# Model Configuration
+# ======================
+DATASETS="llava_hound_64k_32frame,spar_234k,vsi_590k_32frame,vlm3r_vsi_205k_32frames,vlm3r_vst_132k_32frames,phygames_140k,mindcube_10k,cambrian_s_3m_subset_32frame"
+
+# ======================
+# Training Hyperparameters
+# ======================
+LR=1e-5
+total_batch_size=64
+GRADIENT_ACCUMULATION_STEPS=$(($total_batch_size / $NPROC_PER_NODE))
+
+torchrun --nproc_per_node=$NPROC_PER_NODE \
+            --master_addr=$MASTER_ADDR \
+            --master_port=$MASTER_PORT \
+            src/qwen_vl/train/train_qwen.py \
+            --model_name_or_path $MODEL_PATH \
+            --tune_mm_llm True \
+            --tune_mm_vision False \
+            --tune_mm_mlp False \
+            --dataset_use $DATASETS \
+            --output_dir $OUTPUT_DIR \
+            --cache_dir $CACHE_DIR \
+            --bf16 \
+            --per_device_train_batch_size 1 \
+            --gradient_accumulation_steps $GRADIENT_ACCUMULATION_STEPS \
+            --learning_rate $LR \
+            --mm_projector_lr 1e-5 \
+            --vision_tower_lr 1e-6 \
+            --optim adamw_torch \
+            --model_max_length 12800 \
+            --data_flatten False \
+            --max_pixels $((576*28*28)) \
+            --min_pixels $((16*28*28)) \
+            --base_interval 2 \
+            --video_max_frames 8 \
+            --video_min_frames 4 \
+            --video_max_frame_pixels $((1664*28*28)) \
+            --video_min_frame_pixels $((256*28*28)) \
+            --num_train_epochs 1 \
+            --warmup_ratio 0.03 \
+            --lr_scheduler_type "cosine" \
+            --weight_decay 0.01 \
+            --logging_steps 50 \
+            --save_steps 1000 \
+            --save_total_limit 1 \
+            --deepspeed "scripts/zero2_opt.json" \
+            --gradient_checkpointing \
+            --dataloader_num_workers 4 \
+            --group_by_modality_length true \
+            --seed 0 \
+            --report_to "none" \
+            --use_geometry_encoder true \
+            --geometry_encoder_type $GEOMETRY_ENCODER_TYPE \
+            --geometry_encoder_path $GEOMETRY_ENCODER_PATH \
+            --feature_fusion_method "zero" \
+            --geo_cross_attn True \
+            --geo_importance_gate True \
+            --depart_smi_token True \
+            > ${OUTPUT_DIR}/train.log 2>&1

spatial-model/GeoThinker/scripts/zero2.json

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

spatial-model/GeoThinker/scripts/zero2_opt.json

@@ -0,0 +1,33 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "train_micro_batch_size_per_gpu": "auto",
+    "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "zero_optimization": {
+        "stage": 2,
+        "overlap_comm": false,
+        "contiguous_gradients": true,
+        "sub_group_size": 1e9,
+        "reduce_bucket_size": 5e7,
+        "allgather_bucket_size": 5e7,
+        "round_robin_gradients": true
+    },
+    "activation_checkpointing": {
+        "partition_activations": true,
+        "cpu_checkpointing": true,
+        "contiguous_memory_optimization": true,
+        "number_checkpoints": null,
+        "synchronize_checkpoint_boundary": true,
+        "profile": false
+    }
+}

spatial-model/VLM-3R/llava/model/multimodal_encoder/dev_eva_clip/eva_clip/model_configs/EVA-CLIP-18B.json

@@ -0,0 +1,27 @@
+{
+    "embed_dim": 1536,
+    "vision_cfg": {
+        "image_size": 224,
+        "layers": 48,
+        "width": 5120,
+        "head_width": 128,
+        "mlp_ratio": 5,
+        "patch_size": 14,
+        "eva_model_name": "eva-clip-18b-14-x",
+        "drop_path_rate": 0,
+        "qkv_bias": false,
+        "xattn": true,
+        "postnorm": true,
+        "fusedLN": false,
+        "use_rms_norm": true
+    },
+    "text_cfg": {
+        "context_length": 77,
+        "vocab_size": 49408,
+        "width": 1280,
+        "heads": 20,
+        "layers": 32,
+        "xattn": false,
+        "fusedLN": false
+    }
+}

spatial-model/VLM-3R/llava/model/multimodal_encoder/dev_eva_clip/eva_clip/model_configs/EVA-CLIP-8B-plus.json

@@ -0,0 +1,27 @@
+{
+    "embed_dim": 1280,
+    "vision_cfg": {
+        "image_size": 448,
+        "layers": 32,
+        "width": 4096,
+        "head_width": 128,
+        "mlp_ratio": 5,
+        "patch_size": 14,
+        "eva_model_name": "eva-clip-8b-14-plus-x",
+        "drop_path_rate": 0,
+        "qkv_bias": false,
+        "xattn": true,
+        "postnorm": false,
+        "fusedLN": false,
+        "use_rms_norm": true
+    },
+    "text_cfg": {
+        "context_length": 77,
+        "vocab_size": 49408,
+        "width": 1280,
+        "heads": 20,
+        "layers": 32,
+        "xattn": false,
+        "fusedLN": false
+    }
+}

spatial-model/VLM-3R/llava/model/multimodal_encoder/dev_eva_clip/eva_clip/model_configs/EVA-CLIP-8B.json

@@ -0,0 +1,27 @@
+{
+    "embed_dim": 1280,
+    "vision_cfg": {
+        "image_size": 224,
+        "layers": 32,
+        "width": 4096,
+        "head_width": 128,
+        "mlp_ratio": 5,
+        "patch_size": 14,
+        "eva_model_name": "eva-clip-8b-14-x",
+        "drop_path_rate": 0,
+        "qkv_bias": false,
+        "xattn": true,
+        "postnorm": false,
+        "fusedLN": false,
+        "use_rms_norm": true
+    },
+    "text_cfg": {
+        "context_length": 77,
+        "vocab_size": 49408,
+        "width": 1280,
+        "heads": 20,
+        "layers": 32,
+        "xattn": false,
+        "fusedLN": false
+    }
+}

spatial-model/VLM-3R/scripts/extract_spatial_features.py

@@ -0,0 +1,593 @@
+import argparse
+import os
+import sys # Added for path manipulation
+import torch
+import torch.nn as nn
+import torch.multiprocessing as mp # Added for multiprocessing
+from tqdm import tqdm
+import json
+import re
+import math
+import random
+import yaml
+from PIL import Image, ImageFile
+import numpy as np
+import copy
+from transformers import AutoProcessor # Added import
+from glob import glob # For finding video files
+from pathlib import Path # For path manipulation
+import traceback # For error reporting in subprocesses
+import h5py # Added for potential HDF5 saving (though not used currently for point clouds)
+
+# Assume necessary imports from llava are available in the PYTHONPATH
+# You might need to adjust imports based on your project structure
+from llava.utils import process_video_with_decord # Or other video processing functions used
+from llava.utils import rank0_print # Use rank0_print for controlled output
+from llava.train.train import DataArguments # Re-use DataArguments for consistency
+from llava.constants import DEFAULT_IMAGE_TOKEN
+from llava.model.multimodal_encoder.siglip_encoder import SigLipImageProcessor # Added direct import
+
+# Add imports for direct spatial tower loading
+from llava.model.multimodal_spatial_encoder.cut3r_spatial_encoder import Cut3rSpatialConfig, Cut3rEncoder
+from src.dust3r.model import ARCroco3DStereo # Import CUT3R model class
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+# --- Constants ---
+VIDEO_EXTENSIONS = ['.mp4', '.avi', '.mov', '.mkv'] # Add more if needed
+
+# --- Image/Video Loading and Preprocessing ---
+# (Adapted from LazySupervisedDataset and encode_spatial_features)
+
+def load_image(image_path):
+    try:
+        image = Image.open(image_path).convert("RGB")
+        return image
+    except Exception as e:
+        rank0_print(f"Error loading image {image_path}: {e}") # Use rank0_print
+        return None
+
+def preprocess_image_for_spatial(image, processor, target_size=(432, 432)):
+    """Preprocesses a single PIL image for spatial feature extraction using the provided processor."""
+    # Process using the vision model's processor
+    try:
+        processed_output = processor(images=image, return_tensors='pt')
+        image_tensor = processed_output['pixel_values'].squeeze(0) # Shape (C, H_proc, W_proc)
+    except Exception as e:
+        rank0_print(f"Error processing image with processor: {e}") # Use rank0_print
+        return None
+
+    # Resize to the target size expected by the spatial tower (if different)
+    c, h_proc, w_proc = image_tensor.shape
+    if h_proc != target_size[0] or w_proc != target_size[1]:
+        image_scaled = nn.functional.interpolate(
+            image_tensor.unsqueeze(0), # Add batch dim for interpolate
+            size=target_size,
+            mode='bilinear',
+            align_corners=False
+        ).squeeze(0) # Remove batch dim
+    else:
+        image_scaled = image_tensor
+
+    # Return shape (1, C, H_target, W_target) - batch dim added later before spatial tower
+    return image_scaled.unsqueeze(0)
+
+    # Old manual preprocessing:
+    # image_tensor = torch.from_numpy(np.array(image)).permute(2, 0, 1).float() / 255.0
+    # image_scaled = nn.functional.interpolate(image_tensor.unsqueeze(0), size=target_size, mode='bilinear', align_corners=False)
+    # return image_scaled # Output shape (1, C, H, W)
+
+def load_and_preprocess_video_frames(video_path, data_args, processor, target_size=(432, 432), rank=0):
+    """
+    Loads video, samples frames, preprocesses them using the processor,
+    and returns a tensor of shape (F, C, H_target, W_target).
+    Includes rank for logging.
+    """
+    try:
+        # Use the same video processing function as in training
+        video_frames, video_time, frame_time, num_frames_to_sample = process_video_with_decord(video_path, data_args)
+
+        # Preprocess all frames together using the processor
+        try:
+            # Ensure video_frames is a list of PIL Images or compatible format
+            processed_output = processor.preprocess(images=video_frames, return_tensors="pt")
+            frames_tensor = processed_output['pixel_values'] # Shape (F, C, H_proc, W_proc)
+        except Exception as e:
+            rank0_print(f"[GPU {rank}] Error processing video frames with processor for {video_path}: {e}")
+            return None
+
+        # Resize frames to the target size if necessary
+        f, c, h_proc, w_proc = frames_tensor.shape
+        if h_proc != target_size[0] or w_proc != target_size[1]:
+            # Interpolate expects (B, C, H, W) or (C, H, W)
+            # Process frame by frame or reshape if possible, let's do frame by frame for simplicity
+            frames_scaled_list = []
+            for i in range(f):
+                frame_scaled = nn.functional.interpolate(
+                    frames_tensor[i].unsqueeze(0), # Add batch dim
+                    size=target_size,
+                    mode='bilinear',
+                    align_corners=False
+                ).squeeze(0) # Remove batch dim
+                frames_scaled_list.append(frame_scaled)
+            frames_scaled = torch.stack(frames_scaled_list) # Shape (F, C, H_target, W_target)
+        else:
+            frames_scaled = frames_tensor
+
+        # Return shape (F, C, H_target, W_target) - Batch dim added later during batching
+        return frames_scaled
+
+    except Exception as e:
+        rank0_print(f"[GPU {rank}] Error processing video {video_path}: {e}")
+        return None
+
+# --- Main Extraction Logic ---
+
+def find_video_files(input_dir):
+    """Recursively finds all video files in the input directory."""
+    video_files = []
+    rank0_print(f"Scanning for video files in {input_dir}...")
+    for ext in VIDEO_EXTENSIONS:
+        # Using Path for easier relative path calculation
+        input_path = Path(input_dir)
+        # **/*{ext} finds files in input_dir and subdirectories
+        video_files.extend(input_path.rglob(f"*{ext}"))
+        # Case-insensitive search for extensions
+        video_files.extend(input_path.rglob(f"*{ext.upper()}"))
+
+    # Remove duplicates if extensions overlap (e.g., .MP4 and .mp4)
+    unique_video_files = sorted(list(set(video_files)))
+    rank0_print(f"Found {len(unique_video_files)} potential video files.")
+    return [str(f) for f in unique_video_files] # Return as strings
+
+def get_output_path(input_file_path: Path, input_base_dir: Path, output_base_dir: Path) -> Path:
+    """Calculates the output path for a given input file."""
+    try:
+        relative_path = input_file_path.relative_to(input_base_dir)
+    except ValueError:
+        rank0_print(f"Warning: Input file {input_file_path} is not within the specified base input directory {input_base_dir}. Outputting directly to {output_base_dir}.")
+        relative_path = input_file_path.name # Use only the filename
+
+    # Change extension to .pt
+    output_filename_path = output_base_dir / relative_path.with_suffix('.pt')
+    return output_filename_path
+
+def get_point_cloud_output_path(input_file_path: Path, input_base_dir: Path, point_cloud_output_base_dir: Path) -> Path:
+    """Calculates the output path for the point cloud corresponding to an input file."""
+    try:
+        relative_path = input_file_path.relative_to(input_base_dir)
+    except ValueError:
+        rank0_print(f"Warning: Input file {input_file_path} is not within the specified base input directory {input_base_dir}. Outputting point cloud directly to {point_cloud_output_base_dir}.")
+        relative_path = input_file_path.name # Use only the filename
+
+    # Change extension to .ply
+    output_filename_path = point_cloud_output_base_dir / relative_path.with_suffix('.ply')
+    return output_filename_path
+
+def get_preprocessed_frames_output_dir(input_file_path: Path, input_base_dir: Path, frames_output_base_dir: Path) -> Path:
+    """Calculates the output directory for the preprocessed frames corresponding to an input file."""
+    try:
+        relative_path = input_file_path.relative_to(input_base_dir)
+    except ValueError:
+        rank0_print(f"Warning: Input file {input_file_path} is not within the specified base input directory {input_base_dir}. Outputting frames directly under {frames_output_base_dir}.")
+        relative_path = input_file_path.stem # Use only the filename stem (no extension)
+
+    # Create a directory based on the relative path (without extension)
+    output_dir_path = frames_output_base_dir / relative_path.parent / relative_path.stem
+    return output_dir_path
+
+# --- Worker Process Function ---
+def process_videos_on_gpu(rank, gpu_id, args, video_files_chunk, input_base_dir, output_dir):
+    """
+    Worker function executed by each process to handle a chunk of videos on a specific GPU.
+    """
+    device = torch.device(f"cuda:{gpu_id}")
+    torch.cuda.set_device(device) # Ensure this process uses the assigned GPU
+
+    processed_count = 0
+    skipped_count = 0
+    total_files_in_chunk = len(video_files_chunk)
+    batch_size = args.batch_size
+
+    rank0_print(f"[GPU {gpu_id}] Worker started, assigned {total_files_in_chunk} files.")
+
+    # -- Load Model Components (within each worker process) --
+    try:
+        rank0_print(f"[GPU {gpu_id}] Loading CUT3R Spatial Tower...")
+        if not os.path.exists(args.cut3r_weights_path):
+            rank0_print(f"[GPU {gpu_id}] ERROR: CUT3R weights file not found at: {args.cut3r_weights_path}")
+            return 0, total_files_in_chunk # Return counts
+
+        # Pass point cloud config from args
+        cut3r_config = Cut3rSpatialConfig(
+            weights_path=args.cut3r_weights_path,
+            export_point_cloud=args.export_point_cloud,
+            point_cloud_output_dir=args.point_cloud_output_dir, # Pass base dir, specific file handled later
+            point_cloud_voxel_size=args.point_cloud_voxel_size
+        )
+        spatial_tower = Cut3rEncoder(config=cut3r_config)
+
+        model_dtype = torch.bfloat16 if args.precision == 'bf16' else torch.float16 if args.precision == 'fp16' else torch.float32
+        spatial_tower.to(device=device, dtype=model_dtype).eval()
+        rank0_print(f"[GPU {gpu_id}] CUT3R Spatial Tower loaded on {device}.")
+
+        # -- Load Image Processor Config and Initialize Processor --
+        rank0_print(f"[GPU {gpu_id}] Loading Processor config from {args.processor_config_path}...")
+        with open(args.processor_config_path, 'r') as f:
+            processor_config = json.load(f)
+
+        image_mean_list = processor_config.get("image_mean", (0.5, 0.5, 0.5))
+        image_std_list = processor_config.get("image_std", (0.5, 0.5, 0.5))
+        size_config = processor_config.get("size", {"height": 384, "width": 384})
+        size_tuple = (size_config["height"], size_config["width"])
+        resample_val = processor_config.get("resample", 3)
+        rescale_factor_val = processor_config.get("rescale_factor", 1/255.0)
+
+        image_processor = SigLipImageProcessor(
+            image_mean=image_mean_list,
+            image_std=image_std_list,
+            size=size_tuple,
+            resample=resample_val,
+            rescale_factor=rescale_factor_val
+        )
+        rank0_print(f"[GPU {gpu_id}] SigLipImageProcessor initialized.")
+
+        # Convert mean/std to tensors for de-normalization if saving frames
+        if args.save_preprocessed_frames:
+            mean_tensor = torch.tensor(image_mean_list, device=device).view(3, 1, 1)
+            std_tensor = torch.tensor(image_std_list, device=device).view(3, 1, 1)
+        else:
+            mean_tensor, std_tensor = None, None # Avoid unused variables
+
+    except Exception as e:
+        rank0_print(f"[GPU {gpu_id}] Error during initialization: {e}\n{traceback.format_exc()}")
+        return 0, total_files_in_chunk # Indicate all files skipped due to init error
+
+    # --- Load Dummy DataArguments ---
+    data_args = DataArguments(
+        video_fps=args.video_fps,
+        frames_upbound=args.frames_upbound,
+        force_sample=True
+    )
+
+    # --- Feature Extraction Loop for the Chunk (Batched Processing) ---
+    # Use tqdm only on rank 0 or manage it externally if needed
+    # Simple loop without per-process tqdm for now
+    for i in range(0, total_files_in_chunk, batch_size):
+        batch_paths_str = video_files_chunk[i:min(i + batch_size, total_files_in_chunk)]
+        batch_paths = [Path(p) for p in batch_paths_str]
+
+        # --- Batch Preprocessing ---
+        batch_data_to_process = [] # Stores (preprocessed_input, feature_output_filename, point_cloud_output_filename, video_full_path)
+        files_in_batch = 0
+        skipped_in_batch = 0
+        max_frames_in_batch = 0
+        point_cloud_base_dir = Path(args.point_cloud_output_dir) if args.export_point_cloud else None
+        frames_base_dir = Path(args.save_preprocessed_frames_dir) if args.save_preprocessed_frames else None
+
+        for video_full_path in batch_paths:
+            files_in_batch += 1
+            feature_output_filename_path = get_output_path(video_full_path, input_base_dir, output_dir)
+            feature_output_filename = str(feature_output_filename_path)
+
+            point_cloud_output_filename = None
+            if args.export_point_cloud and point_cloud_base_dir:
+                point_cloud_output_filename_path = get_point_cloud_output_path(video_full_path, input_base_dir, point_cloud_base_dir)
+                point_cloud_output_filename = str(point_cloud_output_filename_path)
+                # Ensure parent dir for point cloud exists
+                point_cloud_output_filename_path.parent.mkdir(parents=True, exist_ok=True)
+
+
+            # Check feature file existence
+            feature_output_filename_path.parent.mkdir(parents=True, exist_ok=True)
+            feature_exists = os.path.exists(feature_output_filename)
+
+            # Check point cloud existence (if exporting)
+            point_cloud_exists = False
+            if args.export_point_cloud and point_cloud_output_filename:
+                point_cloud_exists = os.path.exists(point_cloud_output_filename)
+
+            # Determine if skipping is needed
+            # Skip if NOT overwriting AND (feature exists AND (point cloud exists OR not exporting point cloud))
+            should_skip = not args.overwrite and (feature_exists and (point_cloud_exists or not args.export_point_cloud))
+
+            if should_skip:
+                skipped_in_batch += 1
+                continue
+
+
+            preprocessed_input = load_and_preprocess_video_frames(
+                str(video_full_path), data_args, image_processor, rank=gpu_id # Pass rank for logging
+            )
+
+            if preprocessed_input is not None and preprocessed_input.nelement() > 0:
+                # Store point cloud path only if exporting
+                pc_path_to_store = point_cloud_output_filename if args.export_point_cloud else None
+
+                # --- Save Preprocessed Frames (if enabled) ---
+                if args.save_preprocessed_frames and frames_base_dir is not None and mean_tensor is not None and std_tensor is not None:
+                    try:
+                        frames_output_dir_path = get_preprocessed_frames_output_dir(video_full_path, input_base_dir, frames_base_dir)
+                        frames_output_dir_path.mkdir(parents=True, exist_ok=True)
+
+                        # De-normalize and save each frame
+                        # Move tensor to CPU for processing/saving if it isn't already
+                        # Note: preprocessed_input is on CPU from load_and_preprocess...
+                        preprocessed_input_float = preprocessed_input.float() # Ensure float32 for calculation
+                        for frame_idx in range(preprocessed_input_float.shape[0]):
+                            frame_tensor = preprocessed_input_float[frame_idx] # Shape (C, H, W)
+
+                            # De-normalize: (tensor * std + mean) / rescale_factor
+                            # Assuming rescale_factor = 1/255.0
+                            # (tensor * std + mean) * 255.0
+                            # Move mean/std to the frame's device (likely CPU here)
+                            denormalized_frame = (frame_tensor * std_tensor.to(frame_tensor.device) + mean_tensor.to(frame_tensor.device)) / rescale_factor_val
+
+                            # Clamp and convert to uint8
+                            denormalized_frame = torch.clamp(denormalized_frame, 0, 255).to(torch.uint8)
+
+                            # Convert to PIL Image (C, H, W) -> (H, W, C)
+                            pil_image = Image.fromarray(denormalized_frame.permute(1, 2, 0).cpu().numpy())
+
+                            # Construct filename
+                            frame_filename = frames_output_dir_path / f"frame_{frame_idx:04d}.png"
+
+                            # Save the image
+                            pil_image.save(frame_filename)
+
+                    except Exception as e_save_frame:
+                        rank0_print(f"[GPU {gpu_id}] Error saving preprocessed frame for {video_full_path}, frame {frame_idx}: {e_save_frame}")
+                        # Continue processing other frames/videos
+
+                # Append data for batch inference
+                batch_data_to_process.append((preprocessed_input, feature_output_filename, pc_path_to_store, video_full_path))
+                max_frames_in_batch = max(max_frames_in_batch, preprocessed_input.shape[0])
+            else:
+                rank0_print(f"[GPU {gpu_id}] Failed to load/preprocess {video_full_path}. Skipping.")
+                skipped_in_batch += 1
+
+        # --- Batch Inference (True Batching) ---
+        processed_in_batch = 0
+        if batch_data_to_process:
+            padded_tensors = []
+            output_info = [] # Stores (feature_output_filename, point_cloud_output_filename, video_full_path)
+
+            for preprocessed_input, feature_output_filename, point_cloud_output_filename, video_full_path in batch_data_to_process:
+                num_frames = preprocessed_input.shape[0]
+                padding_needed = max_frames_in_batch - num_frames
+                padded_tensor = torch.nn.functional.pad(
+                    preprocessed_input,
+                    (0, 0, 0, 0, 0, 0, 0, padding_needed),
+                    mode='constant',
+                    value=0
+                )
+                padded_tensors.append(padded_tensor)
+                output_info.append((feature_output_filename, point_cloud_output_filename, video_full_path))
+
+            # Stack padded tensors into a single batch
+            # Note: Cut3rEncoder expects input shape (B, F, C, H, W) or (F, C, H, W)
+            # Our load function returns (F, C, H, W), stack adds batch: (B, F, C, H, W) ? Check stack dim.
+            # torch.stack(tensors, dim=0) makes (B, F, C, H, W)
+            # Let's adjust the input format if needed, assuming Cut3rEncoder handles (B, F, C, H, W) or (F, C, H, W)
+            # If it expects (F, B, C, H, W), need permute. Sticking with (B, F, C, H, W) for now.
+            batch_tensor = torch.stack(padded_tensors, dim=1).to(device=device, dtype=model_dtype) # Shape (F_max, B, C, H, W)
+            point_cloud_paths_for_batch = [info[1] for info in output_info] if args.export_point_cloud else None
+
+            try:
+                with torch.no_grad():
+                    # Pass batch_tensor directly. Cut3rEncoder handles iterating through frames internally.
+                    # Expected input is (B, F, C, H, W) or (F, C, H, W)
+                    # Expected output is (B * F, token_num, token_dim)
+                    # Pass point cloud paths if exporting
+                    camera_tokens_batch, patch_tokens_batch = spatial_tower(
+                        batch_tensor,
+                        point_cloud_output_paths=point_cloud_paths_for_batch # Pass the paths here
+                    )
+
+
+                # Reshape the outputs to separate Batch and Frame dimensions
+                B = batch_tensor.shape[0] # Actual batch size processed
+                F_max = max_frames_in_batch
+                # Note: The Cut3rEncoder might flatten B*F in the output. Confirm expected output shape.
+                # Assuming output is (B * F_max, token_num, token_dim)
+                expected_output_len = B * F_max
+                if camera_tokens_batch.shape[0] != expected_output_len:
+                    rank0_print(f"[GPU {gpu_id}] Warning: Output dimension mismatch. Expected {expected_output_len} but got {camera_tokens_batch.shape[0]}. Skipping save for this batch.")
+                    skipped_in_batch += B # Mark all items in batch as skipped
+                else:
+                    _, token_num_cam, token_dim_cam = camera_tokens_batch.shape
+                    _, token_num_patch, token_dim_patch = patch_tokens_batch.shape
+
+                    # View as (B, F_max, token_num, token_dim)
+                    camera_tokens_reshaped = camera_tokens_batch.view(B, F_max, token_num_cam, token_dim_cam)
+                    patch_tokens_reshaped = patch_tokens_batch.view(B, F_max, token_num_patch, token_dim_patch)
+
+                    for idx, (feature_output_filename, point_cloud_output_filename, video_full_path) in enumerate(output_info):
+                        try:
+                            # Save features regardless
+                            features_to_save = {
+                                "camera_tokens": camera_tokens_reshaped[idx].cpu(),
+                                "patch_tokens": patch_tokens_reshaped[idx].cpu()
+                            }
+                            torch.save(features_to_save, feature_output_filename)
+
+                            # Point cloud saving is handled inside spatial_tower if enabled
+
+                            processed_in_batch += 1
+                        except Exception as e_save:
+                            rank0_print(f"[GPU {gpu_id}] Error saving features for {video_full_path} (point cloud saving handled separately): {e_save}")
+                            skipped_in_batch += 1
+                            # Attempt to remove potentially corrupted feature file
+                            if os.path.exists(feature_output_filename):
+                                try: os.remove(feature_output_filename)
+                                except OSError: rank0_print(f"Warning: Could not remove potentially corrupted file {feature_output_filename}")
+                            # Note: Point cloud file removal isn't handled here as saving happens in the model
+
+            except Exception as e_batch:
+                rank0_print(f"[GPU {gpu_id}] Error during batch inference (features or point clouds): {e_batch}\n{traceback.format_exc()}")
+                skipped_in_batch += len(batch_data_to_process) - processed_in_batch
+
+        processed_count += processed_in_batch
+        skipped_count += skipped_in_batch
+
+        # Optional: Print progress per worker periodically
+        if (i // batch_size) % 10 == 0: # Print every 10 batches
+             rank0_print(f"[GPU {gpu_id}] Progress: Batch {i//batch_size+1}/{math.ceil(total_files_in_chunk/batch_size)}, Processed: {processed_count}, Skipped: {skipped_count}")
+
+
+    rank0_print(f"[GPU {gpu_id}] Worker finished. Processed: {processed_count}, Skipped: {skipped_count}")
+    return processed_count, skipped_count
+
+
+# --- Main Execution ---
+if __name__ == "__main__":
+    mp.set_start_method('spawn', force=True) # Recommended for CUDA with multiprocessing
+
+    parser = argparse.ArgumentParser(description="Extract Spatial Features using CUT3R (Multi-GPU)")
+    parser.add_argument("--cut3r-weights-path", type=str, required=True, help="Path to the CUT3R weights file (e.g., cut3r_512_dpt_4_64.pth)")
+    parser.add_argument("--input-dir", type=str, default=None, help="Root directory containing video files to process recursively (ignored if --input-file is provided)")
+    parser.add_argument("--input-file", type=str, default=None, help="Path to a single video file to process")
+    parser.add_argument("--output-dir", type=str, required=True, help="Root directory to save the extracted features, mirroring input structure")
+    parser.add_argument("--processor-config-path", type=str, required=True, help="Path to the processor_config.json file for SigLipImageProcessor")
+    # parser.add_argument("--device", type=str, default="cuda:0", help="Device to use (e.g., 'cuda:0', 'cpu')") # Replaced by gpu-ids
+    parser.add_argument("--gpu-ids", type=str, default="0", help="Comma-separated list of GPU IDs to use (e.g., '0,1,2') or 'all'")
+    parser.add_argument("--precision", type=str, default="fp16", choices=['fp16', 'bf16', 'fp32'], help="Computation precision")
+    parser.add_argument("--overwrite", action="store_true", help="Overwrite existing feature files")
+    parser.add_argument("--video-fps", type=int, default=1, help="FPS for video frame sampling")
+    parser.add_argument("--frames-upbound", type=int, default=10, help="Max frames to sample per video")
+    parser.add_argument("--batch-size", type=int, default=1, help="Number of videos to process per batch *per GPU*") # Clarified batch size scope
+    parser.add_argument("--export-point-cloud", action="store_true", help="Export generated point cloud for each video")
+    parser.add_argument("--point-cloud-output-dir", type=str, default="point_clouds", help="Directory to save exported point clouds (used if --export-point-cloud is set)")
+    parser.add_argument("--point-cloud-voxel-size", type=float, default=0.01, help="Voxel size for downsampling exported point clouds")
+    parser.add_argument("--save-preprocessed-frames", action="store_true", help="Save the preprocessed frames used for feature extraction as images")
+    parser.add_argument("--save-preprocessed-frames-dir", type=str, default="preprocessed_frames", help="Directory to save preprocessed frames (used if --save-preprocessed-frames is set)")
+
+    args = parser.parse_args()
+
+    # --- Validate Input Arguments ---
+    if not args.input_dir and not args.input_file:
+        parser.error("Either --input-dir or --input-file must be specified.")
+    if args.input_dir and args.input_file:
+        rank0_print("Warning: Both --input-dir and --input-file provided. --input-file will be used.")
+        args.input_dir = None # Prioritize input_file
+
+    # --- Determine GPUs to Use ---
+    if args.gpu_ids.lower() == 'all':
+        if torch.cuda.is_available():
+            num_gpus = torch.cuda.device_count()
+            gpu_ids = list(range(num_gpus))
+            if num_gpus == 0:
+                 rank0_print("Error: 'all' GPUs requested, but no CUDA devices found.")
+                 sys.exit(1)
+            rank0_print(f"Using all available GPUs: {gpu_ids}")
+        else:
+            rank0_print("Error: 'all' GPUs requested, but CUDA is not available.")
+            sys.exit(1)
+    else:
+        try:
+            gpu_ids = [int(id.strip()) for id in args.gpu_ids.split(',')]
+            # Validate GPU IDs
+            if torch.cuda.is_available():
+                num_gpus = torch.cuda.device_count()
+                for gpu_id in gpu_ids:
+                    if gpu_id < 0 or gpu_id >= num_gpus:
+                        rank0_print(f"Error: Invalid GPU ID {gpu_id}. Available GPUs: {list(range(num_gpus))}")
+                        sys.exit(1)
+            else:
+                 rank0_print(f"Warning: Specified GPU IDs {gpu_ids}, but CUDA is not available. Will attempt CPU if possible (not recommended/tested).")
+                 # Or exit if CPU processing is not intended/supported
+                 # sys.exit(1)
+            rank0_print(f"Using specified GPUs: {gpu_ids}")
+        except ValueError:
+            rank0_print(f"Error: Invalid format for --gpu-ids. Expected comma-separated integers (e.g., '0,1,2') or 'all'. Got: {args.gpu_ids}")
+            sys.exit(1)
+
+    if not gpu_ids:
+        rank0_print("Error: No valid GPUs specified or found.")
+        sys.exit(1)
+
+    num_workers = len(gpu_ids)
+
+    # --- Prepare Output Directory ---
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True) # Use Path.mkdir
+    if args.export_point_cloud:
+        pc_output_dir = Path(args.point_cloud_output_dir)
+        pc_output_dir.mkdir(parents=True, exist_ok=True)
+        rank0_print(f"Point clouds will be saved to: {args.point_cloud_output_dir}")
+    if args.save_preprocessed_frames:
+        frames_output_dir = Path(args.save_preprocessed_frames_dir)
+        frames_output_dir.mkdir(parents=True, exist_ok=True)
+        rank0_print(f"Preprocessed frames will be saved to: {args.save_preprocessed_frames_dir}")
+
+    # --- Determine Input Files ---
+    if args.input_file:
+        input_file_path = Path(args.input_file)
+        if not input_file_path.is_file():
+            rank0_print(f"Error: Provided --input-file '{args.input_file}' not found or is not a file.")
+            sys.exit(1)
+        all_video_files_paths = [input_file_path]
+        input_base_dir = Path(args.input_dir) if args.input_dir and input_file_path.is_relative_to(args.input_dir) else input_file_path.parent
+        rank0_print(f"Processing single input file: {args.input_file}")
+    elif args.input_dir:
+        input_base_dir = Path(args.input_dir)
+        # Find files needs Path objects
+        all_video_files_paths_str = find_video_files(args.input_dir)
+        all_video_files_paths = [Path(p) for p in all_video_files_paths_str] # Keep as Path objects
+        if not all_video_files_paths:
+            rank0_print(f"No video files found in {args.input_dir}. Exiting.")
+            sys.exit(0)
+        rank0_print(f"Found {len(all_video_files_paths)} video files in {args.input_dir}.")
+    else:
+        # This case should be caught by parser.error earlier
+        rank0_print("Error: No input specified.")
+        sys.exit(1)
+
+    # --- Distribute Files Among Workers ---
+    files_per_worker = [[] for _ in range(num_workers)]
+    for i, file_path in enumerate(all_video_files_paths):
+        worker_index = i % num_workers
+        # Pass file paths as strings to worker processes
+        files_per_worker[worker_index].append(str(file_path))
+
+    # --- Launch Worker Processes ---
+    rank0_print(f"Starting feature extraction with {num_workers} worker process(es) on GPUs {gpu_ids}...")
+    pool_args = []
+    for rank, gpu_id in enumerate(gpu_ids):
+        pool_args.append(
+            (rank, gpu_id, args, files_per_worker[rank], input_base_dir, output_dir)
+        )
+
+    total_processed = 0
+    total_skipped = 0
+    try:
+        with mp.Pool(processes=num_workers) as pool:
+            # Use starmap to pass multiple arguments to the worker function
+            results = pool.starmap(process_videos_on_gpu, pool_args)
+
+        # Aggregate results
+        for processed, skipped in results:
+            total_processed += processed
+            total_skipped += skipped
+
+    except Exception as e:
+         rank0_print(f"\n--- An error occurred during multiprocessing ---")
+         rank0_print(f"Error: {e}")
+         rank0_print(traceback.format_exc())
+         rank0_print("Feature extraction may be incomplete.")
+         # Ensure totals reflect potentially partial completion if some processes finished
+         if 'results' in locals():
+              for processed, skipped in results:
+                   total_processed += processed
+                   total_skipped += skipped
+         else: # If pool creation failed or starmap didn't even start
+              total_skipped = len(all_video_files_paths)
+
+
+    # --- Final Summary ---
+    rank0_print("-" * 30)
+    rank0_print(f"Feature extraction complete.")
+    rank0_print(f"Successfully processed: {total_processed}")
+    rank0_print(f"Skipped (exists or error): {total_skipped}")
+    rank0_print(f"Total files considered: {len(all_video_files_paths)}")
+    rank0_print(f"Features saved in: {args.output_dir}")

spatial-model/VLM-3R/scripts/qwen.py

@@ -0,0 +1,19 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+device = "cuda"  # the device to load the model onto
+
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-MoE-A2.7B-Chat", torch_dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen1.5-MoE-A2.7B-Chat")
+
+prompt = "Give me a short introduction to large language model."
+messages = [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": prompt}]
+text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+model_inputs = tokenizer([text], return_tensors="pt").to(device)
+
+generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512)
+generated_ids = [output_ids[len(input_ids) :] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)]
+
+response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+
+print(response)

spatial-model/VLM-3R/scripts/summarize_data.py

@@ -0,0 +1,81 @@
+import json
+import os
+from tqdm import tqdm
+
+with open("/mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA/playground/data/llava_v1_5_mix665k.json") as f:
+    llava_v1_5_mix665k = json.load(f)  # 665298
+
+with open("/mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA/playground/data/llava_instruct_150k.json") as f:
+    llava_instruct_150k = json.load(f)  # 157712
+
+# Create sets of "id" fields
+mix665k_ids = set()
+for item in llava_v1_5_mix665k:
+    all_conv = ""
+    for cur_conversation in item["conversations"]:
+        all_conv += cur_conversation["value"]
+    mix665k_ids.add(f'{item["id"]}_{all_conv}')
+
+instruct_150k_ids = set()
+for item in llava_instruct_150k:
+    all_conv = ""
+    for cur_conversation in item["conversations"]:
+        all_conv += cur_conversation["value"]
+    instruct_150k_ids.add(f'{item["id"]}_{all_conv}')
+
+share_gpt_ids = set()
+for item in llava_v1_5_mix665k:
+    if "image" not in item:
+        all_conv = ""
+        for cur_conversation in item["conversations"]:
+            all_conv += cur_conversation["value"]
+        share_gpt_ids.add(f'{item["id"]}_{all_conv}')  # 40688
+
+# Get "id" fields that are in mix665k but not in instruct_150k and share_gpt
+new_ids = mix665k_ids - instruct_150k_ids - share_gpt_ids  # 466898
+
+# Get "id" fields that are in mix665k but not in share_gpt
+# new_ids = mix665k_ids - share_gpt_ids #624610
+
+# import pdb; pdb.set_trace()
+
+# Filter mix665k data based on new_ids
+new_data = []
+for item in llava_v1_5_mix665k:
+    all_conv = ""
+    for cur_conversation in item["conversations"]:
+        all_conv += cur_conversation["value"]
+    if f'{item["id"]}_{all_conv}' in new_ids:
+        new_data.append(item)
+
+import pdb
+
+pdb.set_trace()
+
+with open("/mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA/playground/data/mixtral_instruct_135K_of_158K_V1.5.json") as f:
+    new_mixtral_instruct = json.load(f)
+
+# mixtral_instruct_50K_of_80K_V1.json@
+
+# print(len(new_data))
+# for _ in new_mixtral_instruct:
+#     # import pdb; pdb.set_trace()
+#     if "coco" not in _["image"]:
+#         _["image"] = f"coco/train2017/{_['image']}"
+#     new_data.append(_)
+
+# print(len(instruct_150k_ids))
+print(len(new_data))
+
+# for _ in tqdm(new_data):
+#     if "image" in _:
+#         if "000000442654" in _["image"]:
+#             all_conv = ""
+#             for cur_conversation in _["conversations"]:
+#                 all_conv += cur_conversation["value"]
+#         # if not os.path.exists(f'/mnt/bn/vl-research/workspace/boli01/data/playground/data/{_["image"]}'):
+#             import pdb; pdb.set_trace()
+
+# Write new_data to a new JSON file
+with open("/mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA/playground/data/llava_v1_5_mix665k_minus_llava_instruct_150k_minus_sharegpt_plus_mixtral_instruct_135K_of_158K_V1.5.json", "w") as f:
+    json.dump(new_data, f)

spatial-model/VLM-3R/scripts/zero2.json

@@ -0,0 +1,41 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+    "zero_optimization": {
+        "stage": 2,
+        "offload_optimizer": {
+            "device": "none",
+            "pin_memory": true
+        },
+        "allgather_partitions": true,
+        "allgather_bucket_size": 2e8,
+        "overlap_comm": false,
+        "reduce_scatter": true,
+        "reduce_bucket_size": 2e8,
+        "contiguous_gradients": true
+    },
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 100,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+}

spatial-model/VLM-3R/scripts/zero2_offload.json

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

spatial-model/VLM-3R/scripts/zero3.json

@@ -0,0 +1,41 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+
+    "zero_optimization": {
+        "stage": 3,
+        "offload_optimizer": {
+            "device": "none",
+            "pin_memory": true
+        },
+        "offload_param": {
+            "device": "none",
+            "pin_memory": true
+        },
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "sub_group_size": 1e9,
+        "reduce_bucket_size": "auto",
+        "stage3_prefetch_bucket_size": "auto",
+        "stage3_param_persistence_threshold": "auto",
+        "stage3_max_live_parameters": 1e9,
+        "stage3_max_reuse_distance": 1e9,
+        "stage3_gather_16bit_weights_on_model_save": true
+    },
+
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 100,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+}

spatial-model/VLM-3R/scripts/zero3_offload.json

@@ -0,0 +1,48 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+    "zero_optimization": {
+        "stage": 3,
+        "offload_optimizer": {
+            "device": "cpu",
+            "pin_memory": true
+        },
+        "offload_param": {
+            "device": "cpu",
+            "pin_memory": true
+        },
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "sub_group_size": 1e9,
+        "reduce_bucket_size": "auto",
+        "stage3_prefetch_bucket_size": "auto",
+        "stage3_param_persistence_threshold": "auto",
+        "stage3_max_live_parameters": 1e9,
+        "stage3_max_reuse_distance": 1e9,
+        "gather_16bit_weights_on_model_save": true
+    },
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "steps_per_print": 1e5,
+    "wall_clock_breakdown": false
+}

spatial-model/VLM-3R/scripts/zero3pp.json

@@ -0,0 +1,53 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+
+    "zero_optimization": {
+        "stage": 3,
+        "offload_optimizer": {
+            "device": "none",
+            "pin_memory": true
+        },
+        "offload_param": {
+            "device": "none",
+            "pin_memory": true
+        },
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "zero_quantized_weights": true,
+        "zero_hpz_partition_size": 16,
+        "zero_quantized_gradients": true,
+        "sub_group_size": 1e9,
+        "reduce_bucket_size": "auto",
+        "stage3_prefetch_bucket_size": "auto",
+        "stage3_param_persistence_threshold": "auto",
+        "stage3_max_live_parameters": 1e9,
+        "stage3_max_reuse_distance": 1e9,
+        "stage3_gather_16bit_weights_on_model_save": true
+    },
+
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 100,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+}

spatial-model/VLM-3R/thinking-in-space/tools/live_bench/live_bench/data_generator/live_bench_data.py

@@ -0,0 +1,139 @@
+import datasets
+from live_bench.data_generator.qa_generator import QAGenerator
+from live_bench.data_generator.question_finalizer import QuestionFinalizer
+from live_bench.data_generator.utils.extract_infomation import ImageInfomation
+from live_bench.screen_shoter.screen import ScreenImage
+
+
+class LiveBenchData(object):
+    SUBTASKS = ("Basic Understanding", "Contextual Analysis", "Deeper Implications", "Broader Implications", "Further Insights")
+
+    features = datasets.Features(
+        {
+            "id": datasets.Value("int32"),
+            "images": datasets.Sequence(datasets.Image()),
+            "website": datasets.Value("string"),
+            "question": datasets.Value("string"),
+            "answer": datasets.Value("string"),
+            "criteria": datasets.Value("string"),
+            "subtask": datasets.Value("string"),
+            "data_generator": datasets.Value("string"),
+            "checker": datasets.Value("string"),
+            "date_time": datasets.Value("string"),
+            "screen_shoter": datasets.Value("string"),
+            "screen_size": datasets.Value("string"),
+            "score": datasets.Value("int32"),
+            "reason": datasets.Value("string"),
+            "scorer_name": datasets.Value("string"),
+        }
+    )
+
+    def __init__(
+        self,
+        *,
+        screen: ScreenImage,
+        question: str,
+        answer: str,
+        criteria: str,
+        subtask: str,
+        data_generator: str,
+        infomation: ImageInfomation = None,
+        score: int = None,
+        reason: str = None,
+        checker: QAGenerator = None,
+        finalizer: QuestionFinalizer = None,
+        scorer_name=None,
+        scorer=None,
+    ):
+        self.screen = screen
+        self.question = question
+        self.answer = answer
+        self.criteria = criteria
+        self.subtask = subtask
+        self.data_generator = data_generator
+        self.infomation = infomation
+        self.checker = None
+        if checker:
+            response = checker.check(screen, question, answer, criteria, subtask, infomation=infomation)
+            if response.success:
+                formatted_response = checker.format_checked_response(response)
+                if formatted_response.question and formatted_response.answer and formatted_response.criteria:
+                    self.question = formatted_response.question
+                    self.answer = formatted_response.answer
+                    self.criteria = formatted_response.criteria
+                    if formatted_response.subtask:
+                        self.subtask = formatted_response.subtask
+                    else:
+                        self.subtask = subtask
+                    self.checker = checker.get_name()
+        if finalizer:
+            try:
+                qa = finalizer.finalize_question(self.question, self.answer, self.criteria, self.screen.images)
+            except Exception as e:
+                raise e
+            self.question = qa["question"]
+            self.answer = qa["answer"]
+            self.criteria = qa["criteria"]
+        if self.subtask:
+            for sub in LiveBenchData.SUBTASKS:
+                if sub.lower() in self.subtask.lower():
+                    self.subtask = sub
+                    break
+            else:
+                self.subtask = "Further Insights"
+        else:
+            self.subtask = "Not Specified"
+        if score is not None:
+            self.score = score
+            self.reason = reason
+            self.scorer_name = scorer_name
+        else:
+            score = scorer.get_score(question, answer, screen.images)
+            self.score = score.score
+            self.reason = score.reason
+            self.scorer_name = scorer.get_name()
+
+    def to_dict(self):
+        images = self.screen.images
+        website = self.screen.website.get_info()
+        question = self.question
+        answer = self.answer
+        subtask = self.subtask
+        data_generator = self.data_generator
+        date_time = self.screen.capture_datetime
+        screen_shoter = self.screen.shoter
+        screen_size = self.screen.screen_size
+        criteria = self.criteria
+        return {
+            "images": images,
+            "website": website,
+            "question": question,
+            "answer": answer,
+            "criteria": criteria,
+            "subtask": subtask,
+            "data_generator": data_generator,
+            "checker": self.checker,
+            "date_time": date_time,
+            "screen_shoter": screen_shoter,
+            "screen_size": screen_size,
+            "score": self.score,
+            "reason": self.reason,
+            "scorer_name": self.scorer_name,
+        }
+
+    def to_hf_dict(self):
+        return self.features.encode_example(self.to_dict())
+
+    def to_output_dict(self):
+        return {
+            "screen": self.screen.to_output_dict(),
+            "question": self.question,
+            "answer": self.answer,
+            "criteria": self.criteria,
+            "subtask": self.subtask,
+            "data_generator": self.data_generator,
+            "checker": self.checker,
+            "score": self.score,
+            "reason": self.reason,
+            "scorer_name": self.scorer_name,
+        }

spatial-model/VLM-3R/thinking-in-space/tools/live_bench/live_bench/data_generator/prompt.md

@@ -0,0 +1,17 @@
+I would like you to act as a quizmaster who designs questions based on a provided image that would challenge adults to think critically. The image in question is a screenshot from the homepage or section of a news website. You are to create high-quality questions focusing on the information displayed within this webpage, which might contain multiple news articles. Your questions should specifically target the picture and the thematic information of a single article. Your question should be answerable, and checkable. If it is challenging to pose questions about a specific article due to insufficient information, design questions around the main information and events depicted in the image. Within your capabilities, try to make the questions more challenging.
+
+A well-crafted question about an event should allow respondents to gain deeper insights by observing and analyzing the event, paying attention to the following aspects:
+
+- Basic Understanding: Questions that require direct observation or recall of the information presented in the image. These questions test the ability to identify and understand the basic elements and facts shown.
+- Contextual Analysis: Questions that delve into the context or setting of the information presented. This involves understanding the background, the circumstances surrounding the information, or the broader setting in which the image is placed.
+- Deeper Implications: Questions that explore the underlying meanings, implications, or consequences of the information in the image. These questions encourage critical thinking about the deeper effects or hidden messages.
+- Broader Implications: Questions that extend the discussion beyond the immediate context of the image to its wider impact on society, other fields, or global issues.
+- Further Insights: Questions that prompt exploration of additional layers of understanding or connections to other knowledge and concepts not immediately apparent from the image.
+
+Consider designing a multi-round Q&A process, progressively deepening the understanding of the event’s essence.
+
+Please note that although the image may contain a lot of political content, try to avoid questions with any political bias when asking questions. Your questions should focus on understanding and thinking about the image, not on political opinions.
+
+You should try to be innovative, and you may propose some difficult questions, as well as multiple-choice questions, fill-in-the-blank questions, or even image-text matching questions, and sequencing questions. Within your capabilities, try to make the questions more challenging.
+
+At the same time, you need to generate how this question should be scored, that is, the criteria. Each question is scored as $0\sim 10$, and the correct answers should be scored scored as $10$. Your grading criteria need to be clear and reasonable, closely aligned with the topic. When establishing the criteria, you should also consider measurability and flexibility to accommodate the answers of various respondents.

spatial-model/VLM-3R/thinking-in-space/tools/live_bench/live_bench/data_generator/question_finalizer.py

@@ -0,0 +1,138 @@
+import json
+import os
+from abc import ABC, abstractmethod
+from typing import List
+
+import anthropic
+import google.generativeai as genai
+import openai
+from live_bench.data_generator.qa_generator import QAData
+from live_bench.data_generator.utils.claude import (
+    claude_generate_response,
+    format_claude_images,
+)
+from live_bench.data_generator.utils.gemini import gemini_generate_response
+from live_bench.data_generator.utils.gpt4v import (
+    format_gpt4v_images,
+    gpt4v_generate_response,
+)
+from PIL import Image
+
+REJECT_TO_ANSWER = "Reject to answer"
+
+
+class AnswerGetter(ABC):
+    @abstractmethod
+    def get_answer(self, question: str, images: List[Image.Image]):
+        raise NotImplementedError("get_answer not implemented")
+
+
+class GPT4VAnswerGetter(AnswerGetter):
+    def __init__(self, model: str = "gpt-4o", api_key=None):
+        self.model = model
+        if api_key is None:
+            self.api_key = os.getenv("OPENAI_API_KEY", None)
+        else:
+            self.api_key = api_key
+        self.client = openai.OpenAI(api_key=self.api_key)
+
+    def get_answer(self, question: str, images: List[Image.Image]):
+        messages = [{"role": "user", "content": format_gpt4v_images(images) + [{"type": "text", "text": question}]}]
+        response = gpt4v_generate_response(messages=messages, client=self.client, model=self.model)
+        if response.success:
+            return response.content
+        else:
+            return REJECT_TO_ANSWER
+
+
+class ClaudeAnswerGetter(AnswerGetter):
+    def __init__(self, model: str = "claude-3-5-sonnet-20240620", api_key=None):
+        self.model = model
+        if api_key is None:
+            self.api_key = os.getenv("ANTHROPIC_API_KEY", None)
+        else:
+            self.api_key = api_key
+        self.client = anthropic.Anthropic(api_key=self.api_key)
+
+    def get_answer(self, question: str, images: List[Image.Image]):
+        messages = [{"role": "user", "content": format_claude_images(images) + [{"type": "text", "text": question}]}]
+        response = claude_generate_response(self.client, self.model, messages)
+        if response.success:
+            return response.content
+        else:
+            return REJECT_TO_ANSWER
+
+
+class GeminiAnswerGetter(AnswerGetter):
+    def __init__(self, model: str = "gemini-1.5-pro", api_key=None):
+        self.model = model
+        self.client = genai.GenerativeModel(model)
+
+    def get_answer(self, question: str, images: List[Image.Image]):
+        response = gemini_generate_response(self.client, images + [question], max_tokens=2048)
+        if response.success:
+            return response.content
+        else:
+            return REJECT_TO_ANSWER
+
+
+QUESTION_FINALIZER_PROMPT = """\
+You are a question setter, and your task is to modify the following question, answer, and scoring criteria to ensure:
+
+1. The question is clear and unambiguous.
+2. The answer is correct and reasonable (although the original ground truth answer is mostly correct, it may not be perfect, and sometimes the answer maybe incorrect).
+3. The scoring criteria are rational and facilitate the accurate assessment of responses.
+4. The full score for the scoring criteria must be 10 points, and it must directly relate to the specific answer.
+5. Except for some multiple-choice questions or other questions with only one possible answer, the scoring criteria should not be an all-or-nothing system. Partially correct answers should receive proportional points.
+6. Ensure that the scoring system is flexible enough to accommodate slight variations in correct answers while still maintaining a standard for what is considered an acceptable answer.
+7. Clearly define what constitutes a full score, partial score, and zero score.
+8. The criteria should be as detailed as possible, even if a LLM without image understanding capabilities could still score the answer based on the criteria and ground truth answer correctly.
+
+Your task is to finalize these standards, thus ensuring the correctness of the answer and the rationality of the scoring criteria.
+
+Some tips:
+
+1. For some extremely hard open-ended questions where answers may vary, hitting all points perfectly may not be realistic. In such cases, you can relax the criteria slightly. For example, if there are five possible points in an answer, but answering three adequately could merit full points. An other option is to change the question to a multiple-choice / multi-select question. But remember, it only applies to extremely hard open-ended questions which are impossible to answer perfectly.
+2. For some questions, changing the format might be beneficial. You can consider transforming them into different types of questions such as essay, fill-in-the-blank, multiple-choice (or multiple-select), true/false, ranking (e.g., based on time, importance, etc.), or matching questions to enhance the difficulty and rationality of the scoring criteria.
+"""
+
+FINALIZER_OUTPUT_FORMAT_PROMPT = """\
+Please provide the final question, answer, and scoring criteria in the following json format:
+{
+    "question": "The final question",
+    "answer": "The final answer",
+    "criteria": "The final scoring criteria"
+}
+
+One thing as a reminder is that if you want to add a new line in the json string, you should use the escape character "\\n" instead to represent the new line.
+"""
+
+
+class QuestionFinalizer(object):
+    def __init__(self, gpt4v_model: str = "gpt-4o", claude_model: str = "claude-3-5-sonnet-20240620", gemini_model: str = "gemini-1.5-pro"):
+        self.models = {"GPT4V": GPT4VAnswerGetter(gpt4v_model), "Claude": ClaudeAnswerGetter(claude_model), "Gemini": GeminiAnswerGetter(gemini_model)}
+        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY", None))
+        # self.client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY", None))
+
+    def finalize_question(self, question, answer, criteria, images: List[Image.Image]):
+        information = [f"[Original Question]\n{question}", f"[Original Answer]\n{answer}", f"[Original Criteria]\n{criteria}"]
+        information.append(
+            "Below are answers from three candidates for reference. These answers may not be correct but are reasonably credible (but mostly correct). If any candidate rejects to answer, consider whether there is an issue with the question (such as containing violent or graphic content, or having a clear political bias). If so, please make necessary modifications. For open-ended questions, also consider the reasonableness of these answers. If they are reasonable, you may need to adjust the scoring criteria or the answer itself."
+        )
+        for model_name, model in self.models.items():
+            information.append(f"[{model_name} Answer]\n{model.get_answer(question, images)}")
+        information.append(FINALIZER_OUTPUT_FORMAT_PROMPT)
+        prompt = "\n\n".join(information)
+        messages = [{"role": "user", "content": format_gpt4v_images(images) + [{"type": "text", "text": prompt}]}]
+        try:
+            response = gpt4v_generate_response(client=self.client, model="gpt-4o", messages=messages, system=QUESTION_FINALIZER_PROMPT)
+            if response.success:
+                data = json.loads(response.content)
+                return {
+                    "question": data["question"],
+                    "answer": data["answer"],
+                    "criteria": data["criteria"],
+                }
+        except Exception as e:
+            print(f"Failed to generate response: {e}")
+            return None