SignX/doc/quick_coverage_eval.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Quick coverage evaluation using pre-generated attention analysis outputs.

This script walks through a detailed attention directory (e.g.
checkpoints_asllrp/detailed_eval-init.trans_*.*/sample_XXX), loads the
frame_alignment.json produced for each sample, aligns it with the
corresponding reference gloss sequence, and approximates frame coverage
against ASLLRP ground-truth annotations.

Usage:
    python quick_coverage_eval.py \
        --detail-dir checkpoints_asllrp/detailed_eval-init.trans_20251228_041351 \
        --ref-file preprocessed-asllrp/dev.bpe.gloss
"""

import argparse
import json
import re
from pathlib import Path
from collections import defaultdict
from difflib import SequenceMatcher


def clean_gloss_text(text: str) -> str:
    """Remove BPE annotations and trim whitespace."""
    return text.replace('@@ ', '').replace('@@', '').strip()


def load_reference_sentences(ref_path: Path):
    """Load reference sentences (sorted by numeric index)."""
    refs = []
    with ref_path.open('r', encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            parts = line.split()
            try:
                idx = int(parts[0])
            except ValueError:
                continue
            sent = clean_gloss_text(' '.join(parts[1:]))
            refs.append((idx, sent))
    refs.sort(key=lambda x: x[0])
    ordered = [sent for _, sent in refs]
    return ordered


def load_mapping(mapping_path: Path):
    """Map gloss sentence -> list of ASLLRP utterance IDs."""
    mapping = defaultdict(list)
    with mapping_path.open('r', encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            if not line or ':' not in line:
                continue
            utt_id, gloss = line.split(':', 1)
            mapping[clean_gloss_text(gloss.strip())].append(utt_id.strip())
    return mapping


def pop_video_id(mapping, sentence):
    ids = mapping.get(sentence)
    if not ids:
        return None
    return ids.pop(0)


def normalized_iou(pred, gt):
    """Compute IoU between two normalized [start, end] intervals."""
    start = max(pred[0], gt[0])
    end = min(pred[1], gt[1])
    inter = max(0.0, end - start)
    union = max(pred[1], gt[1]) - min(pred[0], gt[0])
    if union <= 0:
        return 0.0
    return inter / union


def normalize_interval(start, end, total):
    if total <= 0:
        return 0.0, 0.0
    return start / total, end / total


def normalize_token(token):
    """Normalize gloss tokens to be more tolerant (case/punctuation insensitive)."""
    if token is None:
        return ""
    token = token.lower().replace("@@", "")
    token = re.sub(r'[^a-z0-9]+', '', token)
    return token


def token_similarity(a, b):
    if not a or not b:
        return 1.0 if a == b else 0.0
    if a == b:
        return 1.0
    return SequenceMatcher(None, a, b).ratio()


def compute_coverage(detail_dir: Path,
                     ref_sentences,
                     mapping_path: Path,
                     gt_json_path: Path,
                     output_path: Path,
                     expansion_factors,
                     overflow_penalty):
    mapping = load_mapping(mapping_path)
    with gt_json_path.open('r', encoding='utf-8') as f:
        gt_data = json.load(f)

    samples = sorted([d for d in detail_dir.iterdir() if d.is_dir()])
    assert len(samples) <= len(ref_sentences), \
        "Reference sentences shorter than number of samples"

    overall = {
        "matched_tokens": 0,
        "complete_coverage_hits": 0,
        "iou_sum": 0.0,
        "samples_with_matches": 0,
        "skipped_samples": 0,
    }
    per_sample = []

    for idx, sample_dir in enumerate(samples):
        frame_file = sample_dir / "frame_alignment.json"
        if not frame_file.exists():
            overall["skipped_samples"] += 1
            continue

        with frame_file.open('r', encoding='utf-8') as f:
            frame_data = json.load(f)

        sentence = ref_sentences[idx]
        video_id = pop_video_id(mapping, sentence)
        if not video_id or video_id not in gt_data:
            overall["skipped_samples"] += 1
            continue

        gt_glosses = gt_data[video_id]["glosses"]
        if not gt_glosses:
            overall["skipped_samples"] += 1
            continue

        gt_total = max(g['end_24fps'] for g in gt_glosses if 'end_24fps' in g)
        if gt_total <= 0:
            overall["skipped_samples"] += 1
            continue

        gt_entries = [{
            'gloss': gt['gloss'],
            'norm': normalize_token(gt['gloss']),
            'start': gt['start_24fps'],
            'end': gt['end_24fps']
        } for gt in gt_glosses if 'start_24fps' in gt and 'end_24fps' in gt]
        gt_used = [False] * len(gt_entries)
        last_match_idx = 0

        matches = []

        total_frames_pred = max(frame_data.get("total_video_frames", 0), 1)
        for pred in frame_data.get("frame_ranges", []):
            word = pred['word']
            word_norm = normalize_token(word)

            match_idx = None
            # search sequentially starting from last matched position
            for idx in range(last_match_idx, len(gt_entries)):
                if gt_used[idx]:
                    continue
                if token_similarity(word_norm, gt_entries[idx]['norm']) >= 0.7:
                    match_idx = idx
                    break

            if match_idx is None:
                # fallback search entire list
                for idx in range(len(gt_entries)):
                    if gt_used[idx]:
                        continue
                    if token_similarity(word_norm, gt_entries[idx]['norm']) >= 0.7:
                        match_idx = idx
                        break

            if match_idx is None:
                continue

            gt_used[match_idx] = True
            last_match_idx = max(last_match_idx, match_idx)
            gt_entry = gt_entries[match_idx]

            pred_norm = normalize_interval(
                pred['start_frame'], pred['end_frame'], total_frames_pred)
            gt_norm = normalize_interval(gt_entry['start'], gt_entry['end'], gt_total)

            iou = normalized_iou(pred_norm, gt_norm)
            complete = pred_norm[0] <= gt_norm[0] and pred_norm[1] >= gt_norm[1]

            matches.append({
                "word": word,
                "pred_norm": pred_norm,
                "gt_norm": gt_norm,
                "iou": iou,
                "complete": complete,
                "pred_frames": (pred['start_frame'], pred['end_frame'], total_frames_pred),
                "gt_frames": (gt_entry['start'], gt_entry['end'], gt_total)
            })

        if not matches:
            overall["skipped_samples"] += 1
            continue

        sample_stats = {
            "sample": sample_dir.name,
            "video_id": video_id,
            "matched": len(matches),
            "complete_coverage": sum(1 for m in matches if m["complete"]),
            "avg_iou": sum(m["iou"] for m in matches) / len(matches),
        }
        per_sample.append(sample_stats)

        overall["matched_tokens"] += sample_stats["matched"]
        overall["complete_coverage_hits"] += sample_stats["complete_coverage"]
        overall["iou_sum"] += sample_stats["avg_iou"]
        overall["samples_with_matches"] += 1

        # word-level coverage stats with expansion
        for factor in expansion_factors:
            factor_stats = overall.setdefault("factor_stats", {}).setdefault(
                factor, {"coverage_sum": 0.0, "count": 0, "perfect_hits": 0, "penalized": 0}
            )

            for match in matches:
                pred_start, pred_end, pred_total = match["pred_frames"]
                gt_start, gt_end, gt_total = match["gt_frames"]

                if pred_total <= 0 or gt_total <= 0:
                    continue

                pred_start_abs = pred_start / pred_total * gt_total
                pred_end_abs = pred_end / pred_total * gt_total
                if pred_end_abs <= pred_start_abs:
                    pred_end_abs = pred_start_abs + 1e-6

                center = (pred_start_abs + pred_end_abs) / 2.0
                half_len = (pred_end_abs - pred_start_abs) / 2.0 * factor
                start_exp = max(0.0, center - half_len)
                end_exp = min(gt_total, center + half_len)

                overlap = max(0.0, min(end_exp, gt_end) - max(start_exp, gt_start))
                gt_len = max(gt_end - gt_start, 1e-6)
                coverage = overlap / gt_len

                penalized = False
                if start_exp < gt_start or end_exp > gt_end:
                    coverage = max(0.0, coverage - overflow_penalty)
                    penalized = True

                factor_stats["coverage_sum"] += coverage
                factor_stats["count"] += 1
                if coverage >= 1.0:
                    factor_stats["perfect_hits"] += 1
                if penalized:
                    factor_stats["penalized"] += 1

    factor_summary = {}
    factor_stats = overall.get("factor_stats", {})
    for factor, stats in factor_stats.items():
        if stats["count"] == 0:
            continue
        factor_summary[str(factor)] = {
            "avg_coverage": stats["coverage_sum"] / stats["count"],
            "perfect_rate": stats["perfect_hits"] / stats["count"],
            "penalized_rate": stats["penalized"] / stats["count"],
            "count": stats["count"],
        }

    overall_summary = {
        "samples_evaluated": len(samples),
        "samples_with_matches": overall["samples_with_matches"],
        "samples_skipped": overall["skipped_samples"],
        "avg_complete_coverage": (
            overall["complete_coverage_hits"] / overall["matched_tokens"]
            if overall["matched_tokens"] > 0 else 0.0
        ),
        "avg_iou": (
            overall["iou_sum"] / overall["samples_with_matches"]
            if overall["samples_with_matches"] > 0 else 0.0
        ),
        "word_level": factor_summary
    }

    output = {
        "detail_dir": str(detail_dir),
        "overall": overall_summary,
        "sample_stats": per_sample,
    }
    with output_path.open('w', encoding='utf-8') as f:
        json.dump(output, f, indent=2)

    return output


def main():
    parser = argparse.ArgumentParser(description="Quick coverage evaluator")
    parser.add_argument("--detail-dir", type=Path, required=True,
                        help="Path to detailed attention directory")
    parser.add_argument("--ref-file", type=Path,
                        default=Path("preprocessed-asllrp/dev.bpe.gloss"),
                        help="Reference gloss file with indices")
    parser.add_argument("--mapping-file", type=Path,
                        default=Path("../ASLLRP_utterances_mapping.txt"),
                        help="Utterance mapping file (video_id: gloss ...)")
    parser.add_argument("--gt-json", type=Path,
                        default=Path("../ASLLRP_utterances_with_frames.json"),
                        help="JSON with ground-truth frame annotations")
    parser.add_argument("--output", type=Path,
                        default=Path("coverage_summary.json"),
                        help="Output summary JSON path")
    parser.add_argument("--expansion-factors", type=str, default="1.0,1.5,2.0",
                        help="Comma-separated list of expansion multipliers to test")
    parser.add_argument("--overflow-penalty", type=float, default=0.5,
                        help="Penalty to subtract if expanded window exceeds GT range")
    args = parser.parse_args()

    expansion_factors = [float(x) for x in args.expansion_factors.split(',') if x.strip()]

    ref_sentences = load_reference_sentences(args.ref_file)
    summary = compute_coverage(
        detail_dir=args.detail_dir,
        ref_sentences=ref_sentences,
        mapping_path=args.mapping_file,
        gt_json_path=args.gt_json,
        output_path=args.output,
        expansion_factors=expansion_factors,
        overflow_penalty=args.overflow_penalty
    )

    print(json.dumps(summary["overall"], indent=2))
    print(f"\nPer-sample stats saved to {args.output}")


if __name__ == "__main__":
    main()