tests/test_spatial_beats_integration.py

#!/usr/bin/env python3
"""Integration tests for the Spatial-BEATs (v11a, 10 Hz) encoder wrapper.

Usage:
    python tests/test_spatial_beats_integration.py
"""

import os
import sys
import traceback

# --- Setup paths ---
REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
BEATS_REPO = os.path.normpath(os.path.join(REPO_ROOT, "..", "unilm", "beats"))

sys.path.insert(0, REPO_ROOT)
sys.path.insert(0, BEATS_REPO)

import torch

CHECKPOINT_PATH = os.path.join(
    BEATS_REPO,
    "checkpoints",
    "spatial_beats_ov1_local_spatial_v11a_real_balanced_10hz_exp",
    "03_ov123_top4",
    "best.pt",
)

SAMPLE_RATE = 16000
LLM_HIDDEN_SIZE = 3584
ENCODER_DIM = 768
PROJECTOR_HIDDEN_DIM = 768
ENCODER_TOKEN_RATE = 10.0   # v11a native
LLM_TOKEN_RATE = 2.5        # after pixel-shuffle k=4
SHUFFLE_FACTOR = 4

results = []


def report(name, passed, detail=""):
    status = "PASS" if passed else "FAIL"
    results.append((name, passed))
    msg = f"[{status}] {name}"
    if detail:
        msg += f" -- {detail}"
    print(msg)


def test_encoder_single_clip():
    """v11a emits 10 Hz natively; 10s clip → 100 tokens @ dim 768."""
    from spatial_qwen.modules.spatial_beats_encoder import (
        SpatialBEATsEncoderWrapper, SpatialBEATsEncoderOutput,
    )
    wrapper = SpatialBEATsEncoderWrapper(
        checkpoint_path=CHECKPOINT_PATH, beats_repo_path=BEATS_REPO,
        freeze_backbone=True, max_audio_seconds=20.0,
        encoder_token_rate=ENCODER_TOKEN_RATE,
    )
    wrapper._build_model()
    B, T_audio = 1, SAMPLE_RATE * 10
    spatial_audio = torch.randn(B, T_audio, 4)
    with torch.no_grad():
        out = wrapper(spatial_audio=spatial_audio)
    assert isinstance(out, SpatialBEATsEncoderOutput)
    expected_tokens = int(round(10 * ENCODER_TOKEN_RATE))
    assert out.spatial_tokens.shape == (1, expected_tokens, ENCODER_DIM), \
        f"Expected [1, {expected_tokens}, {ENCODER_DIM}], got {list(out.spatial_tokens.shape)}"
    assert out.spatial_token_lengths[0].item() == expected_tokens
    report("encoder_single_clip_10hz", True,
           f"shape={list(out.spatial_tokens.shape)}, length={out.spatial_token_lengths.tolist()}")
    return wrapper


def test_encoder_variable_batch(wrapper):
    """Variable-length FOA → per-sample encoder token lengths at 10 Hz."""
    B, T_max = 2, SAMPLE_RATE * 10
    spatial_audio = torch.randn(B, T_max, 4)
    lengths = torch.tensor([SAMPLE_RATE * 10, SAMPLE_RATE * 8], dtype=torch.long)
    with torch.no_grad():
        out = wrapper(spatial_audio=spatial_audio, spatial_audio_lengths=lengths)
    expected_lengths = [
        int(round(10 * ENCODER_TOKEN_RATE)),
        int(round(8 * ENCODER_TOKEN_RATE)),
    ]
    actual_lengths = out.spatial_token_lengths.tolist()
    assert out.spatial_tokens.shape[0] == B
    assert out.spatial_tokens.shape[1] == int(round(10 * ENCODER_TOKEN_RATE))
    assert out.spatial_tokens.shape[2] == ENCODER_DIM
    assert actual_lengths == expected_lengths, \
        f"Expected {expected_lengths}, got {actual_lengths}"
    report("encoder_variable_batch_2_10hz", True,
           f"shape={list(out.spatial_tokens.shape)}, lengths={actual_lengths}")


def test_projector_pixel_shuffle_k4():
    """pixel_shuffle(k=4) collapses 10 Hz → 2.5 Hz and maps 768 → 3584."""
    from spatial_qwen.modules.spatial_token_projector import (
        build_spatial_token_projector,
    )
    proj = build_spatial_token_projector(
        projector_type="pixel_shuffle",
        input_dim=ENCODER_DIM,
        hidden_dim=PROJECTOR_HIDDEN_DIM,
        output_dim=LLM_HIDDEN_SIZE,
        shuffle_factor=SHUFFLE_FACTOR,
    )
    B, T_s_enc = 2, int(round(20 * ENCODER_TOKEN_RATE))  # 200
    tokens = torch.randn(B, T_s_enc, ENCODER_DIM)
    out = proj(tokens)
    expected_T = T_s_enc // SHUFFLE_FACTOR  # 50
    assert out.shape == (B, expected_T, LLM_HIDDEN_SIZE), \
        f"Expected [{B}, {expected_T}, {LLM_HIDDEN_SIZE}], got {list(out.shape)}"
    report("projector_pixel_shuffle_k4", True,
           f"in={list(tokens.shape)} → out={list(out.shape)}")


def test_encoder_plus_projector_end_to_end(wrapper):
    """Wire encoder(10 Hz) → pixel_shuffle(k=4) → [B, 25, 3584] for 10s clip."""
    from spatial_qwen.modules.spatial_token_projector import (
        build_spatial_token_projector,
    )
    proj = build_spatial_token_projector(
        projector_type="pixel_shuffle",
        input_dim=ENCODER_DIM,
        hidden_dim=PROJECTOR_HIDDEN_DIM,
        output_dim=LLM_HIDDEN_SIZE,
        shuffle_factor=SHUFFLE_FACTOR,
    )
    B, T_audio = 1, SAMPLE_RATE * 10
    spatial_audio = torch.randn(B, T_audio, 4)
    with torch.no_grad():
        enc_out = wrapper(spatial_audio=spatial_audio)
        projected = proj(enc_out.spatial_tokens)
    expected_T = int(round(10 * LLM_TOKEN_RATE))  # 25
    assert projected.shape == (B, expected_T, LLM_HIDDEN_SIZE), \
        f"Expected [1, {expected_T}, {LLM_HIDDEN_SIZE}], got {list(projected.shape)}"
    report("encoder_to_projector_end_to_end", True,
           f"10s clip → encoder {list(enc_out.spatial_tokens.shape)} → projector {list(projected.shape)}")


def test_spatial_mask():
    SPATIAL_TOKEN_ID = 999999
    B, T_text, T_s = 2, 80, 50  # 20s clip at 2.5 Hz = 50 placeholders
    input_ids = torch.randint(0, 1000, (B, T_text))
    for b in range(B):
        input_ids[b, 10:10 + T_s] = SPATIAL_TOKEN_ID
    mask = (input_ids == SPATIAL_TOKEN_ID)
    count = mask.sum().item()
    expected = B * T_s
    assert count == expected, f"Expected {expected} spatial positions, got {count}"
    report("spatial_mask_building", True, f"mask_count={count}, expected={expected}")


def test_flatten():
    B, T_max = 3, 50
    lengths = torch.tensor([50, 40, 25], dtype=torch.long)
    projected = torch.randn(B, T_max, LLM_HIDDEN_SIZE)
    valid_rows = [projected[i, :l] for i, l in enumerate(lengths.tolist())]
    flat = torch.cat(valid_rows, dim=0)
    expected_total = lengths.sum().item()
    assert flat.shape == (expected_total, LLM_HIDDEN_SIZE), \
        f"Expected [{expected_total}, {LLM_HIDDEN_SIZE}], got {list(flat.shape)}"
    report("flatten_variable_lengths", True,
           f"flat_shape={list(flat.shape)}, total_tokens={expected_total}")


def test_no_interference():
    SPATIAL_TOKEN_ID = 999999
    B, T_text, T_s = 1, 80, 25
    input_ids = torch.randint(0, 1000, (B, T_text))
    input_ids[0, 5:5 + T_s] = SPATIAL_TOKEN_ID
    inputs_embeds = torch.randn(B, T_text, LLM_HIDDEN_SIZE)
    original_embeds = inputs_embeds.clone()
    projected_flat = torch.randn(T_s, LLM_HIDDEN_SIZE)
    spatial_mask = (input_ids == SPATIAL_TOKEN_ID).unsqueeze(-1).expand_as(inputs_embeds)
    result = inputs_embeds.masked_scatter(spatial_mask, projected_flat)
    non_spatial_mask = ~spatial_mask
    assert torch.allclose(
        result[non_spatial_mask], original_embeds[non_spatial_mask]
    ), "Non-spatial positions were modified!"
    assert not torch.allclose(
        result[spatial_mask].view(T_s, LLM_HIDDEN_SIZE),
        original_embeds[0, 5:5 + T_s],
    ), "Spatial positions were NOT replaced!"
    report("no_interference_masked_scatter", True, "non-spatial positions preserved")


if __name__ == "__main__":
    print("=" * 70)
    print("Spatial-BEATs v11a Integration Tests (encoder 10 Hz, LLM 2.5 Hz)")
    print("=" * 70)
    print()

    if not os.path.exists(CHECKPOINT_PATH):
        report("encoder_checkpoint_available", False,
               f"v11a ckpt not found: {CHECKPOINT_PATH}")
        wrapper = None
    else:
        try:
            wrapper = test_encoder_single_clip()
        except Exception as e:
            report("encoder_single_clip_10hz", False, f"{e}")
            traceback.print_exc()
            wrapper = None

    if wrapper is not None:
        for test_fn in [test_encoder_variable_batch, test_encoder_plus_projector_end_to_end]:
            try:
                test_fn(wrapper)
            except Exception as e:
                report(test_fn.__name__.replace("test_", ""), False, f"{e}")
                traceback.print_exc()
    else:
        report("encoder_variable_batch_2_10hz", False, "skipped (no wrapper)")
        report("encoder_to_projector_end_to_end", False, "skipped (no wrapper)")

    for test_fn in [test_projector_pixel_shuffle_k4, test_spatial_mask, test_flatten, test_no_interference]:
        try:
            test_fn()
        except Exception as e:
            report(test_fn.__name__.replace("test_", ""), False, f"{e}")
            traceback.print_exc()

    print()
    print("=" * 70)
    passed = sum(1 for _, p in results if p)
    total = len(results)
    print(f"Results: {passed}/{total} passed")
    if passed < total:
        for name, p in results:
            if not p:
                print(f"  FAILED: {name}")
    print("=" * 70)