Successfully completed the attention-based segmentation inference

SignX/detailed_prediction_20251225_154414/sample_000/analysis_report.txt

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

SignX/detailed_prediction_20251225_154414/sample_000/attention_weights.npy

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

SignX/detailed_prediction_20251225_154414/sample_000/frame_alignment.json

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

SignX/detailed_prediction_20251225_154414/sample_000/translation.txt

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

SignX/eval/attention_analysis.py

@@ -0,0 +1,387 @@
+#!/usr/bin/env python3
+"""
+Attention权重分析和可视化模块
+
+功能:
+1. 解析attention权重数据
+2. 计算每个词对应的视频帧范围
+3. 生成可视化图表（热图、对齐图、时间线）
+4. 保存详细分析报告
+
+使用示例:
+    from eval.attention_analysis import AttentionAnalyzer
+
+    analyzer = AttentionAnalyzer(
+        attentions=attention_weights,  # [time, batch, beam, src_len]
+        translation="WORD1 WORD2 WORD3",
+        video_frames=100
+    )
+
+    # 生成所有可视化
+    analyzer.generate_all_visualizations(output_dir="results/")
+"""
+
+import os
+import json
+import numpy as np
+from pathlib import Path
+from datetime import datetime
+
+
+class AttentionAnalyzer:
+    """Attention权重分析器"""
+
+    def __init__(self, attentions, translation, video_frames, beam_sequences=None, beam_scores=None):
+        """
+        Args:
+            attentions: numpy array, shape [time_steps, batch, beam, src_len]
+                       或 [time_steps, src_len] (已提取最佳beam)
+            translation: str, 翻译结果（BPE已移除）
+            video_frames: int, 视频总帧数
+            beam_sequences: list, 所有beam的序列 (可选)
+            beam_scores: list, 所有beam的分数 (可选)
+        """
+        self.attentions = attentions
+        self.translation = translation
+        self.words = translation.split()
+        self.video_frames = video_frames
+        self.beam_sequences = beam_sequences
+        self.beam_scores = beam_scores
+
+        # 提取最佳路径的attention (batch=0, beam=0)
+        if len(attentions.shape) == 4:
+            self.attn_best = attentions[:, 0, 0, :]  # [time, src_len]
+        elif len(attentions.shape) == 3:
+            self.attn_best = attentions[:, 0, :]  # [time, src_len]
+        else:
+            self.attn_best = attentions  # [time, src_len]
+
+        # 计算词-帧对应关系
+        self.word_frame_ranges = self._compute_word_frame_ranges()
+
+    def _compute_word_frame_ranges(self):
+        """
+        计算每个词对应的主要视频帧范围
+
+        Returns:
+            list of dict: [
+                {
+                    'word': str,
+                    'start_frame': int,
+                    'end_frame': int,
+                    'peak_frame': int,
+                    'avg_attention': float,
+                    'confidence': str
+                },
+                ...
+            ]
+        """
+        word_ranges = []
+
+        for word_idx, word in enumerate(self.words):
+            if word_idx >= self.attn_best.shape[0]:
+                # 超出attention范围
+                word_ranges.append({
+                    'word': word,
+                    'start_frame': 0,
+                    'end_frame': 0,
+                    'peak_frame': 0,
+                    'avg_attention': 0.0,
+                    'confidence': 'unknown'
+                })
+                continue
+
+            attn_weights = self.attn_best[word_idx, :]
+
+            # 找到权重最高的帧
+            peak_frame = int(np.argmax(attn_weights))
+            peak_weight = attn_weights[peak_frame]
+
+            # 计算显著帧范围（权重 >= 最大值的30%）
+            threshold = peak_weight * 0.3
+            significant_frames = np.where(attn_weights >= threshold)[0]
+
+            if len(significant_frames) > 0:
+                start_frame = int(significant_frames[0])
+                end_frame = int(significant_frames[-1])
+                avg_weight = float(attn_weights[significant_frames].mean())
+            else:
+                start_frame = peak_frame
+                end_frame = peak_frame
+                avg_weight = float(peak_weight)
+
+            # 判断置信度
+            if avg_weight > 0.5:
+                confidence = 'high'
+            elif avg_weight > 0.2:
+                confidence = 'medium'
+            else:
+                confidence = 'low'
+
+            word_ranges.append({
+                'word': word,
+                'start_frame': start_frame,
+                'end_frame': end_frame,
+                'peak_frame': peak_frame,
+                'avg_attention': avg_weight,
+                'confidence': confidence
+            })
+
+        return word_ranges
+
+    def generate_all_visualizations(self, output_dir):
+        """
+        生成所有可视化图表
+
+        Args:
+            output_dir: 输出目录路径
+        """
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        print(f"\n生成可视化图表到: {output_dir}")
+
+        # 1. Attention热图
+        self.plot_attention_heatmap(output_dir / "attention_heatmap.png")
+
+        # 2. 帧对齐图
+        self.plot_frame_alignment(output_dir / "frame_alignment.png")
+
+        # 3. 保存数值数据
+        self.save_alignment_data(output_dir / "frame_alignment.json")
+
+        # 4. 保存详细报告
+        self.save_text_report(output_dir / "analysis_report.txt")
+
+        # 5. 保存numpy数据（供进一步分析）
+        np.save(output_dir / "attention_weights.npy", self.attentions)
+
+        print(f"✓ 已生成 {len(list(output_dir.glob('*')))} 个文件")
+
+    def plot_attention_heatmap(self, output_path):
+        """生成Attention热图"""
+        try:
+            import matplotlib
+            matplotlib.use('Agg')
+            import matplotlib.pyplot as plt
+        except ImportError:
+            print("  跳过热图: matplotlib未安装")
+            return
+
+        fig, ax = plt.subplots(figsize=(14, 8))
+
+        # 绘制热图
+        im = ax.imshow(self.attn_best.T, cmap='hot', aspect='auto',
+                      interpolation='nearest', origin='lower')
+
+        # 设置标签
+        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')
+
+        # 词标签
+        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)
+
+        # 添加颜色条
+        cbar = plt.colorbar(im, ax=ax, label='Attention Weight', fraction=0.046, pad=0.04)
+        cbar.ax.tick_params(labelsize=10)
+
+        plt.tight_layout()
+        plt.savefig(output_path, dpi=150, bbox_inches='tight')
+        plt.close()
+
+        print(f"  ✓ {output_path.name}")
+
+    def plot_frame_alignment(self, output_path):
+        """生成帧对齐可视化"""
+        try:
+            import matplotlib
+            matplotlib.use('Agg')
+            import matplotlib.pyplot as plt
+            import matplotlib.patches as patches
+            from matplotlib.gridspec import GridSpec
+        except ImportError:
+            print("  跳过对齐图: matplotlib未安装")
+            return
+
+        fig = plt.figure(figsize=(18, 8))
+        gs = GridSpec(3, 1, height_ratios=[4, 1, 0.5], hspace=0.4)
+
+        # === 上图: 词-帧对齐 ===
+        ax1 = fig.add_subplot(gs[0])
+
+        colors = plt.cm.tab20(np.linspace(0, 1, max(len(self.words), 20)))
+
+        for i, word_info in enumerate(self.word_frame_ranges):
+            start = word_info['start_frame']
+            end = word_info['end_frame']
+            word = word_info['word']
+            confidence = word_info['confidence']
+
+            # 根据置信度设置透明度
+            alpha = 0.9 if confidence == 'high' else 0.7 if confidence == 'medium' else 0.5
+
+            # 绘制矩形
+            rect = patches.Rectangle(
+                (start, i), end - start + 1, 0.8,
+                linewidth=2, edgecolor='black',
+                facecolor=colors[i % 20], alpha=alpha
+            )
+            ax1.add_patch(rect)
+
+            # 添加词标签
+            ax1.text(start + (end - start) / 2, i + 0.4, word,
+                    ha='center', va='center', fontsize=11,
+                    fontweight='bold', color='white',
+                    bbox=dict(boxstyle='round,pad=0.3', facecolor='black', alpha=0.5))
+
+            # 标记峰值帧
+            peak = word_info['peak_frame']
+            ax1.plot(peak, i + 0.4, 'r*', markersize=15, markeredgecolor='yellow',
+                    markeredgewidth=1.5)
+
+        ax1.set_xlim(-2, self.video_frames + 2)
+        ax1.set_ylim(-0.5, len(self.words))
+        ax1.set_xlabel('Video Frame Index', fontsize=13, fontweight='bold')
+        ax1.set_ylabel('Generated Word', fontsize=13, fontweight='bold')
+        ax1.set_title('Word-to-Frame Alignment\n(based on attention peaks, ★ = peak frame)',
+                     fontsize=15, pad=15, fontweight='bold')
+        ax1.grid(True, alpha=0.3, axis='x', linestyle='--')
+        ax1.set_yticks(range(len(self.words)))
+        ax1.set_yticklabels([w['word'] for w in self.word_frame_ranges], fontsize=10)
+
+        # === 中图: 时间线进度条 ===
+        ax2 = fig.add_subplot(gs[1])
+
+        # 背景
+        ax2.barh(0, self.video_frames, height=0.6, color='lightgray',
+                edgecolor='black', linewidth=2)
+
+        # 每个词的区域
+        for i, word_info in enumerate(self.word_frame_ranges):
+            start = word_info['start_frame']
+            end = word_info['end_frame']
+            confidence = word_info['confidence']
+            alpha = 0.9 if confidence == 'high' else 0.7 if confidence == 'medium' else 0.5
+
+            ax2.barh(0, end - start + 1, left=start, height=0.6,
+                    color=colors[i % 20], alpha=alpha, edgecolor='black', linewidth=0.5)
+
+        ax2.set_xlim(-2, self.video_frames + 2)
+        ax2.set_ylim(-0.4, 0.4)
+        ax2.set_xlabel('Frame Index', fontsize=12, fontweight='bold')
+        ax2.set_yticks([])
+        ax2.set_title('Timeline Progress Bar', fontsize=13, fontweight='bold')
+        ax2.grid(True, alpha=0.3, axis='x', linestyle='--')
+
+        # === 下图: 置信度图例 ===
+        ax3 = fig.add_subplot(gs[2])
+        ax3.axis('off')
+
+        legend_text = "Confidence:  ■ High (avg attn > 0.5)  ■ Medium (0.2-0.5)  ■ Low (< 0.2)"
+        ax3.text(0.5, 0.5, legend_text, ha='center', va='center',
+                fontsize=11, transform=ax3.transAxes)
+
+        plt.tight_layout()
+        plt.savefig(output_path, dpi=150, bbox_inches='tight')
+        plt.close()
+
+        print(f"  ✓ {output_path.name}")
+
+    def save_alignment_data(self, output_path):
+        """保存帧对齐数据为JSON"""
+        data = {
+            'translation': self.translation,
+            'words': self.words,
+            'total_video_frames': self.video_frames,
+            'frame_ranges': self.word_frame_ranges,
+            'statistics': {
+                'avg_confidence': np.mean([w['avg_attention'] for w in self.word_frame_ranges]),
+                'high_confidence_words': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'high'),
+                'medium_confidence_words': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'medium'),
+                'low_confidence_words': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'low'),
+            }
+        }
+
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        print(f"  ✓ {output_path.name}")
+
+    def save_text_report(self, output_path):
+        """保存文本格式的详细报告"""
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write("=" * 80 + "\n")
+            f.write("  Sign Language Recognition - Attention分析报告\n")
+            f.write("=" * 80 + "\n\n")
+
+            f.write(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+
+            f.write("翻译结果:\n")
+            f.write("-" * 80 + "\n")
+            f.write(f"{self.translation}\n\n")
+
+            f.write("视频信息:\n")
+            f.write("-" * 80 + "\n")
+            f.write(f"总帧数: {self.video_frames}\n")
+            f.write(f"词数量: {len(self.words)}\n\n")
+
+            f.write("Attention权重信息:\n")
+            f.write("-" * 80 + "\n")
+            f.write(f"形状: {self.attentions.shape}\n")
+            f.write(f"  - 解码步数: {self.attentions.shape[0]}\n")
+            if len(self.attentions.shape) >= 3:
+                f.write(f"  - Batch大小: {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("\n")
+
+            f.write("词-帧对应详情:\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")
+
+            for i, w in enumerate(self.word_frame_ranges):
+                frame_range = f"{w['start_frame']}-{w['end_frame']}"
+                f.write(f"{i+1:<5} {w['word']:<20} {frame_range:<15} "
+                       f"{w['peak_frame']:<8} {w['avg_attention']:<8.3f} {w['confidence']:<10}\n")
+
+            f.write("\n" + "=" * 80 + "\n")
+
+            # 统计信息
+            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'),
+                'medium': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'medium'),
+                'low': sum(1 for w in self.word_frame_ranges if w['confidence'] == 'low'),
+            }
+
+            f.write("\n统计摘要:\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("\n" + "=" * 80 + "\n")
+
+        print(f"  ✓ {output_path.name}")
+
+
+def analyze_from_numpy_file(attention_file, translation, video_frames, output_dir):
+    """
+    从numpy文件加载attention并分析
+
+    Args:
+        attention_file: .npy文件路径
+        translation: 翻译结果字符串
+        video_frames: 视频总帧数
+        output_dir: 输出目录
+    """
+    attentions = np.load(attention_file)
+    analyzer = AttentionAnalyzer(attentions, translation, video_frames)
+    analyzer.generate_all_visualizations(output_dir)
+    return analyzer

SignX/inference.sh

@@ -88,7 +88,8 @@ source "${CONDA_BASE}/etc/profile.d/conda.sh"
 
 # 临时目录
 TEMP_DIR=$(mktemp -d)
-trap "rm -rf $TEMP_DIR" EXIT
+# 不要在EXIT时删除，因为我们需要保存详细的attention分析结果
+# 我们将在脚本结束前手动清理不需要的部分
 
 echo -e "${BLUE}[1/2] 使用 SMKD 提取视频特征...${NC}"
 echo "  环境: signx-slt (PyTorch)"
@@ -180,6 +181,10 @@ fi
 
 export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
 
+# 获取输出目录（用于保存详细分析）
+OUTPUT_DIR=$(dirname "$OUTPUT_PATH")
+PREDICTION_TXT="$TEMP_DIR/prediction.txt"
+
 # 创建临时配置文件用于推理
 cat > "$TEMP_DIR/infer_config.py" <<EOF
 {
@@ -194,22 +199,25 @@ cat > "$TEMP_DIR/infer_config.py" <<EOF
     'src_codes': '$BPE_CODES',
     'tgt_codes': '$BPE_CODES',
     'output_dir': '$SLTUNET_CHECKPOINT',
-    'test_output': '$TEMP_DIR/prediction.txt',
+    'test_output': '$PREDICTION_TXT',
     'eval_batch_size': 1,
     'gpus': [0],
     'remove_bpe': True,
+    'collect_attention_weights': True,
 }
 EOF
 
 echo "  加载 SLTUNET 模型..."
 echo "  开始翻译..."
+echo ""
 
 cd "$SCRIPT_DIR"
 
+# 运行推理，保存完整输出以便后续检查详细分析
 python run.py \
     --mode test \
     --config "$TEMP_DIR/infer_config.py" \
-    2>&1 | grep -E "(Loading|Evaluating|BLEU|Scores|Error)" || true
+    2>&1 | tee "$TEMP_DIR/full_output.log" | grep -E "(Loading|Evaluating|BLEU|Scores|Saving detailed|Error)" || true
 
 if [ -f "$TEMP_DIR/prediction.txt" ]; then
     echo ""
@@ -222,6 +230,25 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
     # 移除BPE标记 (@@) 并保存清理后的版本
     sed 's/@@ //g' "$OUTPUT_PATH" > "$OUTPUT_PATH.clean"
 
+    # 检查并移动详细的attention分析结果
+    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}"
+        for detailed_dir in $DETAILED_DIRS; do
+            dir_name=$(basename "$detailed_dir")
+            dest_path="$OUTPUT_DIR/$dir_name"
+            mv "$detailed_dir" "$dest_path"
+            ATTENTION_ANALYSIS_DIR="$dest_path"
+
+            # 统计样本数量
+            sample_count=$(find "$dest_path" -maxdepth 1 -type d -name "sample_*" | wc -l)
+            echo "  ✓ 已保存 $sample_count 个样本的详细分析到: $dest_path"
+        done
+    fi
+
+    echo ""
     echo "======================================================================"
     echo "  推理成功！"
     echo "======================================================================"
@@ -229,6 +256,17 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
     echo "输出文件:"
     echo "  原始输出 (带BPE): $OUTPUT_PATH"
     echo "  清理后输出:       $OUTPUT_PATH.clean"
+
+    if [ ! -z "$ATTENTION_ANALYSIS_DIR" ]; then
+        echo "  详细分析目录:     $ATTENTION_ANALYSIS_DIR"
+        echo ""
+        echo "Attention分析包含:"
+        echo "  - 注意力权重热图 (attention_heatmap.png)"
+        echo "  - 词-帧对齐图 (word_frame_alignment.png)"
+        echo "  - 分析报告 (analysis_report.txt)"
+        echo "  - 原始数据 (attention_weights.npy)"
+    fi
+
     echo ""
     echo "识别结果 (移除BPE后):"
     echo "----------------------------------------------------------------------"
@@ -237,7 +275,15 @@ if [ -f "$TEMP_DIR/prediction.txt" ]; then
     echo ""
     echo -e "${GREEN}✓ 完整 Pipeline 执行成功 (SMKD → SLTUNET)${NC}"
     echo ""
+
+    # 清理临时目录
+    echo -e "${BLUE}清理临时文件...${NC}"
+    rm -rf "$TEMP_DIR"
+    echo "  ✓ 临时文件已清理"
+    echo ""
 else
     echo -e "${RED}错误: 推理失败，未生成输出文件${NC}"
+    # 清理临时目录
+    rm -rf "$TEMP_DIR"
     exit 1
 fi

SignX/inference_output.txt

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

SignX/inference_output.txt.clean

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

SignX/main.py

@@ -61,7 +61,10 @@ def tower_infer_graph(eval_features, graph, params):
         params.gpus, use_cpu=(len(params.gpus) == 0))
     eval_seqs, eval_scores = eval_outputs['seq'], eval_outputs['score']
 
-    return eval_seqs, eval_scores
+    # Extract attention history if available (for detailed analysis)
+    eval_attention = eval_outputs.get('attention_history', None)
+
+    return eval_seqs, eval_scores, eval_attention
 
 
 def train(params):
@@ -135,7 +138,7 @@ def train(params):
         tf.logging.info("Begin Building Inferring Graph")
 
         # set up infer graph
-        eval_seqs, eval_scores = tower_infer_graph(features, graph, params)
+        eval_seqs, eval_scores, _ = tower_infer_graph(features, graph, params)
 
         tf.logging.info(f"End Building Inferring Graph, within {time.time() - start_time} seconds")
 
@@ -448,7 +451,7 @@ def evaluate(params):
         graph = sltunet
 
         # set up infer graph
-        eval_seqs, eval_scores = tower_infer_graph(features, graph, params)
+        eval_seqs, eval_scores, eval_attention = tower_infer_graph(features, graph, params)
 
         tf.logging.info(f"End Building Inferring Graph, within {time.time() - start_time} seconds")
 
@@ -467,7 +470,7 @@ def evaluate(params):
 
         tf.logging.info("Starting Evaluating")
         eval_start_time = time.time()
-        tranes, scores, indices = evalu.decoding(sess, features, eval_seqs, eval_scores, test_dataset, params)
+        tranes, scores, indices, attentions = evalu.decoding(sess, features, eval_seqs, eval_scores, test_dataset, params, eval_attention)
         bleu = evalu.eval_metric(tranes, params.tgt_test_file, indices=indices, remove_bpe=params.remove_bpe)
         eval_end_time = time.time()
 
@@ -477,7 +480,7 @@ def evaluate(params):
         )
 
         # save translation
-        evalu.dump_tanslation(tranes, params.test_output, indices=indices)
+        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions)
 
     return bleu
 
@@ -541,7 +544,7 @@ def inference(params):
         graph = sltunet
 
         # set up infer graph
-        eval_seqs, eval_scores = tower_infer_graph(features, graph, params)
+        eval_seqs, eval_scores, eval_attention = tower_infer_graph(features, graph, params)
 
         tf.logging.info(f"End Building Inferring Graph, within {time.time() - start_time} seconds")
 
@@ -560,7 +563,7 @@ def inference(params):
 
         tf.logging.info("Starting Evaluating")
         eval_start_time = time.time()
-        tranes, scores, indices = evalu.decoding(sess, features, eval_seqs, eval_scores, test_dataset, params)
+        tranes, scores, indices, attentions = evalu.decoding(sess, features, eval_seqs, eval_scores, test_dataset, params, eval_attention)
         eval_end_time = time.time()
 
         tf.logging.info(
@@ -569,4 +572,4 @@ def inference(params):
         )
 
         # save translation
-        evalu.dump_tanslation(tranes, params.test_output, indices=indices)
+        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions)

SignX/models/evalu.py

@@ -46,11 +46,16 @@ def decode_hypothesis(seqs, scores, params, mask=None):
     return hypoes, marks
 
 
-def decoding(session, features, out_seqs, out_scores, dataset, params):
+def decoding(session, features, out_seqs, out_scores, dataset, params, out_attention=None):
     """Performing decoding with exising information"""
+    tf.logging.info(f"[DEBUG] decoding called with out_attention={out_attention is not None}")
+    if out_attention is not None:
+        tf.logging.info(f"[DEBUG] out_attention type: {type(out_attention)}")
+
     translations = []
     scores = []
     indices = []
+    attentions = [] if out_attention is not None else None
 
     eval_queue = queuer.EnQueuer(
         dataset.batcher(params.eval_batch_size,
@@ -84,14 +89,31 @@ def decoding(session, features, out_seqs, out_scores, dataset, params):
         valid_out_seqs = out_seqs[:data_size]
         valid_out_scores = out_scores[:data_size]
 
-        _decode_seqs, _decode_scores = session.run(
-            [valid_out_seqs, valid_out_scores], feed_dict=feed_dicts)
+        # Prepare outputs to fetch
+        fetch_list = [valid_out_seqs, valid_out_scores]
+        if out_attention is not None:
+            valid_out_attention = out_attention[:data_size]
+            fetch_list.append(valid_out_attention)
+
+        # Run session
+        fetch_results = session.run(fetch_list, feed_dict=feed_dicts)
+        _decode_seqs, _decode_scores = fetch_results[0], fetch_results[1]
+        _decode_attention = fetch_results[2] if out_attention is not None else None
+
+        # DEBUG: Check what we got from session.run
+        if _decode_attention is not None and bidx == 0:  # Only log first batch to avoid spam
+            tf.logging.info(f"[DEBUG] _decode_attention type: {type(_decode_attention)}")
+            if isinstance(_decode_attention, list):
+                tf.logging.info(f"[DEBUG] _decode_attention is list, len: {len(_decode_attention)}")
+                for i, item in enumerate(_decode_attention):
+                    if item is not None:
+                        tf.logging.info(f"[DEBUG]   item[{i}] type: {type(item)}, shape: {item.shape if hasattr(item, 'shape') else 'no shape'}")
 
         _step_translations, _step_scores = decode_hypothesis(
             _decode_seqs, _decode_scores, params
         )
 
-        return _step_translations, _step_scores, _step_indices
+        return _step_translations, _step_scores, _step_indices, _decode_attention
 
     very_begin_time = time.time()
     data_on_gpu = []
@@ -112,6 +134,8 @@ def decoding(session, features, out_seqs, out_scores, dataset, params):
         translations.extend(step_outputs[0])
         scores.extend(step_outputs[1])
         indices.extend(step_outputs[2])
+        if attentions is not None and step_outputs[3] is not None:
+            attentions.append(step_outputs[3])
 
         tf.logging.info(
             "Decoding Batch {} using {:.3f} s, translating {} "
@@ -129,6 +153,8 @@ def decoding(session, features, out_seqs, out_scores, dataset, params):
         translations.extend(step_outputs[0])
         scores.extend(step_outputs[1])
         indices.extend(step_outputs[2])
+        if attentions is not None and step_outputs[3] is not None:
+            attentions.append(step_outputs[3])
 
         tf.logging.info(
             "Decoding Batch {} using {:.3f} s, translating {} "
@@ -138,7 +164,7 @@ def decoding(session, features, out_seqs, out_scores, dataset, params):
             )
         )
 
-    return translations, scores, indices
+    return translations, scores, indices, attentions
 
 
 def eval_metric(trans, target_file, indices=None, remove_bpe=False):
@@ -172,7 +198,7 @@ def eval_metric(trans, target_file, indices=None, remove_bpe=False):
     return metric.bleu(trans, references)
 
 
-def dump_tanslation(tranes, output, indices=None):
+def dump_tanslation(tranes, output, indices=None, attentions=None):
     """save translation"""
     if indices is not None:
         tranes = [data[1] for data in
@@ -185,6 +211,23 @@ def dump_tanslation(tranes, output, indices=None):
                 writer.write(str(hypo) + "\n")
     tf.logging.info("Saving translations into {}".format(output))
 
+    # DEBUG: Check attention status
+    tf.logging.info(f"[DEBUG] attentions is None: {attentions is None}")
+    if attentions is not None:
+        tf.logging.info(f"[DEBUG] attentions type: {type(attentions)}, len: {len(attentions)}")
+
+    # Save detailed attention analysis if available
+    if attentions is not None and len(attentions) > 0:
+        tf.logging.info("[DEBUG] Calling dump_detailed_attention_output")
+        try:
+            dump_detailed_attention_output(tranes, output, indices, attentions)
+        except Exception as e:
+            tf.logging.warning(f"Failed to save detailed attention output: {e}")
+            import traceback
+            tf.logging.warning(traceback.format_exc())
+    else:
+        tf.logging.info("[DEBUG] Skipping attention analysis (attentions is None or empty)")
+
 
 def dump_translation_with_reference(tranes, output, ref_file, indices=None, remove_bpe=False):
     """Save translation with reference for easy comparison"""
@@ -234,3 +277,140 @@ def dump_translation_with_reference(tranes, output, ref_file, indices=None, remo
             writer.write("-" * 100 + "\n\n")
 
     tf.logging.info("Saving comparison into {}".format(comparison_file))
+
+
+def dump_detailed_attention_output(tranes, output, indices, attentions):
+    """
+    保存详细的attention分析结果
+
+    Args:
+        tranes: 翻译结果列表
+        output: 输出文件路径
+        indices: 样本索引
+        attentions: attention权重数据（list of numpy arrays）
+    """
+    import os
+    import sys
+    from datetime import datetime
+    from pathlib import Path
+
+    # 获取输出目录和文件名
+    output_path = Path(output)
+    base_dir = output_path.parent
+    base_name = output_path.stem  # 不带扩展名
+
+    # 创建带时间戳的详细分析目录
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    detail_dir = base_dir / f"detailed_{base_name}_{timestamp}"
+    detail_dir.mkdir(parents=True, exist_ok=True)
+
+    tf.logging.info(f"Saving detailed attention analysis to: {detail_dir}")
+
+    # 重排序翻译结果
+    if indices is not None:
+        sorted_items = sorted(zip(indices, tranes), key=lambda x: x[0])
+        tranes = [item[1] for item in sorted_items]
+
+    # 合并所有batch的attention数据
+    # attentions是list，每个元素shape: [time, batch, beam, src_len]
+    try:
+        import numpy as np
+
+        # 连接所有batch
+        if len(attentions) > 0:
+            # DEBUG: Check what we received
+            tf.logging.info(f"[DEBUG] attentions list length: {len(attentions)}")
+            for i, attn_batch in enumerate(attentions):
+                tf.logging.info(f"[DEBUG] attentions[{i}]: type={type(attn_batch)}, is None={attn_batch is None}")
+                if attn_batch is not None:
+                    tf.logging.info(f"[DEBUG]   isinstance numpy: {isinstance(attn_batch, np.ndarray)}")
+                    if hasattr(attn_batch, 'shape'):
+                        tf.logging.info(f"[DEBUG]   shape: {attn_batch.shape if isinstance(attn_batch, np.ndarray) else 'no shape'}")
+
+            # 检查是否所有元素都是numpy array
+            # Note: Each element in attentions is a list (one per GPU), so we need to extract from it
+            all_attentions = []
+            for attn_batch in attentions:
+                if attn_batch is not None:
+                    # Handle both list (multi-GPU) and numpy array (already processed) cases
+                    if isinstance(attn_batch, list):
+                        # Extract first element (GPU 0's result)
+                        if len(attn_batch) > 0 and isinstance(attn_batch[0], np.ndarray):
+                            all_attentions.append(attn_batch[0])
+                    elif isinstance(attn_batch, np.ndarray):
+                        all_attentions.append(attn_batch)
+
+            if len(all_attentions) == 0:
+                tf.logging.warning("No valid attention data found")
+                return
+
+            tf.logging.info(f"[DEBUG] Found {len(all_attentions)} valid attention batches")
+
+            # 保存每个样本的详细分析
+            sample_idx = 0
+            for batch_attn in all_attentions:
+                # batch_attn shape: [time, batch_size, beam, src_len]
+                batch_size = batch_attn.shape[1]
+
+                for i in range(batch_size):
+                    if sample_idx >= len(tranes):
+                        break
+
+                    # 提取该样本的attention
+                    sample_attn = batch_attn[:, i, :, :]  # [time, beam, src_len]
+
+                    # 获取翻译结果
+                    trans = tranes[sample_idx]
+                    if isinstance(trans, list):
+                        trans = ' '.join(trans)
+                    trans_clean = trans.replace('@@ ', '')  # 移除BPE标记
+
+                    # 创建样本专属目录
+                    sample_dir = detail_dir / f"sample_{sample_idx:03d}"
+                    sample_dir.mkdir(exist_ok=True)
+
+                    # 保存numpy数据
+                    np.save(sample_dir / "attention_weights.npy", sample_attn)
+
+                    # 保存翻译结果
+                    with open(sample_dir / "translation.txt", 'w', encoding='utf-8') as f:
+                        f.write(f"With BPE: {trans}\n")
+                        f.write(f"Clean: {trans_clean}\n")
+
+                    # 使用attention_analysis模块生成可视化
+                    try:
+                        # 添加eval目录到路径
+                        script_dir = Path(__file__).parent.parent
+                        eval_dir = script_dir / "eval"
+                        if str(eval_dir) not in sys.path:
+                            sys.path.insert(0, str(eval_dir))
+
+                        from attention_analysis import AttentionAnalyzer
+
+                        # 估计视频帧数（从attention的src_len维度）
+                        video_frames = sample_attn.shape[2]
+
+                        # 创建分析器并生成可视化
+                        analyzer = AttentionAnalyzer(
+                            attentions=sample_attn,
+                            translation=trans_clean,
+                            video_frames=video_frames
+                        )
+
+                        analyzer.generate_all_visualizations(sample_dir)
+
+                        tf.logging.info(f"  ✓ Sample {sample_idx}: {sample_dir.name}")
+
+                    except Exception as e:
+                        tf.logging.warning(f"Failed to generate visualizations for sample {sample_idx}: {e}")
+
+                    sample_idx += 1
+
+            tf.logging.info(f"Detailed attention analysis complete: {detail_dir}")
+            tf.logging.info(f"  - Analyzed {sample_idx} samples")
+            tf.logging.info(f"  - Output directory: {detail_dir}")
+
+    except Exception as e:
+        import traceback
+        tf.logging.error(f"Error in dump_detailed_attention_output: {e}")
+        tf.logging.error(traceback.format_exc())

SignX/models/search.py

@@ -12,7 +12,7 @@ from tensorflow.python.util import nest
 
 
 class BeamSearchState(namedtuple("BeamSearchState",
-                                 ("inputs", "state", "finish"))):
+                                 ("inputs", "state", "finish", "attention_history"))):
     pass
 
 
@@ -24,6 +24,10 @@ def beam_search(features, encoding_fn, decoding_fn, params):
     pad_id = params.tgt_vocab.pad()
     eval_task = params.eval_task
 
+    # Check if attention collection is enabled
+    collect_attention = getattr(params, 'collect_attention_weights', False)
+    tf.logging.info(f"[DEBUG] beam_search: collect_attention_weights={collect_attention}")
+
     batch_size = tf.shape(features["image"])[0]
     beam_i32 = tf.constant(beam_size, dtype=tf.int32)
     one_i32 = tf.constant(1, dtype=tf.int32)
@@ -80,10 +84,26 @@ def beam_search(features, encoding_fn, decoding_fn, params):
 
     model_state = cache_init(init_seq, model_state)
 
+    # Remove cross_attention from initial state (it's not part of the recurrent state)
+    # It will be computed fresh at each step and collected separately
+    if 'cross_attention' in model_state:
+        model_state = {k: v for k, v in model_state.items() if k != 'cross_attention'}
+
+    # Always initialize attention history TensorArray (for while_loop compatibility)
+    # But only write to it if collection is enabled
+    init_attention_history = tf.TensorArray(
+        dtype=tfdtype,
+        size=0,
+        dynamic_size=True,
+        clear_after_read=False,
+        element_shape=tf.TensorShape([None, None, None])  # [batch, beam, src_len]
+    )
+
     bsstate = BeamSearchState(
         inputs=(init_seq, init_log_probs, init_scores),
         state=model_state,
-        finish=(init_finish_seq, init_finish_scores, init_finish_flags)
+        finish=(init_finish_seq, init_finish_scores, init_finish_flags),
+        attention_history=init_attention_history
     )
 
     def _not_finished(time, bsstate):
@@ -201,6 +221,21 @@ def beam_search(features, encoding_fn, decoding_fn, params):
         )
         alive_log_probs = alive_scores * length_penality
 
+        # Collect cross-attention weights if collection is enabled
+        # Also remove cross_attention from alive_state to maintain consistent structure
+        updated_attention_history = bsstate.attention_history
+        if 'cross_attention' in alive_state:
+            if collect_attention:
+                # step_state['cross_attention']: [batch, beam, 1, src_len] (already unmerged)
+                # Squeeze the tgt_len dimension: [batch, beam, src_len]
+                attention_weights = step_state['cross_attention'][:, :, 0, :]
+                # Reorder according to alive beams
+                attention_weights = tf.gather_nd(attention_weights, beam_coordinates)
+                # Write to TensorArray
+                updated_attention_history = bsstate.attention_history.write(time, attention_weights)
+            # Remove cross_attention from alive_state (not part of recurrent state)
+            alive_state = {k: v for k, v in alive_state.items() if k != 'cross_attention'}
+
         # 4. handle finished sequences
         # reducing 3 * beam to beam
         prev_fin_seq, prev_fin_scores, prev_fin_flags = bsstate.finish
@@ -222,7 +257,8 @@ def beam_search(features, encoding_fn, decoding_fn, params):
         next_state = BeamSearchState(
             inputs=(alive_seq, alive_log_probs, alive_scores),
             state=alive_state,
-            finish=(fin_seq, fin_scores, fin_flags)
+            finish=(fin_seq, fin_scores, fin_flags),
+            attention_history=updated_attention_history
         )
 
         return time + 1, next_state
@@ -238,7 +274,8 @@ def beam_search(features, encoding_fn, decoding_fn, params):
         ),
         finish=(tf.TensorShape([None, None, None]),
                 tf.TensorShape([None, None]),
-                tf.TensorShape([None, None]))
+                tf.TensorShape([None, None])),
+        attention_history=tf.TensorShape(None)  # TensorArray shape
     )
     outputs = tf.while_loop(_not_finished, _step_fn, [time, bsstate],
                             shape_invariants=[tf.TensorShape([]),
@@ -261,7 +298,16 @@ def beam_search(features, encoding_fn, decoding_fn, params):
     final_scores = tf.where(tf.reduce_any(final_flags, 1), final_scores,
                             init_scores)
 
-    return {
+    result = {
         'seq': final_seqs[:, :, 1:],
         'score': final_scores
     }
+
+    # Only include attention history if collection was enabled
+    if collect_attention:
+        # Stack attention history from TensorArray
+        # Returns [time_steps, batch, beam, src_len]
+        attention_history_tensor = final_state.attention_history.stack()
+        result['attention_history'] = attention_history_tensor
+
+    return result

SignX/models/sltunet.py

@@ -117,12 +117,15 @@ def encoder(source, mask, params, in_text=False, to_gloss=False):
     }
 
 
-def decoder(target, state, params, labels=None, is_img=None):
+def decoder(target, state, params, labels=None, is_img=None, collect_attention=False):
     mask = dtype.tf_to_float(tf.cast(target, tf.bool))
     hidden_size = params.hidden_size
     initializer = tf.random_normal_initializer(0.0, hidden_size ** -0.5)
     is_training = ('decoder' not in state)
 
+    # Collect cross-attention weights for analysis (only during inference)
+    cross_attention_weights = [] if (collect_attention and not is_training) else None
+
     embed_name = "embedding" if params.shared_source_target_embedding \
         else "tgt_embedding"
     tgt_emb = tf.get_variable(embed_name,
@@ -192,6 +195,12 @@ def decoder(target, state, params, labels=None, is_img=None):
                         # mk, mv
                         state['decoder']['state']['layer_{}'.format(layer)].update(y['cache'])
 
+                    # Collect cross-attention weights (last layer only, averaged over heads)
+                    if cross_attention_weights is not None and layer == params.num_decoder_layer - 1:
+                        # y['weights']: [batch, num_heads, tgt_len, src_len]
+                        # Average over heads: [batch, tgt_len, src_len]
+                        cross_attention_weights.append(tf.reduce_mean(y['weights'], axis=1))
+
                     y = y['output']
                     x = func.residual_fn(x, y, dropout=params.residual_dropout)
                     x = func.layer_norm(x)
@@ -265,6 +274,11 @@ def decoder(target, state, params, labels=None, is_img=None):
 
         loss = params.ctc_alpha * ctc_loss + loss
 
+    # Return attention weights if collected
+    if cross_attention_weights is not None and len(cross_attention_weights) > 0:
+        # Shape: [batch, 1, src_len] (only last token's attention)
+        state['cross_attention'] = cross_attention_weights[0]
+
     return loss, logits, state, per_sample_loss
 
 
@@ -345,8 +359,10 @@ def infer_fn(params):
                                dtype=tf.as_dtype(dtype.floatx()),
                                custom_getter=dtype.float32_variable_storage_getter):
             state['time'] = time
+            # Enable attention collection if requested via params
+            collect_attn = getattr(params, 'collect_attention_weights', False)
             step_loss, step_logits, step_state, _ = decoder(
-                target, state, params)
+                target, state, params, collect_attention=collect_attn)
             del state['time']
 
             return step_logits, step_state

SignX/run.py

@@ -30,13 +30,16 @@ global_params = tc.training.HParams(
     shared_source_target_embedding=False,
     # whether share target and softmax word embedding
     shared_target_softmax_embedding=True,
-    
+
     # sign embedding yaml config
     sign_cfg='',
     # sign gloss dict path
     gloss_path='',
     smkd_model_path='',
 
+    # collect attention weights during inference for detailed analysis
+    collect_attention_weights=False,  # Disabled by default, enable when needed
+
     # separately encoding textual and sign video until `sep_layer`
     sep_layer=0,
     # source/target BPE codes and dropout rate => used for BPE-dropout
@@ -340,6 +343,10 @@ def main(_):
     # print parameters
     print_parameters(params)
 
+    # DEBUG: Check collect_attention_weights
+    collect_attn = getattr(params, 'collect_attention_weights', None)
+    tf.logging.info(f"[DEBUG] params.collect_attention_weights = {collect_attn}")
+
     # set up the default datatype
     dtype.set_floatx(params.default_dtype)
     dtype.set_epsilon(params.dtype_epsilon)