Relative time and the original frame can now be displayed.

SignX/detailed_prediction_20251225_192957/sample_000/analysis_report.txt

@@ -0,0 +1,44 @@
+================================================================================
+  Sign Language Recognition - Attention分析报告
+================================================================================
+
+生成时间: 2025-12-25 19:30:01
+
+翻译结果:
+--------------------------------------------------------------------------------
+<unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING
+
+视频信息:
+--------------------------------------------------------------------------------
+总帧数: 24
+词数量: 8
+
+Attention权重信息:
+--------------------------------------------------------------------------------
+形状: (29, 8, 24)
+  - 解码步数: 29
+  - Batch大小: 8
+
+词-帧对应详情:
+================================================================================
+No.   Word                 Frames          Peak     Attn     Conf      
+--------------------------------------------------------------------------------
+1     <unk>                0-23            0        0.068    low       
+2     NOW-WEEK             2-3             2        0.479    medium    
+3     STUDENT              1-23            21       0.134    low       
+4     IX                   1-23            3        0.092    low       
+5     HAVE                 4-6             5        0.274    medium    
+6     NONE/NOTHING         7-8             7        0.324    medium    
+7     GO                   7-23            7        0.188    low       
+8     NONE/NOTHING         8-8             8        0.733    high      
+
+================================================================================
+
+统计摘要:
+--------------------------------------------------------------------------------
+平均attention权重: 0.287
+高置信度词: 1 (12.5%)
+中置信度词: 3 (37.5%)
+低置信度词: 4 (50.0%)
+
+================================================================================

SignX/detailed_prediction_20251225_192957/sample_000/attention_weights.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25434051e14c2b1741bf1376aaae36ca9a9fc276b01859a40b74bab3b603bcf8
+size 22400

SignX/detailed_prediction_20251225_192957/sample_000/debug_video_path.txt

@@ -0,0 +1,4 @@
+video_path = '/common/users/sf895/output/huggingface_asllrp_repo/SignX/eval/tiny_test_data/videos/666.mp4'
+video_path type = <class 'str'>
+video_path is None: False
+bool(video_path): True

SignX/detailed_prediction_20251225_192957/sample_000/frame_alignment.json

@@ -0,0 +1,86 @@
+{
+  "translation": "<unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING",
+  "words": [
+    "<unk>",
+    "NOW-WEEK",
+    "STUDENT",
+    "IX",
+    "HAVE",
+    "NONE/NOTHING",
+    "GO",
+    "NONE/NOTHING"
+  ],
+  "total_video_frames": 24,
+  "frame_ranges": [
+    {
+      "word": "<unk>",
+      "start_frame": 0,
+      "end_frame": 23,
+      "peak_frame": 0,
+      "avg_attention": 0.06790952384471893,
+      "confidence": "low"
+    },
+    {
+      "word": "NOW-WEEK",
+      "start_frame": 2,
+      "end_frame": 3,
+      "peak_frame": 2,
+      "avg_attention": 0.4792596399784088,
+      "confidence": "medium"
+    },
+    {
+      "word": "STUDENT",
+      "start_frame": 1,
+      "end_frame": 23,
+      "peak_frame": 21,
+      "avg_attention": 0.13404551148414612,
+      "confidence": "low"
+    },
+    {
+      "word": "IX",
+      "start_frame": 1,
+      "end_frame": 23,
+      "peak_frame": 3,
+      "avg_attention": 0.09226731956005096,
+      "confidence": "low"
+    },
+    {
+      "word": "HAVE",
+      "start_frame": 4,
+      "end_frame": 6,
+      "peak_frame": 5,
+      "avg_attention": 0.27426692843437195,
+      "confidence": "medium"
+    },
+    {
+      "word": "NONE/NOTHING",
+      "start_frame": 7,
+      "end_frame": 8,
+      "peak_frame": 7,
+      "avg_attention": 0.3239603638648987,
+      "confidence": "medium"
+    },
+    {
+      "word": "GO",
+      "start_frame": 7,
+      "end_frame": 23,
+      "peak_frame": 7,
+      "avg_attention": 0.1878073364496231,
+      "confidence": "low"
+    },
+    {
+      "word": "NONE/NOTHING",
+      "start_frame": 8,
+      "end_frame": 8,
+      "peak_frame": 8,
+      "avg_attention": 0.7333312630653381,
+      "confidence": "high"
+    }
+  ],
+  "statistics": {
+    "avg_confidence": 0.2866059858351946,
+    "high_confidence_words": 1,
+    "medium_confidence_words": 3,
+    "low_confidence_words": 4
+  }
+}

SignX/detailed_prediction_20251225_192957/sample_000/translation.txt

@@ -0,0 +1,2 @@
+With BPE: <unk> NOW@@ -@@ WEEK STUDENT I@@ X HAVE NONE/NOTHING GO NONE/NOTHING
+Clean: <unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING

SignX/detailed_prediction_20251225_193758/sample_000/analysis_report.txt

@@ -0,0 +1,44 @@
+================================================================================
+  Sign Language Recognition - Attention分析报告
+================================================================================
+
+生成时间: 2025-12-25 19:38:00
+
+翻译结果:
+--------------------------------------------------------------------------------
+<unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING
+
+视频信息:
+--------------------------------------------------------------------------------
+总帧数: 24
+词数量: 8
+
+Attention权重信息:
+--------------------------------------------------------------------------------
+形状: (29, 8, 24)
+  - 解码步数: 29
+  - Batch大小: 8
+
+词-帧对应详情:
+================================================================================
+No.   Word                 Frames          Peak     Attn     Conf      
+--------------------------------------------------------------------------------
+1     <unk>                0-23            0        0.068    low       
+2     NOW-WEEK             2-3             2        0.479    medium    
+3     STUDENT              1-23            21       0.134    low       
+4     IX                   1-23            3        0.092    low       
+5     HAVE                 4-6             5        0.274    medium    
+6     NONE/NOTHING         7-8             7        0.324    medium    
+7     GO                   7-23            7        0.188    low       
+8     NONE/NOTHING         8-8             8        0.733    high      
+
+================================================================================
+
+统计摘要:
+--------------------------------------------------------------------------------
+平均attention权重: 0.287
+高置信度词: 1 (12.5%)
+中置信度词: 3 (37.5%)
+低置信度词: 4 (50.0%)
+
+================================================================================

SignX/detailed_prediction_20251225_193758/sample_000/attention_weights.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25434051e14c2b1741bf1376aaae36ca9a9fc276b01859a40b74bab3b603bcf8
+size 22400

SignX/detailed_prediction_20251225_193758/sample_000/debug_video_path.txt

@@ -0,0 +1,4 @@
+video_path = '/common/users/sf895/output/huggingface_asllrp_repo/SignX/eval/tiny_test_data/videos/666.mp4'
+video_path type = <class 'str'>
+video_path is None: False
+bool(video_path): True

SignX/detailed_prediction_20251225_193758/sample_000/frame_alignment.json

@@ -0,0 +1,86 @@
+{
+  "translation": "<unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING",
+  "words": [
+    "<unk>",
+    "NOW-WEEK",
+    "STUDENT",
+    "IX",
+    "HAVE",
+    "NONE/NOTHING",
+    "GO",
+    "NONE/NOTHING"
+  ],
+  "total_video_frames": 24,
+  "frame_ranges": [
+    {
+      "word": "<unk>",
+      "start_frame": 0,
+      "end_frame": 23,
+      "peak_frame": 0,
+      "avg_attention": 0.06790952384471893,
+      "confidence": "low"
+    },
+    {
+      "word": "NOW-WEEK",
+      "start_frame": 2,
+      "end_frame": 3,
+      "peak_frame": 2,
+      "avg_attention": 0.4792596399784088,
+      "confidence": "medium"
+    },
+    {
+      "word": "STUDENT",
+      "start_frame": 1,
+      "end_frame": 23,
+      "peak_frame": 21,
+      "avg_attention": 0.13404551148414612,
+      "confidence": "low"
+    },
+    {
+      "word": "IX",
+      "start_frame": 1,
+      "end_frame": 23,
+      "peak_frame": 3,
+      "avg_attention": 0.09226731956005096,
+      "confidence": "low"
+    },
+    {
+      "word": "HAVE",
+      "start_frame": 4,
+      "end_frame": 6,
+      "peak_frame": 5,
+      "avg_attention": 0.27426692843437195,
+      "confidence": "medium"
+    },
+    {
+      "word": "NONE/NOTHING",
+      "start_frame": 7,
+      "end_frame": 8,
+      "peak_frame": 7,
+      "avg_attention": 0.3239603638648987,
+      "confidence": "medium"
+    },
+    {
+      "word": "GO",
+      "start_frame": 7,
+      "end_frame": 23,
+      "peak_frame": 7,
+      "avg_attention": 0.1878073364496231,
+      "confidence": "low"
+    },
+    {
+      "word": "NONE/NOTHING",
+      "start_frame": 8,
+      "end_frame": 8,
+      "peak_frame": 8,
+      "avg_attention": 0.7333312630653381,
+      "confidence": "high"
+    }
+  ],
+  "statistics": {
+    "avg_confidence": 0.2866059858351946,
+    "high_confidence_words": 1,
+    "medium_confidence_words": 3,
+    "low_confidence_words": 4
+  }
+}

SignX/detailed_prediction_20251225_193758/sample_000/translation.txt

@@ -0,0 +1,2 @@
+With BPE: <unk> NOW@@ -@@ WEEK STUDENT I@@ X HAVE NONE/NOTHING GO NONE/NOTHING
+Clean: <unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING

SignX/eval/attention_analysis.py

@@ -22,7 +22,10 @@ Attention权重分析和可视化模块
 """
 
 import os
+import io
 import json
+import shutil
+import subprocess
 import numpy as np
 from pathlib import Path
 from datetime import datetime
@@ -31,23 +34,44 @@ from datetime import datetime
 class AttentionAnalyzer:
     """Attention权重分析器"""
 
-    def __init__(self, attentions, translation, video_frames, beam_sequences=None, beam_scores=None):
+    def __init__(self, attentions, translation, video_frames, beam_sequences=None, beam_scores=None,
+                 video_path=None, original_video_fps=30, original_video_total_frames=None):
         """
         Args:
             attentions: numpy array, shape [time_steps, batch, beam, src_len]
                        或 [time_steps, src_len] (已提取最佳beam)
             translation: str, 翻译结果（BPE已移除）
-            video_frames: int, 视频总帧数
+            video_frames: int, SMKD特征序列帧数
             beam_sequences: list, 所有beam的序列 (可选)
             beam_scores: list, 所有beam的分数 (可选)
+            video_path: str, 原始视频文件路径 (可选,用于提取视频帧)
+            original_video_fps: int, 原始视频FPS (默认30)
+            original_video_total_frames: int, 原始视频总帧数 (可选,如果不提供则从视频中读取)
         """
         self.attentions = attentions
         self.translation = translation
         self.words = translation.split()
-        self.video_frames = video_frames
+        self.video_frames = video_frames  # SMKD特征帧数
         self.beam_sequences = beam_sequences
         self.beam_scores = beam_scores
 
+        # 原始视频相关
+        self.video_path = video_path
+        self.original_video_fps = original_video_fps
+        self.original_video_total_frames = original_video_total_frames
+        self._cv2_module = None
+        self._cv2_checked = False
+
+        # 如果提供了视频路径但没有提供总帧数,尝试读取
+        if video_path and original_video_total_frames is None:
+            metadata = self._read_video_metadata()
+            if metadata:
+                self.original_video_total_frames = metadata.get('frames')
+                if metadata.get('fps'):
+                    self.original_video_fps = metadata['fps']
+            elif video_path:
+                print(f"Warning: 无法解析视频信息, Gloss-to-Frames 可视化将无法对齐实际帧 ({video_path})")
+
         # 提取最佳路径的attention (batch=0, beam=0)
         if len(attentions.shape) == 4:
             self.attn_best = attentions[:, 0, 0, :]  # [time, src_len]
@@ -156,6 +180,28 @@ class AttentionAnalyzer:
         # 5. 保存numpy数据（供进一步分析）
         np.save(output_dir / "attention_weights.npy", self.attentions)
 
+        # 6. Gloss-to-Frames可视化 (如果提供了视频路径)
+        # Write debug info to file
+        debug_file = output_dir / "debug_video_path.txt"
+        with open(debug_file, 'w') as f:
+            f.write(f"video_path = {repr(self.video_path)}\n")
+            f.write(f"video_path type = {type(self.video_path)}\n")
+            f.write(f"video_path is None: {self.video_path is None}\n")
+            f.write(f"bool(video_path): {bool(self.video_path)}\n")
+
+        print(f"[DEBUG] video_path = {self.video_path}")
+        if self.video_path:
+            print(f"[DEBUG] Generating gloss-to-frames visualization with video: {self.video_path}")
+            try:
+                self.generate_gloss_to_frames_visualization(output_dir / "gloss_to_frames.png")
+                print(f"[DEBUG] Successfully generated gloss_to_frames.png")
+            except Exception as e:
+                print(f"[DEBUG] Failed to generate gloss_to_frames.png: {e}")
+                import traceback
+                traceback.print_exc()
+        else:
+            print("[DEBUG] Skipping gloss-to-frames visualization (no video path provided)")
+
         print(f"✓ 已生成 {len(list(output_dir.glob('*')))} 个文件")
 
     def plot_attention_heatmap(self, output_path):
@@ -371,6 +417,352 @@ class AttentionAnalyzer:
         print(f"  ✓ {output_path.name}")
 
 
+    def _map_feature_frame_to_original(self, feature_frame_idx):
+        """
+        将SMKD特征帧索引映射到原始视频帧索引
+
+        Args:
+            feature_frame_idx: SMKD特征帧索引 (0-based)
+
+        Returns:
+            int: 原始视频帧索引,如果无法映射则返回None
+        """
+        if self.original_video_total_frames is None:
+            return None
+
+        # 计算降采样率
+        downsample_ratio = self.original_video_total_frames / self.video_frames
+
+        # 映射到原始视频帧
+        original_frame_idx = int(feature_frame_idx * downsample_ratio)
+
+        return min(original_frame_idx, self.original_video_total_frames - 1)
+
+    def _extract_video_frames(self, frame_indices):
+        """
+        从视频中提取指定索引的帧
+
+        Args:
+            frame_indices: list of int, 要提取的帧索引列表
+
+        Returns:
+            dict: {frame_idx: numpy_array}, 帧索引到图像数据的映射
+        """
+        if not self.video_path:
+            return {}
+
+        cv2 = self._get_cv2_module()
+        if cv2 is not None:
+            return self._extract_frames_with_cv2(cv2, frame_indices)
+
+        return self._extract_frames_with_ffmpeg(frame_indices)
+
+    def _get_cv2_module(self):
+        """惰性加载cv2, 缓存导入结果"""
+        if self._cv2_checked:
+            return self._cv2_module
+
+        try:
+            import cv2
+            self._cv2_module = cv2
+        except ImportError:
+            self._cv2_module = None
+        finally:
+            self._cv2_checked = True
+
+        if self._cv2_module is None:
+            print("Warning: opencv-python 未安装, 将尝试使用 ffmpeg 提取视频帧")
+        return self._cv2_module
+
+    def _extract_frames_with_cv2(self, cv2, frame_indices):
+        """使用opencv提取视频帧"""
+        frames = {}
+        cap = cv2.VideoCapture(self.video_path)
+
+        if not cap.isOpened():
+            print(f"Warning: Cannot open video file: {self.video_path}")
+            return {}
+
+        for frame_idx in sorted(frame_indices):
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+            ret, frame = cap.read()
+            if ret:
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frames[frame_idx] = frame_rgb
+
+        cap.release()
+        return frames
+
+    def _extract_frames_with_ffmpeg(self, frame_indices):
+        """使用ffmpeg + Pillow提取视频帧(在opencv缺失时调用)"""
+        if shutil.which("ffmpeg") is None:
+            print("Warning: 未找到 ffmpeg, 无法提取视频帧")
+            return {}
+
+        try:
+            from PIL import Image
+        except ImportError:
+            print("Warning: Pillow 未安装, 无法解码ffmpeg输出的图像")
+            return {}
+
+        frames = {}
+        for frame_idx in sorted(frame_indices):
+            cmd = [
+                "ffmpeg",
+                "-v", "error",
+                "-i", str(self.video_path),
+                "-vf", f"select=eq(n\\,{frame_idx})",
+                "-vframes", "1",
+                "-f", "image2pipe",
+                "-vcodec", "png",
+                "-"
+            ]
+            try:
+                result = subprocess.run(
+                    cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+                )
+                if not result.stdout:
+                    continue
+                image = Image.open(io.BytesIO(result.stdout)).convert("RGB")
+                frames[frame_idx] = np.array(image)
+            except subprocess.CalledProcessError as e:
+                print(f"Warning: ffmpeg 提取帧 {frame_idx} 失败: {e}")
+            except Exception as ex:
+                print(f"Warning: 解码帧 {frame_idx} 失败: {ex}")
+
+        if frames:
+            print(f"  ✓ 使用 ffmpeg 提取了 {len(frames)} 帧")
+        else:
+            print("  ⓘ ffmpeg 未能提取任何帧")
+        return frames
+
+    def generate_gloss_to_frames_visualization(self, output_path):
+        """
+        生成 Gloss-to-Frames 可视化图像
+        布局: 每行对应一个gloss
+        列1: Gloss文本
+        列2: 相对时间和帧索引信息
+        列3: 该时间段内的视频帧缩略图
+
+        Args:
+            output_path: 输出图像路径
+        """
+        if not self.video_path:
+            print("  ⓘ Skipping gloss-to-frames visualization (no video path provided)")
+            return
+
+        try:
+            import matplotlib.pyplot as plt
+            import matplotlib.gridspec as gridspec
+        except ImportError:
+            print("Warning: matplotlib not installed")
+            return
+
+        # 收集所有需要提取的原始视频帧
+        all_original_frames = set()
+        for word_info in self.word_frame_ranges:
+            # 特征帧范围
+            start_feat = word_info['start_frame']
+            end_feat = word_info['end_frame']
+            peak_feat = word_info['peak_frame']
+
+            # 映射到原始视频帧
+            for feat_idx in [start_feat, peak_feat, end_feat]:
+                orig_idx = self._map_feature_frame_to_original(feat_idx)
+                if orig_idx is not None:
+                    all_original_frames.add(orig_idx)
+
+        # 提取视频帧
+        print(f"  提取 {len(all_original_frames)} 个视频帧...")
+        video_frames_dict = self._extract_video_frames(list(all_original_frames))
+
+        if not video_frames_dict:
+            print("  ⓘ No video frames extracted, skipping visualization")
+            return
+
+        # 创建figure
+        n_words = len(self.words)
+        fig = plt.figure(figsize=(20, 3 * n_words))
+        gs = gridspec.GridSpec(n_words, 3, width_ratios=[1.5, 2, 6], hspace=0.3, wspace=0.2)
+
+        for row_idx, (word, word_info) in enumerate(zip(self.words, self.word_frame_ranges)):
+            # 列1: Gloss文本
+            ax_gloss = fig.add_subplot(gs[row_idx, 0])
+            ax_gloss.text(0.5, 0.5, word, fontsize=24, weight='bold',
+                         ha='center', va='center', wrap=True)
+            ax_gloss.axis('off')
+
+            # 列2: 时间和帧信息
+            ax_info = fig.add_subplot(gs[row_idx, 1])
+
+            # 特征帧信息
+            feat_start = word_info['start_frame']
+            feat_end = word_info['end_frame']
+            feat_peak = word_info['peak_frame']
+
+            # 相对时间 (0-100%)
+            rel_start = (feat_start / self.video_frames) * 100
+            rel_end = (feat_end / self.video_frames) * 100
+            rel_peak = (feat_peak / self.video_frames) * 100
+
+            info_text = f"Feature Frames:\n"
+            info_text += f"  Range: {feat_start}-{feat_end}\n"
+            info_text += f"  Peak: {feat_peak}\n\n"
+            info_text += f"Relative Time:\n"
+            info_text += f"  Range: {rel_start:.1f}%-{rel_end:.1f}%\n"
+            info_text += f"  Peak: {rel_peak:.1f}%\n"
+
+            # 如果有原始视频帧映射
+            if self.original_video_total_frames:
+                orig_start = self._map_feature_frame_to_original(feat_start)
+                orig_end = self._map_feature_frame_to_original(feat_end)
+                orig_peak = self._map_feature_frame_to_original(feat_peak)
+                info_text += f"\nOriginal Video:\n"
+                info_text += f"  Total: {self.original_video_total_frames} frames\n"
+                info_text += f"  Range: {orig_start}-{orig_end}\n"
+                info_text += f"  Peak: {orig_peak}\n"
+
+            ax_info.text(0.05, 0.5, info_text, fontsize=10, family='monospace',
+                        va='center', ha='left')
+            ax_info.axis('off')
+
+            # 列3: 视频帧
+            ax_frames = fig.add_subplot(gs[row_idx, 2])
+
+            # 选择要显示的帧: start, peak, end
+            frames_to_show = []
+            labels_to_show = []
+
+            for feat_idx, label in [(feat_start, 'Start'), (feat_peak, 'Peak'), (feat_end, 'End')]:
+                orig_idx = self._map_feature_frame_to_original(feat_idx)
+                if orig_idx is not None and orig_idx in video_frames_dict:
+                    frames_to_show.append(video_frames_dict[orig_idx])
+                    labels_to_show.append(f"{label}\nF{orig_idx}")
+
+            if frames_to_show:
+                # 水平拼接帧
+                combined = np.hstack(frames_to_show)
+                ax_frames.imshow(combined)
+
+                # 添加标签
+                frame_width = frames_to_show[0].shape[1]
+                for i, label in enumerate(labels_to_show):
+                    x_pos = (i + 0.5) * frame_width
+                    ax_frames.text(x_pos, -20, label, fontsize=10, weight='bold',
+                                  ha='center', va='top', color='blue')
+            else:
+                ax_frames.text(0.5, 0.5, "No frames available",
+                              ha='center', va='center', transform=ax_frames.transAxes)
+
+            ax_frames.axis('off')
+
+        plt.suptitle(f"Gloss-to-Frames Alignment\nTranslation: {self.translation}",
+                     fontsize=16, weight='bold', y=0.995)
+
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close()
+
+        print(f"  ✓ {Path(output_path).name}")
+
+    def _read_video_metadata(self):
+        """尝试读取原始视频的帧数和fps"""
+        metadata = self._read_metadata_with_cv2()
+        if metadata:
+            return metadata
+        return self._read_metadata_with_ffprobe()
+
+    def _read_metadata_with_cv2(self):
+        cv2 = self._get_cv2_module()
+        if cv2 is None:
+            return None
+
+        cap = cv2.VideoCapture(self.video_path)
+        if not cap.isOpened():
+            return None
+
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        cap.release()
+
+        if total_frames <= 0:
+            return None
+
+        return {'frames': total_frames, 'fps': fps or self.original_video_fps}
+
+    def _read_metadata_with_ffprobe(self):
+        if shutil.which("ffprobe") is None:
+            return None
+
+        cmd = [
+            "ffprobe",
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "stream=nb_frames,r_frame_rate,avg_frame_rate,duration",
+            "-of", "json",
+            str(self.video_path)
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+            )
+        except subprocess.CalledProcessError:
+            return None
+
+        try:
+            info = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return None
+
+        streams = info.get("streams") or []
+        if not streams:
+            return None
+
+        stream = streams[0]
+        total_frames = stream.get("nb_frames")
+        fps = stream.get("avg_frame_rate") or stream.get("r_frame_rate")
+        duration = stream.get("duration")
+
+        fps_value = self._parse_ffprobe_fps(fps)
+        total_frames_value = None
+
+        if isinstance(total_frames, str) and total_frames.isdigit():
+            total_frames_value = int(total_frames)
+
+        if total_frames_value is None and duration and fps_value:
+            try:
+                total_frames_value = int(round(float(duration) * fps_value))
+            except ValueError:
+                total_frames_value = None
+
+        if total_frames_value is None:
+            return None
+
+        return {'frames': total_frames_value, 'fps': fps_value or self.original_video_fps}
+
+    @staticmethod
+    def _parse_ffprobe_fps(rate_str):
+        """解析ffprobe输出的帧率字符串，例如'30000/1001'"""
+        if not rate_str or rate_str in ("0/0", "0"):
+            return None
+
+        if "/" in rate_str:
+            num, denom = rate_str.split("/", 1)
+            try:
+                num = float(num)
+                denom = float(denom)
+                if denom == 0:
+                    return None
+                return num / denom
+            except ValueError:
+                return None
+
+        try:
+            return float(rate_str)
+        except ValueError:
+            return None
+
+
 def analyze_from_numpy_file(attention_file, translation, video_frames, output_dir):
     """
     从numpy文件加载attention并分析

SignX/eval/generate_gloss_frames.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+后处理脚本：从已有的详细分析结果生成 gloss-to-frames 可视化
+使用方法：
+    python generate_gloss_frames.py <detailed_prediction_dir> <video_path>
+
+例如：
+    python generate_gloss_frames.py detailed_prediction_20251225_170455 ./eval/tiny_test_data/videos/666.mp4
+"""
+
+import sys
+import json
+import numpy as np
+import cv2
+from pathlib import Path
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+
+def extract_video_frames(video_path, frame_indices):
+    """从视频中提取指定索引的帧"""
+    cap = cv2.VideoCapture(video_path)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    frames = {}
+    for idx in frame_indices:
+        if idx >= total_frames:
+            idx = total_frames - 1
+        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+        ret, frame = cap.read()
+        if ret:
+            # BGR to RGB
+            frames[idx] = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+    cap.release()
+    return frames, total_frames
+
+def generate_gloss_to_frames_visualization(sample_dir, video_path, output_path):
+    """生成 gloss-to-frames 可视化"""
+
+    sample_dir = Path(sample_dir)
+
+    # 1. 读取对齐数据
+    with open(sample_dir / "frame_alignment.json", 'r') as f:
+        alignment_data = json.load(f)
+
+    # 2. 读取翻译结果
+    with open(sample_dir / "translation.txt", 'r') as f:
+        lines = f.readlines()
+        gloss_sequence = None
+        for line in lines:
+            if line.startswith('Clean:'):
+                gloss_sequence = line.replace('Clean:', '').strip()
+                break
+
+    if not gloss_sequence:
+        print("无法找到翻译结果")
+        return
+
+    glosses = gloss_sequence.split()
+    print(f"Gloss序列: {glosses}")
+
+    # 3. 获取视频信息
+    cap = cv2.VideoCapture(str(video_path))
+    total_video_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    cap.release()
+
+    print(f"视频总帧数: {total_video_frames}, FPS: {fps}")
+
+    # 4. 从对齐数据中提取每个gloss的特征帧范围
+    gloss_frames_info = []
+
+    # 获取特征帧总数（从 attention weights 的 shape 推断）
+    attention_weights = np.load(sample_dir / "attention_weights.npy")
+    total_feature_frames = attention_weights.shape[1]  # shape: [time, src_len, beam]
+
+    # 计算映射到原始视频帧
+    # 原始帧索引 = 特征帧索引 * (总视频帧数 / 总特征帧数)
+    scale_factor = total_video_frames / total_feature_frames
+
+    for gloss_data in alignment_data['frame_ranges']:
+        gloss = gloss_data['word']
+        start_feat_frame = gloss_data['start_frame']
+        peak_feat_frame = gloss_data['peak_frame']
+        end_feat_frame = gloss_data['end_frame']
+
+        # 映射到原始视频帧
+        start_video_frame = int(start_feat_frame * scale_factor)
+        peak_video_frame = int(peak_feat_frame * scale_factor)
+        end_video_frame = int(end_feat_frame * scale_factor)
+
+        # 计算相对时间 (%)
+        relative_time_start = (start_feat_frame / total_feature_frames) * 100
+        relative_time_end = (end_feat_frame / total_feature_frames) * 100
+
+        gloss_frames_info.append({
+            'gloss': gloss,
+            'feature_frames': (start_feat_frame, peak_feat_frame, end_feat_frame),
+            'video_frames': (start_video_frame, peak_video_frame, end_video_frame),
+            'relative_time': (relative_time_start, relative_time_end),
+            'total_feature_frames': total_feature_frames,
+            'confidence': gloss_data.get('confidence', 'unknown'),
+            'avg_attention': gloss_data.get('avg_attention', 0.0)
+        })
+
+    # 5. 提取所需的视频帧
+    all_frame_indices = set()
+    for info in gloss_frames_info:
+        all_frame_indices.update(info['video_frames'])
+
+    print(f"提取 {len(all_frame_indices)} 个视频帧...")
+    video_frames, _ = extract_video_frames(str(video_path), sorted(all_frame_indices))
+
+    # 6. 生成可视化
+    num_glosses = len(gloss_frames_info)
+    fig = plt.figure(figsize=(16, num_glosses * 2.5))
+
+    for i, info in enumerate(gloss_frames_info):
+        gloss = info['gloss']
+        feat_start, feat_peak, feat_end = info['feature_frames']
+        vid_start, vid_peak, vid_end = info['video_frames']
+        rel_start, rel_end = info['relative_time']
+        total_feat = info['total_feature_frames']
+
+        # 创建3列布局：Gloss | 时间信息 | 帧图像
+
+        # 列1：Gloss文本
+        ax_text = plt.subplot(num_glosses, 3, i*3 + 1)
+        ax_text.text(0.5, 0.5, gloss,
+                     fontsize=20, fontweight='bold',
+                     ha='center', va='center')
+        ax_text.axis('off')
+
+        # 列2：时间和帧信息
+        ax_info = plt.subplot(num_glosses, 3, i*3 + 2)
+        confidence = info.get('confidence', 'unknown')
+        avg_attn = info.get('avg_attention', 0.0)
+
+        info_text = f"""特征帧: {feat_start} → {feat_peak} → {feat_end}
+相对时间: {rel_start:.1f}% → {rel_end:.1f}%
+原始帧: {vid_start} → {vid_peak} → {vid_end}
+
+总特征帧: {total_feat}
+总视频帧: {total_video_frames}
+
+置信度: {confidence}
+注意力: {avg_attn:.3f}"""
+
+        ax_info.text(0.1, 0.5, info_text,
+                     fontsize=10, family='monospace',
+                     ha='left', va='center')
+        ax_info.axis('off')
+
+        # 列3：视频帧（Start | Peak | End）横向拼接
+        ax_frames = plt.subplot(num_glosses, 3, i*3 + 3)
+
+        # 获取三个关键帧
+        frames_to_show = []
+        labels = []
+        for idx, label in [(vid_start, 'Start'), (vid_peak, 'Peak'), (vid_end, 'End')]:
+            if idx in video_frames:
+                frames_to_show.append(video_frames[idx])
+                labels.append(f"{label}\n(#{idx})")
+
+        if frames_to_show:
+            # 调整帧大小
+            frame_height = 120
+            resized_frames = []
+            for frame in frames_to_show:
+                h, w = frame.shape[:2]
+                new_w = int(w * frame_height / h)
+                resized = cv2.resize(frame, (new_w, frame_height))
+                resized_frames.append(resized)
+
+            # 横向拼接
+            combined = np.hstack(resized_frames)
+            ax_frames.imshow(combined)
+
+            # 添加标签
+            x_pos = 0
+            for j, (frame, label) in enumerate(zip(resized_frames, labels)):
+                w = frame.shape[1]
+                ax_frames.text(x_pos + w//2, -10, label,
+                             ha='center', va='bottom',
+                             fontsize=9, fontweight='bold')
+                x_pos += w
+
+        ax_frames.axis('off')
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches='tight')
+    print(f"✓ 已生成可视化: {output_path}")
+    plt.close()
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print("使用方法: python generate_gloss_frames.py <detailed_prediction_dir> <video_path>")
+        print("例如: python generate_gloss_frames.py detailed_prediction_20251225_170455 ./eval/tiny_test_data/videos/666.mp4")
+        sys.exit(1)
+
+    detailed_dir = Path(sys.argv[1])
+    video_path = sys.argv[2]
+
+    if not detailed_dir.exists():
+        print(f"错误: 目录不存在: {detailed_dir}")
+        sys.exit(1)
+
+    if not Path(video_path).exists():
+        print(f"错误: 视频文件不存在: {video_path}")
+        sys.exit(1)
+
+    # 处理所有样本
+    sample_dirs = sorted(detailed_dir.glob("sample_*"))
+
+    for sample_dir in sample_dirs:
+        print(f"\n处理 {sample_dir.name}...")
+        output_path = sample_dir / "gloss_to_frames.png"
+        generate_gloss_to_frames_visualization(sample_dir, video_path, output_path)
+
+    print(f"\n✓ 完成！共处理 {len(sample_dirs)} 个样本")

SignX/inference.sh

@@ -204,6 +204,7 @@ cat > "$TEMP_DIR/infer_config.py" <<EOF
     'gpus': [0],
     'remove_bpe': True,
     'collect_attention_weights': True,
+    'inference_video_path': '$VIDEO_PATH',
 }
 EOF
 
@@ -245,6 +246,15 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
             # 统计样本数量
             sample_count=$(find "$dest_path" -maxdepth 1 -type d -name "sample_*" | wc -l)
             echo "  ✓ 已保存 $sample_count 个样本的详细分析到: $dest_path"
+
+            # 后处理：生成 gloss-to-frames 可视化
+            echo ""
+            echo -e "${BLUE}生成 Gloss-to-Frames 可视化...${NC}"
+            if [ -f "$SCRIPT_DIR/eval/generate_gloss_frames.py" ]; then
+                python "$SCRIPT_DIR/eval/generate_gloss_frames.py" "$dest_path" "$VIDEO_PATH" 2>&1 | grep -E "(处理|提取|生成|完成|✓)"
+            else
+                echo "  ⓘ generate_gloss_frames.py 未找到，跳过后处理"
+            fi
         done
     fi
 
@@ -263,6 +273,7 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
         echo "Attention分析包含:"
         echo "  - 注意力权重热图 (attention_heatmap.png)"
         echo "  - 词-帧对齐图 (word_frame_alignment.png)"
+        echo "  - Gloss-视频帧对应图 (gloss_to_frames.png)"
         echo "  - 分析报告 (analysis_report.txt)"
         echo "  - 原始数据 (attention_weights.npy)"
     fi

SignX/inference_output.txt

@@ -0,0 +1 @@
+<unk> NOW@@ -@@ WEEK STUDENT I@@ X HAVE NONE/NOTHING GO NONE/NOTHING

SignX/inference_output.txt.clean

@@ -0,0 +1 @@
+<unk> NOW-WEEK STUDENT IX HAVE NONE/NOTHING GO NONE/NOTHING

SignX/main.py

@@ -480,7 +480,9 @@ def evaluate(params):
         )
 
         # save translation
-        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions)
+        # Get video path from params if available (for test mode with inference video)
+        video_path = getattr(params, 'inference_video_path', None)
+        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions, video_path=video_path)
 
     return bleu
 
@@ -572,4 +574,6 @@ def inference(params):
         )
 
         # save translation
-        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions)
+        # Get video path from params if available (for inference mode)
+        video_path = getattr(params, 'inference_video_path', None)
+        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions, video_path=video_path)

SignX/models/evalu.py

@@ -198,7 +198,7 @@ def eval_metric(trans, target_file, indices=None, remove_bpe=False):
     return metric.bleu(trans, references)
 
 
-def dump_tanslation(tranes, output, indices=None, attentions=None):
+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
@@ -220,7 +220,7 @@ def dump_tanslation(tranes, output, indices=None, attentions=None):
     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)
+            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
@@ -279,7 +279,7 @@ def dump_translation_with_reference(tranes, output, ref_file, indices=None, remo
     tf.logging.info("Saving comparison into {}".format(comparison_file))
 
 
-def dump_detailed_attention_output(tranes, output, indices, attentions):
+def dump_detailed_attention_output(tranes, output, indices, attentions, video_path=None):
     """
     保存详细的attention分析结果
 
@@ -288,6 +288,7 @@ def dump_detailed_attention_output(tranes, output, indices, attentions):
         output: 输出文件路径
         indices: 样本索引
         attentions: attention权重数据（list of numpy arrays）
+        video_path: 视频文件路径（可选，用于提取视频帧）
     """
     import os
     import sys
@@ -329,16 +330,24 @@ def dump_detailed_attention_output(tranes, output, indices, attentions):
 
             # 检查是否所有元素都是numpy array
             # Note: Each element in attentions is a list (one per GPU), so we need to extract from it
+            def extract_numpy_array(obj):
+                """Recursively extract numpy array from nested lists"""
+                if isinstance(obj, np.ndarray):
+                    return obj
+                elif isinstance(obj, list) and len(obj) > 0:
+                    return extract_numpy_array(obj[0])
+                else:
+                    return None
+
             all_attentions = []
-            for attn_batch in attentions:
+            for idx, attn_batch in enumerate(attentions):
                 if attn_batch is not None:
-                    # Handle both list (multi-GPU) and numpy array (already processed) cases
-                    if isinstance(attn_batch, list):
-                        # Extract first element (GPU 0's result)
-                        if len(attn_batch) > 0 and isinstance(attn_batch[0], np.ndarray):
-                            all_attentions.append(attn_batch[0])
-                    elif isinstance(attn_batch, np.ndarray):
-                        all_attentions.append(attn_batch)
+                    extracted = extract_numpy_array(attn_batch)
+                    if extracted is not None:
+                        tf.logging.info(f"[DEBUG] attn_batch[{idx}] extracted shape: {extracted.shape}")
+                        all_attentions.append(extracted)
+                    else:
+                        tf.logging.info(f"[DEBUG] attn_batch[{idx}] could not extract numpy array")
 
             if len(all_attentions) == 0:
                 tf.logging.warning("No valid attention data found")
@@ -394,7 +403,8 @@ def dump_detailed_attention_output(tranes, output, indices, attentions):
                         analyzer = AttentionAnalyzer(
                             attentions=sample_attn,
                             translation=trans_clean,
-                            video_frames=video_frames
+                            video_frames=video_frames,
+                            video_path=video_path
                         )
 
                         analyzer.generate_all_visualizations(sample_dir)

SignX/run.py

@@ -40,6 +40,9 @@ global_params = tc.training.HParams(
     # collect attention weights during inference for detailed analysis
     collect_attention_weights=False,  # Disabled by default, enable when needed
 
+    # video path for inference (used to extract video frames for visualization)
+    inference_video_path=None,
+
     # separately encoding textual and sign video until `sep_layer`
     sep_layer=0,
     # source/target BPE codes and dropout rate => used for BPE-dropout