Datasets:

Torwnexial
/

temp

Problem: In the original format, subset_concepts and correct_order had the same sequence, allowing models to answer "ABCD" based on position bias rather than true temporal understanding.

Solution: Now correct_order (temporal sequence) is randomly shuffled, while subset_concepts maintains fixed label order (A, B, C, D).

Example

Before (Flawed):

{
  "subset_concepts": ["signpost", "shipping container", "fire hydrant", "tower"],
  "correct_order": ["signpost", "shipping container", "fire hydrant", "tower"],
  "answer": "ABCD"
}
// Model can answer "ABCD" by position bias → CORRECT (undeserved)

After (Fixed):

{
  "subset_concepts": ["signpost", "shipping container", "fire hydrant", "tower"],
  "correct_order": ["shipping container", "tower", "signpost", "fire hydrant"],
  "answer": "BDAC"
}
// Model must understand: B→D→A→C, not just output "ABCD"

Label Mapping (Fixed):

A = signpost
B = shipping container
C = fire hydrant
D = tower

Temporal Sequence (Shuffled): shipping container → tower → signpost → fire hydrant

Answer: "BDAC" (must map temporal order to fixed labels)

Data Files

File	Size	Videos	Eval Items	Description
`part1_long_videos_all.json`	26MB	40	20,705	Long videos, all tasks, dual format
`part2_short_place_motion.json`	37MB	426	18,154	Short videos, spatial & motion tasks
`part3_short_objects.json`	14MB	426	21,828	Short videos, object tasks, dual format

Data Structure

Part 1: Long Videos (40 videos, 111.9 hours)

Source: new_long_video/corrected_json_2 (fully rechecked)

Tasks:

Task	Format	Eval Items	Metric
Object Counting	Fill-in-blank	3,799	MRA
First Appearance Recall	Choice + Direct	1,559 × 2	Acc / Exact Match
Last Appearance Recall	Choice + Direct	1,506 × 2	Acc / Exact Match
Frame Recall (Baseline)	Multiple Choice	4,770	Accuracy
Frame Recall (Rotated)	Multiple Choice	4,770	Accuracy
Motion Direction	Multiple Choice	1,236	Accuracy

Part 2: Short Videos - Place & Motion (426 videos)

Tasks:

Task	Format	Eval Items	Metric
Frame Recall (Baseline)	Multiple Choice	8,040	Accuracy
Frame Recall (Rotated)	Multiple Choice	8,040	Accuracy
Motion Direction	Multiple Choice	2,074	Accuracy

Part 3: Short Videos - Objects (426 videos)

⚠️ Note: Partially rechecked

Tasks:

Task	Format	Eval Items	Metric
Object Counting	Fill-in-blank	7,396	MRA
First Appearance Recall	Choice + Direct	3,608 × 2	Acc / Exact Match
Last Appearance Recall	Choice + Direct	3,608 × 2	Acc / Exact Match

Appearance Task Format Details

Direct Order Format (`*_direct`)

{
  "task_type": "first_appearance_recall_direct",
  "question_format": "direct_order",
  "evaluation_metric": "exact_match",
  "subset_concepts": ["signpost", "shipping container", "fire hydrant", "tower"],
  "correct_order": ["shipping container", "tower", "signpost", "fire hydrant"],
  "original_order": ["signpost", "shipping container", "fire hydrant", "tower"],
  "shuffled": true,
  "question": "[Direct-Order] Arrange by first appearance: signpost, shipping container, fire hydrant, tower",
  "checkpoints": [{
    "checkpoint": 10,
    "answer": "BDAC",
    "concepts_seen": ["shipping container", "tower", "signpost", "fire hydrant"]
  }]
}

Label Mapping:

A → signpost
B → shipping container
C → fire hydrant
D → tower

Temporal Order: B → D → A → C

Prompt Template:

Arrange objects by first appearance:

Objects:
A) signpost
B) shipping container
C) fire hydrant
D) tower

Output the order as a sequence of 4 letters.
Answer with only the 4 letters in order, nothing else.

Expected Answer: "BDAC"

Why this prevents bias: Model cannot simply output "ABCD". It must understand that "shipping container" (B) appears first, then "tower" (D), etc.

Choice Format (`*_choice`)

{
  "task_type": "first_appearance_recall_choice",
  "question_format": "single_choice",
  "evaluation_metric": "accuracy",
  "subset_concepts": ["signpost", "shipping container", "fire hydrant", "tower"],
  "question": "[Single-Choice] Arrange by first appearance: signpost, shipping container, fire hydrant, tower",
  "checkpoints": [{
    "options": [
      "A) signpost → shipping container → fire hydrant → tower",
      "B) shipping container → tower → signpost → fire hydrant",
      "C) fire hydrant → signpost → tower → shipping container",
      "D) tower → fire hydrant → shipping container → signpost"
    ],
    "answer": "B"
  }]
}

Correct Option: "B) shipping container → tower → signpost → fire hydrant"

Evaluation Guide

Loading Data

import json

# Load Part 1 (long videos)
with open('benchmark_shuffled/part1_long_videos_all.json') as f:
    part1 = json.load(f)

# Access a video
video = part1['videos'][0]
task = video['tasks'][0]  # First task

if 'first_appearance_recall_direct' in task['task_type']:
    # Direct order format
    concepts = task['subset_concepts']  # Fixed order
    label_map = {c: chr(ord('A')+i) for i, c in enumerate(concepts)}
    
    for cp in task['checkpoints']:
        if cp.get('answer'):
            correct_order = cp['correct_order']  # Shuffled temporal order
            answer = cp['answer']  # Sequence like "BDAC"
            
            # Verify
            expected = ''.join([label_map[c] for c in correct_order])
            assert answer == expected, "Answer mismatch!"

Direct Format Evaluation

def evaluate_direct(model, task, video_path=None):
    """Evaluate direct order format task."""
    results = []
    
    concepts = task['subset_concepts']  # Fixed order
    
    # Build concept list for prompt
    concept_list = '\n'.join([f"{chr(ord('A')+i)}) {c}" for i, c in enumerate(concepts)])
    n = len(concepts)
    
    for cp in task['checkpoints']:
        if cp.get('answer') is None:
            continue
        
        # Build prompt
        prompt = f"""{task['question']}

Objects:
{concept_list}

Output the order as a sequence of {n} letters.
Answer with only the {n} letters in order, nothing else."""
        
        # Get prediction
        pred = model.generate(prompt, video_path)
        pred_seq = parse_sequence(pred)
        
        # Check correctness (exact match)
        is_correct = (pred_seq == cp['answer'])
        
        results.append({
            'gt': cp['answer'],
            'pred': pred_seq,
            'correct': is_correct
        })
    
    return results


def parse_sequence(text):
    """Parse sequence like 'BDAC' from model output."""
    import re
    text = text.upper()
    text = text.replace('→', '').replace('->', '').replace(' ', '').replace(',', '')
    match = re.search(r'[ABCD]{2,4}', text)
    if match:
        return match.group(0)
    return ''

Choice Format Evaluation

def evaluate_choice(model, task, video_path=None):
    """Evaluate choice format task."""
    results = []
    
    for cp in task['checkpoints']:
        if cp.get('answer') is None:
            continue
        
        # Build prompt
        prompt = f"""{task['question']}

Options:
{chr(10).join(cp['options'])}

Answer with only the letter (A, B, C, or D)."""
        
        # Get prediction
        pred = model.generate(prompt, video_path)
        pred_letter = extract_letter(pred)
        
        # Check correctness
        is_correct = (pred_letter == cp['answer'])
        
        results.append({
            'gt': cp['answer'],
            'pred': pred_letter,
            'correct': is_correct
        })
    
    return results


def extract_letter(text):
    """Extract A/B/C/D from model output."""
    text = text.upper()
    for letter in ['A', 'B', 'C', 'D']:
        if letter in text:
            return letter
    return 'A'

Object Counting Evaluation

def evaluate_counting(model, task, video_path=None):
    """Evaluate object counting task."""
    results = []
    
    for cp in task['checkpoints']:
        if cp.get('answer') is None:
            continue
        
        prompt = f"""{task['question']}

You are at checkpoint {cp['checkpoint']} of {cp['checkpoint_of']}.

Answer with only a single integer number."""
        
        pred = model.generate(prompt, video_path)
        nums = re.findall(r'\d+', pred)
        pred_val = int(nums[0]) if nums else 0
        gt_val = cp['answer']
        
        # MRA metric
        mra = max(0.0, 1.0 - abs(pred_val - gt_val) / max(gt_val, 1))
        
        results.append({
            'gt': gt_val,
            'pred': pred_val,
            'mra': mra
        })
    
    return results

Metrics Calculation

Accuracy (Choice tasks)

accuracy = sum(r['correct'] for r in results) / len(results) * 100

Exact Match (Direct tasks)

exact_match = sum(r['correct'] for r in results) / len(results) * 100

MRA (Counting tasks)

mra = sum(r['mra'] for r in results) / len(results) * 100

Dual Format Comparison

Run both formats on same checkpoints:

# Load both formats
choice_task = load_task('first_appearance_recall_choice')
direct_task = load_task('first_appearance_recall_direct')

# Evaluate
choice_results = evaluate_choice(model, choice_task, video_path)
direct_results = evaluate_direct(model, direct_task, video_path)

# Compare
choice_acc = sum(r['correct'] for r in choice_results) / len(choice_results)
direct_acc = sum(r['correct'] for r in direct_results) / len(direct_results)

print(f"Choice: {choice_acc:.2%}")
print(f"Direct: {direct_acc:.2%}")
print(f"Gap: {choice_acc - direct_acc:.2%}")

Expected Gap:

First Appearance: ~40% (60% → 20%)
Last Appearance: ~44% (55% → 11%)

Large gap → model relies on bias/heuristics
Small gap → model truly understands temporal order

Data Quality

Part	Quality	Recommendation
Part 1	✅ Fully rechecked	Publication-ready
Part 2	✅ Standard	Publication-ready
Part 3	⚠️ Partially rechecked	Development only

Migration to Other Clusters

1. Transfer Package

tar -czf benchmark_shuffled.tar.gz benchmark_shuffled/
scp benchmark_shuffled.tar.gz user@cluster:/data/benchmarks/
ssh user@cluster "cd /data/benchmarks/ && tar -xzf benchmark_shuffled.tar.gz"

2. Install Dependencies

pip install transformers>=4.40.0 torch>=2.0.0 qwen-vl-utils

3. Run Evaluation

python your_eval_script.py --data benchmark_shuffled/part1_long_videos_all.json

Citation

@dataset{cambrian_w_2025,
  title={Cambrian-W: Panoramic Video Understanding Benchmark},
  year={2025},
  note={Shuffled Correct Order, Dual Format Version}
}

File Manifest

benchmark_shuffled/
├── README.md                    # This file
├── part1_long_videos_all.json   # 40 videos
├── part2_short_place_motion.json # 426 videos
└── part3_short_objects.json     # 426 videos

Key Points for Implementation

Fixed Labels: subset_concepts order determines A, B, C, D labels
Shuffled Order: correct_order is temporal sequence (randomized)
Answer Mapping: Answer is sequence of labels based on correct_order
No Position Bias: Model cannot simply output "ABCD"

Example Verification:

concepts = ['signpost', 'shipping container', 'fire hydrant', 'tower']
# Labels: A=signpost, B=shipping container, C=fire hydrant, D=tower

correct_order = ['shipping container', 'tower', 'signpost', 'fire hydrant']
# Temporal: B → D → A → C

answer = 'BDAC'
# Expected answer

# Verify
label_map = {c: chr(ord('A')+i) for i, c in enumerate(concepts)}
expected = ''.join([label_map[c] for c in correct_order])
assert answer == expected  # 'BDAC' == 'BDAC' ✓

Ready for cluster deployment! 🚀

Cambrian-W Benchmark - Shuffled Correct Order

Critical Fix: Shuffled Temporal Order

Example

Data Files

Data Structure

Part 1: Long Videos (40 videos, 111.9 hours)

Part 2: Short Videos - Place & Motion (426 videos)

Part 3: Short Videos - Objects (426 videos)

Appearance Task Format Details

Direct Order Format (*_direct)

Choice Format (*_choice)

Evaluation Guide

Loading Data

Direct Format Evaluation

Choice Format Evaluation

Object Counting Evaluation

Metrics Calculation

Accuracy (Choice tasks)

Exact Match (Direct tasks)

MRA (Counting tasks)

Dual Format Comparison

Data Quality

Migration to Other Clusters

1. Transfer Package

2. Install Dependencies

3. Run Evaluation

Citation

File Manifest

Key Points for Implementation

Direct Order Format (`*_direct`)

Choice Format (`*_choice`)