The reasoning has been converted into English.

SignX/eval/attention_analysis.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 """
-Attention权重分析和可视化模块
+Attention weight analysis and visualization helpers for SignX.
 
-功能:
-1. 解析attention权重数据
-2. 计算每个词对应的视频帧范围
-3. 生成可视化图表（热图、对齐图、时间线）
-4. 保存详细分析报告
+Capabilities:
+1. Parse attention weight tensors
+2. Map each generated gloss to video frame ranges
+3. Render visual assets (heatmaps, alignment plots, timelines)
+4. Write detailed analysis reports
 
-使用示例:
+Example:
     from eval.attention_analysis import AttentionAnalyzer
 
     analyzer = AttentionAnalyzer(
@@ -17,7 +17,6 @@ Attention权重分析和可视化模块
         video_frames=100
     )
 
-    # 生成所有可视化
     analyzer.generate_all_visualizations(output_dir="results/")
 """
 
@@ -32,37 +31,37 @@ from datetime import datetime
 
 
 class AttentionAnalyzer:
-    """Attention权重分析器"""
+    """Analyze attention tensors and generate visual/debug artifacts."""
 
     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, SMKD特征序列帧数
-            beam_sequences: list, 所有beam的序列 (可选)
-            beam_scores: list, 所有beam的分数 (可选)
-            video_path: str, 原始视频文件路径 (可选,用于提取视频帧)
-            original_video_fps: int, 原始视频FPS (默认30)
-            original_video_total_frames: int, 原始视频总帧数 (可选,如果不提供则从视频中读取)
+                       or [time_steps, src_len] (best beam already selected)
+            translation: str, BPE-removed gloss sequence
+            video_frames: int, number of SMKD feature frames
+            beam_sequences: list, optional beam texts
+            beam_scores: list, optional beam scores
+            video_path: str, optional path to original video (for frame grabs)
+            original_video_fps: int, FPS of original video (default 30)
+            original_video_total_frames: optional exact frame count
         """
         self.attentions = attentions
         self.translation = translation
         self.words = translation.split()
-        self.video_frames = video_frames  # SMKD特征帧数
+        self.video_frames = video_frames
         self.beam_sequences = beam_sequences
         self.beam_scores = beam_scores
 
-        # 原始视频相关
+        # Video metadata
         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
 
-        # 如果提供了视频路径但没有提供总帧数,尝试读取
+        # Auto-read metadata if only video path is given
         if video_path and original_video_total_frames is None:
             metadata = self._read_video_metadata()
             if metadata:
@@ -70,9 +69,9 @@ class AttentionAnalyzer:
                 if metadata.get('fps'):
                     self.original_video_fps = metadata['fps']
             elif video_path:
-                print(f"Warning: 无法解析视频信息, Gloss-to-Frames 可视化将无法对齐实际帧 ({video_path})")
+                print(f"Warning: failed to parse video metadata; gloss-to-frame visualization may be misaligned ({video_path})")
 
-        # 提取最佳路径的attention (batch=0, beam=0)
+        # Always operate on the best path (batch=0, beam=0)
         if len(attentions.shape) == 4:
             self.attn_best = attentions[:, 0, 0, :]  # [time, src_len]
         elif len(attentions.shape) == 3:
@@ -80,32 +79,22 @@ class AttentionAnalyzer:
         else:
             self.attn_best = attentions  # [time, src_len]
 
-        # 计算词-帧对应关系
+        # Pre-compute gloss-to-frame ranges
         self.word_frame_ranges = self._compute_word_frame_ranges()
         self.frame_attention_strength = self._compute_frame_attention_strength()
 
     def _compute_word_frame_ranges(self):
         """
-        计算每个词对应的主要视频帧范围
+        Compute the dominant video frame range for each generated word.
 
         Returns:
-            list of dict: [
-                {
-                    'word': str,
-                    'start_frame': int,
-                    'end_frame': int,
-                    'peak_frame': int,
-                    'avg_attention': float,
-                    'confidence': str
-                },
-                ...
-            ]
+            list of dict entries containing word, frame range, peak, and confidence.
         """
         word_ranges = []
 
         for word_idx, word in enumerate(self.words):
             if word_idx >= self.attn_best.shape[0]:
-                # 超出attention范围
+                # Out of range
                 word_ranges.append({
                     'word': word,
                     'start_frame': 0,
@@ -118,11 +107,11 @@ class AttentionAnalyzer:
 
             attn_weights = self.attn_best[word_idx, :]
 
-            # 找到权重最高的帧
+            # Peak frame for this word
             peak_frame = int(np.argmax(attn_weights))
             peak_weight = attn_weights[peak_frame]
 
-            # 计算显著帧范围（权重 >= 最大值的90%）
+            # Frames whose weight >= 90% of the peak
             threshold = peak_weight * 0.9
             significant_frames = np.where(attn_weights >= threshold)[0]
 
@@ -135,7 +124,7 @@ class AttentionAnalyzer:
                 end_frame = peak_frame
                 avg_weight = float(peak_weight)
 
-            # 判断置信度
+            # Qualitative confidence bucket
             if avg_weight > 0.5:
                 confidence = 'high'
             elif avg_weight > 0.2:
@@ -204,32 +193,29 @@ class AttentionAnalyzer:
 
     def generate_all_visualizations(self, output_dir):
         """
-        生成所有可视化图表
-
-        Args:
-            output_dir: 输出目录路径
+        Generate every visualization artifact to the provided directory.
         """
         output_dir = Path(output_dir)
         output_dir.mkdir(parents=True, exist_ok=True)
 
-        print(f"\n生成可视化图表到: {output_dir}")
+        print(f"\nGenerating visualization assets in: {output_dir}")
 
-        # 1. Attention热图
+        # 1. Attention heatmap
         self.plot_attention_heatmap(output_dir / "attention_heatmap.png")
 
-        # 2. 帧对齐图
+        # 2. Frame alignment
         self.plot_frame_alignment(output_dir / "frame_alignment.png")
 
-        # 3. 保存数值数据
+        # 3. JSON metadata
         self.save_alignment_data(output_dir / "frame_alignment.json")
 
-        # 4. 保存详细报告
+        # 4. Text report
         self.save_text_report(output_dir / "analysis_report.txt")
 
-        # 5. 保存numpy数据（供进一步分析）
+        # 5. Raw numpy dump (for downstream tooling)
         np.save(output_dir / "attention_weights.npy", self.attentions)
 
-        # 6. Gloss-to-Frames可视化 (如果提供了视频路径)
+        # 6. Gloss-to-Frames visualization (if video is available)
         # Write debug info to file
         debug_file = output_dir / "debug_video_path.txt"
         with open(debug_file, 'w') as f:
@@ -251,36 +237,36 @@ class AttentionAnalyzer:
         else:
             print("[DEBUG] Skipping gloss-to-frames visualization (no video path provided)")
 
-        print(f"✓ 已生成 {len(list(output_dir.glob('*')))} 个文件")
+        print(f"✓ Wrote {len(list(output_dir.glob('*')))} file(s)")
 
     def plot_attention_heatmap(self, output_path):
-        """生成Attention热图"""
+        """Render the attention heatmap (image + PDF copy)."""
         try:
             import matplotlib
             matplotlib.use('Agg')
             import matplotlib.pyplot as plt
         except ImportError:
-            print("  跳过热图: matplotlib未安装")
+            print("  Skipping heatmap: matplotlib is not available")
             return
 
         fig, ax = plt.subplots(figsize=(14, 8))
 
-        # 绘制热图
+        # Heatmap
         im = ax.imshow(self.attn_best.T, cmap='hot', aspect='auto',
                       interpolation='nearest', origin='lower')
 
-        # 设置标签
+        # Axis labels
         ax.set_xlabel('Generated Word Index', fontsize=13)
         ax.set_ylabel('Video Frame Index', fontsize=13)
         ax.set_title('Cross-Attention Weights\n(Decoder → Video Frames)',
                     fontsize=15, pad=20, fontweight='bold')
 
-        # 词标签
+        # Word labels on the x-axis
         if len(self.words) <= self.attn_best.shape[0]:
             ax.set_xticks(range(len(self.words)))
             ax.set_xticklabels(self.words, rotation=45, ha='right', fontsize=10)
 
-        # 添加颜色条
+        # Color bar
         cbar = plt.colorbar(im, ax=ax, label='Attention Weight', fraction=0.046, pad=0.04)
         cbar.ax.tick_params(labelsize=10)
 
@@ -294,7 +280,7 @@ class AttentionAnalyzer:
         print(f"  ✓ {output_path.name} (PDF copy saved)")
 
     def plot_frame_alignment(self, output_path):
-        """生成帧对齐可视化"""
+        """Render the frame-alignment charts (full + compact)."""
         try:
             import matplotlib
             matplotlib.use('Agg')
@@ -302,7 +288,7 @@ class AttentionAnalyzer:
             import matplotlib.patches as patches
             from matplotlib.gridspec import GridSpec
         except ImportError:
-            print("  跳过对齐图: matplotlib未安装")
+            print("  Skipping alignment plot: matplotlib is not available")
             return
 
         output_path = Path(output_path)
@@ -347,7 +333,7 @@ class AttentionAnalyzer:
                 fig = plt.figure(figsize=(18, 7.5))
                 gs = GridSpec(2, 1, height_ratios=[4, 1], hspace=0.32)
 
-            # === 上图: 词-帧对齐 ===
+            # === Top plot: word-to-frame alignment ===
             ax1 = fig.add_subplot(gs[0])
             colors = plt.cm.tab20(np.linspace(0, 1, max(len(self.words), 20)))
 
@@ -384,7 +370,7 @@ class AttentionAnalyzer:
             ax1.set_yticks(range(len(self.words)))
             ax1.set_yticklabels([w['word'] for w in self.word_frame_ranges], fontsize=10)
 
-            # === 中图1: Latent timeline ===
+            # === Middle plot: latent timeline ===
             ax2 = fig.add_subplot(gs[1])
             ax2.barh(0, self.video_frames, height=0.6, color='lightgray',
                     edgecolor='black', linewidth=2)
@@ -481,7 +467,7 @@ class AttentionAnalyzer:
             render_alignment(short_path, latent_short_limit, orig_short_limit if orig_short_limit else orig_full_limit)
 
     def save_alignment_data(self, output_path):
-        """保存帧对齐数据为JSON"""
+        """Persist frame-alignment metadata to JSON."""
         data = {
             'translation': self.translation,
             'words': self.words,
@@ -501,35 +487,35 @@ class AttentionAnalyzer:
         print(f"  ✓ {output_path.name}")
 
     def save_text_report(self, output_path):
-        """保存文本格式的详细报告"""
+        """Write a plain-text report (used for analysis_report.txt)."""
         with open(output_path, 'w', encoding='utf-8') as f:
             f.write("=" * 80 + "\n")
-            f.write("  Sign Language Recognition - Attention分析报告\n")
+            f.write("  Sign Language Recognition - Attention Analysis Report\n")
             f.write("=" * 80 + "\n\n")
 
-            f.write(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+            f.write(f"Generated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
 
-            f.write("翻译结果:\n")
+            f.write("Translation:\n")
             f.write("-" * 80 + "\n")
             f.write(f"{self.translation}\n\n")
 
-            f.write("视频信息:\n")
+            f.write("Video info:\n")
             f.write("-" * 80 + "\n")
-            f.write(f"总帧数: {self.video_frames}\n")
-            f.write(f"词数量: {len(self.words)}\n\n")
+            f.write(f"Total feature frames: {self.video_frames}\n")
+            f.write(f"Word count: {len(self.words)}\n\n")
 
-            f.write("Attention权重信息:\n")
+            f.write("Attention tensor:\n")
             f.write("-" * 80 + "\n")
-            f.write(f"形状: {self.attentions.shape}\n")
-            f.write(f"  - 解码步数: {self.attentions.shape[0]}\n")
+            f.write(f"Shape: {self.attentions.shape}\n")
+            f.write(f"  - Decoder steps: {self.attentions.shape[0]}\n")
             if len(self.attentions.shape) >= 3:
-                f.write(f"  - Batch大小: {self.attentions.shape[1]}\n")
+                f.write(f"  - Batch size: {self.attentions.shape[1]}\n")
             if len(self.attentions.shape) >= 4:
-                f.write(f"  - Beam大小: {self.attentions.shape[2]}\n")
-                f.write(f"  - 源序列长度: {self.attentions.shape[3]}\n")
+                f.write(f"  - Beam size: {self.attentions.shape[2]}\n")
+                f.write(f"  - Source length: {self.attentions.shape[3]}\n")
             f.write("\n")
 
-            f.write("词-帧对应详情:\n")
+            f.write("Word-to-frame details:\n")
             f.write("=" * 80 + "\n")
             f.write(f"{'No.':<5} {'Word':<20} {'Frames':<15} {'Peak':<8} {'Attn':<8} {'Conf':<10}\n")
             f.write("-" * 80 + "\n")
@@ -541,7 +527,7 @@ class AttentionAnalyzer:
 
             f.write("\n" + "=" * 80 + "\n")
 
-            # 统计信息
+            # Summary
             stats = {
                 'avg_confidence': np.mean([w['avg_attention'] for w in self.word_frame_ranges]),
                 'high': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'high'),
@@ -549,12 +535,12 @@ class AttentionAnalyzer:
                 'low': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'low'),
             }
 
-            f.write("\n统计摘要:\n")
+            f.write("\nSummary:\n")
             f.write("-" * 80 + "\n")
-            f.write(f"平均attention权重: {stats['avg_confidence']:.3f}\n")
-            f.write(f"高置信度词: {stats['high']} ({stats['high']/len(self.words)*100:.1f}%)\n")
-            f.write(f"中置信度词: {stats['medium']} ({stats['medium']/len(self.words)*100:.1f}%)\n")
-            f.write(f"低置信度词: {stats['low']} ({stats['low']/len(self.words)*100:.1f}%)\n")
+            f.write(f"Average attention weight: {stats['avg_confidence']:.3f}\n")
+            f.write(f"High-confidence words: {stats['high']} ({stats['high']/len(self.words)*100:.1f}%)\n")
+            f.write(f"Medium-confidence words: {stats['medium']} ({stats['medium']/len(self.words)*100:.1f}%)\n")
+            f.write(f"Low-confidence words: {stats['low']} ({stats['low']/len(self.words)*100:.1f}%)\n")
             f.write("\n" + "=" * 80 + "\n")
 
         print(f"  ✓ {output_path.name}")
@@ -562,34 +548,34 @@ class AttentionAnalyzer:
 
     def _map_feature_frame_to_original(self, feature_frame_idx):
         """
-        将SMKD特征帧索引映射到原始视频帧索引
+        Map a SMKD feature frame index back to the original video frame index.
 
         Args:
-            feature_frame_idx: SMKD特征帧索引 (0-based)
+            feature_frame_idx: Zero-based feature frame index
 
         Returns:
-            int: 原始视频帧索引,如果无法映射则返回None
+            int: Original frame index, or None if unavailable.
         """
         if self.original_video_total_frames is None:
             return None
 
-        # 计算降采样率
+        # Approximate downsampling ratio between latent frames and original frames
         downsample_ratio = self.original_video_total_frames / self.video_frames
 
-        # 映射到原始视频帧
+        # Map latent index to original frame index
         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):
         """
-        从视频中提取指定索引的帧
+        Extract the requested original video frames (best-effort).
 
         Args:
-            frame_indices: list of int, 要提取的帧索引列表
+            frame_indices: list[int] of original frame IDs to load
 
         Returns:
-            dict: {frame_idx: numpy_array}, 帧索引到图像数据的映射
+            dict mapping frame index to numpy array (BGR).
         """
         if not self.video_path:
             return {}
@@ -601,7 +587,7 @@ class AttentionAnalyzer:
         return self._extract_frames_with_ffmpeg(frame_indices)
 
     def _get_cv2_module(self):
-        """惰性加载cv2, 缓存导入结果"""
+        """Lazy-load cv2 and cache the import outcome."""
         if self._cv2_checked:
             return self._cv2_module
 
@@ -614,11 +600,11 @@ class AttentionAnalyzer:
             self._cv2_checked = True
 
         if self._cv2_module is None:
-            print("Warning: opencv-python 未安装, 将尝试使用 ffmpeg 提取视频帧")
+            print("Warning: opencv-python is missing; falling back to ffmpeg grabs")
         return self._cv2_module
 
     def _extract_frames_with_cv2(self, cv2, frame_indices):
-        """使用opencv提取视频帧"""
+        """Extract frames via OpenCV if available."""
         frames = {}
         cap = cv2.VideoCapture(self.video_path)
 
@@ -637,15 +623,15 @@ class AttentionAnalyzer:
         return frames
 
     def _extract_frames_with_ffmpeg(self, frame_indices):
-        """使用ffmpeg + Pillow提取视频帧(在opencv缺失时调用)"""
+        """Extract frames via ffmpeg + Pillow (OpenCV fallback)."""
         if shutil.which("ffmpeg") is None:
-            print("Warning: 未找到 ffmpeg, 无法提取视频帧")
+            print("Warning: ffmpeg not found; cannot extract frames")
             return {}
 
         try:
             from PIL import Image
         except ImportError:
-            print("Warning: Pillow 未安装, 无法解码ffmpeg输出的图像")
+            print("Warning: Pillow not installed; cannot decode ffmpeg output")
             return {}
 
         frames = {}
@@ -669,26 +655,22 @@ class AttentionAnalyzer:
                 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}")
+                print(f"Warning: ffmpeg failed to extract frame {frame_idx}: {e}")
             except Exception as ex:
-                print(f"Warning: 解码帧 {frame_idx} 失败: {ex}")
+                print(f"Warning: failed to decode frame {frame_idx}: {ex}")
 
         if frames:
-            print(f"  ✓ 使用 ffmpeg 提取了 {len(frames)} 帧")
+            print(f"  ✓ Extracted {len(frames)} frame(s) via ffmpeg")
         else:
-            print("  ⓘ ffmpeg 未能提取任何帧")
+            print("  ⓘ ffmpeg did not return any frames")
         return frames
 
     def generate_gloss_to_frames_visualization(self, output_path):
         """
-        生成 Gloss-to-Frames 可视化图像
-        布局: 每行对应一个gloss
-        列1: Gloss文本
-        列2: 相对时间和帧索引信息
-        列3: 该时间段内的视频帧缩略图
-
-        Args:
-            output_path: 输出图像路径
+        Create the gloss-to-frames visualization:
+            Column 1: gloss text
+            Column 2: relative time + frame indices
+            Column 3: representative video thumbnails
         """
         if not self.video_path:
             print("  ⓘ Skipping gloss-to-frames visualization (no video path provided)")
@@ -701,7 +683,7 @@ class AttentionAnalyzer:
             print("Warning: matplotlib not installed")
             return
 
-        # 加载feature-to-frame mapping
+        # Load feature-to-frame mapping if available
         feature_mapping = None
         output_dir = Path(output_path).parent
         mapping_file = output_dir / "feature_frame_mapping.json"
@@ -713,53 +695,53 @@ class AttentionAnalyzer:
             except Exception as e:
                 print(f"  Warning: Failed to load feature mapping: {e}")
 
-        # 收集所有需要提取的原始视频帧
+        # Collect every original frame we need to grab
         all_original_frames = set()
         for word_info in self.word_frame_ranges:
-            # 特征帧范围
+            # Feature frame range
             start_feat = word_info['start_frame']
             end_feat = word_info['end_frame']
 
-            # 映射整个feature范围到原始视频帧
+            # Map the feature range onto original video frames
             if feature_mapping:
-                # 使用实际的feature mapping
+                # Use the precomputed mapping data
                 for feat_idx in range(start_feat, end_feat + 1):
                     if feat_idx < len(feature_mapping):
-                        # 从feature_mapping中获取该feature对应的所有原始帧
+                        # Pull every original frame for that feature segment
                         feat_info = feature_mapping[feat_idx]
                         for orig_idx in range(feat_info['frame_start'], feat_info['frame_end']):
                             all_original_frames.add(orig_idx)
             else:
-                # 后备方案：使用uniform mapping
+                # Fallback: assume uniform downsampling
                 for feat_idx in range(start_feat, end_feat + 1):
                     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)} 个视频帧...")
+        # Extract the necessary frames
+        print(f"  Extracting {len(all_original_frames)} original video frame(s)...")
         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 (4列布局: Gloss | Feature Index | Peak Frame | All Frames)
+        # Create figure (4 columns: Gloss | Feature Index | Peak Frame | Full Span)
         n_words = len(self.words)
         fig = plt.figure(figsize=(28, 3 * n_words))
         gs = gridspec.GridSpec(n_words, 4, width_ratios=[1.5, 1.5, 2.5, 8], hspace=0.3, wspace=0.2)
 
         for row_idx, (word, word_info) in enumerate(zip(self.words, self.word_frame_ranges)):
-            # 列1: Gloss文本
+            # Column 1: Gloss label
             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: 特征索引信息 (Feature Index Layer)
+            # Column 2: Feature index info
             ax_feature = fig.add_subplot(gs[row_idx, 1])
 
-            # 特征帧信息
+            # Feature frame details
             feat_start = word_info['start_frame']
             feat_end = word_info['end_frame']
             feat_peak = word_info['peak_frame']
@@ -776,28 +758,28 @@ class AttentionAnalyzer:
                                    edgecolor='darkblue', linewidth=2, alpha=0.7))
             ax_feature.axis('off')
 
-            # 列3: 峰值feature对应的原始帧
+            # Column 3: Original frames for the peak feature
             ax_peak_frames = fig.add_subplot(gs[row_idx, 2])
 
             peak_frames_to_show = []
             orig_peak_start, orig_peak_end = None, None
             if feature_mapping and feat_peak is not None and feat_peak < len(feature_mapping):
-                # 使用实际的feature mapping
+                # Use detailed mapping to determine the original frame span
                 peak_info = feature_mapping[feat_peak]
                 orig_peak_start = peak_info['frame_start']
                 orig_peak_end = peak_info['frame_end']
 
-                # 显示峰值feature对应的所有原始帧
+                # Show each original frame linked to the peak feature range
                 for orig_idx in range(orig_peak_start, orig_peak_end):
                     if orig_idx in video_frames_dict:
                         peak_frames_to_show.append(video_frames_dict[orig_idx])
 
             if peak_frames_to_show:
-                # 水平拼接帧
+                # Horizontally stitch frames
                 combined_peak = np.hstack(peak_frames_to_show)
                 ax_peak_frames.imshow(combined_peak)
 
-                # 添加标题
+                # Add caption
                 ax_peak_frames.text(0.5, -0.05, f"Peak Feature {feat_peak}\nFrames {orig_peak_start}-{orig_peak_end-1} ({len(peak_frames_to_show)} frames)",
                                    ha='center', va='top', transform=ax_peak_frames.transAxes,
                                    fontsize=10, weight='bold', color='red',
@@ -808,28 +790,28 @@ class AttentionAnalyzer:
 
             ax_peak_frames.axis('off')
 
-            # 列4: 整个gloss覆盖的所有原始帧
+            # Column 4: All frames covered by the gloss span
             ax_all_frames = fig.add_subplot(gs[row_idx, 3])
 
             all_frames_to_show = []
             orig_start, orig_end = None, None
             if feature_mapping:
-                # 使用实际的feature mapping获取范围
+                # Determine range via mapping
                 if feat_start < len(feature_mapping) and feat_end < len(feature_mapping):
                     orig_start = feature_mapping[feat_start]['frame_start']
                     orig_end = feature_mapping[feat_end]['frame_end']
 
-                    # 收集所有原始帧
+                    # Collect every frame in the span
                     for orig_idx in range(orig_start, orig_end):
                         if orig_idx in video_frames_dict:
                             all_frames_to_show.append(video_frames_dict[orig_idx])
 
             if all_frames_to_show:
-                # 水平拼接所有帧
+                # Stitch all frames horizontally
                 combined_all = np.hstack(all_frames_to_show)
                 ax_all_frames.imshow(combined_all)
 
-                # 添加标题显示帧数
+                # Add caption showing total
                 frame_count = len(all_frames_to_show)
                 ax_all_frames.text(0.5, -0.05, f"All Frames ({frame_count} frames)\nRange: {orig_start}-{orig_end-1}",
                                   ha='center', va='top', transform=ax_all_frames.transAxes,
@@ -850,7 +832,7 @@ class AttentionAnalyzer:
         print(f"  ✓ {Path(output_path).name}")
 
     def _read_video_metadata(self):
-        """尝试读取原始视频的帧数和fps"""
+        """Attempt to read the original video's frame count and FPS."""
         metadata = self._read_metadata_with_cv2()
         if metadata:
             return metadata
@@ -927,7 +909,7 @@ class AttentionAnalyzer:
 
     @staticmethod
     def _parse_ffprobe_fps(rate_str):
-        """解析ffprobe输出的帧率字符串，例如'30000/1001'"""
+        """Parse an ffprobe frame-rate string such as '30000/1001'."""
         if not rate_str or rate_str in ("0/0", "0"):
             return None
 
@@ -950,13 +932,13 @@ class AttentionAnalyzer:
 
 def analyze_from_numpy_file(attention_file, translation, video_frames, output_dir):
     """
-    从numpy文件加载attention并分析
+    Load attention weights from a .npy file and generate visualization assets.
 
     Args:
-        attention_file: .npy文件路径
-        translation: 翻译结果字符串
-        video_frames: 视频总帧数
-        output_dir: 输出目录
+        attention_file: Path to the numpy file
+        translation: Clean translation string
+        video_frames: Number of SMKD feature frames
+        output_dir: Destination directory for outputs
     """
     attentions = np.load(attention_file)
     analyzer = AttentionAnalyzer(attentions, translation, video_frames)

SignX/eval/extract_attention_keyframes.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-提取peak feature对应的关键帧，并将注意力可视化叠加到帧上
+Extract peak-feature keyframes and overlay attention heatmaps on the video frames.
 """
 
 import os
@@ -14,42 +14,36 @@ from matplotlib import cm
 
 def apply_attention_heatmap(frame, attention_weight, alpha=0.5):
     """
-    将注意力热力图叠加到视频帧上
+    Overlay a synthetic attention heatmap on top of a video frame.
 
     Args:
-        frame: 原始帧 (H, W, 3)
-        attention_weight: 注意力权重 (0-1之间的标量值)
-        alpha: 热力图透明度
+        frame: Original frame (H, W, 3)
+        attention_weight: Scalar attention weight in [0, 1]
+        alpha: Heatmap opacity
 
     Returns:
-        带有注意力热力图的帧
+        Frame with the attention heatmap blended in.
     """
     h, w = frame.shape[:2]
 
-    # 创建一个简单的中心高斯热力图（假设注意力集中在中心区域）
-    # 更好的方法是使用真实的空间注意力权重，但这需要模型输出空间维度的注意力
-
-    # 创建热力图 - 使用注意力权重调整强度
+    # Create a simple center-weighted Gaussian heatmap
     y, x = np.ogrid[:h, :w]
     center_y, center_x = h // 2, w // 2
 
-    # 高斯分布，注意力权重越高，热力图越集中
-    sigma = min(h, w) / 3 * (1.5 - attention_weight)  # 权重高时sigma更小，更集中
+    # High attention weight = tighter Gaussian
+    sigma = min(h, w) / 3 * (1.5 - attention_weight)
     gaussian = np.exp(-((x - center_x)**2 + (y - center_y)**2) / (2 * sigma**2))
 
-    # 归一化到 [0, 1]
+    # Normalize to [0, 1]
     gaussian = (gaussian - gaussian.min()) / (gaussian.max() - gaussian.min() + 1e-8)
 
-    # 应用注意力权重
+    # Apply the attention weight
     heatmap = gaussian * attention_weight
 
-    # 使用colormap: 蓝色(低) -> 绿色 -> 黄色 -> 橙色 -> 红色(高)
-    # 使用 'jet' 或 'hot' colormap
-    colormap = cm.get_cmap('jet')  # 或使用 'hot'
-    heatmap_colored = colormap(heatmap)[:, :, :3] * 255  # 转为RGB
+    colormap = cm.get_cmap('jet')
+    heatmap_colored = colormap(heatmap)[:, :, :3] * 255
     heatmap_colored = heatmap_colored.astype(np.uint8)
 
-    # 叠加到原始帧
     result = cv2.addWeighted(frame, 1-alpha, heatmap_colored, alpha, 0)
 
     return result
@@ -57,30 +51,30 @@ def apply_attention_heatmap(frame, attention_weight, alpha=0.5):
 
 def extract_keyframes_with_attention(sample_dir, video_path):
     """
-    提取peak feature对应的关键帧，并叠加注意力可视化
+    Extract peak-feature keyframes and overlay the attention visualization.
 
     Args:
-        sample_dir: sample目录路径 (e.g., detailed_xxx/sample_0)
-        video_path: 原始视频路径
+        sample_dir: Sample directory path (e.g., detailed_xxx/sample_0)
+        video_path: Original video path
     """
     sample_dir = Path(sample_dir)
 
-    print(f"\n处理样本: {sample_dir.name}")
+    print(f"\nProcessing sample: {sample_dir.name}")
 
     # 检查必要文件
     mapping_file = sample_dir / "feature_frame_mapping.json"
     weights_file = sample_dir / "attention_weights.npy"
 
     if not mapping_file.exists():
-        print(f"  ⚠ 未找到映射文件: {mapping_file}")
+        print(f"  ⚠ Mapping file not found: {mapping_file}")
         return
 
     if not weights_file.exists():
-        print(f"  ⚠ 未找到注意力权重: {weights_file}")
+        print(f"  ⚠ Attention weights missing: {weights_file}")
         return
 
     if not os.path.exists(video_path):
-        print(f"  ⚠ 视频文件不存在: {video_path}")
+        print(f"  ⚠ Video file not found: {video_path}")
         return
 
     # 加载映射和注意力权重
@@ -89,22 +83,22 @@ def extract_keyframes_with_attention(sample_dir, video_path):
 
     attention_weights = np.load(weights_file)
 
-    # 创建关键帧输出目录
+    # Create output directory
     keyframes_dir = sample_dir / "attention_keyframes"
     keyframes_dir.mkdir(exist_ok=True)
 
-    print(f"  特征数量: {mapping_data['feature_count']}")
-    print(f"  原始帧数: {mapping_data['original_frame_count']}")
-    print(f"  注意力权重形状: {attention_weights.shape}")
+    print(f"  Feature count: {mapping_data['feature_count']}")
+    print(f"  Original frame count: {mapping_data['original_frame_count']}")
+    print(f"  Attention weight shape: {attention_weights.shape}")
 
     # 打开视频
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
-        print(f"  ✗ 无法打开视频: {video_path}")
+        print(f"  ✗ Failed to open video: {video_path}")
         return
 
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    print(f"  视频总帧数: {total_frames}")
+    print(f"  Total video frames: {total_frames}")
 
     # 构建特征索引到帧的映射（使用中间帧）
     feature_to_frame = {}
@@ -112,57 +106,48 @@ def extract_keyframes_with_attention(sample_dir, video_path):
         feature_idx = item['feature_index']
         frame_start = item['frame_start']
         frame_end = item['frame_end']
-        # 使用中间帧
         mid_frame = (frame_start + frame_end) // 2
         feature_to_frame[feature_idx] = mid_frame
 
     num_glosses = attention_weights.shape[0] if len(attention_weights.shape) > 1 else 0
 
     if num_glosses == 0:
-        print(f"  ⚠ 注意力权重维度不正确")
+        print("  ⚠ Invalid attention weight dimensions")
         cap.release()
         return
 
     saved_count = 0
 
     for gloss_idx in range(num_glosses):
-        # 获取该gloss的注意力权重 (对所有特征的注意力)
         gloss_attention = attention_weights[gloss_idx]  # shape: (num_features,)
 
-        # 找到peak特征 (注意力最高的特征)
         peak_feature_idx = np.argmax(gloss_attention)
         peak_attention = gloss_attention[peak_feature_idx]
 
-        # 获取对应的帧索引
         if peak_feature_idx not in feature_to_frame:
-            print(f"  ⚠ Gloss {gloss_idx}: 特征 {peak_feature_idx} 没有对应的帧")
+            print(f"  ⚠ Gloss {gloss_idx}: feature {peak_feature_idx} missing frame mapping")
             continue
 
         frame_idx = feature_to_frame[peak_feature_idx]
 
-        # 读取该帧
         cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
         ret, frame = cap.read()
 
         if not ret:
-            print(f"  ⚠ Gloss {gloss_idx}: 无法读取帧 {frame_idx}")
+            print(f"  ⚠ Gloss {gloss_idx}: unable to read frame {frame_idx}")
             continue
 
-        # 应用注意力热力图
         frame_with_attention = apply_attention_heatmap(frame, peak_attention, alpha=0.4)
 
-        # 添加文本信息
         text = f"Gloss {gloss_idx} | Feature {peak_feature_idx} | Frame {frame_idx}"
         attention_text = f"Attention: {peak_attention:.3f}"
 
-        # 在图像顶部添加黑色背景条
         cv2.rectangle(frame_with_attention, (0, 0), (frame.shape[1], 60), (0, 0, 0), -1)
         cv2.putText(frame_with_attention, text, (10, 25),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
         cv2.putText(frame_with_attention, attention_text, (10, 50),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
 
-        # 保存关键帧
         output_filename = f"keyframe_{gloss_idx:03d}_feat{peak_feature_idx}_frame{frame_idx}_att{peak_attention:.3f}.jpg"
         output_path = keyframes_dir / output_filename
 
@@ -171,17 +156,17 @@ def extract_keyframes_with_attention(sample_dir, video_path):
 
     cap.release()
 
-    print(f"  ✓ 已保存 {saved_count} 个关键帧到: {keyframes_dir}")
+    print(f"  ✓ Saved {saved_count} keyframes to: {keyframes_dir}")
 
-    # 创建索引文件
+    # Create index file
     index_file = keyframes_dir / "keyframes_index.txt"
     with open(index_file, 'w') as f:
-        f.write(f"关键帧索引\n")
+        f.write("Attention Keyframe Index\n")
         f.write(f"=" * 60 + "\n\n")
-        f.write(f"样本目录: {sample_dir}\n")
-        f.write(f"视频路径: {video_path}\n")
-        f.write(f"总关键帧数: {saved_count}\n\n")
-        f.write(f"关键帧列表:\n")
+        f.write(f"Sample directory: {sample_dir}\n")
+        f.write(f"Video path: {video_path}\n")
+        f.write(f"Total keyframes: {saved_count}\n\n")
+        f.write("Keyframe list:\n")
         f.write(f"-" * 60 + "\n")
 
         for gloss_idx in range(num_glosses):
@@ -194,13 +179,13 @@ def extract_keyframes_with_attention(sample_dir, video_path):
                 filename = f"keyframe_{gloss_idx:03d}_feat{peak_feature_idx}_frame{frame_idx}_att{peak_attention:.3f}.jpg"
                 f.write(f"Gloss {gloss_idx:3d}: {filename}\n")
 
-    print(f"  ✓ 索引文件已创建: {index_file}")
+    print(f"  ✓ Index file written: {index_file}")
 
 
 def main():
     if len(sys.argv) < 3:
-        print("用法: python extract_attention_keyframes.py <sample_dir> <video_path>")
-        print("示例: python extract_attention_keyframes.py detailed_xxx/sample_0 video.mp4")
+        print("Usage: python extract_attention_keyframes.py <sample_dir> <video_path>")
+        print("Example: python extract_attention_keyframes.py detailed_xxx/sample_0 video.mp4")
         sys.exit(1)
 
     sample_dir = sys.argv[1]

SignX/eval/generate_feature_mapping.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 """
-生成特征-帧映射文件
+Generate a feature-to-frame mapping file for SignX inference outputs.
 
 Usage:
     python generate_feature_mapping.py <sample_dir> <video_path>
@@ -17,13 +17,13 @@ import numpy as np
 from pathlib import Path
 
 def generate_feature_mapping(sample_dir, video_path):
-    """为指定样本生成特征-帧映射文件"""
+    """Create the feature-to-frame mapping JSON for a given sample directory."""
     sample_dir = Path(sample_dir)
 
     # Check if attention_weights.npy exists
     attn_file = sample_dir / "attention_weights.npy"
     if not attn_file.exists():
-        print(f"错误: 找不到attention_weights.npy: {attn_file}")
+        print(f"Error: missing attention_weights.npy: {attn_file}")
         return False
 
     # Load attention weights to get feature count
@@ -34,29 +34,29 @@ def generate_feature_mapping(sample_dir, video_path):
     elif attn_weights.ndim == 3:
         feature_count = attn_weights.shape[2]  # Shape: (time, beam, features) - beam search
     else:
-        print(f"错误: attention_weights 维度异常: {attn_weights.shape}")
+        print(f"Error: unexpected attention_weights shape: {attn_weights.shape}")
         return False
 
-    print(f"特征数量: {feature_count}")
+    print(f"Feature count: {feature_count}")
 
     # Get original frame count from video
     try:
         import cv2
         cap = cv2.VideoCapture(str(video_path))
         if not cap.isOpened():
-            print(f"错误: 无法打开视频文件: {video_path}")
+            print(f"Error: failed to open video file: {video_path}")
             return False
 
         original_frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         fps = cap.get(cv2.CAP_PROP_FPS)
         cap.release()
 
-        print(f"原始帧数: {original_frame_count}, FPS: {fps}")
+        print(f"Original frames: {original_frame_count}, FPS: {fps}")
 
     except ImportError:
-        print("警告: OpenCV不可用，使用估算值")
-        # 假设30fps，根据特征数估算
-        original_frame_count = feature_count * 3  # 默认3倍下采样
+        print("Warning: OpenCV not available, falling back to estimates")
+        # Assume 30 fps and approximate the frame count from features
+        original_frame_count = feature_count * 3  # default 3x downsampling
         fps = 30.0
 
     # Calculate uniform mapping: feature i -> frames [start, end]
@@ -84,29 +84,29 @@ def generate_feature_mapping(sample_dir, video_path):
     with open(output_file, 'w') as f:
         json.dump(mapping_data, f, indent=2)
 
-    print(f"\n✓ 已生成映射文件: {output_file}")
-    print(f"  原始帧数: {original_frame_count}")
-    print(f"  特征数量: {feature_count}")
-    print(f"  下采样比例: {mapping_data['downsampling_ratio']:.2f}x")
+    print(f"\n✓ Mapping file written: {output_file}")
+    print(f"  Original frames: {original_frame_count}")
+    print(f"  Feature count: {feature_count}")
+    print(f"  Downsampling ratio: {mapping_data['downsampling_ratio']:.2f}x")
 
     # Print sample mappings
-    print("\n映射示例:")
+    print("\nSample mappings:")
     for i in range(min(3, len(frame_mapping))):
         mapping = frame_mapping[i]
-        print(f"  特征 {mapping['feature_index']}: 帧 {mapping['frame_start']}-{mapping['frame_end']} "
-              f"({mapping['frame_count']} 帧)")
+        print(f"  Feature {mapping['feature_index']}: frames {mapping['frame_start']}-{mapping['frame_end']} "
+              f"({mapping['frame_count']} frames)")
     if len(frame_mapping) > 3:
         print("  ...")
         mapping = frame_mapping[-1]
-        print(f"  特征 {mapping['feature_index']}: 帧 {mapping['frame_start']}-{mapping['frame_end']} "
-              f"({mapping['frame_count']} 帧)")
+        print(f"  Feature {mapping['feature_index']}: frames {mapping['frame_start']}-{mapping['frame_end']} "
+              f"({mapping['frame_count']} frames)")
 
     return True
 
 if __name__ == "__main__":
     if len(sys.argv) != 3:
-        print("用法: python generate_feature_mapping.py <sample_dir> <video_path>")
-        print("\n示例:")
+        print("Usage: python generate_feature_mapping.py <sample_dir> <video_path>")
+        print("\nExample:")
         print("  python generate_feature_mapping.py detailed_prediction_20251226_155113/sample_000 \\")
         print("      eval/tiny_test_data/videos/632051.mp4")
         sys.exit(1)
@@ -115,11 +115,11 @@ if __name__ == "__main__":
     video_path = sys.argv[2]
 
     if not os.path.exists(sample_dir):
-        print(f"错误: 样本目录不存在: {sample_dir}")
+        print(f"Error: sample directory not found: {sample_dir}")
         sys.exit(1)
 
     if not os.path.exists(video_path):
-        print(f"错误: 视频文件不存在: {video_path}")
+        print(f"Error: video file not found: {video_path}")
         sys.exit(1)
 
     success = generate_feature_mapping(sample_dir, video_path)

SignX/eval/generate_interactive_alignment.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
 """
-生成交互式HTML可视化 - 可调整置信度阈值的gloss-to-feature对齐
-参考frame_alignment.png的布局风格
-使用方法：
+Generate an interactive HTML visualization for the gloss-to-feature alignment.
+This mirrors the frame_alignment.png layout but lets viewers adjust confidence thresholds.
+
+Usage:
     python generate_interactive_alignment.py <sample_dir>
 
-例如：
+Example:
     python generate_interactive_alignment.py detailed_prediction_20251226_022246/sample_000
 """
 
@@ -15,11 +16,11 @@ import numpy as np
 from pathlib import Path
 
 def generate_interactive_html(sample_dir, output_path):
-    """生成交互式HTML可视化 - 参考frame_alignment.png的风格"""
+    """Create the interactive alignment HTML for the given sample directory."""
 
     sample_dir = Path(sample_dir)
 
-    # 1. 读取注意力权重
+    # 1. Load attention weights
     attention_weights = np.load(sample_dir / "attention_weights.npy")
     # Handle both 2D (inference mode) and 3D (beam search) shapes
     if attention_weights.ndim == 2:
@@ -29,7 +30,7 @@ def generate_interactive_html(sample_dir, output_path):
     else:
         raise ValueError(f"Unexpected attention weights shape: {attention_weights.shape}")
 
-    # 2. 读取翻译结果
+    # 2. Load translation output
     with open(sample_dir / "translation.txt", 'r') as f:
         lines = f.readlines()
         gloss_sequence = None
@@ -39,19 +40,18 @@ def generate_interactive_html(sample_dir, output_path):
                 break
 
     if not gloss_sequence:
-        print("无法找到翻译结果")
+        print("Error: translation text not found")
         return
 
     glosses = gloss_sequence.split()
     num_glosses = len(glosses)
     num_features = attn_weights.shape[1]
 
-    print(f"Gloss序列: {glosses}")
-    print(f"特征数量: {num_features}")
+    print(f"Gloss sequence: {glosses}")
+    print(f"Feature count: {num_features}")
     print(f"Attention shape: {attn_weights.shape}")
 
-    # 3. 将attention权重转换为JSON可序列化格式
-    # 只取前num_glosses行（实际的gloss，不包括padding）
+    # 3. Convert attention weights to JSON (only keep the num_glosses rows – ignore padding)
     attn_data = []
     for word_idx in range(min(num_glosses, attn_weights.shape[0])):
         weights = attn_weights[word_idx, :].tolist()
@@ -61,9 +61,9 @@ def generate_interactive_html(sample_dir, output_path):
             'weights': weights
         })
 
-    # 4. 生成HTML内容
+    # 4. Build the HTML payload
     html_content = f"""<!DOCTYPE html>
-<html lang="zh-CN">
+<html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
@@ -213,7 +213,7 @@ def generate_interactive_html(sample_dir, output_path):
                 <span class="value-display" id="peak-threshold-value">90%</span>
                 <br>
                 <small style="margin-left: 255px; color: #666;">
-                    帧的注意力权重 ≥ (峰值权重 × 阈值%) 时被认为是"显著帧"
+                    A frame is considered “significant” if its attention ≥ (peak × threshold%)
                 </small>
             </div>
 
@@ -237,7 +237,7 @@ def generate_interactive_html(sample_dir, output_path):
         <div>
             <h3>Word-to-Frame Alignment</h3>
             <p style="color: #666; font-size: 13px;">
-                每个词显示为彩色矩形，宽度表示该词对应的特征帧范围。★ = 峰值帧。矩形内部显示注意力权重波形。
+                Each word appears as a colored block. Width = frame span, ★ = peak frame, waveform = attention trace.
             </p>
             <canvas id="alignment-canvas" width="1600" height="600"></canvas>
 
@@ -643,28 +643,28 @@ def generate_interactive_html(sample_dir, output_path):
 </html>
 """
 
-    # 5. 保存HTML文件
+    # 5. Write the HTML file
     with open(output_path, 'w', encoding='utf-8') as f:
         f.write(html_content)
 
-    print(f"✓ 已生成交互式HTML: {output_path}")
-    print(f"  在浏览器中打开此文件，使用滑块调整阈值")
+    print(f"✓ Interactive HTML generated: {output_path}")
+    print("  Open this file in a browser and use the sliders to adjust thresholds.")
 
 if __name__ == "__main__":
     if len(sys.argv) != 2:
-        print("使用方法: python generate_interactive_alignment.py <sample_dir>")
-        print("例如: python generate_interactive_alignment.py detailed_prediction_20251226_022246/sample_000")
+        print("Usage: python generate_interactive_alignment.py <sample_dir>")
+        print("Example: python generate_interactive_alignment.py detailed_prediction_20251226_022246/sample_000")
         sys.exit(1)
 
     sample_dir = Path(sys.argv[1])
 
     if not sample_dir.exists():
-        print(f"错误: 目录不存在: {sample_dir}")
+        print(f"Error: directory not found: {sample_dir}")
         sys.exit(1)
 
     output_path = sample_dir / "interactive_alignment.html"
     generate_interactive_html(sample_dir, output_path)
 
-    print(f"\n使用方法:")
-    print(f"  在浏览器中打开: {output_path.absolute()}")
-    print(f"  调整滑块实时查看不同阈值下的对齐效果")
+    print("\nUsage:")
+    print(f"  Open in a browser: {output_path.absolute()}")
+    print("  Move the sliders to preview different threshold settings in real time.")

SignX/eval/regenerate_visualizations.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 """
-重新生成所有可视化（使用最新的attention_analysis.py代码）
+Regenerate visualization assets (using the latest attention_analysis.py).
 
-使用方法:
+Usage:
     python regenerate_visualizations.py <detailed_prediction_dir> <video_path>
 
-例如:
+Example:
     python regenerate_visualizations.py detailed_prediction_20251226_161117 ./eval/tiny_test_data/videos/632051.mp4
 """
 
@@ -22,11 +22,11 @@ import numpy as np
 
 
 def regenerate_sample_visualizations(sample_dir, video_path):
-    """为单个样本重新生成所有可视化"""
+    """Regenerate every visualization asset for a single sample directory."""
     sample_dir = Path(sample_dir)
 
     if not sample_dir.exists():
-        print(f"错误: 样本目录不存在: {sample_dir}")
+        print(f"Error: sample directory not found: {sample_dir}")
         return False
 
     # 加载数据
@@ -34,23 +34,23 @@ def regenerate_sample_visualizations(sample_dir, video_path):
     trans_file = sample_dir / "translation.txt"
 
     if not attn_file.exists() or not trans_file.exists():
-        print(f"  跳过 {sample_dir.name}: 缺少必要文件")
+        print(f"  Skipping {sample_dir.name}: required files are missing")
         return False
 
     # 读取数据
     attention_weights = np.load(attn_file)
     with open(trans_file, 'r') as f:
         lines = f.readlines()
-        # 找到 "Clean:" 后的翻译
+        # Prefer the translation following the "Clean:" line
         translation = None
         for line in lines:
             if line.startswith('Clean:'):
                 translation = line.replace('Clean:', '').strip()
                 break
         if translation is None:
-            translation = lines[0].strip()  # 后备方案
+            translation = lines[0].strip()  # fallback
 
-    # 获取特征数量（video_frames）
+    # Determine feature count (video_frames)
     if len(attention_weights.shape) == 4:
         video_frames = attention_weights.shape[3]
     elif len(attention_weights.shape) == 3:
@@ -58,7 +58,7 @@ def regenerate_sample_visualizations(sample_dir, video_path):
     else:
         video_frames = attention_weights.shape[1]
 
-    print(f"  样本: {sample_dir.name}")
+    print(f"  Sample: {sample_dir.name}")
     print(f"    Attention shape: {attention_weights.shape}")
     print(f"    Translation: {translation}")
     print(f"    Features: {video_frames}")
@@ -71,25 +71,25 @@ def regenerate_sample_visualizations(sample_dir, video_path):
         video_path=str(video_path) if video_path else None
     )
 
-    # 重新生成frame_alignment.png (带原始帧层)
-    print(f"    重新生成 frame_alignment.png...")
+    # Regenerate frame_alignment.png (with original-frame layer)
+    print("    Regenerating frame_alignment.png...")
     analyzer.plot_frame_alignment(sample_dir / "frame_alignment.png")
 
-    # 重新生成gloss_to_frames.png (带特征索引层)
+    # Regenerate gloss_to_frames.png (feature index overlay)
     if video_path and Path(video_path).exists():
-        print(f"    重新生成 gloss_to_frames.png...")
+        print("    Regenerating gloss_to_frames.png...")
         try:
             analyzer.generate_gloss_to_frames_visualization(sample_dir / "gloss_to_frames.png")
         except Exception as e:
-            print(f"      警告: gloss_to_frames生成失败: {e}")
+            print(f"      Warning: failed to create gloss_to_frames.png: {e}")
 
     return True
 
 
 def main():
     if len(sys.argv) < 2:
-        print("用法: python regenerate_visualizations.py <detailed_prediction_dir> [<video_path>]")
-        print("\n示例:")
+        print("Usage: python regenerate_visualizations.py <detailed_prediction_dir> [<video_path>]")
+        print("\nExample:")
         print("  python regenerate_visualizations.py detailed_prediction_20251226_161117 ./eval/tiny_test_data/videos/632051.mp4")
         sys.exit(1)
 
@@ -97,16 +97,16 @@ def main():
     video_path = Path(sys.argv[2]) if len(sys.argv) > 2 else None
 
     if not pred_dir.exists():
-        print(f"错误: 预测目录不存在: {pred_dir}")
+        print(f"Error: detailed prediction directory not found: {pred_dir}")
         sys.exit(1)
 
     if video_path and not video_path.exists():
-        print(f"警告: 视频文件不存在: {video_path}")
+        print(f"Warning: video file not found, disabling video overlays: {video_path}")
         video_path = None
 
-    print(f"重新生成可视化:")
-    print(f"  预测目录: {pred_dir}")
-    print(f"  视频路径: {video_path if video_path else 'N/A'}")
+    print("Regenerating visualizations:")
+    print(f"  Detailed prediction dir: {pred_dir}")
+    print(f"  Video path: {video_path if video_path else 'N/A'}")
     print()
 
     # 处理所有样本
@@ -115,7 +115,7 @@ def main():
         if regenerate_sample_visualizations(sample_dir, video_path):
             success_count += 1
 
-    print(f"\n✓ 完成！成功处理 {success_count} 个样本")
+    print(f"\n✓ Done! Successfully processed {success_count} sample(s)")
 
 
 if __name__ == "__main__":

SignX/inference.sh

@@ -1,33 +1,33 @@
 #!/bin/bash
-# 手语识别推理脚本 - 从视频输出 gloss 序列
+# Sign language recognition inference script – video to gloss sequence
 #
-# 使用完整的两阶段 pipeline:
-#   视频 → [SMKD冻结] → 特征 → [SLTUNET] → gloss序列
+# Full two-stage pipeline:
+#   Video → [SMKD frozen] → Features → [SLTUNET] → Gloss sequence
 #
-# 使用方法:
+# Usage:
 #   ./inference.sh <video_path> [output_path]
 #   ./inference.sh --benchmark-efficiency [options...]
 #
-# 示例:
+# Examples:
 #   ./inference.sh test.mp4
 #   ./inference.sh test.mp4 output.txt
 #
-# 基准测试模式 (用于 ACL 论文):
+# Benchmark mode (used for ACL paper experiments):
 #   ./inference.sh --benchmark-efficiency --video test.mp4 --num-samples 100
 #   ./inference.sh --benchmark-efficiency --config full_pipeline
 #   ./inference.sh --benchmark-efficiency --generate-table-only
 
 set -e
 
-# 获取脚本目录（提前定义）
+# Resolve script directory
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 INFERENCE_ROOT="${SCRIPT_DIR}/inference_output"
 mkdir -p "$INFERENCE_ROOT"
 
-# 检查是否是基准测试模式（检查所有参数）
+# Detect benchmark mode (scan all args)
 for arg in "$@"; do
     if [ "$arg" == "--benchmark-efficiency" ]; then
-        # 基准测试模式，提示使用simple_benchmark.sh
+# For benchmarking, redirect to simple_benchmark.sh
         echo ""
         echo "====================================================================="
         echo "  Efficiency Benchmarking"
@@ -40,14 +40,14 @@ for arg in "$@"; do
     fi
 done
 
-# 颜色定义
+# ANSI colors
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
-# 默认参数 (使用第7次训练的pose协助模型)
+# Default configuration (7th training run with pose assistance)
 SMKD_CONFIG="${SCRIPT_DIR}/smkd/asllrp_baseline.yaml"
 SMKD_MODEL="/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/SignX/smkd/work_dir第七次训练全pose协助2000/asllrp_smkd/best_model.pt"
 GLOSS_DICT="/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/SignX/smkd/asllrp第七次训练全pose协助2000/gloss_dict.npy"
@@ -57,24 +57,24 @@ BPE_CODES="${SCRIPT_DIR}/preprocessed-asllrp/asllrp.bpe"
 
 echo ""
 echo "======================================================================"
-echo "  Sign Language Recognition - 完整推理 Pipeline"
+echo "  Sign Language Recognition - Full Inference Pipeline"
 echo "======================================================================"
 echo ""
-echo "  架构: 视频 → [SMKD冻结] → 特征 → [SLTUNET] → Gloss"
-echo "  方法: 使用 inference 模式 (一键完成两阶段)"
+echo "  Pipeline: Video → [SMKD frozen] → Features → [SLTUNET] → Gloss"
+echo "  Mode: inference (one-click two-stage execution)"
 echo ""
 echo "======================================================================"
 echo ""
 
-# 检查参数
+# Validate arguments
 if [ "$#" -lt 1 ]; then
-    echo -e "${RED}错误: 缺少视频路径${NC}"
+    echo -e "${RED}Error: missing video path${NC}"
     echo ""
-    echo "使用方法:"
+    echo "Usage:"
     echo "  $0 <video_path> [output_path]"
     echo "  $0 --benchmark-efficiency [options...]"
     echo ""
-    echo "示例:"
+    echo "Examples:"
     echo "  $0 test.mp4"
     echo "  $0 test.mp4 output.txt"
     echo "  $0 --benchmark-efficiency --video test.mp4"
@@ -89,72 +89,67 @@ else
     OUTPUT_PATH="${2}"
 fi
 
-# 检查视频文件是否存在
+# Verify video file exists
 if [ ! -f "$VIDEO_PATH" ]; then
-    echo -e "${RED}错误: 视频文件不存在: $VIDEO_PATH${NC}"
+    echo -e "${RED}Error: video file not found: $VIDEO_PATH${NC}"
     exit 1
 fi
 
-# 转换为绝对路径
+# Convert to absolute path
 VIDEO_PATH=$(realpath "$VIDEO_PATH")
 
-# 如果OUTPUT_PATH是绝对路径或已存在的文件，直接使用
-# 否则，在脚本目录下创建输出文件
+# If OUTPUT_PATH is already absolute, keep it; otherwise store under inference_output
 if [[ "$OUTPUT_PATH" = /* ]]; then
-    # 已经是绝对路径
     OUTPUT_PATH="$OUTPUT_PATH"
 elif [ -f "$OUTPUT_PATH" ]; then
-    # 文件已存在，转换为绝对路径
     OUTPUT_PATH=$(realpath "$OUTPUT_PATH")
 else
-    # 相对路径或默认值，在 inference_output 目录下输出
     OUTPUT_PATH="${INFERENCE_ROOT}/${OUTPUT_PATH}"
 fi
 OUTPUT_CLEAN_PATH="${OUTPUT_PATH}.clean"
 
-echo -e "${BLUE}[配置信息]${NC}"
-echo "  输入视频: $VIDEO_PATH"
-echo "  输出文件: $OUTPUT_PATH"
-echo "  SMKD模型: $SMKD_MODEL"
+echo -e "${BLUE}[Configuration]${NC}"
+echo "  Input video: $VIDEO_PATH"
+echo "  Output file: $OUTPUT_PATH"
+echo "  SMKD model: $SMKD_MODEL"
 echo "  SLTUNET: $SLTUNET_CHECKPOINT"
 echo ""
 
-# 获取conda base
+# Locate conda base
 CONDA_BASE=$(conda info --base 2>/dev/null || echo "")
 
 if [ -z "$CONDA_BASE" ]; then
-    echo -e "${RED}错误: 未找到conda${NC}"
-    echo "请确保已安装conda"
+    echo -e "${RED}Error: could not find conda${NC}"
+    echo "Please make sure conda is installed."
     exit 1
 fi
 
-# 激活conda
+# Enable conda activation
 source "${CONDA_BASE}/etc/profile.d/conda.sh"
 
-# 临时目录
+# Temporary directory
 TEMP_DIR=$(mktemp -d)
-# 不要在EXIT时删除，因为我们需要保存详细的attention分析结果
-# 我们将在脚本结束前手动清理不需要的部分
+# Do not auto-delete on exit—we need the detailed attention results later
 
-echo -e "${BLUE}[1/2] 使用 SMKD 提取视频特征...${NC}"
-echo "  环境: signx-slt (PyTorch)"
+echo -e "${BLUE}[1/2] Extracting video features with SMKD...${NC}"
+echo "  Environment: signx-slt (PyTorch)"
 echo ""
 
-# 切换到 PyTorch 环境
+# Activate PyTorch environment
 conda activate signx-slt
 
 if [ $? -ne 0 ]; then
-    echo -e "${RED}错误: 无法激活 signx-slt 环境${NC}"
+    echo -e "${RED}Error: failed to activate signx-slt environment${NC}"
     exit 1
 fi
 
-# 创建临时视频列表文件（InferFeeder需要）
+# Create temporary video list file (required by InferFeeder)
 VIDEO_LIST_FILE="$TEMP_DIR/video_list.txt"
 echo "$VIDEO_PATH" > "$VIDEO_LIST_FILE"
 
-echo "  ✓ 临时视频列表已创建: $VIDEO_LIST_FILE"
+echo "  ✓ Temporary video list created: $VIDEO_LIST_FILE"
 
-# 使用 SignEmbedding 提取特征
+# Run SignEmbedding to extract features
 cd "$SCRIPT_DIR"
 
 FEATURE_OUTPUT="$TEMP_DIR/features.h5"
@@ -168,7 +163,7 @@ from smkd.sign_embedder import SignEmbedding
 import h5py
 import numpy as np
 
-print('  加载 SMKD 模型...')
+print('  Loading SMKD model...')
 embedder = SignEmbedding(
     cfg='$SMKD_CONFIG',
     gloss_path='$GLOSS_DICT',
@@ -178,59 +173,59 @@ embedder = SignEmbedding(
     batch_size=1
 )
 
-print('  提取特征...')
+print('  Extracting features...')
 features = embedder.embed()
 
-print('  保存特征到 h5 文件...')
+print('  Saving features to h5 file...')
 with h5py.File('$FEATURE_OUTPUT', 'w') as hf:
     for key, feature in features.items():
         hf.create_dataset(key, data=feature)
 
-print('  ✓ 特征提取完成: $FEATURE_OUTPUT')
-print('  特征数量:', len(features))
+print('  ✓ Feature extraction complete:', '$FEATURE_OUTPUT')
+print('  Number of feature sequences:', len(features))
 
-# 创建源文件和目标文件（SLTUNET Dataset需要）
-# 格式: <image_index> <text>
-# 推理时使用占位符text（因为真实gloss是我们要预测的）
+# Create source/target placeholder files for SLTUNET dataset
+# Format: <image_index> <text>
+# Use placeholder tokens because the gloss is what we want to predict
 with open('$TEMP_DIR/src.txt', 'w') as f:
     for key in sorted(features.keys(), key=lambda x: int(x)):
-        f.write(key + ' <unk>\\n')  # 使用 <unk> 作为占位符
+        f.write(key + ' <unk>\\n')  # placeholder text
 
 with open('$TEMP_DIR/tgt.txt', 'w') as f:
     for key in sorted(features.keys(), key=lambda x: int(x)):
-        f.write('<unk>\\n')  # 使用 <unk> 作为占位符
+        f.write('<unk>\\n')
 
-print('  ✓ 源文件和目标文件已创建')
+print('  ✓ Source/target placeholder files ready')
 "
 
 if [ $? -ne 0 ]; then
-    echo -e "${RED}错误: 特征提取失败${NC}"
+    echo -e "${RED}Error: SMKD feature extraction failed${NC}"
     exit 1
 fi
 
 echo ""
-echo -e "${GREEN}✓ Stage 1 完成: 视频特征已提取${NC}"
+echo -e "${GREEN}✓ Stage 1 complete: features extracted${NC}"
 echo ""
 
-# 切换到 TensorFlow 环境
-echo -e "${BLUE}[2/2] 使用 SLTUNET 生成 Gloss 序列...${NC}"
-echo "  环境: slt_tf1 (TensorFlow)"
+# Switch to TensorFlow environment
+echo -e "${BLUE}[2/2] Generating gloss sequence with SLTUNET...${NC}"
+echo "  Environment: slt_tf1 (TensorFlow)"
 echo ""
 
 conda activate slt_tf1
 
 if [ $? -ne 0 ]; then
-    echo -e "${RED}错误: 无法激活 slt_tf1 环境${NC}"
+    echo -e "${RED}Error: failed to activate slt_tf1 environment${NC}"
     exit 1
 fi
 
 export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
 
-# 获取输出目录（用于保存详细分析）
+# Determine output directory (for attention artifacts)
 OUTPUT_DIR=$(dirname "$OUTPUT_PATH")
 PREDICTION_TXT="$TEMP_DIR/prediction.txt"
 
-# 创建临时配置文件用于推理
+# Build temporary inference config
 cat > "$TEMP_DIR/infer_config.py" <<EOF
 {
     'sign_cfg': '$SMKD_CONFIG',
@@ -253,13 +248,13 @@ cat > "$TEMP_DIR/infer_config.py" <<EOF
 }
 EOF
 
-echo "  加载 SLTUNET 模型..."
-echo "  开始翻译..."
+echo "  Loading SLTUNET model..."
+echo "  Running translation..."
 echo ""
 
 cd "$SCRIPT_DIR"
 
-# 运行推理，保存完整输出以便后续检查详细分析
+# Run inference and capture logs for later inspection
 python run.py \
     --mode test \
     --config "$TEMP_DIR/infer_config.py" \
@@ -267,75 +262,73 @@ python run.py \
 
 if [ -f "$TEMP_DIR/prediction.txt" ]; then
     echo ""
-    echo -e "${GREEN}✓ 推理完成: Gloss 序列已生成${NC}"
+    echo -e "${GREEN}✓ Inference complete: gloss sequence generated${NC}"
     echo ""
 
-    # 复制结果
+    # Copy raw result
     cp "$TEMP_DIR/prediction.txt" "$OUTPUT_PATH"
 
-    # 移除BPE标记 (@@) 并保存清理后的版本
+    # Remove BPE markers (@@) for a clean text version
     sed 's/@@ //g' "$OUTPUT_PATH" > "$OUTPUT_CLEAN_PATH"
 
-    # 检查并移动详细的attention分析结果
+    # Move detailed attention analysis output if present
     DETAILED_DIRS=$(find "$TEMP_DIR" -maxdepth 1 -type d -name "detailed_*" 2>/dev/null)
     ATTENTION_ANALYSIS_DIR=""
 
     if [ ! -z "$DETAILED_DIRS" ]; then
-        echo -e "${BLUE}发现详细的attention分析结果，正在保存...${NC}"
+        echo -e "${BLUE}Detected detailed attention analysis, saving...${NC}"
         for detailed_dir in $DETAILED_DIRS; do
             dir_name=$(basename "$detailed_dir")
             dest_path="$INFERENCE_ROOT/$dir_name"
             mv "$detailed_dir" "$dest_path"
             ATTENTION_ANALYSIS_DIR="$dest_path"
 
-            # 统计样本数量
+            # Count sample directories
             mapfile -t SAMPLE_DIRS < <(find "$dest_path" -mindepth 1 -maxdepth 1 -type d -print | sort)
             sample_count=${#SAMPLE_DIRS[@]}
-            echo "  ✓ 已保存 $sample_count 个样本的详细分析到: $dest_path"
+            echo "  ✓ Saved $sample_count sample analyses to: $dest_path"
 
-            # 步骤1：生成特征-帧映射 (Feature-to-Frame Mapping)
+            # Step 1: feature-to-frame mapping
             echo ""
-            echo -e "${BLUE}生成特征-帧映射...${NC}"
+            echo -e "${BLUE}Generating feature-to-frame mapping...${NC}"
             if [ -f "$SCRIPT_DIR/eval/generate_feature_mapping.py" ]; then
-                # 切换到 signx-slt 环境 (有 cv2)
+                # Switch to signx-slt environment (CV2 available)
                 conda activate signx-slt
                 if [ ${#SAMPLE_DIRS[@]} -eq 0 ]; then
-                    echo "  ⚠ 未找到样本目录，跳过特征映射生成"
+                    echo "  ⚠ No sample directories found, skipping mapping"
                 else
                     for sample_dir in "${SAMPLE_DIRS[@]}"; do
                         if [ -d "$sample_dir" ]; then
-                            python "$SCRIPT_DIR/eval/generate_feature_mapping.py" "$sample_dir" "$VIDEO_PATH" 2>&1 | grep -E "(特征数量|原始帧数|已生成映射|错误)"
+                            python "$SCRIPT_DIR/eval/generate_feature_mapping.py" "$sample_dir" "$VIDEO_PATH" 2>&1 | grep -E "(feature|frame|mapping|error)"
                         fi
                     done
                 fi
             else
-                echo "  ⓘ generate_feature_mapping.py 未找到，跳过特征映射生成"
+                echo "  ⓘ generate_feature_mapping.py not found, skipping mapping"
             fi
 
-            # 步骤2：重新生成所有可视化（使用最新代码）
+            # Step 2: regenerate visualizations
             echo ""
-            echo -e "${BLUE}重新生成可视化（使用最新代码）...${NC}"
+            echo -e "${BLUE}Regenerating visualizations (latest code)...${NC}"
             if [ -f "$SCRIPT_DIR/eval/regenerate_visualizations.py" ]; then
-                # 已在 signx-slt 环境
                 if [ ${#SAMPLE_DIRS[@]} -eq 0 ]; then
-                    echo "  ⚠ 未找到样本目录，跳过可视化生成"
+                    echo "  ⚠ No sample directories found, skipping visualization"
                 else
                     python "$SCRIPT_DIR/eval/regenerate_visualizations.py" "$dest_path" "$VIDEO_PATH"
                 fi
             else
-                echo "  ⓘ regenerate_visualizations.py 未找到，使用旧版本"
+                echo "  ⓘ regenerate_visualizations.py not found, falling back to legacy scripts"
                 if [ -f "$SCRIPT_DIR/eval/generate_gloss_frames.py" ]; then
                     python "$SCRIPT_DIR/eval/generate_gloss_frames.py" "$dest_path" "$VIDEO_PATH"
                 fi
             fi
 
-            # 步骤3：生成交互式HTML可视化
+            # Step 3: interactive HTML visualization
             echo ""
-            echo -e "${BLUE}生成交互式HTML可视化...${NC}"
+            echo -e "${BLUE}Creating interactive HTML visualization...${NC}"
             if [ -f "$SCRIPT_DIR/eval/generate_interactive_alignment.py" ]; then
-                # 处理所有样本
                 if [ ${#SAMPLE_DIRS[@]} -eq 0 ]; then
-                    echo "  ⚠ 未找到样本目录，跳过交互式HTML生成"
+                    echo "  ⚠ No sample directories found, skipping HTML generation"
                 else
                     for sample_dir in "${SAMPLE_DIRS[@]}"; do
                         if [ -d "$sample_dir" ]; then
@@ -344,40 +337,39 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
                     done
                 fi
             else
-                echo "  ⓘ generate_interactive_alignment.py 未找到，跳过交互式HTML生成"
+                echo "  ⓘ generate_interactive_alignment.py not found, skipping HTML generation"
             fi
 
-            # 步骤4：提取关键帧���叠加注意力可视化
+            # Step 4: extract attention keyframes
             echo ""
-            echo -e "${BLUE}提取关键帧并叠加注意力可视化...${NC}"
+            echo -e "${BLUE}Extracting attention keyframes...${NC}"
             if [ -f "$SCRIPT_DIR/eval/extract_attention_keyframes.py" ]; then
-                # 处理所有样本
                 if [ ${#SAMPLE_DIRS[@]} -eq 0 ]; then
-                    echo "  ⚠ 未找到样本目录，跳过关键帧提取"
+                    echo "  ⚠ No sample directories found, skipping keyframes"
                 else
                     for sample_dir in "${SAMPLE_DIRS[@]}"; do
                         if [ -d "$sample_dir" ]; then
-                            echo "  处理样本: $(basename "$sample_dir")"
+                            echo "  Processing sample: $(basename "$sample_dir")"
                             python "$SCRIPT_DIR/eval/extract_attention_keyframes.py" "$sample_dir" "$VIDEO_PATH"
                         fi
                     done
                 fi
             else
-                echo "  ⓘ extract_attention_keyframes.py 未找到，跳过关键帧提取"
+                echo "  ⓘ extract_attention_keyframes.py not found, skipping keyframes"
             fi
 
-            # 切换回 slt_tf1 环境
+            # Switch back to slt_tf1 environment
             conda activate slt_tf1
         done
     fi
 
-    # 将输出文件移动到样本目录中，保持所有结果集中存储
+    # Move final output into the primary sample directory for convenience
     if [ ! -z "$ATTENTION_ANALYSIS_DIR" ] && [ -d "$ATTENTION_ANALYSIS_DIR" ]; then
         PRIMARY_SAMPLE_DIR=$(find "$ATTENTION_ANALYSIS_DIR" -mindepth 1 -maxdepth 1 -type d | sort | head -n 1)
         if [ ! -z "$PRIMARY_SAMPLE_DIR" ] && [ -d "$PRIMARY_SAMPLE_DIR" ]; then
             TRANSLATION_FILE="${PRIMARY_SAMPLE_DIR}/translation.txt"
 
-            # 将推理输出移动到样本目录（便于调试）
+            # Keep a copy for debugging inside the sample directory
             MOVED_BPE_FILE=""
             MOVED_CLEAN_FILE=""
             if [ -f "$OUTPUT_PATH" ]; then
@@ -393,7 +385,7 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
                 MOVED_CLEAN_FILE="$NEW_CLEAN_PATH"
             fi
 
-            # 若不存在 translation.txt，则根据当前推理结果生成一个
+            # Generate translation.txt if it was not created
             if [ ! -f "$TRANSLATION_FILE" ]; then
                 TRANS_BPE=$(head -n 1 "$TEMP_DIR/prediction.txt")
                 TRANS_CLEAN=$(sed 's/@@ //g' "$TEMP_DIR/prediction.txt" | head -n 1)
@@ -404,7 +396,7 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
                 } > "$TRANSLATION_FILE"
             fi
 
-            # 移除不再需要的原始输出文件
+            # Remove redundant files now that translation.txt exists
             if [ -n "$MOVED_BPE_FILE" ] && [ -f "$MOVED_BPE_FILE" ] && [ "$MOVED_BPE_FILE" != "$TRANSLATION_FILE" ]; then
                 rm -f "$MOVED_BPE_FILE"
             fi
@@ -419,44 +411,43 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
 
     echo ""
     echo "======================================================================"
-    echo "  推理成功！"
+    echo "  Inference succeeded!"
     echo "======================================================================"
     echo ""
-    echo "输出文件:"
-    echo "  原始输出 (带BPE): $OUTPUT_PATH"
-    echo "  清理后输出:       $OUTPUT_CLEAN_PATH"
+    echo "Output files:"
+    echo "  Raw (with BPE): $OUTPUT_PATH"
+    echo "  Cleaned result: $OUTPUT_CLEAN_PATH"
 
     if [ ! -z "$ATTENTION_ANALYSIS_DIR" ]; then
-        echo "  详细分析目录:     $ATTENTION_ANALYSIS_DIR"
+        echo "  Detailed analysis dir: $ATTENTION_ANALYSIS_DIR"
         echo ""
-        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)"
-        echo "  - 关键帧可视化 (attention_keyframes/ 文件夹)"
-        echo "    * 包含每个gloss的peak feature帧"
-        echo "    * 注意力热力图叠加（橙红=高注意力，蓝色=低注意力）"
+        echo "Attention assets include:"
+        echo "  - attention_heatmap.png"
+        echo "  - word_frame_alignment.png"
+        echo "  - gloss_to_frames.png"
+        echo "  - analysis_report.txt"
+        echo "  - attention_weights.npy"
+        echo "  - attention_keyframes/ (per-gloss keyframe previews)"
+        echo "    * peak feature frames per gloss"
+        echo "    * heatmaps overlayed on the video frames"
     fi
 
     echo ""
-    echo "识别结果 (移除BPE后):"
+    echo "Recognition result (BPE removed):"
     echo "----------------------------------------------------------------------"
     head -5 "$OUTPUT_CLEAN_PATH" | sed 's/^/  /'
     echo "----------------------------------------------------------------------"
     echo ""
-    echo -e "${GREEN}✓ 完整 Pipeline 执行成功 (SMKD → SLTUNET)${NC}"
+    echo -e "${GREEN}✓ Full pipeline completed (SMKD → SLTUNET)${NC}"
     echo ""
 
-    # 清理临时目录
-    echo -e "${BLUE}清理临时文件...${NC}"
+    # Clean temp directory
+    echo -e "${BLUE}Cleaning temporary files...${NC}"
     rm -rf "$TEMP_DIR"
-    echo "  ✓ 临时文件已清理"
+    echo "  ✓ Temporary files removed"
     echo ""
 else
-    echo -e "${RED}错误: 推理失败，未生成输出文件${NC}"
-    # 清理临时目录
+    echo -e "${RED}Error: inference failed, no output generated${NC}"
     rm -rf "$TEMP_DIR"
     exit 1
 fi

SignX/inference_output/detailed_prediction_20260102_180915/23881350/attention_keyframes/keyframes_index.txt

@@ -1,27 +0,0 @@
-关键帧索引
-============================================================
-
-样本目录: /research/cbim/vast/sf895/code/ControlWorld/plugins/SignX/inference_output/detailed_prediction_20260102_180915/23881350
-视频路径: /common/users/sf895/output/huggingface_asllrp_repo/SignX/eval/tiny_test_data/good_videos/23881350.mp4
-总关键帧数: 18
-
-关键帧列表:
-------------------------------------------------------------
-Gloss   0: keyframe_000_feat2_frame9_att0.338.jpg
-Gloss   1: keyframe_001_feat0_frame1_att0.358.jpg
-Gloss   2: keyframe_002_feat0_frame1_att0.353.jpg
-Gloss   3: keyframe_003_feat0_frame1_att0.403.jpg
-Gloss   4: keyframe_004_feat7_frame28_att0.240.jpg
-Gloss   5: keyframe_005_feat0_frame1_att0.195.jpg
-Gloss   6: keyframe_006_feat0_frame1_att0.346.jpg
-Gloss   7: keyframe_007_feat11_frame43_att0.358.jpg
-Gloss   8: keyframe_008_feat13_frame51_att0.303.jpg
-Gloss   9: keyframe_009_feat17_frame66_att0.248.jpg
-Gloss  10: keyframe_010_feat13_frame51_att0.297.jpg
-Gloss  11: keyframe_011_feat21_frame82_att0.287.jpg
-Gloss  12: keyframe_012_feat0_frame1_att0.413.jpg
-Gloss  13: keyframe_013_feat21_frame82_att0.284.jpg
-Gloss  14: keyframe_014_feat20_frame78_att0.171.jpg
-Gloss  15: keyframe_015_feat0_frame1_att0.314.jpg
-Gloss  16: keyframe_016_feat21_frame82_att0.262.jpg
-Gloss  17: keyframe_017_feat21_frame82_att0.289.jpg

SignX/inference_output/detailed_prediction_20260102_180915/23881350/frame_alignment.json

@@ -1,59 +0,0 @@
-{
-  "translation": "HAPPEN RAIN IX-1p STAY HOME",
-  "words": [
-    "HAPPEN",
-    "RAIN",
-    "IX-1p",
-    "STAY",
-    "HOME"
-  ],
-  "total_video_frames": 22,
-  "frame_ranges": [
-    {
-      "word": "HAPPEN",
-      "start_frame": 2,
-      "end_frame": 2,
-      "peak_frame": 2,
-      "avg_attention": 0.33764514327049255,
-      "confidence": "medium"
-    },
-    {
-      "word": "RAIN",
-      "start_frame": 0,
-      "end_frame": 0,
-      "peak_frame": 0,
-      "avg_attention": 0.3576834201812744,
-      "confidence": "medium"
-    },
-    {
-      "word": "IX-1p",
-      "start_frame": 0,
-      "end_frame": 0,
-      "peak_frame": 0,
-      "avg_attention": 0.3532525599002838,
-      "confidence": "medium"
-    },
-    {
-      "word": "STAY",
-      "start_frame": 0,
-      "end_frame": 0,
-      "peak_frame": 0,
-      "avg_attention": 0.40251624584198,
-      "confidence": "medium"
-    },
-    {
-      "word": "HOME",
-      "start_frame": 7,
-      "end_frame": 7,
-      "peak_frame": 7,
-      "avg_attention": 0.24049112200737,
-      "confidence": "medium"
-    }
-  ],
-  "statistics": {
-    "avg_confidence": 0.33831769824028013,
-    "high_confidence_words": 0,
-    "medium_confidence_words": 5,
-    "low_confidence_words": 0
-  }
-}

SignX/inference_output/detailed_prediction_20260102_180915/23881350/translation.txt

@@ -1,3 +0,0 @@
-With BPE: HA@@ P@@ PE@@ N RA@@ I@@ N IX-1p STAY HOME
-Clean: HAPPEN RAIN IX-1p STAY HOME
-Ground Truth: HAPPEN RAIN IX-1p STAY HOME

SignX/inference_output/{detailed_prediction_20260102_180915/23881350 → detailed_prediction_20260102_182015/632051}/analysis_report.txt

@@ -2,39 +2,42 @@
   Sign Language Recognition - Attention分析报告
 ================================================================================
 
-生成时间: 2026-01-02 18:09:21
+生成时间: 2026-01-02 18:20:20
 
 翻译结果:
 --------------------------------------------------------------------------------
-HAPPEN RAIN IX-1p STAY HOME
+#IF FRIEND GROUP/TOGETHER DEPART PARTY IX-1p JOIN IX-1p
 
 视频信息:
 --------------------------------------------------------------------------------
-总帧数: 22
-词数量: 5
+总帧数: 28
+词数量: 8
 
 Attention权重信息:
 --------------------------------------------------------------------------------
-形状: (18, 22)
-  - 解码步数: 18
+形状: (26, 28)
+  - 解码步数: 26
 
 词-帧对应详情:
 ================================================================================
 No.   Word                 Frames          Peak     Attn     Conf      
 --------------------------------------------------------------------------------
-1     HAPPEN               2-2             2        0.338    medium    
-2     RAIN                 0-0             0        0.358    medium    
-3     IX-1p                0-0             0        0.353    medium    
-4     STAY                 0-0             0        0.403    medium    
-5     HOME                 7-7             7        0.240    medium    
+1     #IF                  2-2             2        0.472    medium    
+2     FRIEND               5-5             5        0.425    medium    
+3     GROUP/TOGETHER       8-8             8        0.375    medium    
+4     DEPART               27-27           27       0.348    medium    
+5     PARTY                27-27           27       0.383    medium    
+6     IX-1p                27-27           27       0.333    medium    
+7     JOIN                 11-11           11       0.520    high      
+8     IX-1p                14-14           14       0.368    medium    
 
 ================================================================================
 
 统计摘要:
 --------------------------------------------------------------------------------
-平均attention权重: 0.338
-高置信度词: 0 (0.0%)
-中置信度词: 5 (100.0%)
+平均attention权重: 0.403
+高置信度词: 1 (12.5%)
+中置信度词: 7 (87.5%)
 低置信度词: 0 (0.0%)
 
 ================================================================================

SignX/inference_output/detailed_prediction_20260102_182015/632051/attention_keyframes/keyframes_index.txt

@@ -0,0 +1,35 @@
+关键帧索引
+============================================================
+
+样本目录: /research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/SignX/inference_output/detailed_prediction_20260102_182015/632051
+视频路径: /common/users/sf895/output/huggingface_asllrp_repo/SignX/eval/tiny_test_data/videos/632051.mp4
+总关键帧数: 26
+
+关键帧列表:
+------------------------------------------------------------
+Gloss   0: keyframe_000_feat2_frame9_att0.472.jpg
+Gloss   1: keyframe_001_feat5_frame20_att0.425.jpg
+Gloss   2: keyframe_002_feat8_frame32_att0.375.jpg
+Gloss   3: keyframe_003_feat27_frame104_att0.348.jpg
+Gloss   4: keyframe_004_feat27_frame104_att0.383.jpg
+Gloss   5: keyframe_005_feat27_frame104_att0.333.jpg
+Gloss   6: keyframe_006_feat11_frame43_att0.520.jpg
+Gloss   7: keyframe_007_feat14_frame54_att0.368.jpg
+Gloss   8: keyframe_008_feat17_frame66_att0.252.jpg
+Gloss   9: keyframe_009_feat19_frame73_att0.884.jpg
+Gloss  10: keyframe_010_feat0_frame1_att0.118.jpg
+Gloss  11: keyframe_011_feat27_frame104_att0.164.jpg
+Gloss  12: keyframe_012_feat25_frame96_att0.265.jpg
+Gloss  13: keyframe_013_feat25_frame96_att0.282.jpg
+Gloss  14: keyframe_014_feat25_frame96_att0.278.jpg
+Gloss  15: keyframe_015_feat25_frame96_att0.277.jpg
+Gloss  16: keyframe_016_feat27_frame104_att0.219.jpg
+Gloss  17: keyframe_017_feat27_frame104_att0.190.jpg
+Gloss  18: keyframe_018_feat27_frame104_att0.225.jpg
+Gloss  19: keyframe_019_feat23_frame88_att0.150.jpg
+Gloss  20: keyframe_020_feat27_frame104_att0.151.jpg
+Gloss  21: keyframe_021_feat25_frame96_att0.360.jpg
+Gloss  22: keyframe_022_feat25_frame96_att0.153.jpg
+Gloss  23: keyframe_023_feat27_frame104_att0.144.jpg
+Gloss  24: keyframe_024_feat25_frame96_att0.144.jpg
+Gloss  25: keyframe_025_feat27_frame104_att0.186.jpg

SignX/inference_output/{detailed_prediction_20260102_180915/23881350 → detailed_prediction_20260102_182015/632051}/attention_weights.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:db90d41d7bb154b5162dd389749f9b12b177c09c69d3961bd8b58585bae1baaa
-size 1712
+oid sha256:d89932ced21ae95e0d7e034d8b3917146effa747bf7236c5eed30dd8cb9a258a
+size 3040

SignX/inference_output/{detailed_prediction_20260102_180915/23881350 → detailed_prediction_20260102_182015/632051}/debug_video_path.txt

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

SignX/inference_output/detailed_prediction_20260102_182015/632051/feature_frame_mapping.json

@@ -0,0 +1,176 @@
+{
+  "original_frame_count": 106,
+  "feature_count": 28,
+  "downsampling_ratio": 3.7857142857142856,
+  "fps": 24.0,
+  "mapping": [
+    {
+      "feature_index": 0,
+      "frame_start": 0,
+      "frame_end": 3,
+      "frame_count": 3
+    },
+    {
+      "feature_index": 1,
+      "frame_start": 3,
+      "frame_end": 7,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 2,
+      "frame_start": 7,
+      "frame_end": 11,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 3,
+      "frame_start": 11,
+      "frame_end": 15,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 4,
+      "frame_start": 15,
+      "frame_end": 18,
+      "frame_count": 3
+    },
+    {
+      "feature_index": 5,
+      "frame_start": 18,
+      "frame_end": 22,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 6,
+      "frame_start": 22,
+      "frame_end": 26,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 7,
+      "frame_start": 26,
+      "frame_end": 30,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 8,
+      "frame_start": 30,
+      "frame_end": 34,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 9,
+      "frame_start": 34,
+      "frame_end": 37,
+      "frame_count": 3
+    },
+    {
+      "feature_index": 10,
+      "frame_start": 37,
+      "frame_end": 41,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 11,
+      "frame_start": 41,
+      "frame_end": 45,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 12,
+      "frame_start": 45,
+      "frame_end": 49,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 13,
+      "frame_start": 49,
+      "frame_end": 53,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 14,
+      "frame_start": 53,
+      "frame_end": 56,
+      "frame_count": 3
+    },
+    {
+      "feature_index": 15,
+      "frame_start": 56,
+      "frame_end": 60,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 16,
+      "frame_start": 60,
+      "frame_end": 64,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 17,
+      "frame_start": 64,
+      "frame_end": 68,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 18,
+      "frame_start": 68,
+      "frame_end": 71,
+      "frame_count": 3
+    },
+    {
+      "feature_index": 19,
+      "frame_start": 71,
+      "frame_end": 75,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 20,
+      "frame_start": 75,
+      "frame_end": 79,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 21,
+      "frame_start": 79,
+      "frame_end": 83,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 22,
+      "frame_start": 83,
+      "frame_end": 87,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 23,
+      "frame_start": 87,
+      "frame_end": 90,
+      "frame_count": 3
+    },
+    {
+      "feature_index": 24,
+      "frame_start": 90,
+      "frame_end": 94,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 25,
+      "frame_start": 94,
+      "frame_end": 98,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 26,
+      "frame_start": 98,
+      "frame_end": 102,
+      "frame_count": 4
+    },
+    {
+      "feature_index": 27,
+      "frame_start": 102,
+      "frame_end": 106,
+      "frame_count": 4
+    }
+  ]
+}

SignX/inference_output/detailed_prediction_20260102_182015/632051/frame_alignment.json

@@ -0,0 +1,86 @@
+{
+  "translation": "#IF FRIEND GROUP/TOGETHER DEPART PARTY IX-1p JOIN IX-1p",
+  "words": [
+    "#IF",
+    "FRIEND",
+    "GROUP/TOGETHER",
+    "DEPART",
+    "PARTY",
+    "IX-1p",
+    "JOIN",
+    "IX-1p"
+  ],
+  "total_video_frames": 28,
+  "frame_ranges": [
+    {
+      "word": "#IF",
+      "start_frame": 2,
+      "end_frame": 2,
+      "peak_frame": 2,
+      "avg_attention": 0.47214657068252563,
+      "confidence": "medium"
+    },
+    {
+      "word": "FRIEND",
+      "start_frame": 5,
+      "end_frame": 5,
+      "peak_frame": 5,
+      "avg_attention": 0.4252290427684784,
+      "confidence": "medium"
+    },
+    {
+      "word": "GROUP/TOGETHER",
+      "start_frame": 8,
+      "end_frame": 8,
+      "peak_frame": 8,
+      "avg_attention": 0.37518179416656494,
+      "confidence": "medium"
+    },
+    {
+      "word": "DEPART",
+      "start_frame": 27,
+      "end_frame": 27,
+      "peak_frame": 27,
+      "avg_attention": 0.3480324149131775,
+      "confidence": "medium"
+    },
+    {
+      "word": "PARTY",
+      "start_frame": 27,
+      "end_frame": 27,
+      "peak_frame": 27,
+      "avg_attention": 0.38299673795700073,
+      "confidence": "medium"
+    },
+    {
+      "word": "IX-1p",
+      "start_frame": 27,
+      "end_frame": 27,
+      "peak_frame": 27,
+      "avg_attention": 0.33272165060043335,
+      "confidence": "medium"
+    },
+    {
+      "word": "JOIN",
+      "start_frame": 11,
+      "end_frame": 11,
+      "peak_frame": 11,
+      "avg_attention": 0.5199229121208191,
+      "confidence": "high"
+    },
+    {
+      "word": "IX-1p",
+      "start_frame": 14,
+      "end_frame": 14,
+      "peak_frame": 14,
+      "avg_attention": 0.3677118122577667,
+      "confidence": "medium"
+    }
+  ],
+  "statistics": {
+    "avg_confidence": 0.4029928669333458,
+    "high_confidence_words": 1,
+    "medium_confidence_words": 7,
+    "low_confidence_words": 0
+  }
+}

SignX/inference_output/detailed_prediction_20260102_182015/632051/interactive_alignment.html

@@ -0,0 +1,579 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Interactive Word-Frame Alignment</title>
+    <style>
+        body {
+            font-family: 'Arial', sans-serif;
+            margin: 20px;
+            background-color: #f5f5f5;
+        }
+        .container {
+            max-width: 1800px;
+            margin: 0 auto;
+            background-color: white;
+            padding: 30px;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        h1 {
+            color: #333;
+            border-bottom: 3px solid #4CAF50;
+            padding-bottom: 10px;
+            margin-bottom: 20px;
+        }
+        .stats {
+            background-color: #E3F2FD;
+            padding: 15px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+            border-left: 4px solid #2196F3;
+            font-size: 14px;
+        }
+        .controls {
+            background-color: #f9f9f9;
+            padding: 20px;
+            border-radius: 5px;
+            margin-bottom: 30px;
+            border: 1px solid #ddd;
+        }
+        .control-group {
+            margin-bottom: 15px;
+        }
+        label {
+            font-weight: bold;
+            display: inline-block;
+            width: 250px;
+            color: #555;
+        }
+        input[type="range"] {
+            width: 400px;
+            vertical-align: middle;
+        }
+        .value-display {
+            display: inline-block;
+            width: 80px;
+            font-family: monospace;
+            font-size: 14px;
+            color: #2196F3;
+            font-weight: bold;
+        }
+        .reset-btn {
+            margin-top: 15px;
+            padding: 10px 25px;
+            background-color: #2196F3;
+            color: white;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: bold;
+        }
+        .reset-btn:hover {
+            background-color: #1976D2;
+        }
+        canvas {
+            border: 1px solid #999;
+            display: block;
+            margin: 20px auto;
+            background: white;
+        }
+        .legend {
+            margin-top: 20px;
+            padding: 15px;
+            background-color: #fff;
+            border: 1px solid #ddd;
+            border-radius: 5px;
+        }
+        .legend-item {
+            display: inline-block;
+            margin-right: 25px;
+            font-size: 13px;
+            margin-bottom: 10px;
+        }
+        .color-box {
+            display: inline-block;
+            width: 30px;
+            height: 15px;
+            margin-right: 8px;
+            vertical-align: middle;
+            border: 1px solid #666;
+        }
+        .info-panel {
+            margin-top: 20px;
+            padding: 15px;
+            background-color: #f9f9f9;
+            border-radius: 5px;
+            border: 1px solid #ddd;
+        }
+        .confidence {
+            display: inline-block;
+            padding: 3px 10px;
+            border-radius: 10px;
+            font-weight: bold;
+            font-size: 11px;
+            text-transform: uppercase;
+        }
+        .confidence.high {
+            background-color: #4CAF50;
+            color: white;
+        }
+        .confidence.medium {
+            background-color: #FF9800;
+            color: white;
+        }
+        .confidence.low {
+            background-color: #f44336;
+            color: white;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎯 Interactive Word-to-Frame Alignment Visualizer</h1>
+
+        <div class="stats">
+            <strong>Translation:</strong> #IF FRIEND GROUP/TOGETHER DEPART PARTY IX-1p JOIN IX-1p<br>
+            <strong>Total Words:</strong> 8 |
+            <strong>Total Features:</strong> 28
+        </div>
+
+        <div class="controls">
+            <h3>⚙️ Threshold Controls</h3>
+
+            <div class="control-group">
+                <label for="peak-threshold">Peak Threshold (% of max):</label>
+                <input type="range" id="peak-threshold" min="1" max="100" value="90" step="1">
+                <span class="value-display" id="peak-threshold-value">90%</span>
+                <br>
+                <small style="margin-left: 255px; color: #666;">
+                    帧的注意力权重 ≥ (峰值权重 × 阈值%) 时被认为是"显著帧"
+                </small>
+            </div>
+
+            <div class="control-group">
+                <label for="confidence-high">High Confidence (avg attn >):</label>
+                <input type="range" id="confidence-high" min="0" max="100" value="50" step="1">
+                <span class="value-display" id="confidence-high-value">0.50</span>
+            </div>
+
+            <div class="control-group">
+                <label for="confidence-medium">Medium Confidence (avg attn >):</label>
+                <input type="range" id="confidence-medium" min="0" max="100" value="20" step="1">
+                <span class="value-display" id="confidence-medium-value">0.20</span>
+            </div>
+
+            <button class="reset-btn" onclick="resetDefaults()">
+                Reset to Defaults
+            </button>
+        </div>
+
+        <div>
+            <h3>Word-to-Frame Alignment</h3>
+            <p style="color: #666; font-size: 13px;">
+                每个词显示为彩色矩形，宽度表示该词对应的特征帧范围。★ = 峰值帧。矩形内部显示注意力权重波形。
+            </p>
+            <canvas id="alignment-canvas" width="1600" height="600"></canvas>
+
+            <h3 style="margin-top: 30px;">Timeline Progress Bar</h3>
+            <canvas id="timeline-canvas" width="1600" height="100"></canvas>
+
+            <div class="legend">
+                <strong>Legend:</strong><br><br>
+                <div class="legend-item">
+                    <span class="confidence high">High</span>
+                    <span class="confidence medium">Medium</span>
+                    <span class="confidence low">Low</span>
+                    Confidence Levels (opacity reflects confidence)
+                </div>
+                <div class="legend-item">
+                    <span style="color: red; font-size: 20px;">★</span>
+                    Peak Frame (highest attention)
+                </div>
+                <div class="legend-item">
+                    <span style="color: blue;">━</span>
+                    Attention Waveform (within word region)
+                </div>
+            </div>
+        </div>
+
+        <div class="info-panel">
+            <h3>Alignment Details</h3>
+            <div id="alignment-details"></div>
+        </div>
+    </div>
+
+    <script>
+        // Attention data from Python
+        const attentionData = [{"word": "#IF", "word_idx": 0, "weights": [0.013499895110726357, 0.02982642501592636, 0.47214657068252563, 0.4107391834259033, 0.04950176924467087, 0.011385880410671234, 0.007043282967060804, 0.0014652750687673688, 0.0005238102748990059, 0.00040972864371724427, 0.0001160625834017992, 6.416538963094354e-05, 5.9505786339286715e-05, 5.076597517472692e-05, 6.82844765833579e-05, 0.00012157609307905659, 6.597878382308409e-05, 0.00010269331687595695, 0.00013462362403515726, 6.423696322599426e-05, 8.642762986710295e-05, 9.25226995605044e-05, 0.00011670421372400597, 0.0001578366500325501, 0.00020240909361746162, 0.0003825947642326355, 0.0007172566256485879, 0.0008544913143850863]}, {"word": "FRIEND", "word_idx": 1, "weights": [0.009660173207521439, 0.010518566705286503, 0.011222519911825657, 0.014483344741165638, 0.1795402616262436, 0.4252290427684784, 0.25737643241882324, 0.05393827706575394, 0.01512613520026207, 0.013365501537919044, 0.002376752672716975, 0.00014935070066712797, 8.692959818290547e-05, 0.0004998841905035079, 0.0008451194153167307, 0.0011626698542386293, 0.00042453958303667605, 0.00017692227265797555, 0.00016767902707215399, 4.8644251364748925e-05, 8.348096889676526e-05, 0.0001094180770451203, 0.00030694258748553693, 0.0002885134017560631, 0.00031121523352339864, 0.0006241592927835882, 0.0008697768207639456, 0.0010077793849632144]}, {"word": "GROUP/TOGETHER", "word_idx": 2, "weights": [0.010994982905685902, 0.004551935940980911, 0.002873026067391038, 0.003936904948204756, 0.008626177906990051, 0.014811795204877853, 0.02318989858031273, 0.12032425403594971, 0.37518179416656494, 0.2971201539039612, 0.08549409359693527, 0.014250868931412697, 0.008063109591603279, 0.00339426938444376, 0.0037573552690446377, 0.004879903048276901, 0.0018731161253526807, 0.0011690640822052956, 0.0013268929906189442, 0.0007135092164389789, 0.000632062554359436, 0.000777124660089612, 0.0009553946438245475, 0.0009487943025305867, 0.0007010120898485184, 0.001496487995609641, 0.0037835948169231415, 0.004172381013631821]}, {"word": "DEPART", "word_idx": 3, "weights": [0.22514434158802032, 0.12377114593982697, 0.00781786348670721, 0.0074639273807406425, 0.01298774778842926, 0.00438598683103919, 0.004350316245108843, 0.006786263547837734, 0.006216868292540312, 0.0061629218980669975, 0.004193580709397793, 0.0015793128404766321, 0.0011525226291269064, 0.0014239393640309572, 0.0007423617644235492, 0.0008507575839757919, 0.0008870838792063296, 0.00024679809575900435, 0.00034805957693606615, 0.005230794660747051, 0.0011639633448794484, 0.001367528340779245, 0.010013289749622345, 0.018452608957886696, 0.0018141826149076223, 0.001117207808420062, 0.19629621505737305, 0.3480324149131775]}, {"word": "PARTY", "word_idx": 4, "weights": [0.1664648950099945, 0.06123431771993637, 0.0020844682585448027, 0.0020428383722901344, 0.0058554718270897865, 0.004360921215265989, 0.004692059941589832, 0.009323552250862122, 0.015183845534920692, 0.016528787091374397, 0.015347503125667572, 0.007253072690218687, 0.005231750197708607, 0.009598116390407085, 0.00704572768881917, 0.007053114008158445, 0.006423295009881258, 0.0010452027199789882, 0.0009786873124539852, 0.004494669381529093, 0.005323153454810381, 0.006433582864701748, 0.022334398701786995, 0.03912580758333206, 0.004556183237582445, 0.0021732028108090162, 0.18481463193893433, 0.38299673795700073]}, {"word": "IX-1p", "word_idx": 5, "weights": [0.2268882542848587, 0.10439852625131607, 0.005018203519284725, 0.005008632782846689, 0.005379822570830584, 0.00215631234459579, 0.0024426421150565147, 0.007580526173114777, 0.011461855843663216, 0.010575865395367146, 0.010204891674220562, 0.004322281572967768, 0.0023845669347792864, 0.0016265056328848004, 0.0011272492120042443, 0.0014091862831264734, 0.0019118450582027435, 0.0019068039255216718, 0.002558623207733035, 0.005466249771416187, 0.002576562575995922, 0.0033958060666918755, 0.014094071462750435, 0.03357496112585068, 0.005502632353454828, 0.003941097296774387, 0.19036439061164856, 0.33272165060043335]}, {"word": "JOIN", "word_idx": 6, "weights": [0.006536237895488739, 0.002151536289602518, 0.0006580766057595611, 0.0008207014761865139, 0.0003112705599050969, 0.0003111894184257835, 0.0008894064230844378, 0.004121360369026661, 0.01069970428943634, 0.008291625417768955, 0.01931559480726719, 0.5199229121208191, 0.40212148427963257, 0.004480497911572456, 0.0010337198618799448, 0.0007998707587830722, 0.00024323497200384736, 7.284984894795343e-05, 0.00011325528612360358, 0.00540410028770566, 0.0011726750526577234, 0.0009422790608368814, 0.0003188242844771594, 0.00024731658049859107, 3.1396619306178764e-05, 4.355102646513842e-05, 0.0036189379170536995, 0.005326398182660341]}, {"word": "IX-1p", "word_idx": 7, "weights": [0.0013159031514078379, 0.0007256589597091079, 0.00017777174070943147, 0.0001744187029544264, 0.00025140171055682003, 0.00039260604535229504, 0.0003829205525107682, 0.000333531730575487, 0.0007308170897886157, 0.0010108469286933541, 0.0015992401167750359, 0.003526317421346903, 0.012568545527756214, 0.2852487564086914, 0.3677118122577667, 0.19535787403583527, 0.07697467505931854, 0.012815488502383232, 0.007124335505068302, 0.0009805350564420223, 0.007633780129253864, 0.007437399588525295, 0.005485337693244219, 0.003693929873406887, 0.0026681837625801563, 0.0011110405903309584, 0.0008843602845445275, 0.0016825739294290543]}];
+        const numGlosses = 8;
+        const numFeatures = 28;
+
+        // Colors for different words (matching matplotlib tab20)
+        const colors = [
+            '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd',
+            '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf',
+            '#aec7e8', '#ffbb78', '#98df8a', '#ff9896', '#c5b0d5',
+            '#c49c94', '#f7b6d2', '#c7c7c7', '#dbdb8d', '#9edae5'
+        ];
+
+        // Get controls
+        const peakThresholdSlider = document.getElementById('peak-threshold');
+        const peakThresholdValue = document.getElementById('peak-threshold-value');
+        const confidenceHighSlider = document.getElementById('confidence-high');
+        const confidenceHighValue = document.getElementById('confidence-high-value');
+        const confidenceMediumSlider = document.getElementById('confidence-medium');
+        const confidenceMediumValue = document.getElementById('confidence-medium-value');
+        const alignmentCanvas = document.getElementById('alignment-canvas');
+        const timelineCanvas = document.getElementById('timeline-canvas');
+        const alignmentCtx = alignmentCanvas.getContext('2d');
+        const timelineCtx = timelineCanvas.getContext('2d');
+
+        // Update displays when sliders change
+        peakThresholdSlider.oninput = function() {
+            peakThresholdValue.textContent = this.value + '%';
+            updateVisualization();
+        };
+
+        confidenceHighSlider.oninput = function() {
+            confidenceHighValue.textContent = (this.value / 100).toFixed(2);
+            updateVisualization();
+        };
+
+        confidenceMediumSlider.oninput = function() {
+            confidenceMediumValue.textContent = (this.value / 100).toFixed(2);
+            updateVisualization();
+        };
+
+        function resetDefaults() {
+            peakThresholdSlider.value = 90;
+            confidenceHighSlider.value = 50;
+            confidenceMediumSlider.value = 20;
+            peakThresholdValue.textContent = '90%';
+            confidenceHighValue.textContent = '0.50';
+            confidenceMediumValue.textContent = '0.20';
+            updateVisualization();
+        }
+
+        function calculateAlignment(weights, peakThreshold) {
+            // Find peak
+            let peakIdx = 0;
+            let peakWeight = weights[0];
+            for (let i = 1; i < weights.length; i++) {
+                if (weights[i] > peakWeight) {
+                    peakWeight = weights[i];
+                    peakIdx = i;
+                }
+            }
+
+            // Find significant frames
+            const threshold = peakWeight * (peakThreshold / 100);
+            let startIdx = peakIdx;
+            let endIdx = peakIdx;
+            let sumWeight = 0;
+            let count = 0;
+
+            for (let i = 0; i < weights.length; i++) {
+                if (weights[i] >= threshold) {
+                    if (i < startIdx) startIdx = i;
+                    if (i > endIdx) endIdx = i;
+                    sumWeight += weights[i];
+                    count++;
+                }
+            }
+
+            const avgWeight = count > 0 ? sumWeight / count : peakWeight;
+
+            return {
+                startIdx: startIdx,
+                endIdx: endIdx,
+                peakIdx: peakIdx,
+                peakWeight: peakWeight,
+                avgWeight: avgWeight,
+                threshold: threshold
+            };
+        }
+
+        function getConfidenceLevel(avgWeight, highThreshold, mediumThreshold) {
+            if (avgWeight > highThreshold) return 'high';
+            if (avgWeight > mediumThreshold) return 'medium';
+            return 'low';
+        }
+
+        function drawAlignmentChart() {
+            const peakThreshold = parseInt(peakThresholdSlider.value);
+            const highThreshold = parseInt(confidenceHighSlider.value) / 100;
+            const mediumThreshold = parseInt(confidenceMediumSlider.value) / 100;
+
+            // Canvas dimensions
+            const width = alignmentCanvas.width;
+            const height = alignmentCanvas.height;
+            const leftMargin = 180;
+            const rightMargin = 50;
+            const topMargin = 60;
+            const bottomMargin = 80;
+
+            const plotWidth = width - leftMargin - rightMargin;
+            const plotHeight = height - topMargin - bottomMargin;
+
+            const rowHeight = plotHeight / numGlosses;
+            const featureWidth = plotWidth / numFeatures;
+
+            // Clear canvas
+            alignmentCtx.clearRect(0, 0, width, height);
+
+            // Draw title
+            alignmentCtx.fillStyle = '#333';
+            alignmentCtx.font = 'bold 18px Arial';
+            alignmentCtx.textAlign = 'center';
+            alignmentCtx.fillText('Word-to-Frame Alignment', width / 2, 30);
+            alignmentCtx.font = '13px Arial';
+            alignmentCtx.fillText('(based on attention peaks, ★ = peak frame)', width / 2, 48);
+
+            // Calculate alignments
+            const alignments = [];
+            for (let wordIdx = 0; wordIdx < numGlosses; wordIdx++) {
+                const data = attentionData[wordIdx];
+                const alignment = calculateAlignment(data.weights, peakThreshold);
+                alignment.word = data.word;
+                alignment.wordIdx = wordIdx;
+                alignment.weights = data.weights;
+                alignments.push(alignment);
+            }
+
+            // Draw grid
+            alignmentCtx.strokeStyle = '#e0e0e0';
+            alignmentCtx.lineWidth = 0.5;
+            for (let i = 0; i <= numFeatures; i++) {
+                const x = leftMargin + i * featureWidth;
+                alignmentCtx.beginPath();
+                alignmentCtx.moveTo(x, topMargin);
+                alignmentCtx.lineTo(x, topMargin + plotHeight);
+                alignmentCtx.stroke();
+            }
+
+            // Draw word regions
+            for (let wordIdx = 0; wordIdx < numGlosses; wordIdx++) {
+                const alignment = alignments[wordIdx];
+                const confidence = getConfidenceLevel(alignment.avgWeight, highThreshold, mediumThreshold);
+                const y = topMargin + wordIdx * rowHeight;
+
+                // Alpha based on confidence
+                const alpha = confidence === 'high' ? 0.9 : confidence === 'medium' ? 0.7 : 0.5;
+
+                // Draw rectangle for word region
+                const startX = leftMargin + alignment.startIdx * featureWidth;
+                const rectWidth = (alignment.endIdx - alignment.startIdx + 1) * featureWidth;
+
+                alignmentCtx.fillStyle = colors[wordIdx % 20];
+                alignmentCtx.globalAlpha = alpha;
+                alignmentCtx.fillRect(startX, y, rectWidth, rowHeight * 0.8);
+                alignmentCtx.globalAlpha = 1.0;
+
+                // Draw border
+                alignmentCtx.strokeStyle = '#000';
+                alignmentCtx.lineWidth = 2;
+                alignmentCtx.strokeRect(startX, y, rectWidth, rowHeight * 0.8);
+
+                // Draw attention waveform inside rectangle
+                alignmentCtx.strokeStyle = 'rgba(0, 0, 255, 0.8)';
+                alignmentCtx.lineWidth = 1.5;
+                alignmentCtx.beginPath();
+                for (let i = alignment.startIdx; i <= alignment.endIdx; i++) {
+                    const x = leftMargin + i * featureWidth + featureWidth / 2;
+                    const weight = alignment.weights[i];
+                    const maxWeight = alignment.peakWeight;
+                    const normalizedWeight = weight / (maxWeight * 1.2); // Scale for visibility
+                    const waveY = y + rowHeight * 0.8 - (normalizedWeight * rowHeight * 0.6);
+
+                    if (i === alignment.startIdx) {
+                        alignmentCtx.moveTo(x, waveY);
+                    } else {
+                        alignmentCtx.lineTo(x, waveY);
+                    }
+                }
+                alignmentCtx.stroke();
+
+                // Draw word label
+                const labelX = startX + rectWidth / 2;
+                const labelY = y + rowHeight * 0.4;
+
+                alignmentCtx.fillStyle = 'rgba(0, 0, 0, 0.7)';
+                alignmentCtx.fillRect(labelX - 60, labelY - 12, 120, 24);
+                alignmentCtx.fillStyle = '#fff';
+                alignmentCtx.font = 'bold 13px Arial';
+                alignmentCtx.textAlign = 'center';
+                alignmentCtx.textBaseline = 'middle';
+                alignmentCtx.fillText(alignment.word, labelX, labelY);
+
+                // Mark peak frame with star
+                const peakX = leftMargin + alignment.peakIdx * featureWidth + featureWidth / 2;
+                const peakY = y + rowHeight * 0.4;
+
+                // Draw star
+                alignmentCtx.fillStyle = '#ff0000';
+                alignmentCtx.strokeStyle = '#ffff00';
+                alignmentCtx.lineWidth = 1.5;
+                alignmentCtx.font = '20px Arial';
+                alignmentCtx.textAlign = 'center';
+                alignmentCtx.strokeText('★', peakX, peakY);
+                alignmentCtx.fillText('★', peakX, peakY);
+
+                // Y-axis label (word names)
+                alignmentCtx.fillStyle = '#333';
+                alignmentCtx.font = '12px Arial';
+                alignmentCtx.textAlign = 'right';
+                alignmentCtx.textBaseline = 'middle';
+                alignmentCtx.fillText(alignment.word, leftMargin - 10, y + rowHeight * 0.4);
+            }
+
+            // Draw horizontal grid lines
+            alignmentCtx.strokeStyle = '#ccc';
+            alignmentCtx.lineWidth = 0.5;
+            for (let i = 0; i <= numGlosses; i++) {
+                const y = topMargin + i * rowHeight;
+                alignmentCtx.beginPath();
+                alignmentCtx.moveTo(leftMargin, y);
+                alignmentCtx.lineTo(leftMargin + plotWidth, y);
+                alignmentCtx.stroke();
+            }
+
+            // Draw axes
+            alignmentCtx.strokeStyle = '#000';
+            alignmentCtx.lineWidth = 2;
+            alignmentCtx.strokeRect(leftMargin, topMargin, plotWidth, plotHeight);
+
+            // X-axis labels (frame indices)
+            alignmentCtx.fillStyle = '#000';
+            alignmentCtx.font = '11px Arial';
+            alignmentCtx.textAlign = 'center';
+            alignmentCtx.textBaseline = 'top';
+            for (let i = 0; i < numFeatures; i++) {
+                const x = leftMargin + i * featureWidth + featureWidth / 2;
+                alignmentCtx.fillText(i.toString(), x, topMargin + plotHeight + 10);
+            }
+
+            // Axis titles
+            alignmentCtx.fillStyle = '#333';
+            alignmentCtx.font = 'bold 14px Arial';
+            alignmentCtx.textAlign = 'center';
+            alignmentCtx.fillText('Feature Frame Index', leftMargin + plotWidth / 2, height - 20);
+
+            alignmentCtx.save();
+            alignmentCtx.translate(30, topMargin + plotHeight / 2);
+            alignmentCtx.rotate(-Math.PI / 2);
+            alignmentCtx.fillText('Generated Word', 0, 0);
+            alignmentCtx.restore();
+
+            return alignments;
+        }
+
+        function drawTimeline(alignments) {
+            const highThreshold = parseInt(confidenceHighSlider.value) / 100;
+            const mediumThreshold = parseInt(confidenceMediumSlider.value) / 100;
+
+            const width = timelineCanvas.width;
+            const height = timelineCanvas.height;
+            const leftMargin = 180;
+            const rightMargin = 50;
+            const plotWidth = width - leftMargin - rightMargin;
+            const featureWidth = plotWidth / numFeatures;
+
+            // Clear canvas
+            timelineCtx.clearRect(0, 0, width, height);
+
+            // Background bar
+            timelineCtx.fillStyle = '#ddd';
+            timelineCtx.fillRect(leftMargin, 30, plotWidth, 40);
+            timelineCtx.strokeStyle = '#000';
+            timelineCtx.lineWidth = 2;
+            timelineCtx.strokeRect(leftMargin, 30, plotWidth, 40);
+
+            // Draw word regions on timeline
+            for (let wordIdx = 0; wordIdx < alignments.length; wordIdx++) {
+                const alignment = alignments[wordIdx];
+                const confidence = getConfidenceLevel(alignment.avgWeight, highThreshold, mediumThreshold);
+                const alpha = confidence === 'high' ? 0.9 : confidence === 'medium' ? 0.7 : 0.5;
+
+                const startX = leftMargin + alignment.startIdx * featureWidth;
+                const rectWidth = (alignment.endIdx - alignment.startIdx + 1) * featureWidth;
+
+                timelineCtx.fillStyle = colors[wordIdx % 20];
+                timelineCtx.globalAlpha = alpha;
+                timelineCtx.fillRect(startX, 30, rectWidth, 40);
+                timelineCtx.globalAlpha = 1.0;
+                timelineCtx.strokeStyle = '#000';
+                timelineCtx.lineWidth = 0.5;
+                timelineCtx.strokeRect(startX, 30, rectWidth, 40);
+            }
+
+            // Title
+            timelineCtx.fillStyle = '#333';
+            timelineCtx.font = 'bold 13px Arial';
+            timelineCtx.textAlign = 'left';
+            timelineCtx.fillText('Timeline Progress Bar', leftMargin, 20);
+        }
+
+        function updateDetailsPanel(alignments, highThreshold, mediumThreshold) {
+            const panel = document.getElementById('alignment-details');
+            let html = '<table style="width: 100%; border-collapse: collapse;">';
+            html += '<tr style="background: #f0f0f0; font-weight: bold;">';
+            html += '<th style="padding: 8px; border: 1px solid #ddd;">Word</th>';
+            html += '<th style="padding: 8px; border: 1px solid #ddd;">Feature Range</th>';
+            html += '<th style="padding: 8px; border: 1px solid #ddd;">Peak</th>';
+            html += '<th style="padding: 8px; border: 1px solid #ddd;">Span</th>';
+            html += '<th style="padding: 8px; border: 1px solid #ddd;">Avg Attention</th>';
+            html += '<th style="padding: 8px; border: 1px solid #ddd;">Confidence</th>';
+            html += '</tr>';
+
+            for (const align of alignments) {
+                const confidence = getConfidenceLevel(align.avgWeight, highThreshold, mediumThreshold);
+                const span = align.endIdx - align.startIdx + 1;
+
+                html += '<tr>';
+                html += `<td style="padding: 8px; border: 1px solid #ddd;"><strong>${align.word}</strong></td>`;
+                html += `<td style="padding: 8px; border: 1px solid #ddd;">${align.startIdx} → ${align.endIdx}</td>`;
+                html += `<td style="padding: 8px; border: 1px solid #ddd;">${align.peakIdx}</td>`;
+                html += `<td style="padding: 8px; border: 1px solid #ddd;">${span}</td>`;
+                html += `<td style="padding: 8px; border: 1px solid #ddd;">${align.avgWeight.toFixed(4)}</td>`;
+                html += `<td style="padding: 8px; border: 1px solid #ddd;"><span class="confidence ${confidence}">${confidence}</span></td>`;
+                html += '</tr>';
+            }
+
+            html += '</table>';
+            panel.innerHTML = html;
+        }
+
+        function updateVisualization() {
+            const alignments = drawAlignmentChart();
+            drawTimeline(alignments);
+            const highThreshold = parseInt(confidenceHighSlider.value) / 100;
+            const mediumThreshold = parseInt(confidenceMediumSlider.value) / 100;
+            updateDetailsPanel(alignments, highThreshold, mediumThreshold);
+        }
+
+        // Event listeners for sliders
+        peakSlider.addEventListener('input', function() {
+            peakValue.textContent = peakSlider.value + '%';
+            updateVisualization();
+        });
+
+        confidenceHighSlider.addEventListener('input', function() {
+            const val = parseInt(confidenceHighSlider.value) / 100;
+            confidenceHighValue.textContent = val.toFixed(2);
+            updateVisualization();
+        });
+
+        confidenceMediumSlider.addEventListener('input', function() {
+            const val = parseInt(confidenceMediumSlider.value) / 100;
+            confidenceMediumValue.textContent = val.toFixed(2);
+            updateVisualization();
+        });
+
+        // Initial visualization
+        updateVisualization();
+    </script>
+</body>
+</html>

SignX/inference_output/detailed_prediction_20260102_182015/632051/translation.txt

@@ -0,0 +1,3 @@
+With BPE: #IF FRIEND GROUP/TOGE@@ TH@@ E@@ R DEPART PARTY IX-1p JO@@ I@@ N IX-1p
+Clean: #IF FRIEND GROUP/TOGETHER DEPART PARTY IX-1p JOIN IX-1p
+Ground Truth: #IF FRIEND GROUP/TOGETHER GO-OUT PARTY IX-1p JOIN IX-1p

SignX/inference_output/detailed_prediction_20260102_183038/97998032/analysis_report.txt

@@ -0,0 +1,42 @@
+================================================================================
+  Sign Language Recognition - Attention Analysis Report
+================================================================================
+
+Generated at: 2026-01-02 18:30:43
+
+Translation:
+--------------------------------------------------------------------------------
+BOX/ROOM REALLY BIG #DOG "I don't know"
+
+Video info:
+--------------------------------------------------------------------------------
+Total feature frames: 19
+Word count: 7
+
+Attention tensor:
+--------------------------------------------------------------------------------
+Shape: (30, 19)
+  - Decoder steps: 30
+
+Word-to-frame details:
+================================================================================
+No.   Word                 Frames          Peak     Attn     Conf      
+--------------------------------------------------------------------------------
+1     BOX/ROOM             3-3             3        0.557    high      
+2     REALLY               7-7             7        0.479    medium    
+3     BIG                  9-9             9        0.435    medium    
+4     #DOG                 12-14           14       0.160    low       
+5     "I                   7-7             7        0.448    medium    
+6     don't                9-9             9        0.445    medium    
+7     know"                14-15           15       0.172    low       
+
+================================================================================
+
+Summary:
+--------------------------------------------------------------------------------
+Average attention weight: 0.385
+High-confidence words: 1 (14.3%)
+Medium-confidence words: 4 (57.1%)
+Low-confidence words: 2 (28.6%)
+
+================================================================================

SignX/inference_output/detailed_prediction_20260102_183038/97998032/attention_keyframes/keyframes_index.txt

@@ -0,0 +1,39 @@
+Attention Keyframe Index
+============================================================
+
+Sample directory: /research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/SignX/inference_output/detailed_prediction_20260102_183038/97998032
+Video path: /common/users/sf895/output/huggingface_asllrp_repo/SignX/eval/tiny_test_data/videos/97998032.mp4
+Total keyframes: 30
+
+Keyframe list:
+------------------------------------------------------------
+Gloss   0: keyframe_000_feat3_frame13_att0.557.jpg
+Gloss   1: keyframe_001_feat7_frame28_att0.479.jpg
+Gloss   2: keyframe_002_feat9_frame35_att0.435.jpg
+Gloss   3: keyframe_003_feat14_frame54_att0.166.jpg
+Gloss   4: keyframe_004_feat7_frame28_att0.448.jpg
+Gloss   5: keyframe_005_feat9_frame35_att0.445.jpg
+Gloss   6: keyframe_006_feat15_frame58_att0.181.jpg
+Gloss   7: keyframe_007_feat0_frame1_att0.212.jpg
+Gloss   8: keyframe_008_feat17_frame66_att0.165.jpg
+Gloss   9: keyframe_009_feat17_frame66_att0.158.jpg
+Gloss  10: keyframe_010_feat18_frame70_att0.164.jpg
+Gloss  11: keyframe_011_feat17_frame66_att0.163.jpg
+Gloss  12: keyframe_012_feat17_frame66_att0.156.jpg
+Gloss  13: keyframe_013_feat0_frame1_att0.227.jpg
+Gloss  14: keyframe_014_feat0_frame1_att0.224.jpg
+Gloss  15: keyframe_015_feat0_frame1_att0.202.jpg
+Gloss  16: keyframe_016_feat0_frame1_att0.240.jpg
+Gloss  17: keyframe_017_feat17_frame66_att0.149.jpg
+Gloss  18: keyframe_018_feat0_frame1_att0.252.jpg
+Gloss  19: keyframe_019_feat0_frame1_att0.240.jpg
+Gloss  20: keyframe_020_feat0_frame1_att0.241.jpg
+Gloss  21: keyframe_021_feat0_frame1_att0.289.jpg
+Gloss  22: keyframe_022_feat0_frame1_att0.289.jpg
+Gloss  23: keyframe_023_feat0_frame1_att0.244.jpg
+Gloss  24: keyframe_024_feat15_frame58_att0.187.jpg
+Gloss  25: keyframe_025_feat0_frame1_att0.239.jpg
+Gloss  26: keyframe_026_feat0_frame1_att0.266.jpg
+Gloss  27: keyframe_027_feat0_frame1_att0.193.jpg
+Gloss  28: keyframe_028_feat18_frame70_att0.173.jpg
+Gloss  29: keyframe_029_feat0_frame1_att0.242.jpg

SignX/inference_output/detailed_prediction_20260102_183038/97998032/attention_weights.npy

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

SignX/inference_output/detailed_prediction_20260102_183038/97998032/debug_video_path.txt

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

SignX/inference_output/{detailed_prediction_20260102_180915/23881350 → detailed_prediction_20260102_183038/97998032}/feature_frame_mapping.json

@@ -1,7 +1,7 @@
 {
-  "original_frame_count": 84,
-  "feature_count": 22,
-  "downsampling_ratio": 3.8181818181818183,
+  "original_frame_count": 72,
+  "feature_count": 19,
+  "downsampling_ratio": 3.789473684210526,
   "fps": 30.0,
   "mapping": [
     {
@@ -31,14 +31,14 @@
     {
       "feature_index": 4,
       "frame_start": 15,
-      "frame_end": 19,
-      "frame_count": 4
+      "frame_end": 18,
+      "frame_count": 3
     },
     {
       "feature_index": 5,
-      "frame_start": 19,
+      "frame_start": 18,
       "frame_end": 22,
-      "frame_count": 3
+      "frame_count": 4
     },
     {
       "feature_index": 6,
@@ -61,20 +61,20 @@
     {
       "feature_index": 9,
       "frame_start": 34,
-      "frame_end": 38,
-      "frame_count": 4
+      "frame_end": 37,
+      "frame_count": 3
     },
     {
       "feature_index": 10,
-      "frame_start": 38,
-      "frame_end": 42,
+      "frame_start": 37,
+      "frame_end": 41,
       "frame_count": 4
     },
     {
       "feature_index": 11,
-      "frame_start": 42,
+      "frame_start": 41,
       "frame_end": 45,
-      "frame_count": 3
+      "frame_count": 4
     },
     {
       "feature_index": 12,
@@ -91,20 +91,20 @@
     {
       "feature_index": 14,
       "frame_start": 53,
-      "frame_end": 57,
-      "frame_count": 4
+      "frame_end": 56,
+      "frame_count": 3
     },
     {
       "feature_index": 15,
-      "frame_start": 57,
-      "frame_end": 61,
+      "frame_start": 56,
+      "frame_end": 60,
       "frame_count": 4
     },
     {
       "feature_index": 16,
-      "frame_start": 61,
+      "frame_start": 60,
       "frame_end": 64,
-      "frame_count": 3
+      "frame_count": 4
     },
     {
       "feature_index": 17,
@@ -117,24 +117,6 @@
       "frame_start": 68,
       "frame_end": 72,
       "frame_count": 4
-    },
-    {
-      "feature_index": 19,
-      "frame_start": 72,
-      "frame_end": 76,
-      "frame_count": 4
-    },
-    {
-      "feature_index": 20,
-      "frame_start": 76,
-      "frame_end": 80,
-      "frame_count": 4
-    },
-    {
-      "feature_index": 21,
-      "frame_start": 80,
-      "frame_end": 84,
-      "frame_count": 4
     }
   ]
 }

SignX/inference_output/detailed_prediction_20260102_183038/97998032/frame_alignment.json

@@ -0,0 +1,77 @@
+{
+  "translation": "BOX/ROOM REALLY BIG #DOG \"I don't know\"",
+  "words": [
+    "BOX/ROOM",
+    "REALLY",
+    "BIG",
+    "#DOG",
+    "\"I",
+    "don't",
+    "know\""
+  ],
+  "total_video_frames": 19,
+  "frame_ranges": [
+    {
+      "word": "BOX/ROOM",
+      "start_frame": 3,
+      "end_frame": 3,
+      "peak_frame": 3,
+      "avg_attention": 0.557424008846283,
+      "confidence": "high"
+    },
+    {
+      "word": "REALLY",
+      "start_frame": 7,
+      "end_frame": 7,
+      "peak_frame": 7,
+      "avg_attention": 0.4792027473449707,
+      "confidence": "medium"
+    },
+    {
+      "word": "BIG",
+      "start_frame": 9,
+      "end_frame": 9,
+      "peak_frame": 9,
+      "avg_attention": 0.43524169921875,
+      "confidence": "medium"
+    },
+    {
+      "word": "#DOG",
+      "start_frame": 12,
+      "end_frame": 14,
+      "peak_frame": 14,
+      "avg_attention": 0.1597622036933899,
+      "confidence": "low"
+    },
+    {
+      "word": "\"I",
+      "start_frame": 7,
+      "end_frame": 7,
+      "peak_frame": 7,
+      "avg_attention": 0.44769182801246643,
+      "confidence": "medium"
+    },
+    {
+      "word": "don't",
+      "start_frame": 9,
+      "end_frame": 9,
+      "peak_frame": 9,
+      "avg_attention": 0.4446210265159607,
+      "confidence": "medium"
+    },
+    {
+      "word": "know\"",
+      "start_frame": 14,
+      "end_frame": 15,
+      "peak_frame": 15,
+      "avg_attention": 0.17181915044784546,
+      "confidence": "low"
+    }
+  ],
+  "statistics": {
+    "avg_confidence": 0.3851089520113809,
+    "high_confidence_words": 1,
+    "medium_confidence_words": 4,
+    "low_confidence_words": 2
+  }
+}

SignX/inference_output/{detailed_prediction_20260102_180915/23881350 → detailed_prediction_20260102_183038/97998032}/interactive_alignment.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="zh-CN">
+<html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
@@ -135,9 +135,9 @@
         <h1>🎯 Interactive Word-to-Frame Alignment Visualizer</h1>
 
         <div class="stats">
-            <strong>Translation:</strong> HAPPEN RAIN IX-1p STAY HOME<br>
-            <strong>Total Words:</strong> 5 |
-            <strong>Total Features:</strong> 22
+            <strong>Translation:</strong> BOX/ROOM REALLY BIG #DOG "I don't know"<br>
+            <strong>Total Words:</strong> 7 |
+            <strong>Total Features:</strong> 19
         </div>
 
         <div class="controls">
@@ -149,7 +149,7 @@
                 <span class="value-display" id="peak-threshold-value">90%</span>
                 <br>
                 <small style="margin-left: 255px; color: #666;">
-                    帧的注意力权重 ≥ (峰值权重 × 阈值%) 时被认为是"显著帧"
+                    A frame is considered “significant” if its attention ≥ (peak × threshold%)
                 </small>
             </div>
 
@@ -173,7 +173,7 @@
         <div>
             <h3>Word-to-Frame Alignment</h3>
             <p style="color: #666; font-size: 13px;">
-                每个词显示为彩色矩形，宽度表示该词对应的特征帧范围。★ = 峰值帧。矩形内部显示注意力权重波形。
+                Each word appears as a colored block. Width = frame span, ★ = peak frame, waveform = attention trace.
             </p>
             <canvas id="alignment-canvas" width="1600" height="600"></canvas>
 
@@ -207,9 +207,9 @@
 
     <script>
         // Attention data from Python
-        const attentionData = [{"word": "HAPPEN", "word_idx": 0, "weights": [0.01291993260383606, 0.22621376812458038, 0.33764514327049255, 0.27050673961639404, 0.09817569702863693, 0.02714376524090767, 0.011113409884274006, 0.005296836141496897, 0.0037311457563191652, 0.003827065462246537, 0.0006870391080155969, 0.0002082101273117587, 0.00037049551610834897, 0.00017867473070509732, 0.00019952311413362622, 0.0002196609857492149, 0.0002739514457061887, 0.0002957700635306537, 0.0002758886548690498, 0.00030245655216276646, 0.00020353472791612148, 0.00021125243802089244]}, {"word": "RAIN", "word_idx": 1, "weights": [0.3576834201812744, 0.06338081508874893, 0.04800238460302353, 0.049258649349212646, 0.05412573739886284, 0.05381090193986893, 0.030251972377300262, 0.02207508496940136, 0.02118324674665928, 0.023231113329529762, 0.010185010731220245, 0.003157678060233593, 0.0062621720135211945, 0.04268598556518555, 0.029935674741864204, 0.006265602074563503, 0.004162208177149296, 0.00504302280023694, 0.008224229328334332, 0.010121803730726242, 0.034552425146102905, 0.11640084534883499]}, {"word": "IX-1p", "word_idx": 2, "weights": [0.3532525599002838, 0.04980245977640152, 0.04337240383028984, 0.06047032028436661, 0.06392523646354675, 0.03436466306447983, 0.02429746463894844, 0.02106122486293316, 0.02133776992559433, 0.025554073974490166, 0.016313916072249413, 0.003731244709342718, 0.007006840314716101, 0.04077312350273132, 0.02346269227564335, 0.0029797866009175777, 0.0017814883030951023, 0.00229285447858274, 0.004264588467776775, 0.005742882378399372, 0.03171425312757492, 0.16249814629554749]}, {"word": "STAY", "word_idx": 3, "weights": [0.40251624584198, 0.029755407944321632, 0.014557132497429848, 0.01463515404611826, 0.019380902871489525, 0.014376296661794186, 0.007390746846795082, 0.006403730250895023, 0.007509394083172083, 0.011107773520052433, 0.015461954288184643, 0.008160914294421673, 0.015393615700304508, 0.049521077424287796, 0.02762117236852646, 0.0039024795405566692, 0.0022697332315146923, 0.002971042413264513, 0.0064276838675141335, 0.00918453000485897, 0.059506580233573914, 0.27194643020629883]}, {"word": "HOME", "word_idx": 4, "weights": [0.004598479717969894, 0.004125811159610748, 0.010973671451210976, 0.027834169566631317, 0.05619348585605621, 0.11399403214454651, 0.1471027433872223, 0.24049112200737, 0.18445074558258057, 0.13784004747867584, 0.052242521196603775, 0.00787721760571003, 0.00459145987406373, 0.0007465958478860557, 0.0008116196841001511, 0.0007541333325207233, 0.0007234851364046335, 0.000789315381553024, 0.0007666726596653461, 0.0007141060195863247, 0.0008214113186113536, 0.001557175419293344]}];
-        const numGlosses = 5;
-        const numFeatures = 22;
+        const attentionData = [{"word": "BOX/ROOM", "word_idx": 0, "weights": [0.002408777829259634, 0.0024341775570064783, 0.03761057183146477, 0.557424008846283, 0.352936714887619, 0.03772226721048355, 0.005863560829311609, 0.0013187339063733816, 0.0006791671621613204, 0.00032966560684144497, 9.721100650494918e-05, 8.92743410076946e-05, 9.339430107502267e-05, 0.00012962566688656807, 0.0002221816248493269, 0.00024164406931959093, 0.00015803848509676754, 0.0001251799112651497, 0.0001158745726570487]}, {"word": "REALLY", "word_idx": 1, "weights": [0.0026851091533899307, 0.0017755258595570922, 0.0021002113353461027, 0.00464355293661356, 0.009926511906087399, 0.05862388014793396, 0.07301068305969238, 0.4792027473449707, 0.24775737524032593, 0.09779708087444305, 0.013734006322920322, 0.0036178771406412125, 0.00126516108866781, 0.0006283684633672237, 0.0005421006353572011, 0.0004540205409284681, 0.0005231587565504014, 0.0008070130716077983, 0.0009056107373908162]}, {"word": "BIG", "word_idx": 2, "weights": [0.0033648894168436527, 0.0024659072514623404, 0.001798246055841446, 0.0024246324319392443, 0.003872026689350605, 0.033719416707754135, 0.04568067193031311, 0.04394841566681862, 0.27093446254730225, 0.43524169921875, 0.10514841973781586, 0.02633197419345379, 0.00916079618036747, 0.004303758963942528, 0.002990439534187317, 0.001977356616407633, 0.001934203552082181, 0.002392182359471917, 0.002310538897290826]}, {"word": "#DOG", "word_idx": 3, "weights": [0.003395852167159319, 0.0022946521639823914, 0.0013094337191432714, 0.001907510682940483, 0.0014237307477742434, 0.0012601837515830994, 0.0016997121274471283, 0.002569732256233692, 0.007368206512182951, 0.022247344255447388, 0.08171797543764114, 0.13777881860733032, 0.151152104139328, 0.16236612200737, 0.16576839983463287, 0.14751452207565308, 0.0665179044008255, 0.025248302146792412, 0.016459539532661438]}, {"word": "\"I", "word_idx": 4, "weights": [0.0019984443206340075, 0.0012192379217594862, 0.0013845543144270778, 0.0029638358391821384, 0.006774703040719032, 0.04147785156965256, 0.04095124825835228, 0.44769182801246643, 0.3094656765460968, 0.1222718134522438, 0.01613483391702175, 0.003763768821954727, 0.001163386506959796, 0.0004717711126431823, 0.0003339226823300123, 0.0002554724342189729, 0.0003666701668407768, 0.000614481046795845, 0.0006964970380067825]}, {"word": "don't", "word_idx": 5, "weights": [0.003398515982553363, 0.0023782167118042707, 0.0015607323730364442, 0.0018948124488815665, 0.0028244417626410723, 0.02270398661494255, 0.026757270097732544, 0.03139280155301094, 0.2563266456127167, 0.4446210265159607, 0.12968029081821442, 0.0390482135117054, 0.014498664066195488, 0.006633279379457235, 0.00436902791261673, 0.0027454677037894726, 0.002826108131557703, 0.0032868734560906887, 0.0030536367557942867]}, {"word": "know\"", "word_idx": 6, "weights": [0.019786883145570755, 0.015500817447900772, 0.013907048851251602, 0.009185242466628551, 0.005570622161030769, 0.0035703633911907673, 0.0028947137761861086, 0.0038008512929081917, 0.005732583813369274, 0.004597889259457588, 0.008673366159200668, 0.03249302878975868, 0.06597991287708282, 0.10256516188383102, 0.1631372570991516, 0.1805010437965393, 0.15080885589122772, 0.11721422523260117, 0.09408010542392731]}];
+        const numGlosses = 7;
+        const numFeatures = 19;
 
         // Colors for different words (matching matplotlib tab20)
         const colors = [

SignX/inference_output/detailed_prediction_20260102_183038/97998032/translation.txt

@@ -0,0 +1,3 @@
+With BPE: BOX/ROOM REALLY BIG #DOG "@@ I d@@ on@@ '@@ t know"
+Clean: BOX/ROOM REALLY BIG #DOG "I don't know"
+Ground Truth: BOX/ROOM BIG