Add frame-annotated gloss files and documentation

- Generated ASLLRP_utterances_with_frames.json with precise frame numbers for each gloss
- Added comprehensive documentation for ASLLRP dataset structure and usage
- Updated .gitignore to exclude xlsx files (using CSV instead)
- Moved analysis scripts to SignX/doc/ directory

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -8,4 +8,4 @@
 .vscode
 .envrc
 *.jpg
-*.npz
+*.npz*.xlsx

SignX/doc/ASLLRP_DATA_STRUCTURE.md

@@ -0,0 +1,237 @@
+# ASLLRP 数据集结构说明
+
+## 概述
+这是ASLLRP数据集的处理后数据，包含2108个手语utterance（句子）的视频、帧、姿态估计和精确的时间标注。
+
+## 数据文件结构
+
+### 1. ASLLRP_utterances_mapping.txt
+**作用**: 每个视频utterance对应的gloss序列（简化标注）
+
+**格式**:
+```
+视频ID: GLOSS1 GLOSS2 GLOSS3 ...
+```
+
+**示例**:
+```
+10006709: THAT AMONG DIFFERENT KIND VARY BELONG MEAN FOR VOICE IX INCLUDE/INVOLVE OTHER VARY BELONG WITH FOCUS/NARROW "WHAT" NOT OF-COURSE
+```
+
+**统计**:
+- 总共2108个utterance
+- 每个utterance包含5-25个gloss不等
+
+---
+
+### 2. asllrp_sentence_signs_2025_06_28.csv
+**作用**: 精确标注每个sign（手语词）的时间、手型等详细信息
+
+**重要列**:
+| 列名 | 说明 | 示例 |
+|------|------|------|
+| Video ID number | Sign的唯一ID | 384585 |
+| Main entry gloss label | 主要的gloss标签 | THAT |
+| **Start frame of the sign video** | Sign的开始帧号 | 2409 |
+| **End frame of the sign video** | Sign的结束帧号 | 2413 |
+| **Start frame of the containing utterance** | 整个句子的开始帧 | 2400 |
+| **End frame of the containing utterance** | 整个句子的结束帧 | 2680 |
+| Dominant start handshape | 主手的起始手型 | Y |
+| Non-dominant start handshape | 副手的起始手型 | - |
+| **Utterance video filename** | 对应的视频文件名 | 10006709.mp4 |
+| Sign type | Sign的类型 | Lexical Signs |
+| Master video filename | 原始视频文件名 | 3-Voice-Life.mov |
+
+**统计**:
+- 总共17,522个sign标注
+- 覆盖2,130个不同的utterance视频
+
+**CSV文件的关键用途**:
+1. **精确的时间对齐**: 可以根据帧号从视频中提取特定sign的片段
+2. **Sign级别的分析**: 每个sign的详细语言学特征（手型、类型等）
+3. **Utterance级别的上下文**: 了解整个句子的范围
+
+---
+
+### 3. ASLLRP_utterances_results/
+**作用**: 每个视频utterance的处理结果（裁剪视频、帧、姿态估计）
+
+**目录结构**:
+```
+ASLLRP_utterances_results/
+├── 10006709/
+│   ├── crop_frame/              # 裁剪后的视频帧
+│   │   ├── 00000001.jpg
+│   │   ├── 00000002.jpg
+│   │   └── ... (224帧)
+│   ├── crop_original_video.mp4   # 裁剪后的视频
+│   └── results_dwpose/           # DWPose姿态估计结果
+│       └── npz/
+│           ├── 00000001.npz
+│           ├── 00000002.npz
+│           └── ... (224个npz文件)
+├── 10036884/
+│   └── ...
+└── ... (2124个文件夹)
+```
+
+**统计**:
+- 总共2,124个视频文件夹
+- 每个文件夹包含：
+  - 约224帧裁剪图片
+  - 1个裁剪视频（约0.2-0.5 MB）
+  - 224个DWPose姿态估计文件
+
+---
+
+## 数据之间的对应关系
+
+```
+ASLLRP_utterances_mapping.txt          asllrp_sentence_signs_2025_06_28.csv
+        ↓                                           ↓
+    10006709: THAT AMONG ...          "10006709.mp4", THAT, 2409, 2413, ...
+                                       "10006709.mp4", AMONG, 2427, 2432, ...
+        ↓                                           ↓
+                    ASLLRP_utterances_results/10006709/
+                            ├── crop_frame/
+                            ├── crop_original_video.mp4
+                            └── results_dwpose/
+```
+
+**关系说明**:
+1. `mapping.txt` 中的视频ID (如 `10006709`) 对应
+2. `csv文件` 中的 `Utterance video filename` (如 `10006709.mp4`)
+3. `results目录` 中的文件夹名 (如 `10006709/`)
+
+---
+
+## 如何使用这些数据
+
+### 用例1: 提取特定utterance的所有signs及其时间
+
+```python
+import csv
+
+def get_signs_for_utterance(utterance_id):
+    """提取一个utterance中所有signs的信息"""
+    csv_file = "asllrp_sentence_signs_2025_06_28.csv"
+
+    signs = []
+    with open(csv_file, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            if row['Utterance video filename'] == f"{utterance_id}.mp4":
+                signs.append({
+                    'gloss': row['Main entry gloss label'],
+                    'start_frame': int(row['Start frame of the sign video']),
+                    'end_frame': int(row['End frame of the sign video']),
+                    'sign_type': row['Sign type']
+                })
+
+    return signs
+
+# 示例
+signs = get_signs_for_utterance("10006709")
+print(f"共{len(signs)}个signs:")
+for sign in signs:
+    duration = sign['end_frame'] - sign['start_frame']
+    print(f"  {sign['gloss']}: 帧{sign['start_frame']}-{sign['end_frame']} (持续{duration}帧)")
+```
+
+### 用例2: 从视频中提取特定sign的片段
+
+```python
+import cv2
+
+def extract_sign_frames(utterance_id, gloss, start_frame, end_frame):
+    """从裁剪视频中提取特定sign的帧"""
+    video_path = f"ASLLRP_utterances_results/{utterance_id}/crop_original_video.mp4"
+
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+
+    cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+    for i in range(start_frame, end_frame + 1):
+        ret, frame = cap.read()
+        if ret:
+            frames.append(frame)
+
+    cap.release()
+    return frames
+```
+
+### 用例3: 加载DWPose姿态估计数据
+
+```python
+import numpy as np
+
+def load_dwpose_for_frame(utterance_id, frame_num):
+    """加载特定帧的DWPose姿态估计"""
+    npz_path = f"ASLLRP_utterances_results/{utterance_id}/results_dwpose/npz/{frame_num:08d}.npz"
+
+    # 需要allow_pickle=True来读取包含对象的npz文件
+    data = np.load(npz_path, allow_pickle=True)
+
+    return data
+```
+
+---
+
+## CSV文件中的帧号说明
+
+**重要**: CSV文件中的帧号是相对于**原始master视频**的帧号，而不是裁剪后视频的帧号。
+
+- **原始视频**: `Master video filename` (如 `3-Voice-Life.mov`)
+- **Utterance范围**: 帧2400-2680（相对于原始视频）
+- **Sign范围**: 帧2409-2413（相对于原始视频）
+
+**如果要使用裁剪后的视频**:
+```python
+# 计算相对于裁剪视频的帧号
+utterance_start = 2400  # 从CSV获取
+sign_start = 2409       # 从CSV获取
+
+# 裁剪视频中的帧号 = sign帧号 - utterance开始帧号
+cropped_frame_num = sign_start - utterance_start  # = 9
+```
+
+---
+
+## 数据总结
+
+| 项目 | 数量 |
+|------|------|
+| Utterance视频 | 2,108-2,130个 |
+| Sign标注 | 17,522个 |
+| 总帧数 | ~470,000帧 (2124 × 224) |
+| 总视频大小 | ~500 MB |
+| DWPose文件 | ~470,000个npz文件 |
+
+---
+
+## 训练建议
+
+基于这些数据，你可以进行：
+
+1. **Sign级别识别**: 使用CSV中的精确时间标注训练单个sign的识别模型
+2. **Utterance级别翻译**: 使用整个utterance的视频和gloss序列训练翻译模型
+3. **姿态驱动的手语生成**: 使用DWPose数据训练姿态估计或生成模型
+4. **时间对齐研究**: 研究sign的时间边界和持续时间模式
+
+---
+
+## 常见问题
+
+**Q: 为什么mapping.txt有2108个条目，而CSV显示2130个视频？**
+A: 可能有些utterance没有被包含在mapping.txt中，或者CSV包含了一些额外的变体。
+
+**Q: DWPose npz文件包含什么数据？**
+A: 包含姿态关键点、骨架信息等，需要使用`allow_pickle=True`读取。
+
+**Q: 如何知道每个视频的帧率？**
+A: 需要从原始视频metadata中获取，或者假设标准帧率（通常是25或30 FPS）。
+
+---
+
+生成日期: 2025-12-27
+作者: Claude Code

SignX/doc/FPS_AND_FRAME_NUMBERS.md

@@ -0,0 +1,154 @@
+# ASLLRP 数据集 FPS 和帧号说明
+
+## 重要发现
+
+### 1. 帧率信息
+- **CSV文件中的帧号**: 基于原始视频的**30 FPS** (ASLLRP原始数据集标准)
+- **裁剪视频的帧率**: **24 FPS** (处理时可能重新编码)
+- **crop_frame图片数量**: 与裁剪视频帧数一致
+
+### 2. 帧数不匹配问题
+
+以 `10006709` 为例：
+
+| 项目 | 值 | 说明 |
+|------|-----|------|
+| CSV中utterance帧范围 | 2400-2680 | 280帧 (@ 30 FPS = 9.33秒) |
+| 裁剪视频实际帧数 | 224帧 | @ 24 FPS = 9.33秒 |
+| 裁剪视频时长 | 9.33秒 | 与CSV一致 |
+| CSV最后一个sign帧号 | 2659-2668 | 相对起始点259-268 |
+
+**关键问题**: CSV中的帧号(相对于utterance起始)最大到268，但裁剪视频只有224帧！
+
+### 3. 帧号转换公式
+
+#### 情况A: CSV帧号是30 FPS，裁剪视频是24 FPS
+
+```python
+# CSV中的帧号（30 FPS）转换为裁剪视频帧号（24 FPS）
+csv_frame = 2409  # CSV中的sign开始帧
+utterance_start = 2400  # CSV中的utterance开始帧
+
+# 转换步骤：
+# 1. 计算相对于utterance的帧号（30 FPS）
+relative_frame_30fps = csv_frame - utterance_start  # 2409 - 2400 = 9
+
+# 2. 转换FPS: 30 FPS -> 24 FPS
+relative_frame_24fps = int(relative_frame_30fps * 24 / 30)  # 9 * 0.8 = 7.2 ≈ 7
+
+# 3. 在裁剪视频中对应第7帧（从0开始计数）
+```
+
+#### 情况B: 裁剪视频被截断了
+
+另一种可能是裁剪视频在处理过程中被截断，只保留了前224帧：
+
+```python
+# 直接使用相对帧号，但注意边界
+csv_frame = 2659  # 最后一个sign
+relative_frame = csv_frame - utterance_start  # 259
+
+# 警告：超出裁剪视频范围(224帧)！
+if relative_frame >= 224:
+    print("警告：此sign的帧号超出裁剪视频范围！")
+```
+
+## 实际使用建议
+
+### 使用 crop_frame 图片
+
+如果使用 `crop_frame/` 中的图片（最可靠）：
+
+```python
+import csv
+
+def get_sign_frames_from_images(utterance_id, gloss):
+    """从图片文件夹提取sign的帧"""
+    csv_file = 'asllrp_sentence_signs_2025_06_28.csv'
+
+    with open(csv_file, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            if row['Utterance video filename'] == f"{utterance_id}.mp4" and \
+               row['Main entry gloss label'] == gloss:
+
+                utterance_start = int(row['Start frame of the containing utterance'])
+                sign_start = int(row['Start frame of the sign video'])
+                sign_end = int(row['End frame of the sign video'])
+
+                # 方法1: 假设是30 FPS -> 24 FPS转换
+                start_24fps = int((sign_start - utterance_start) * 24 / 30)
+                end_24fps = int((sign_end - utterance_start) * 24 / 30)
+
+                # 方法2: 直接使用相对帧号（如果CSV也是24 FPS）
+                # start_frame = sign_start - utterance_start
+                # end_frame = sign_end - utterance_start
+
+                # 加载对应的图片
+                image_dir = f"ASLLRP_utterances_results/{utterance_id}/crop_frame"
+                frames = []
+                for i in range(start_24fps, min(end_24fps + 1, 224)):  # 限制在224帧内
+                    img_path = f"{image_dir}/{i+1:08d}.jpg"  # 图片从00000001.jpg开始
+                    frames.append(img_path)
+
+                return frames
+```
+
+### 使用裁剪视频
+
+```python
+import cv2
+
+def extract_from_cropped_video(utterance_id, start_frame_24fps, end_frame_24fps):
+    """从裁剪视频提取帧"""
+    video_path = f"ASLLRP_utterances_results/{utterance_id}/crop_original_video.mp4"
+
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)  # 应该是24
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))  # 224
+
+    print(f"视频FPS: {fps}, 总帧数: {total_frames}")
+
+    frames = []
+    for frame_num in range(start_frame_24fps, min(end_frame_24fps + 1, total_frames)):
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+        ret, frame = cap.read()
+        if ret:
+            frames.append(frame)
+
+    cap.release()
+    return frames
+```
+
+## 测试验证
+
+```bash
+cd /research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo
+
+# 验证视频帧率
+ffprobe -v error -select_streams v:0 -show_entries stream=r_frame_rate \
+  ASLLRP_utterances_results/10006709/crop_original_video.mp4
+
+# 验证视频帧数
+ffprobe -v error -select_streams v:0 -show_entries stream=nb_frames \
+  ASLLRP_utterances_results/10006709/crop_original_video.mp4
+
+# 验证图片数量
+ls ASLLRP_utterances_results/10006709/crop_frame/*.jpg | wc -l
+```
+
+## 总结
+
+1. **CSV帧号**: 基于原始ASLLRP视频（可能是30 FPS）
+2. **裁剪视频**: 24 FPS，但帧数少于CSV显示的范围
+3. **建议**: 优先使用 `crop_frame/` 图片，它们的数量(224)是确定的
+4. **转换**: 使用 `csv_frame * 24/30` 来转换帧号（需要验证）
+
+## 未解决的问题
+
+- [ ] 确认CSV中的帧号是30 FPS还是24 FPS
+- [ ] 为什么裁剪视频���有224帧而不是280帧？
+- [ ] crop_frame的图片编号(00000001-00000224)如何对应CSV的帧号？
+- [ ] 是否所有utterance都有这个问题？
+
+建议检查多个视频来确认FPS转换规则！

SignX/doc/README.md

@@ -0,0 +1,221 @@
+# ASLLRP 数据集说明
+
+## 数据概览
+
+这个目录包含ASLLRP手语数据集的处理后数据：
+
+- **2,108个** 手语utterance（句子）视频
+- **17,522个** sign（手语词）的精确标注
+- **~470,000帧** 视频帧和DWPose姿态估计
+
+## 文件结构
+
+```
+huggingface_asllrp_repo/
+├── ASLLRP_utterances_mapping.txt       # 每个视频对应的gloss序列（原始）
+├── ASLLRP_utterances_with_frames.json  # 带帧号的gloss数据（JSON，推荐）★
+├── ASLLRP_utterances_with_frames.txt   # 带帧号的gloss数据（可读文本）
+├── ASLLRP_utterances_compact_frames.txt # 带帧号的gloss数据（紧凑格式）
+├── asllrp_sentence_signs_2025_06_28.csv # 每个sign的精确时间和手型标注
+├── ASLLRP_utterances_results/           # 处理后的视频和姿态数据
+│   ├── 10006709/
+│   │   ├── crop_frame/                  # 裁剪后的视频帧（JPG）
+│   │   ├── crop_original_video.mp4      # 裁剪后的视频（24 FPS）
+│   │   └── results_dwpose/npz/          # DWPose姿态估计（NPZ）
+│   └── ...
+├── ASLLRP_DATA_STRUCTURE.md            # 详细的数据结构说明
+├── FPS_AND_FRAME_NUMBERS.md            # FPS和帧号转换说明
+├── analyze_asllrp_data.py              # 数据分析脚本
+├── query_asllrp_data.py                # 数据查询工具
+└── generate_gloss_with_frames.py       # 生成带帧号的gloss数据
+```
+
+## 快速使用
+
+### 1. 查询特定视频的信息
+
+```bash
+python query_asllrp_data.py --utterance 10006709
+```
+
+输出示例：
+```
+Utterance ID: 10006709
+Gloss序列 (19个): THAT AMONG DIFFERENT KIND VARY ...
+Utterance帧范围: 2400 - 2680 (总共280帧)
+
+详细Signs列表:
+序号  Gloss            原始视频帧范围    裁剪视频帧范围    类型
+1     THAT             2409-2413 (4帧)   9-13              Lexical Signs
+2     AMONG            2427-2432 (5帧)   27-32             Lexical Signs
+...
+```
+
+### 2. 搜索特定的gloss
+
+```bash
+python query_asllrp_data.py --search THAT
+```
+
+### 3. 查看数据集统计
+
+```bash
+python query_asllrp_data.py --list
+```
+
+输出示例：
+```
+Mapping.txt中的utterances: 2108
+CSV中的utterances: 2130
+平均每个utterance: 8.0 个glosses
+
+Sign类型分布:
+  Lexical Signs: 14736
+  Fingerspelled Signs: 1018
+  Loan Signs: 581
+```
+
+### 4. 提取特定sign的信息
+
+```bash
+python query_asllrp_data.py --extract 10006709 THAT
+```
+
+## 数据说明
+
+### ASLLRP_utterances_mapping.txt
+简单的utterance到gloss序列的映射：
+```
+10006709: THAT AMONG DIFFERENT KIND VARY BELONG MEAN ...
+```
+
+### asllrp_sentence_signs_2025_06_28.csv
+详细的sign级别标注（CSV格式），包含：
+- **时间信息**: Sign的开始/结束帧号
+- **手型信息**: 主手和副手的起始/结束手型
+- **分类信息**: Sign类型（Lexical Signs, Fingerspelled Signs等）
+
+**重要**: CSV中的帧号是相对于**原始视频**的。如果使用裁剪视频，需要减去utterance的开始帧号。
+
+### ASLLRP_utterances_results/
+每个视频的处理结果：
+- `crop_frame/`: ~224张裁剪后的JPG图片（每个视频的帧数不同）
+- `crop_original_video.mp4`: 裁剪后的视频文件
+- `results_dwpose/npz/`: DWPose姿态估计结果（每帧一个NPZ文件）
+
+## 新增功能：带帧号的Gloss数据 ★
+
+现在你可以直接使用 **`ASLLRP_utterances_with_frames.json`** 获取每个gloss词的精确帧号！
+
+### 使用JSON文件（推荐）
+
+```python
+import json
+
+# 加载带帧号的gloss数据
+with open('ASLLRP_utterances_with_frames.json', 'r') as f:
+    data = json.load(f)
+
+# 获取特定utterance的gloss和帧号
+utterance = data['10006709']
+print(f"总时长: {utterance['duration_seconds']} 秒")
+print(f"总帧数: {utterance['total_frames_24fps']} 帧 (24fps)")
+
+# 遍历每个gloss词
+for gloss in utterance['glosses']:
+    print(f"{gloss['gloss']}: "
+          f"24fps[{gloss['start_24fps']}:{gloss['end_24fps']}] "
+          f"持续{gloss['duration_24fps']}帧")
+
+# 输出:
+# THAT: 24fps[7:10] 持续3帧
+# AMONG: 24fps[21:25] 持续4帧
+# ...
+```
+
+### 使用紧凑文本格式
+
+```python
+# 读取紧凑格式（每行一个utterance）
+with open('ASLLRP_utterances_compact_frames.txt', 'r') as f:
+    for line in f:
+        utterance_id, glosses = line.strip().split(': ', 1)
+        # 格式: GLOSS1|start-end GLOSS2|start-end ...
+        gloss_pairs = glosses.split()
+        for pair in gloss_pairs:
+            gloss, frames = pair.split('|')
+            start, end = frames.split('-')
+            print(f"{gloss}: 帧{start}-{end}")
+```
+
+## 代码示例
+
+### 提取utterance的所有signs（旧方法 - 需要FPS转换）
+
+```python
+import csv
+
+def get_signs(utterance_id):
+    with open('asllrp_sentence_signs_2025_06_28.csv', 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            if row['Utterance video filename'] == f"{utterance_id}.mp4":
+                print(f"{row['Main entry gloss label']}: 帧{row['Start frame of the sign video']}-{row['End frame of the sign video']}")
+
+get_signs("10006709")
+```
+
+### 新方法：直接使用带帧号的数据（推荐）
+
+```python
+import json
+
+def get_signs_with_frames(utterance_id):
+    """获取utterance的所有signs及其24fps帧号（已转换）"""
+    with open('ASLLRP_utterances_with_frames.json', 'r') as f:
+        data = json.load(f)
+
+    if utterance_id in data:
+        for gloss in data[utterance_id]['glosses']:
+            print(f"{gloss['gloss']}: "
+                  f"帧{gloss['start_24fps']}-{gloss['end_24fps']} "
+                  f"({gloss['duration_24fps']}帧, {gloss['sign_type']})")
+
+get_signs_with_frames("10006709")
+```
+
+### 从裁剪视频中提取sign的帧
+
+```python
+import cv2
+
+def extract_sign(utterance_id, start_frame, end_frame):
+    # 注意：需要转换为裁剪视频的帧号
+    video_path = f"ASLLRP_utterances_results/{utterance_id}/crop_original_video.mp4"
+    cap = cv2.VideoCapture(video_path)
+
+    frames = []
+    for frame_num in range(start_frame, end_frame + 1):
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+        ret, frame = cap.read()
+        if ret:
+            frames.append(frame)
+
+    cap.release()
+    return frames
+```
+
+## 数据统计
+
+| 项目 | 数量 |
+|------|------|
+| Utterance视频 | 2,108-2,130 |
+| Sign标注 | 17,522 |
+| Lexical Signs | 14,736 (84.1%) |
+| Fingerspelled Signs | 1,018 (5.8%) |
+| 平均每个utterance的glosses | 8.0个 |
+| Gloss数量范围 | 2-30个 |
+
+## 更多信息
+
+详细的数据结构说明请参阅 [ASLLRP_DATA_STRUCTURE.md](ASLLRP_DATA_STRUCTURE.md)

SignX/doc/analyze_asllrp_data.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+分析ASLLRP数据集的结构和关系
+"""
+import os
+import csv
+from collections import defaultdict
+import numpy as np
+
+# 数据路径
+BASE_PATH = "/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo"
+MAPPING_FILE = os.path.join(BASE_PATH, "ASLLRP_utterances_mapping.txt")
+CSV_FILE = os.path.join(BASE_PATH, "asllrp_sentence_signs_2025_06_28.csv")
+RESULTS_DIR = os.path.join(BASE_PATH, "ASLLRP_utterances_results")
+
+def analyze_mapping_file():
+    """分析mapping文件"""
+    print("="*80)
+    print("分析 ASLLRP_utterances_mapping.txt")
+    print("="*80)
+
+    with open(MAPPING_FILE, 'r') as f:
+        lines = f.readlines()
+
+    print(f"总共有 {len(lines)} 个视频utterance")
+
+    # 示例
+    print("\n前5个示例:")
+    for i, line in enumerate(lines[:5], 1):
+        video_id, glosses = line.strip().split(': ', 1)
+        gloss_list = glosses.split()
+        print(f"{i}. 视频ID: {video_id}")
+        print(f"   Gloss数量: {len(gloss_list)}")
+        print(f"   Gloss序列: {' '.join(gloss_list[:10])}{'...' if len(gloss_list) > 10 else ''}")
+        print()
+
+    return lines
+
+def analyze_csv_file(example_video_id="10006709"):
+    """分析CSV文件 - 包含每个sign的精确时间标注"""
+    print("="*80)
+    print("分析 asllrp_sentence_signs_2025_06_28.csv")
+    print("="*80)
+
+    # 读取CSV
+    utterance_signs = defaultdict(list)
+
+    with open(CSV_FILE, 'r') as f:
+        reader = csv.DictReader(f)
+        headers = reader.fieldnames
+
+        print(f"\nCSV文件包含以下列:")
+        for i, header in enumerate(headers, 1):
+            print(f"  {i}. {header}")
+
+        # 按utterance video filename分组
+        for row in reader:
+            utterance_video = row['Utterance video filename']
+            utterance_signs[utterance_video].append(row)
+
+    print(f"\n总共有 {len(utterance_signs)} 个不同的utterance视频")
+    print(f"总共有 {sum(len(signs) for signs in utterance_signs.values())} 个sign标注")
+
+    # 分析示例视频
+    example_key = f"{example_video_id}.mp4"
+    if example_key in utterance_signs:
+        signs = utterance_signs[example_key]
+        print(f"\n示例视频 {example_video_id} 的详细信息:")
+        print(f"  包含 {len(signs)} 个sign")
+        print(f"\n  前5个signs:")
+        for i, sign in enumerate(signs[:5], 1):
+            print(f"    {i}. {sign['Main entry gloss label']}")
+            print(f"       - Sign开始帧: {sign['Start frame of the sign video']}")
+            print(f"       - Sign结束帧: {sign['End frame of the sign video']}")
+            print(f"       - Utterance开始帧: {sign['Start frame of the containing utterance']}")
+            print(f"       - Utterance结束帧: {sign['End frame of the containing utterance']}")
+            print(f"       - Sign类型: {sign['Sign type']}")
+            print()
+
+    return utterance_signs
+
+def analyze_results_directory(example_video_id="10006709"):
+    """分析results目录结构"""
+    print("="*80)
+    print("分析 ASLLRP_utterances_results 目录")
+    print("="*80)
+
+    video_dirs = [d for d in os.listdir(RESULTS_DIR)
+                  if os.path.isdir(os.path.join(RESULTS_DIR, d))]
+
+    print(f"\n总共有 {len(video_dirs)} 个视频文件夹")
+
+    # 分析示例文件夹
+    example_dir = os.path.join(RESULTS_DIR, example_video_id)
+    if os.path.exists(example_dir):
+        print(f"\n示例视频 {example_video_id} 的文件结构:")
+
+        # crop_frame
+        crop_frame_dir = os.path.join(example_dir, "crop_frame")
+        if os.path.exists(crop_frame_dir):
+            frames = sorted([f for f in os.listdir(crop_frame_dir) if f.endswith('.jpg')])
+            print(f"  - crop_frame/: {len(frames)} 个裁剪帧")
+            print(f"    帧范围: {frames[0]} 到 {frames[-1]}")
+
+        # crop_original_video.mp4
+        video_path = os.path.join(example_dir, "crop_original_video.mp4")
+        if os.path.exists(video_path):
+            size_mb = os.path.getsize(video_path) / (1024 * 1024)
+            print(f"  - crop_original_video.mp4: {size_mb:.2f} MB")
+
+        # results_dwpose
+        dwpose_dir = os.path.join(example_dir, "results_dwpose/npz")
+        if os.path.exists(dwpose_dir):
+            npz_files = sorted([f for f in os.listdir(dwpose_dir) if f.endswith('.npz')])
+            print(f"  - results_dwpose/npz/: {len(npz_files)} 个姿态估计文件")
+
+            # 查看一个npz文件的内容
+            if npz_files:
+                sample_npz = np.load(os.path.join(dwpose_dir, npz_files[0]))
+                print(f"    NPZ文件包含的数据:")
+                for key in sample_npz.files:
+                    data = sample_npz[key]
+                    print(f"      - {key}: shape={data.shape}, dtype={data.dtype}")
+
+def understand_csv_usage():
+    """说明如何使用CSV文件"""
+    print("\n" + "="*80)
+    print("如何使用 asllrp_sentence_signs_2025_06_28.csv")
+    print("="*80)
+
+    print("""
+这个CSV文件的主要用途：
+
+1. **精确的时间标注**
+   - 每一行代表一个sign（手语词）
+   - "Start frame of the sign video" 和 "End frame of the sign video"
+     表示这个sign在整个视频中的精确帧范围
+   - 可以用来从视频中提取单个sign的片段
+
+2. **Utterance级别的上下文**
+   - "Start frame of the containing utterance" 和 "End frame of the containing utterance"
+     表示包含这个sign的整个句子（utterance）的帧范围
+   - 一个utterance可能包含多个signs
+
+3. **手语学语言特征**
+   - Dominant/Non-dominant start/end handshape: 起始和结束手型
+   - Sign type: 手语类型（Lexical Signs, Fingerspelled Signs, etc.）
+   - Class label: 手语词的分类标签
+
+4. **数据关联**
+   - "Utterance video filename": 对应 ASLLRP_utterances_results 中的文件夹名
+   - "Sign video filename": 单个sign的视频文件名（在原始ASLLRP数据集中）
+
+使用示例代码：
+    """)
+
+    print("""
+# 提取特定utterance的所有signs及其时间
+import csv
+
+utterance_id = "10006709"
+with open(CSV_FILE, 'r') as f:
+    reader = csv.DictReader(f)
+    for row in reader:
+        if row['Utterance video filename'] == f"{utterance_id}.mp4":
+            gloss = row['Main entry gloss label']
+            start_frame = int(row['Start frame of the sign video'])
+            end_frame = int(row['End frame of the sign video'])
+            print(f"{gloss}: 帧 {start_frame}-{end_frame}")
+    """)
+
+def create_example_script():
+    """创建一个示例脚本展示如何使用这些数据"""
+    print("\n" + "="*80)
+    print("示例：从CSV提取sign的时间信息并与视频对应")
+    print("="*80)
+
+    script = '''
+import csv
+import cv2
+import os
+
+def extract_signs_from_utterance(utterance_id):
+    """提取一个utterance中所有signs的信息"""
+    csv_file = "/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/asllrp_sentence_signs_2025_06_28.csv"
+
+    signs = []
+    with open(csv_file, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            if row['Utterance video filename'] == f"{utterance_id}.mp4":
+                signs.append({
+                    'gloss': row['Main entry gloss label'],
+                    'start_frame': int(row['Start frame of the sign video']),
+                    'end_frame': int(row['End frame of the sign video']),
+                    'sign_type': row['Sign type']
+                })
+
+    return signs
+
+# 示例使用
+utterance_id = "10006709"
+signs = extract_signs_from_utterance(utterance_id)
+print(f"Utterance {utterance_id} 包含 {len(signs)} 个signs:")
+for sign in signs[:5]:
+    print(f"  {sign['gloss']}: 帧 {sign['start_frame']}-{sign['end_frame']} ({sign['sign_type']})")
+'''
+
+    print(script)
+
+if __name__ == "__main__":
+    print("\nASLLRP数据集结构分析")
+    print("作者: Claude Code")
+    print("日期: 2025-12-27\n")
+
+    # 分析三个主要组件
+    analyze_mapping_file()
+    print()
+
+    analyze_csv_file()
+    print()
+
+    analyze_results_directory()
+
+    # 使用说明
+    understand_csv_usage()
+
+    # 示例脚本
+    create_example_script()
+
+    print("\n" + "="*80)
+    print("分析完成!")
+    print("="*80)

SignX/doc/generate_gloss_with_frames.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+为ASLLRP_utterances_mapping.txt中的每个gloss词添加起始和结束帧号
+
+输出格式：
+{
+    "utterance_id": {
+        "glosses": [
+            {
+                "gloss": "THAT",
+                "start_30fps": 9,      # 相对于utterance起始的帧号（30 FPS）
+                "end_30fps": 13,
+                "start_24fps": 7,      # 转换为24 FPS后的帧号
+                "end_24fps": 10,
+                "duration_30fps": 4,   # 持续帧数（30 FPS）
+                "duration_24fps": 3,   # 持续帧数（24 FPS）
+                "sign_type": "Lexical Signs"
+            },
+            ...
+        ],
+        "total_frames_30fps": 280,
+        "total_frames_24fps": 224,
+        "duration_seconds": 9.33
+    }
+}
+"""
+
+import csv
+import json
+from collections import defaultdict, OrderedDict
+
+# 文件路径
+MAPPING_FILE = "ASLLRP_utterances_mapping.txt"
+CSV_FILE = "asllrp_sentence_signs_2025_06_28.csv"
+OUTPUT_JSON = "ASLLRP_utterances_with_frames.json"
+OUTPUT_TXT = "ASLLRP_utterances_with_frames.txt"
+
+def load_mapping():
+    """加载mapping文件"""
+    mapping = {}
+    with open(MAPPING_FILE, 'r') as f:
+        for line in f:
+            utterance_id, glosses = line.strip().split(': ', 1)
+            mapping[utterance_id] = glosses.split()
+    return mapping
+
+def load_csv_signs():
+    """从CSV加载所有signs的详细信息"""
+    signs_by_utterance = defaultdict(list)
+    skipped_rows = 0
+
+    with open(CSV_FILE, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            try:
+                utterance_video = row['Utterance video filename'].replace('.mp4', '')
+
+                # 提取帧号信息 - 添加错误处理
+                utterance_start = int(row['Start frame of the containing utterance'])
+                utterance_end = int(row['End frame of the containing utterance'])
+                sign_start = int(row['Start frame of the sign video'])
+                sign_end = int(row['End frame of the sign video'])
+            except (ValueError, KeyError) as e:
+                # 跳过有问题的行
+                skipped_rows += 1
+                continue
+
+            # 计算相对于utterance起始的帧号（假设CSV是30 FPS）
+            relative_start_30fps = sign_start - utterance_start
+            relative_end_30fps = sign_end - utterance_start
+
+            # 转换为24 FPS
+            relative_start_24fps = int(relative_start_30fps * 24 / 30)
+            relative_end_24fps = int(relative_end_30fps * 24 / 30)
+
+            sign_info = {
+                'gloss': row['Main entry gloss label'],
+                'start_30fps': relative_start_30fps,
+                'end_30fps': relative_end_30fps,
+                'start_24fps': relative_start_24fps,
+                'end_24fps': relative_end_24fps,
+                'duration_30fps': relative_end_30fps - relative_start_30fps,
+                'duration_24fps': relative_end_24fps - relative_start_24fps,
+                'sign_type': row['Sign type'],
+                'utterance_start_frame': utterance_start,
+                'utterance_end_frame': utterance_end,
+            }
+
+            signs_by_utterance[utterance_video].append(sign_info)
+
+    if skipped_rows > 0:
+        print(f"  警告: 跳过了 {skipped_rows} 个格式错误的CSV行")
+
+    return signs_by_utterance
+
+def fps_convert_30_to_24(frame_30fps):
+    """将30 FPS帧号转换为24 FPS"""
+    return int(frame_30fps * 24 / 30)
+
+def generate_gloss_with_frames():
+    """生成包含帧号的gloss数据"""
+    print("加载数据...")
+    mapping = load_mapping()
+    csv_signs = load_csv_signs()
+
+    result = OrderedDict()
+    missing_utterances = []
+
+    print(f"处理 {len(mapping)} 个utterances...")
+
+    for utterance_id, gloss_sequence in mapping.items():
+        if utterance_id not in csv_signs:
+            missing_utterances.append(utterance_id)
+            continue
+
+        signs = csv_signs[utterance_id]
+
+        # 计算总帧数
+        if signs:
+            total_frames_30fps = signs[0]['utterance_end_frame'] - signs[0]['utterance_start_frame']
+            total_frames_24fps = fps_convert_30_to_24(total_frames_30fps)
+            duration_seconds = total_frames_30fps / 30.0
+        else:
+            total_frames_30fps = 0
+            total_frames_24fps = 0
+            duration_seconds = 0
+
+        # 匹配gloss序列与CSV中的signs
+        # 注意：mapping.txt中的gloss数量可能与CSV中的不完全一致
+        glosses_with_frames = []
+
+        for sign in signs:
+            glosses_with_frames.append({
+                'gloss': sign['gloss'],
+                'start_30fps': sign['start_30fps'],
+                'end_30fps': sign['end_30fps'],
+                'start_24fps': sign['start_24fps'],
+                'end_24fps': sign['end_24fps'],
+                'duration_30fps': sign['duration_30fps'],
+                'duration_24fps': sign['duration_24fps'],
+                'sign_type': sign['sign_type']
+            })
+
+        result[utterance_id] = {
+            'glosses': glosses_with_frames,
+            'total_frames_30fps': total_frames_30fps,
+            'total_frames_24fps': total_frames_24fps,
+            'duration_seconds': round(duration_seconds, 2),
+            'gloss_count': len(glosses_with_frames)
+        }
+
+    # 保存JSON格式
+    print(f"\n保存JSON格式到 {OUTPUT_JSON}...")
+    with open(OUTPUT_JSON, 'w', encoding='utf-8') as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+
+    # 保存可读文本格式
+    print(f"保存文本格式到 {OUTPUT_TXT}...")
+    with open(OUTPUT_TXT, 'w', encoding='utf-8') as f:
+        for utterance_id, data in result.items():
+            # 格式: utterance_id: GLOSS1[s30:e30->s24:e24] GLOSS2[...] ...
+            gloss_strings = []
+            for g in data['glosses']:
+                gloss_str = f"{g['gloss']}[{g['start_30fps']}:{g['end_30fps']}->{g['start_24fps']}:{g['end_24fps']}]"
+                gloss_strings.append(gloss_str)
+
+            f.write(f"{utterance_id}: {' '.join(gloss_strings)}\n")
+
+    # 输出统计信息
+    print("\n" + "="*80)
+    print("处理完成!")
+    print("="*80)
+    print(f"总utterances: {len(mapping)}")
+    print(f"成功处理: {len(result)}")
+    print(f"缺失CSV数据: {len(missing_utterances)}")
+
+    if missing_utterances:
+        print(f"\n缺失的utterances (前10个): {missing_utterances[:10]}")
+
+    # 显示一些示例
+    print("\n示例数据 (前3个):")
+    print("-"*80)
+    for i, (utterance_id, data) in enumerate(list(result.items())[:3], 1):
+        print(f"\n{i}. Utterance {utterance_id}:")
+        print(f"   总帧数: {data['total_frames_30fps']} (30fps) / {data['total_frames_24fps']} (24fps)")
+        print(f"   时长: {data['duration_seconds']} 秒")
+        print(f"   Gloss数量: {data['gloss_count']}")
+        print(f"   前5个glosses:")
+        for g in data['glosses'][:5]:
+            print(f"     - {g['gloss']}: "
+                  f"30fps[{g['start_30fps']}:{g['end_30fps']}] "
+                  f"-> 24fps[{g['start_24fps']}:{g['end_24fps']}] "
+                  f"({g['duration_24fps']}帧)")
+
+    return result
+
+def create_compact_format():
+    """创建紧凑格式的输出（类似原始mapping.txt）"""
+    OUTPUT_COMPACT = "ASLLRP_utterances_compact_frames.txt"
+
+    print(f"\n创建紧凑格式 {OUTPUT_COMPACT}...")
+
+    mapping = load_mapping()
+    csv_signs = load_csv_signs()
+
+    with open(OUTPUT_COMPACT, 'w', encoding='utf-8') as f:
+        for utterance_id in mapping.keys():
+            if utterance_id not in csv_signs:
+                continue
+
+            signs = csv_signs[utterance_id]
+
+            # 格式: utterance_id: gloss1|s24-e24 gloss2|s24-e24 ...
+            gloss_parts = []
+            for sign in signs:
+                # 使用24fps帧号（更常用）
+                gloss_parts.append(f"{sign['gloss']}|{sign['start_24fps']}-{sign['end_24fps']}")
+
+            f.write(f"{utterance_id}: {' '.join(gloss_parts)}\n")
+
+    print(f"紧凑格式已保存到 {OUTPUT_COMPACT}")
+
+if __name__ == "__main__":
+    print("ASLLRP Gloss帧号生成工具")
+    print("="*80)
+
+    result = generate_gloss_with_frames()
+    create_compact_format()
+
+    print("\n" + "="*80)
+    print("生成的文件:")
+    print(f"  1. {OUTPUT_JSON} - 完整JSON格式（包含30fps和24fps）")
+    print(f"  2. {OUTPUT_TXT} - 可读文本格式")
+    print(f"  3. ASLLRP_utterances_compact_frames.txt - 紧凑格式（24fps）")
+    print("="*80)

SignX/doc/query_asllrp_data.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+ASLLRP数据集查询工具
+用于快速查询和提取特定utterance或sign的信息
+"""
+import csv
+import os
+import argparse
+from collections import defaultdict
+
+# 数据路径
+BASE_PATH = "/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo"
+MAPPING_FILE = os.path.join(BASE_PATH, "ASLLRP_utterances_mapping.txt")
+CSV_FILE = os.path.join(BASE_PATH, "asllrp_sentence_signs_2025_06_28.csv")
+RESULTS_DIR = os.path.join(BASE_PATH, "ASLLRP_utterances_results")
+
+def load_csv_data():
+    """加载CSV数据"""
+    data = defaultdict(list)
+    with open(CSV_FILE, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            utterance_video = row['Utterance video filename']
+            data[utterance_video].append(row)
+    return data
+
+def load_mapping_data():
+    """加载mapping数据"""
+    mapping = {}
+    with open(MAPPING_FILE, 'r') as f:
+        for line in f:
+            video_id, glosses = line.strip().split(': ', 1)
+            mapping[video_id] = glosses.split()
+    return mapping
+
+def query_utterance(utterance_id):
+    """查询特定utterance的详细信息"""
+    print("="*80)
+    print(f"Utterance ID: {utterance_id}")
+    print("="*80)
+
+    # 从mapping获取gloss序列
+    mapping = load_mapping_data()
+    if utterance_id in mapping:
+        glosses = mapping[utterance_id]
+        print(f"\nGloss序列 ({len(glosses)}个):")
+        print("  " + " ".join(glosses))
+    else:
+        print(f"\n警告: 在mapping.txt中找不到{utterance_id}")
+
+    # 从CSV获取详细信息
+    csv_data = load_csv_data()
+    utterance_key = f"{utterance_id}.mp4"
+
+    if utterance_key in csv_data:
+        signs = csv_data[utterance_key]
+        print(f"\nCSV中的Signs ({len(signs)}个):")
+
+        # 获取utterance的总帧范围
+        if signs:
+            utterance_start = int(signs[0]['Start frame of the containing utterance'])
+            utterance_end = int(signs[0]['End frame of the containing utterance'])
+            utterance_duration = utterance_end - utterance_start
+            print(f"\nUtterance帧范围: {utterance_start} - {utterance_end} (总共{utterance_duration}帧)")
+
+            print(f"\n详细Signs列表:")
+            print(f"{'序号':<4} {'Gloss':<30} {'原始视频帧范围':<20} {'裁剪视频帧范围':<20} {'类型':<20}")
+            print("-"*100)
+
+            for i, sign in enumerate(signs, 1):
+                gloss = sign['Main entry gloss label']
+                start = int(sign['Start frame of the sign video'])
+                end = int(sign['End frame of the sign video'])
+                sign_type = sign['Sign type']
+
+                # 计算在裁剪视频中的帧号
+                cropped_start = start - utterance_start
+                cropped_end = end - utterance_start
+
+                print(f"{i:<4} {gloss:<30} {start}-{end} ({end-start}帧)".ljust(58) +
+                      f"{cropped_start}-{cropped_end}".ljust(24) +
+                      f"{sign_type}")
+    else:
+        print(f"\n警告: 在CSV文件中找不到{utterance_id}")
+
+    # 检查results目录
+    results_path = os.path.join(RESULTS_DIR, utterance_id)
+    if os.path.exists(results_path):
+        print(f"\n处理结果目录: {results_path}")
+
+        # 检查crop_frame
+        crop_frame_dir = os.path.join(results_path, "crop_frame")
+        if os.path.exists(crop_frame_dir):
+            frames = [f for f in os.listdir(crop_frame_dir) if f.endswith('.jpg')]
+            print(f"  - 裁剪帧数: {len(frames)}")
+
+        # 检查视频
+        video_path = os.path.join(results_path, "crop_original_video.mp4")
+        if os.path.exists(video_path):
+            size_mb = os.path.getsize(video_path) / (1024 * 1024)
+            print(f"  - 裁剪视频大小: {size_mb:.2f} MB")
+
+        # 检查dwpose
+        dwpose_dir = os.path.join(results_path, "results_dwpose/npz")
+        if os.path.exists(dwpose_dir):
+            npz_files = [f for f in os.listdir(dwpose_dir) if f.endswith('.npz')]
+            print(f"  - DWPose文件数: {len(npz_files)}")
+    else:
+        print(f"\n警告: 在results目录中找不到{utterance_id}")
+
+def search_gloss(gloss_query):
+    """搜索包含特定gloss的utterances"""
+    print("="*80)
+    print(f"搜索Gloss: {gloss_query}")
+    print("="*80)
+
+    csv_data = load_csv_data()
+    matches = []
+
+    for utterance_video, signs in csv_data.items():
+        for sign in signs:
+            if gloss_query.upper() in sign['Main entry gloss label'].upper():
+                utterance_id = utterance_video.replace('.mp4', '')
+                matches.append({
+                    'utterance_id': utterance_id,
+                    'gloss': sign['Main entry gloss label'],
+                    'start_frame': int(sign['Start frame of the sign video']),
+                    'end_frame': int(sign['End frame of the sign video']),
+                    'sign_type': sign['Sign type']
+                })
+
+    print(f"\n找到 {len(matches)} 个匹配的signs:")
+    print(f"{'Utterance ID':<15} {'Gloss':<30} {'帧范围':<20} {'类型':<20}")
+    print("-"*90)
+
+    for match in matches[:20]:  # 只显示前20个
+        print(f"{match['utterance_id']:<15} {match['gloss']:<30} "
+              f"{match['start_frame']}-{match['end_frame']}".ljust(24) +
+              f"{match['sign_type']}")
+
+    if len(matches) > 20:
+        print(f"\n... 还有 {len(matches) - 20} 个结果未显示")
+
+def list_all_utterances():
+    """列出所有utterances的统计信息"""
+    print("="*80)
+    print("所有Utterances统计")
+    print("="*80)
+
+    mapping = load_mapping_data()
+    csv_data = load_csv_data()
+
+    print(f"\nMapping.txt中的utterances: {len(mapping)}")
+    print(f"CSV中的utterances: {len(csv_data)}")
+
+    results_dirs = [d for d in os.listdir(RESULTS_DIR)
+                    if os.path.isdir(os.path.join(RESULTS_DIR, d))]
+    print(f"Results目录中的文件夹: {len(results_dirs)}")
+
+    # 统计gloss数量分布
+    gloss_counts = [len(glosses) for glosses in mapping.values()]
+    avg_gloss = sum(gloss_counts) / len(gloss_counts) if gloss_counts else 0
+    min_gloss = min(gloss_counts) if gloss_counts else 0
+    max_gloss = max(gloss_counts) if gloss_counts else 0
+
+    print(f"\nGloss统计:")
+    print(f"  平均每个utterance: {avg_gloss:.1f} 个glosses")
+    print(f"  最少: {min_gloss} 个glosses")
+    print(f"  最多: {max_gloss} 个glosses")
+
+    # 统计sign类型
+    sign_types = defaultdict(int)
+    for signs in csv_data.values():
+        for sign in signs:
+            sign_types[sign['Sign type']] += 1
+
+    print(f"\nSign类型分布:")
+    for sign_type, count in sorted(sign_types.items(), key=lambda x: x[1], reverse=True):
+        print(f"  {sign_type}: {count}")
+
+def extract_sign_info(utterance_id, gloss):
+    """提取特定sign的信息，用于代码中使用"""
+    csv_data = load_csv_data()
+    utterance_key = f"{utterance_id}.mp4"
+
+    if utterance_key not in csv_data:
+        print(f"错误: 找不到utterance {utterance_id}")
+        return None
+
+    signs = csv_data[utterance_key]
+    for sign in signs:
+        if gloss.upper() == sign['Main entry gloss label'].upper():
+            utterance_start = int(sign['Start frame of the containing utterance'])
+            start = int(sign['Start frame of the sign video'])
+            end = int(sign['End frame of the sign video'])
+
+            info = {
+                'gloss': sign['Main entry gloss label'],
+                'start_frame_original': start,
+                'end_frame_original': end,
+                'start_frame_cropped': start - utterance_start,
+                'end_frame_cropped': end - utterance_start,
+                'duration': end - start,
+                'sign_type': sign['Sign type']
+            }
+
+            print(f"Sign信息:")
+            print(f"  Gloss: {info['gloss']}")
+            print(f"  原始视频帧: {info['start_frame_original']} - {info['end_frame_original']}")
+            print(f"  裁剪视频帧: {info['start_frame_cropped']} - {info['end_frame_cropped']}")
+            print(f"  持续时间: {info['duration']} 帧")
+            print(f"  类型: {info['sign_type']}")
+
+            return info
+
+    print(f"错误: 在utterance {utterance_id} 中找不到gloss '{gloss}'")
+    return None
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='ASLLRP数据集查询工具')
+    parser.add_argument('--utterance', '-u', help='查询特定utterance ID')
+    parser.add_argument('--search', '-s', help='搜索包含特定gloss的utterances')
+    parser.add_argument('--list', '-l', action='store_true', help='列出所有utterances的统计')
+    parser.add_argument('--extract', '-e', nargs=2, metavar=('UTTERANCE_ID', 'GLOSS'),
+                       help='提取特定sign的信息')
+
+    args = parser.parse_args()
+
+    if args.utterance:
+        query_utterance(args.utterance)
+    elif args.search:
+        search_gloss(args.search)
+    elif args.list:
+        list_all_utterances()
+    elif args.extract:
+        extract_sign_info(args.extract[0], args.extract[1])
+    else:
+        print("使用示例:")
+        print("  查询utterance: python query_asllrp_data.py --utterance 10006709")
+        print("  搜索gloss: python query_asllrp_data.py --search THAT")
+        print("  列出统计: python query_asllrp_data.py --list")
+        print("  提取sign: python query_asllrp_data.py --extract 10006709 THAT")
+        parser.print_help()

SignX/inference_output.txt

@@ -1 +0,0 @@
-<unk> #IF FRIEND GROUP/TOGE@@ TH@@ E@@ R DEPART PARTY IX-1p FINISH JO@@ I@@ N IX-1p

SignX/inference_output.txt.clean

@@ -1 +0,0 @@
-<unk> #IF FRIEND GROUP/TOGETHER DEPART PARTY IX-1p FINISH JOIN IX-1p