models/evalu.py

# coding: utf-8

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import time
import re
import numpy as np
import tensorflow as tf

from utils import queuer, util, metric
from pathlib import Path


def strip_leading_index_tokens(tokens):
    if not tokens:
        return tokens
    return tokens[1:] if tokens[0].isdigit() else tokens


def _extract_numpy_from_nested(obj):
    """Extract first numpy array from nested list/tuple structures."""
    if isinstance(obj, np.ndarray):
        return obj
    if isinstance(obj, (list, tuple)) and len(obj) > 0:
        for item in obj:
            extracted = _extract_numpy_from_nested(item)
            if extracted is not None:
                return extracted
    return None


def _flatten_attention_batches(attention_batches):
    """
    Convert raw attention fetches (list per eval batch, each possibly nested per GPU)
    into a per-sample list aligned with translation order.
    """
    flattened = []
    if not attention_batches:
        return flattened

    for batch_idx, batch in enumerate(attention_batches):
        arr = _extract_numpy_from_nested(batch)
        if arr is None:
            tf.logging.warning(f"[ATTN] Unable to extract numpy array from batch {batch_idx}")
            continue

        if arr.ndim == 4:
            # [time, batch, beam, src_len]
            time_steps, batch_size = arr.shape[0], arr.shape[1]
            for b in range(batch_size):
                flattened.append(arr[:, b, :, :])
        elif arr.ndim in (2, 3):
            flattened.append(arr)
        else:
            tf.logging.warning(f"[ATTN] Unexpected attention ndim={arr.ndim} for batch {batch_idx}")

    return flattened


def _load_gloss_mapping():
    """Lazy-load ASLLRP gloss mapping (video_id -> text)."""
    cache = getattr(_load_gloss_mapping, "_cache", None)
    if cache is not None:
        return cache

    base_dir = Path(__file__).resolve().parent.parent
    candidate_paths = [
        base_dir / "eval" / "tiny_test_data_for_ASLLRP" / "ground_truth.txt",
        base_dir / "eval" / "tiny_test_data" / "ground_truth.txt",
        Path(__file__).resolve().parent.parent / "../ASLLRP_utterances_mapping.txt",
        Path(__file__).resolve().parent.parent / "ASLLRP_utterances_mapping.txt",
        Path(__file__).resolve().parent.parent / "output/ASLLRP_utterances_mapping.txt",
        Path(__file__).resolve().parent.parent / "../output/ASLLRP_utterances_mapping.txt",
    ]
    candidate_paths.extend(sorted((base_dir / "smkd").glob("asllrp*/asllrp-groundtruth-*.stm")))

    mapping = {}
    loaded_sources = []
    for cand in candidate_paths:
        cand = cand.resolve()
        if not cand.exists():
            continue
        try:
            with cand.open('r', encoding='utf-8') as f:
                for line in f:
                    line = line.strip()
                    if not line:
                        continue

                    key = None
                    text = None
                    if cand.suffix == '.stm':
                        parts = line.split(maxsplit=5)
                        if len(parts) >= 6:
                            key = parts[0].strip()
                            text = parts[5].strip()
                    elif '\t' in line:
                        key, text = line.split('\t', 1)
                        key = key.strip()
                        text = text.strip()
                    elif ':' in line:
                        key, text = line.split(':', 1)
                        key = key.strip()
                        text = text.strip()

                    if not key or not text:
                        continue
                    mapping[key] = text

            loaded_sources.append(str(cand))
        except Exception as exc:
            tf.logging.warning(f"[GT] Failed to load mapping from {cand}: {exc}")
    if loaded_sources:
        tf.logging.info(f"[GT] Loaded {len(mapping)} gloss entries from {len(loaded_sources)} source(s)")
        for source in loaded_sources:
            tf.logging.info(f"[GT] Source: {source}")

    _load_gloss_mapping._cache = mapping if mapping else None
    return _load_gloss_mapping._cache


def _lookup_ground_truth_text(video_path):
    """Return GT gloss string for the given video path if available."""
    if not video_path:
        return None
    mapping = _load_gloss_mapping()
    if not mapping:
        return None

    stem = Path(video_path).stem
    candidates = [stem]
    if '_' in stem:
        candidates.append(stem.split('_')[0])

    for candidate in candidates:
        if candidate in mapping:
            return mapping[candidate]
        # also try stripping leading zeros
        stripped = candidate.lstrip('0')
        if stripped and stripped in mapping:
            return mapping[stripped]
    return None


def decode_target_token(id_seq, vocab):
    """Convert sequence ids into tokens"""
    valid_id_seq = []
    for tok_id in id_seq:
        if tok_id == vocab.eos() \
                or tok_id == vocab.pad():
            break
        valid_id_seq.append(tok_id)
    return vocab.to_tokens(valid_id_seq)


def decode_hypothesis(seqs, scores, params, mask=None):
    """Generate decoded sequence from seqs"""
    if mask is None:
        mask = [1.] * len(seqs)

    hypoes = []
    marks = []
    for _seqs, _scores, _m in zip(seqs, scores, mask):
        if _m < 1.: continue

        for seq, score in zip(_seqs, _scores):
            # Temporarily, Use top-1 decoding
            best_seq = seq[0]
            best_score = score[0]

            hypo = decode_target_token(best_seq, params.tgt_vocab)
            mark = best_score

            hypoes.append(hypo)
            marks.append(mark)

    return hypoes, marks


def decoding(session, features, out_seqs, out_scores, dataset, params, out_attention=None):
    """Performing decoding with exising information"""
    tf.logging.info(f"[DEBUG] decoding called with out_attention={out_attention is not None}")
    if out_attention is not None:
        tf.logging.info(f"[DEBUG] out_attention type: {type(out_attention)}")

    translations = []
    scores = []
    indices = []
    attentions = [] if out_attention is not None else None

    eval_queue = queuer.EnQueuer(
        dataset.batcher(params.eval_batch_size,
                        buffer_size=params.buffer_size,
                        shuffle=False,
                        train=False),
        lambda x: x,
        worker_processes_num=params.process_num,
        input_queue_size=params.input_queue_size,
        output_queue_size=params.output_queue_size,
    )

    def _predict_one_batch(_data_on_gpu):
        feed_dicts = {}

        _step_indices = []
        for fidx, shard_data in enumerate(_data_on_gpu):
            # define feed_dict
            _feed_dict = {
                features[fidx]["image"]: shard_data['img'],
                features[fidx]["mask"]: shard_data['mask'],
                features[fidx]["source"]: shard_data['src'],
            }
            feed_dicts.update(_feed_dict)

            # collect data indices
            _step_indices.extend(shard_data['index'])

        # pick up valid outputs
        data_size = len(_data_on_gpu)
        valid_out_seqs = out_seqs[:data_size]
        valid_out_scores = out_scores[:data_size]

        # Prepare outputs to fetch
        fetch_list = [valid_out_seqs, valid_out_scores]
        if out_attention is not None:
            valid_out_attention = out_attention[:data_size]
            fetch_list.append(valid_out_attention)

        # Run session
        fetch_results = session.run(fetch_list, feed_dict=feed_dicts)
        _decode_seqs, _decode_scores = fetch_results[0], fetch_results[1]
        _decode_attention = fetch_results[2] if out_attention is not None else None

        # DEBUG: Check what we got from session.run
        if _decode_attention is not None and bidx == 0:  # Only log first batch to avoid spam
            tf.logging.info(f"[DEBUG] _decode_attention type: {type(_decode_attention)}")
            if isinstance(_decode_attention, list):
                tf.logging.info(f"[DEBUG] _decode_attention is list, len: {len(_decode_attention)}")
                for i, item in enumerate(_decode_attention):
                    if item is not None:
                        tf.logging.info(f"[DEBUG]   item[{i}] type: {type(item)}, shape: {item.shape if hasattr(item, 'shape') else 'no shape'}")

        _step_translations, _step_scores = decode_hypothesis(
            _decode_seqs, _decode_scores, params
        )

        return _step_translations, _step_scores, _step_indices, _decode_attention

    very_begin_time = time.time()
    data_on_gpu = []
    for bidx, data in enumerate(eval_queue):
        if bidx == 0:
            # remove the data reading time
            very_begin_time = time.time()

        data_on_gpu.append(data)
        # use multiple gpus, and data samples is not enough
        if len(params.gpus) > 0 and len(data_on_gpu) < len(params.gpus):
            continue

        start_time = time.time()
        step_outputs = _predict_one_batch(data_on_gpu)
        data_on_gpu = []

        translations.extend(step_outputs[0])
        scores.extend(step_outputs[1])
        indices.extend(step_outputs[2])
        if attentions is not None and step_outputs[3] is not None:
            attentions.append(step_outputs[3])

        tf.logging.info(
            "Decoding Batch {} using {:.3f} s, translating {} "
            "sentences using {:.3f} s in total".format(
                bidx, time.time() - start_time,
                len(translations), time.time() - very_begin_time
            )
        )

    if len(data_on_gpu) > 0:

        start_time = time.time()
        step_outputs = _predict_one_batch(data_on_gpu)

        translations.extend(step_outputs[0])
        scores.extend(step_outputs[1])
        indices.extend(step_outputs[2])
        if attentions is not None and step_outputs[3] is not None:
            attentions.append(step_outputs[3])

        tf.logging.info(
            "Decoding Batch {} using {:.3f} s, translating {} "
            "sentences using {:.3f} s in total".format(
                'final', time.time() - start_time,
                len(translations), time.time() - very_begin_time
            )
        )

    return translations, scores, indices, attentions


def eval_metric(trans, target_file, indices=None, remove_bpe=False):
    """BLEU Evaluate """
    target_valid_files = util.fetch_valid_ref_files(target_file)
    if target_valid_files is None:
        return 0.0

    if indices is not None:
        trans = [data[1] for data in sorted(zip(indices, trans), key=lambda x: x[0])]

    references = []
    for ref_file in target_valid_files:
        cur_refs = tf.gfile.Open(ref_file).readlines()
        processed = []
        for line in cur_refs:
            tokens = line.strip().split()
            tokens = tokens[1:] if tokens and tokens[0].isdigit() else tokens
            if remove_bpe:
                cleaned = (' '.join(tokens)).replace("@@ ", "").split()
                processed.append(cleaned)
            else:
                processed.append(tokens)
        references.append(processed)

    references = list(zip(*references))

    new_trans = []
    for line in trans:
        tokens = line
        tokens = tokens[1:] if tokens and tokens[0].isdigit() else tokens
        if remove_bpe:
            tokens = (' '.join(tokens)).replace("@@ ", "").split()
        new_trans.append(tokens)

    return metric.bleu(new_trans, references)


def dump_tanslation(tranes, output, indices=None, attentions=None, video_path=None):
    """save translation"""
    if indices is not None:
        tranes = [data[1] for data in
                  sorted(zip(indices, tranes), key=lambda x: x[0])]
    with tf.gfile.Open(output, 'w') as writer:
        for hypo in tranes:
            if isinstance(hypo, list):
                writer.write(' '.join(hypo) + "\n")
            else:
                writer.write(str(hypo) + "\n")
    tf.logging.info("Saving translations into {}".format(output))

    # DEBUG: Check attention status
    tf.logging.info(f"[DEBUG] attentions is None: {attentions is None}")
    if attentions is not None:
        tf.logging.info(f"[DEBUG] attentions type: {type(attentions)}, len: {len(attentions)}")

    # Save detailed attention analysis if available
    if attentions is not None and len(attentions) > 0:
        tf.logging.info("[DEBUG] Calling dump_detailed_attention_output")
        try:
            dump_detailed_attention_output(tranes, output, indices, attentions, video_path)
        except Exception as e:
            tf.logging.warning(f"Failed to save detailed attention output: {e}")
            import traceback
            tf.logging.warning(traceback.format_exc())
    else:
        tf.logging.info("[DEBUG] Skipping attention analysis (attentions is None or empty)")


def dump_translation_with_reference(tranes, output, ref_file, indices=None, remove_bpe=False,
                                     attentions=None, dataset=None):
    """
    Save translation with reference for easy comparison

    Args:
        tranes: Translation results
        output: Output file path
        ref_file: Reference file path
        indices: Sample indices
        remove_bpe: Whether to remove BPE
        attentions: Attention weights (list of numpy arrays) for frame alignment
        dataset: Dataset object for getting video frame counts

    Returns:
        dict: Coverage metrics {'complete_coverage': float, 'avg_iou': float}
    """
    import tensorflow as tf
    import numpy as np
    import json
    import os
    import sys
    from pathlib import Path

    per_sample_attn = None
    if attentions is not None and len(attentions) > 0:
        per_sample_attn = _flatten_attention_batches(attentions)
        if len(per_sample_attn) == 0:
            per_sample_attn = None

    # Align attention list with translations
    if per_sample_attn is None:
        per_sample_attn = [None] * len(tranes)
    elif len(per_sample_attn) < len(tranes):
        per_sample_attn.extend([None] * (len(tranes) - len(per_sample_attn)))

    # Sort translations (and attentions) by sample index if provided
    if indices is not None:
        sorted_data = sorted(
            zip(indices, tranes, per_sample_attn),
            key=lambda x: x[0]
        )
        tranes = [data[1] for data in sorted_data]
        per_sample_attn = [data[2] for data in sorted_data]
        sorted_indices = [data[0] for data in sorted_data]
    else:
        sorted_indices = list(range(len(tranes)))

    # Load references
    references = []
    if tf.gfile.Exists(ref_file):
        refs = tf.gfile.Open(ref_file).readlines()
        for line in refs:
            tokens = strip_leading_index_tokens(line.strip().split())
            ref = ' '.join(tokens)
            if remove_bpe:
                ref = ref.replace("@@ ", "")
            references.append(ref)

    # Initialize coverage metrics
    all_complete_coverage = []
    all_iou = []

    # Try to load GT annotations and test info for ASLLRP
    gt_annotations = None
    test_info = None
    try:
        # Determine repo root from absolute output path
        output_abs = os.path.abspath(output)
        output_parts = output_abs.split(os.sep)
        if 'SignX' in output_parts:
            signx_idx = output_parts.index('SignX')
            repo_root = os.sep.join(output_parts[:signx_idx+1])
        else:
            # Fallback: search parents for directory named SignX
            repo_root = None
            current_path = Path(output_abs).parent
            for parent in [current_path] + list(current_path.parents):
                if parent.name == 'SignX':
                    repo_root = str(parent)
                    break
            if repo_root is None:
                raise RuntimeError("Cannot locate SignX repo root from output path.")

            # Load GT annotations
            gt_path = os.path.join(os.path.dirname(repo_root), 'ASLLRP_utterances_with_frames.json')
            if os.path.exists(gt_path):
                with open(gt_path, 'r') as f:
                    gt_annotations = json.load(f)
                tf.logging.info(f"Loaded GT annotations from {gt_path}")

            # Load test info
            test_info_path = os.path.join(os.path.dirname(repo_root), 'CorrNet_Plus_modified/dataset/ASLLRP/test_info.npy')
            if os.path.exists(test_info_path):
                test_info = np.load(test_info_path, allow_pickle=True)
                tf.logging.info(f"Loaded test info from {test_info_path}")
    except Exception as e:
        tf.logging.warning(f"Could not load GT annotations or test info: {e}")

    # Import AttentionAnalyzer if we have attentions
    AttentionAnalyzer = None
    if attentions is not None and len(attentions) > 0 and gt_annotations is not None:
        try:
            # Add eval directory to path
            eval_dir = os.path.join(os.path.dirname(__file__), '..', 'eval')
            if os.path.exists(eval_dir) and eval_dir not in sys.path:
                sys.path.insert(0, eval_dir)
            from attention_analysis import AttentionAnalyzer as AA
            AttentionAnalyzer = AA
        except ImportError as e:
            tf.logging.warning(f"Could not import AttentionAnalyzer: {e}")

    # Save comparison file
    comparison_file = output.replace('.trans.txt', '.comparison.txt')
    with tf.gfile.Open(comparison_file, 'w') as writer:
        writer.write("=" * 100 + "\n")
        writer.write("TRANSLATION COMPARISON (Hypothesis vs Reference)\n")
        writer.write("=" * 100 + "\n\n")

        for i, hypo in enumerate(tranes):
            # Format hypothesis
            if isinstance(hypo, list):
                hypo_str = ' '.join(hypo)
                hypo_tokens = hypo
            else:
                hypo_str = str(hypo)
                hypo_tokens = hypo_str.split()

            if remove_bpe:
                hypo_str = hypo_str.replace("@@ ", "")
                hypo_tokens = [t.replace("@@", "").strip() for t in hypo_tokens]
                hypo_tokens = [t for t in hypo_tokens if t]  # Remove empty

            # Get reference
            ref_str = references[i] if i < len(references) else "[NO REFERENCE]"
            ref_tokens = strip_leading_index_tokens(ref_str.split())
            ref_str = ' '.join(ref_tokens)

            # Calculate frame alignment if we have attention weights
            pred_frame_info = None
            gt_frame_info = None
            coverage_metrics = None

            sample_attn = per_sample_attn[i] if per_sample_attn and i < len(per_sample_attn) else None

            if (AttentionAnalyzer is not None and sample_attn is not None and
                test_info is not None and gt_annotations is not None):
                try:
                    sample_idx = sorted_indices[i]

                    # Get video ID from test_info
                    video_id = test_info[sample_idx]['video_id']

                    # Get GT annotations for this video
                    if video_id in gt_annotations:
                        gt_glosses = gt_annotations[video_id]['glosses']

                        attn = sample_attn

                        # Get feature frame count from attention shape
                        if isinstance(attn, np.ndarray) and len(attn.shape) >= 2:
                            # Reduce dimensions to [time, src_len]
                            if len(attn.shape) == 4:
                                attn = attn[:, 0, 0, :]
                            elif len(attn.shape) == 3:
                                attn = attn[:, 0, :]

                            feature_frames = attn.shape[1]

                            # Use AttentionAnalyzer to compute frame ranges
                            analyzer = AttentionAnalyzer(
                                attentions=attn,
                                translation=' '.join(hypo_tokens),
                                video_frames=feature_frames
                            )

                            # Get predicted frame ranges
                            pred_frame_ranges = analyzer.word_frame_ranges

                            # Calculate coverage metrics
                            complete_count = 0
                            iou_scores = []

                            # Build GT gloss-to-frame mapping
                            gt_frame_map = {gt['gloss']: (gt['start_24fps'], gt['end_24fps'])
                                           for gt in gt_glosses}

                            for pred_info in pred_frame_ranges:
                                pred_gloss = pred_info['word']
                                pred_start = pred_info['start_frame']
                                pred_end = pred_info['end_frame']

                                if pred_gloss in gt_frame_map:
                                    gt_start, gt_end = gt_frame_map[pred_gloss]

                                    # Complete coverage: prediction contains GT
                                    if pred_start <= gt_start and pred_end >= gt_end:
                                        complete_count += 1

                                    # IoU calculation
                                    intersection_start = max(pred_start, gt_start)
                                    intersection_end = min(pred_end, gt_end)
                                    intersection = max(0, intersection_end - intersection_start + 1)

                                    union_start = min(pred_start, gt_start)
                                    union_end = max(pred_end, gt_end)
                                    union = union_end - union_start + 1

                                    iou = intersection / union if union > 0 else 0.0
                                    iou_scores.append(iou)

                            # Calculate rates
                            num_matched = len(iou_scores)
                            if num_matched > 0:
                                complete_coverage_rate = complete_count / num_matched
                                avg_iou = np.mean(iou_scores)

                                all_complete_coverage.append(complete_coverage_rate)
                                all_iou.append(avg_iou)

                                coverage_metrics = {
                                    'complete_coverage_rate': complete_coverage_rate,
                                    'avg_iou': avg_iou,
                                    'num_matched': num_matched
                                }

                                pred_frame_info = pred_frame_ranges
                                gt_frame_info = gt_frame_map

                except Exception as e:
                    tf.logging.warning(f"Error calculating frame alignment for sample {i}: {e}")

            # Write comparison with frame information
            writer.write(f"[Sample {i}]\n")

            # Write HYP with frames if available
            if pred_frame_info:
                hyp_with_frames = []
                for pred_info in pred_frame_info:
                    gloss = pred_info['word']
                    start = pred_info['start_frame']
                    end = pred_info['end_frame']
                    hyp_with_frames.append(f"{gloss}[{start}-{end}]")
                writer.write(f"HYP: {' '.join(hyp_with_frames)}\n")
            else:
                writer.write(f"HYP: {hypo_str}\n")

            # Write REF with frames if available
            if gt_frame_info:
                ref_with_frames = []
                for token in ref_tokens:
                    if token in gt_frame_info:
                        start, end = gt_frame_info[token]
                        ref_with_frames.append(f"{token}[{start}-{end}]")
                    else:
                        ref_with_frames.append(token)
                writer.write(f"REF: {' '.join(ref_with_frames)}\n")
            else:
                writer.write(f"REF: {ref_str}\n")

            # Write coverage metrics if available
            if coverage_metrics:
                writer.write(f"Complete Coverage: {coverage_metrics['complete_coverage_rate']:.2%} "
                           f"({coverage_metrics['num_matched']} matched glosses)\n")
                writer.write(f"IoU Coverage: {coverage_metrics['avg_iou']:.4f}\n")

            writer.write("-" * 100 + "\n\n")

    tf.logging.info("Saving comparison into {}".format(comparison_file))

    # Return average coverage metrics
    result_metrics = {}
    if all_complete_coverage:
        result_metrics['complete_coverage'] = float(np.mean(all_complete_coverage))
        result_metrics['avg_iou'] = float(np.mean(all_iou))
        tf.logging.info(f"Coverage Metrics: Complete={result_metrics['complete_coverage']:.2%}, "
                       f"IoU={result_metrics['avg_iou']:.4f}")

    return result_metrics


def dump_detailed_attention_output(tranes, output, indices, attentions, video_path=None):
    """
    保存详细的attention分析结果

    Args:
        tranes: 翻译结果列表
        output: 输出文件路径
        indices: 样本索引
        attentions: attention权重数据（list of numpy arrays）
        video_path: 视频文件路径（可选，用于提取视频帧）
    """
    import os
    import sys
    import re
    from datetime import datetime
    from pathlib import Path

    # 获取输出目录和文件名
    output_path = Path(output)
    base_dir = output_path.parent
    base_name = output_path.stem  # 不带扩展名

    # 创建带时间戳的详细分析目录
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    detail_dir = base_dir / f"detailed_{base_name}_{timestamp}"
    detail_dir.mkdir(parents=True, exist_ok=True)

    tf.logging.info(f"Saving detailed attention analysis to: {detail_dir}")

    # 重排序翻译结果
    if indices is not None:
        sorted_items = sorted(zip(indices, tranes), key=lambda x: x[0])
        tranes = [item[1] for item in sorted_items]

    # 合并所有batch的attention数据
    try:
        import numpy as np

        flattened_attn = _flatten_attention_batches(attentions)
        if len(flattened_attn) == 0:
            tf.logging.warning("No valid attention data found")
            return

        tf.logging.info(f"[DEBUG] Found {len(flattened_attn)} valid attention samples")

        # If只推理单个视频，使用文件名作为样本目录，便于定位
        video_based_name = None
        if video_path:
            try:
                candidate = Path(video_path).stem
                if candidate:
                    sanitized = re.sub(r'[^0-9A-Za-z._-]+', '_', candidate).strip('_')
                    if sanitized:
                        video_based_name = sanitized
            except Exception as exc:
                tf.logging.warning(f"Failed to derive video-based sample name: {exc}")

        use_video_name = video_based_name is not None and len(flattened_attn) == 1
        gt_text = _lookup_ground_truth_text(video_path) if video_path else None

        for sample_idx, sample_attn in enumerate(flattened_attn):
            if sample_idx >= len(tranes):
                break

            # Ensure shape is [time, src_len]
            if sample_attn.ndim == 4:
                sample_attn = sample_attn[:, 0, 0, :]
            elif sample_attn.ndim == 3:
                sample_attn = sample_attn[:, 0, :]

            # 获取翻译结果
            trans = tranes[sample_idx]
            if isinstance(trans, list):
                trans = ' '.join(trans)
            trans_clean = trans.replace('@@ ', '')

            # 创建样本专属目录（单视频推理时用文件名，更易记忆）
            if use_video_name and sample_idx == 0:
                sample_name = video_based_name
            else:
                sample_name = f"sample_{sample_idx:03d}"
            sample_dir = detail_dir / sample_name
            sample_dir.mkdir(exist_ok=True)

            # 保存numpy数据
            np.save(sample_dir / "attention_weights.npy", sample_attn)

            # 保存翻译结果
            with open(sample_dir / "translation.txt", 'w', encoding='utf-8') as f:
                f.write(f"With BPE: {trans}\n")
                f.write(f"Clean: {trans_clean}\n")
                if gt_text:
                    f.write(f"Ground Truth: {gt_text}\n")
                else:
                    f.write("Ground Truth: [NOT FOUND]\n")

            # Calculate and save feature-to-frame mapping
            if video_path and os.path.exists(video_path):
                try:
                    import cv2
                    import json

                    cap = cv2.VideoCapture(video_path)
                    original_frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
                    cap.release()

                    feature_count = sample_attn.shape[1]
                    frame_mapping = []
                    for feat_idx in range(feature_count):
                        start_frame = int(feat_idx * original_frame_count / feature_count)
                        end_frame = int((feat_idx + 1) * original_frame_count / feature_count)
                        frame_mapping.append({
                            "feature_index": feat_idx,
                            "frame_start": start_frame,
                            "frame_end": end_frame,
                            "frame_count": end_frame - start_frame
                        })

                    mapping_data = {
                        "original_frame_count": original_frame_count,
                        "feature_count": feature_count,
                        "downsampling_ratio": original_frame_count / feature_count,
                        "mapping": frame_mapping
                    }

                    with open(sample_dir / "feature_frame_mapping.json", 'w') as f:
                        json.dump(mapping_data, f, indent=2)

                    tf.logging.info(f"  ✓ Feature-to-frame mapping saved ({original_frame_count} frames → {feature_count} features)")

                except Exception as e:
                    tf.logging.warning(f"Failed to generate feature-to-frame mapping: {e}")

            # 使用attention_analysis模块生成可视化
            try:
                script_dir = Path(__file__).parent.parent
                eval_dir = script_dir / "eval"
                if str(eval_dir) not in sys.path:
                    sys.path.insert(0, str(eval_dir))

                from attention_analysis import AttentionAnalyzer

                analyzer = AttentionAnalyzer(
                    attentions=sample_attn,
                    translation=trans_clean,
                    video_frames=sample_attn.shape[1],
                    video_path=video_path
                )
                analyzer.generate_all_visualizations(sample_dir)
                tf.logging.info(f"  ✓ Sample {sample_idx}: {sample_dir.name}")

            except Exception as e:
                tf.logging.warning(f"Failed to generate visualizations for sample {sample_idx}: {e}")

        tf.logging.info(f"Detailed attention analysis complete: {detail_dir}")
        tf.logging.info(f"  - Analyzed {min(len(flattened_attn), len(tranes))} samples")
        tf.logging.info(f"  - Output directory: {detail_dir}")

    except Exception as e:
        import traceback
        tf.logging.error(f"Error in dump_detailed_attention_output: {e}")
        tf.logging.error(traceback.format_exc())