Initial SignX import (LFS)

.gitattributes

@@ -0,0 +1,8 @@
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,28 @@
+*.pyc
+*.so
+*.egg-info
+*.whl
+.ipynb_checkpoints
+.DS_Store
+.idea
+.vscode
+.envrc
+*.jpg
+*.npz
+*.xlsx
+
+checkpoints_asllrp第七次训练全pose协助2000
+checkpoints_asllrp第一次训练的基线
+checkpoints_csldaily
+checkpoints_dgs3-t
+checkpoints_phoenix
+doc/
+
+inference_output*
+
+smkd/history/
+smkd/work_dir
+smkd/youtubeasl
+training_asllrp
+training_dgs3-t
+training_phoenix

README.md

@@ -0,0 +1,97 @@
+# SLTUNET: A Simple Unified Model for Sign Language Translation (ICLR 2023)
+
+[**Paper**](https://openreview.net/forum?id=EBS4C77p_5S) | 
+[**Highlights**](#paper-highlights) |
+[**Overview**](#model-visualization) |
+[**DGS3-T**](#dgs3-t) |
+[**Training&Eval**](#training-and-evaluation) |
+[**Model Performance**](#performance) |
+[**Citation**](#citation)
+
+
+* Update (2023/07/09): We release the trained model for phoenix and csldaily at [here](https://data.statmt.org/bzhang/iclr2023_sltunet/). See `infer.sh` for details.
+
+
+## Paper Highlights
+
+Among thousands of languages globally, some are written, some are spoken, while some are signed.
+Sign languages are unique **natural** languages widely used in Deaf communities. They express
+meaning through hand gestures, body movements and facial expressions, and are often in a video form.
+We refer the readers to [Sign language Processing](https://research.sign.mt/) for a better understanding
+of sign languages.
+
+In this study, we aim at improving sign language translation, i.e. translating information from
+sign languages (in a video) to spoken languages (in text). We address the video-text modality gap and 
+the training data scarcity issue via multi-task learning and unified modeling. 
+
+Briefly,
+- We propose a simple unified model, SLTUNET, for SLT, and show that jointly modeling
+multiple SLT-related tasks benefits the translation.
+- We propose a set of optimization techniques for SLTUNET aiming at an improved trade-off
+between model capacity and regularization, which also helps SLT models for single tasks.
+- SLTUNET performs competitively to previous methods and yields the new state-of-the-art
+performance on CSL-Daily.
+- We use the DGS Corpus and propose [DGS3-T](#dgs3-t) for end-to-end SLT, with larger
+scale, richer topics and more significant challenges than existing datasets.
+
+## Model Visualization
+
+![Overview of ur proposal](model.png)
+
+
+## DGS3-T
+
+* Similar to PHOENIX-2014T and CSL-Daily, DGS3-T is a dataset used for the study of SLT, consisting of sign videos and text translations.
+
+* Different from these previous datasets, DGS3-T is larger at scale, covering broader domains and topics with more signers.
+
+* DGS3-T represents more practical challenges in SLT. We encourage researchers to consider it for SLT research.
+
+
+**DGS3-T Licensing**
+
+DGS3-T is based on [the Public DGS Corpus](https://www.sign-lang.uni-hamburg.de/meinedgs/ling/license_en.html). The license of the Public DGS Corpus does not allow any computational research except if express
+permission is given by the University of Hamburg.
+
+**Constructing DGS3-T**
+
+Please check out [dgs3-t](./dgs3-t) for details.
+
+## Requirement
+
+The source code is based on older tensorflow.
+
+- python==3.8
+- tensorflow==1.15
+
+
+## Training and Evaluation
+
+Training includes two phrase: 1) pretrain sign embeddings; 2) train SLTUNet model.
+
+Please check out [example](./example) for details.
+
+
+## Performance
+
+![Resulst on Phoenix](phoenix.png)
+
+Check out [our paper](https://openreview.net/forum?id=EBS4C77p_5S) for more results on CSLDaily and DGS3-T.
+
+* Update (2023/04/02): note, for CSL-Daily, **we always adopt subword preprocessing (NOT character) for the target text 
+and gloss sequence during training and inference**; 
+We post-process the generated subword sequence into a character sequence at evaluation for char-level BLEU.
+
+## Citation
+
+If you draw any inspiration from our study, please consider to cite our paper:
+```
+@inproceedings{
+zhang2023sltunet,
+title={{SLTUNET}: A Simple Unified Model for Sign Language Translation},
+author={Biao Zhang and Mathias M{\"u}ller and Rico Sennrich},
+booktitle={The Eleventh International Conference on Learning Representations },
+year={2023},
+url={https://openreview.net/forum?id=EBS4C77p_5S}
+}
+```

env/signx-slt.txt

@@ -0,0 +1,89 @@
+absl-py==2.1.0
+accelerate==1.0.1
+Brotli @ file:///home/conda/feedstock_root/build_artifacts/brotli-split_1695989787169/work
+cachetools==5.5.1
+certifi @ file:///home/conda/feedstock_root/build_artifacts/certifi_1725278078093/work/certifi
+cffi @ file:///home/conda/feedstock_root/build_artifacts/cffi_1723018376978/work
+charset-normalizer @ file:///home/conda/feedstock_root/build_artifacts/charset-normalizer_1728479282467/work
+click==8.1.8
+contourpy==1.1.1
+cycler==0.12.1
+diffusers==0.32.2
+easy-dwpose
+fastdtw==0.3.4
+filelock @ file:///home/conda/feedstock_root/build_artifacts/filelock_1726613473834/work
+fonttools==4.55.4
+fsspec==2024.12.0
+gmpy2 @ file:///home/conda/feedstock_root/build_artifacts/gmpy2_1715527302982/work
+google-auth==2.37.0
+google-auth-oauthlib==1.0.0
+GPUtil==1.4.0
+graphviz==0.20.3
+grpcio==1.69.0
+h2 @ file:///home/conda/feedstock_root/build_artifacts/h2_1634280454336/work
+h5py==3.11.0
+hiddenlayer==0.3
+hpack==4.0.0
+huggingface-hub==0.27.1
+hyperframe @ file:///home/conda/feedstock_root/build_artifacts/hyperframe_1619110129307/work
+idna @ file:///home/conda/feedstock_root/build_artifacts/idna_1726459485162/work
+importlib_metadata==8.5.0
+importlib_resources==6.4.5
+Jinja2 @ file:///home/conda/feedstock_root/build_artifacts/jinja2_1715127149914/work
+joblib==1.4.2
+kiwisolver==1.4.7
+Markdown==3.7
+MarkupSafe @ file:///home/conda/feedstock_root/build_artifacts/markupsafe_1706899923320/work
+matplotlib==3.7.5
+mpmath @ file:///home/conda/feedstock_root/build_artifacts/mpmath_1678228039184/work
+netron==8.1.3
+networkx @ file:///home/conda/feedstock_root/build_artifacts/networkx_1680692919326/work
+nltk==3.9.1
+numpy @ file:///home/conda/feedstock_root/build_artifacts/numpy_1687808301083/work
+oauthlib==3.2.2
+opencv-python==4.11.0.86
+packaging==24.2
+pandas==2.0.3
+pillow @ file:///home/conda/feedstock_root/build_artifacts/pillow_1719903565503/work
+protobuf==5.29.3
+psutil==7.0.0
+pyarrow==17.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pycparser @ file:///home/conda/feedstock_root/build_artifacts/pycparser_1711811537435/work
+pyparsing==3.1.4
+PySocks @ file:///home/conda/feedstock_root/build_artifacts/pysocks_1661604839144/work
+python-dateutil==2.9.0.post0
+pytz==2024.2
+PyYAML @ file:///home/conda/feedstock_root/build_artifacts/pyyaml_1723018227672/work
+regex==2024.11.6
+requests @ file:///home/conda/feedstock_root/build_artifacts/requests_1717057054362/work
+requests-oauthlib==2.0.0
+rsa==4.9
+safetensors==0.5.2
+scikit-learn==1.3.2
+scipy==1.10.1
+sentencepiece==0.2.0
+six==1.17.0
+sympy @ file:///home/conda/feedstock_root/build_artifacts/sympy_1728484478345/work
+tensorboard==2.14.0
+tensorboard-data-server==0.7.2
+threadpoolctl==3.5.0
+timm==1.0.20
+tokenizers==0.20.3
+torch==2.4.1
+torchaudio==2.4.1
+torchinfo==1.8.0
+torchview==0.2.6
+torchvision==0.20.0
+torchviz==0.0.3
+tqdm==4.67.1
+transformers==4.46.3
+triton==3.0.0
+typing_extensions @ file:///home/conda/feedstock_root/build_artifacts/typing_extensions_1717802530399/work
+tzdata==2025.1
+urllib3 @ file:///home/conda/feedstock_root/build_artifacts/urllib3_1726496430923/work
+Werkzeug==3.0.6
+zipp==3.20.2
+zstandard==0.23.0
+

env/signx-slt.yml

@@ -0,0 +1,255 @@
+name: signx-slt
+channels:
+  - bioconda
+  - anaconda
+  - nvidia
+  - defaults
+  - pytorch
+  - conda-forge
+dependencies:
+  - _libgcc_mutex=0.1=conda_forge
+  - _openmp_mutex=4.5=2_kmp_llvm
+  - aom=3.6.1=h59595ed_0
+  - atk-1.0=2.38.0=h04ea711_2
+  - binutils_impl_linux-64=2.40=ha1999f0_7
+  - binutils_linux-64=2.40=hb3c18ed_4
+  - blas=2.116=mkl
+  - blas-devel=3.9.0=16_linux64_mkl
+  - brotli-python=1.1.0=py38h17151c0_1
+  - bzip2=1.0.8=h4bc722e_7
+  - ca-certificates=2026.1.4=hbd8a1cb_0
+  - cairo=1.18.2=h3394656_1
+  - certifi=2024.8.30=pyhd8ed1ab_0
+  - cffi=1.17.0=py38heb5c249_0
+  - charset-normalizer=3.4.0=pyhd8ed1ab_0
+  - cpython=3.8.20=py38hd8ed1ab_2
+  - cuda-cudart=11.8.89=0
+  - cuda-cupti=11.8.87=0
+  - cuda-libraries=11.8.0=0
+  - cuda-nvrtc=11.8.89=0
+  - cuda-nvtx=11.8.86=0
+  - cuda-runtime=11.8.0=0
+  - cuda-version=12.6=3
+  - ffmpeg=4.4.2=gpl_hdf48244_113
+  - filelock=3.16.1=pyhd8ed1ab_0
+  - font-ttf-dejavu-sans-mono=2.37=hab24e00_0
+  - font-ttf-inconsolata=3.000=h77eed37_0
+  - font-ttf-source-code-pro=2.038=h77eed37_0
+  - font-ttf-ubuntu=0.83=h77eed37_3
+  - fontconfig=2.15.0=h7e30c49_1
+  - fonts-conda-ecosystem=1=0
+  - fonts-conda-forge=1=0
+  - freetype=2.12.1=h267a509_2
+  - fribidi=1.0.10=h36c2ea0_0
+  - gcc_impl_linux-64=11.4.0=h00c12a0_13
+  - gcc_linux-64=11.4.0=ha077dfb_4
+  - gdk-pixbuf=2.42.12=hb9ae30d_0
+  - gettext=0.22.5=he02047a_3
+  - gettext-tools=0.22.5=he02047a_3
+  - giflib=5.2.2=hd590300_0
+  - gmp=6.3.0=hac33072_2
+  - gmpy2=2.1.5=py38h6a1700d_1
+  - gnutls=3.7.9=hb077bed_0
+  - graphite2=1.3.13=h59595ed_1003
+  - gtk2=2.24.33=h8ee276e_7
+  - gts=0.7.6=h977cf35_4
+  - gxx_impl_linux-64=11.4.0=h634f3ee_13
+  - gxx_linux-64=11.4.0=h35bfe5d_4
+  - h2=4.1.0=pyhd8ed1ab_0
+  - harfbuzz=10.2.0=h4bba637_0
+  - hpack=4.0.0=pyh9f0ad1d_0
+  - hyperframe=6.0.1=pyhd8ed1ab_0
+  - icu=75.1=he02047a_0
+  - idna=3.10=pyhd8ed1ab_0
+  - jinja2=3.1.4=pyhd8ed1ab_0
+  - kernel-headers_linux-64=6.12.0=he073ed8_5
+  - lame=3.100=h166bdaf_1003
+  - lcms2=2.16=hb7c19ff_0
+  - ld_impl_linux-64=2.40=hf3520f5_7
+  - lerc=4.0.0=h27087fc_0
+  - libasprintf=0.22.5=he8f35ee_3
+  - libasprintf-devel=0.22.5=he8f35ee_3
+  - libblas=3.9.0=16_linux64_mkl
+  - libcblas=3.9.0=16_linux64_mkl
+  - libcublas=11.11.3.6=0
+  - libcufft=10.9.0.58=0
+  - libcufile=1.11.1.6=0
+  - libcurand=10.3.7.77=0
+  - libcusolver=11.4.1.48=0
+  - libcusparse=11.7.5.86=0
+  - libdeflate=1.23=h4ddbbb0_0
+  - libdrm=2.4.124=hb9d3cd8_0
+  - libegl=1.7.0=ha4b6fd6_2
+  - libexpat=2.6.4=h5888daf_0
+  - libffi=3.4.2=h7f98852_5
+  - libgcc=15.2.0=he0feb66_17
+  - libgcc-devel_linux-64=11.4.0=h8f596e0_113
+  - libgcc-ng=15.2.0=h69a702a_17
+  - libgd=2.3.3=h6f5c62b_11
+  - libgettextpo=0.22.5=he02047a_3
+  - libgettextpo-devel=0.22.5=he02047a_3
+  - libgfortran=14.2.0=h69a702a_1
+  - libgfortran-ng=14.2.0=h69a702a_1
+  - libgfortran5=14.2.0=hd5240d6_1
+  - libgl=1.7.0=ha4b6fd6_2
+  - libglib=2.82.2=h2ff4ddf_1
+  - libglvnd=1.7.0=ha4b6fd6_2
+  - libglx=1.7.0=ha4b6fd6_2
+  - libgomp=15.2.0=he0feb66_17
+  - libhwloc=2.11.2=default_h0d58e46_1001
+  - libiconv=1.17=hd590300_2
+  - libidn2=2.3.7=hd590300_0
+  - libjpeg-turbo=3.0.0=hd590300_1
+  - liblapack=3.9.0=16_linux64_mkl
+  - liblapacke=3.9.0=16_linux64_mkl
+  - liblzma=5.6.3=hb9d3cd8_1
+  - liblzma-devel=5.6.3=hb9d3cd8_1
+  - libnpp=11.8.0.86=0
+  - libnsl=2.0.1=hd590300_0
+  - libnvjpeg=11.9.0.86=0
+  - libpciaccess=0.18=hd590300_0
+  - libpng=1.6.45=h943b412_0
+  - librsvg=2.58.4=h49af25d_2
+  - libsanitizer=11.4.0=h5763a12_13
+  - libsqlite=3.48.0=hee588c1_1
+  - libstdcxx=15.2.0=h934c35e_17
+  - libstdcxx-devel_linux-64=11.4.0=h8f596e0_113
+  - libstdcxx-ng=15.2.0=hdf11a46_17
+  - libtasn1=4.19.0=h166bdaf_0
+  - libtiff=4.7.0=hd9ff511_3
+  - libunistring=0.9.10=h7f98852_0
+  - libuuid=2.38.1=h0b41bf4_0
+  - libva=2.22.0=h8a09558_1
+  - libvpx=1.13.1=h59595ed_0
+  - libwebp=1.5.0=hae8dbeb_0
+  - libwebp-base=1.5.0=h851e524_0
+  - libxcb=1.17.0=h8a09558_0
+  - libxcrypt=4.4.36=hd590300_1
+  - libxml2=2.13.5=h8d12d68_1
+  - libzlib=1.3.1=hb9d3cd8_2
+  - llvm-openmp=15.0.7=h0cdce71_0
+  - markupsafe=2.1.5=py38h01eb140_0
+  - mkl=2022.1.0=h84fe81f_915
+  - mkl-devel=2022.1.0=ha770c72_916
+  - mkl-include=2022.1.0=h84fe81f_915
+  - mpc=1.3.1=h24ddda3_1
+  - mpfr=4.2.1=h90cbb55_3
+  - mpmath=1.3.0=pyhd8ed1ab_0
+  - ncurses=6.5=h2d0b736_2
+  - nettle=3.9.1=h7ab15ed_0
+  - networkx=3.1=pyhd8ed1ab_0
+  - ninja=1.13.2=h171cf75_0
+  - numpy=1.24.4=py38h59b608b_0
+  - openh264=2.3.1=hcb278e6_2
+  - openjpeg=2.5.3=h5fbd93e_0
+  - openssl=3.6.1=h35e630c_1
+  - p11-kit=0.24.1=hc5aa10d_0
+  - pango=1.56.1=h861ebed_0
+  - pcre2=10.44=hba22ea6_2
+  - pillow=10.4.0=py38h2bc05a7_0
+  - pip=24.3.1=pyh8b19718_0
+  - pixman=0.44.2=h29eaf8c_0
+  - pthread-stubs=0.4=hb9d3cd8_1002
+  - pycparser=2.22=pyhd8ed1ab_0
+  - pysocks=1.7.1=pyha2e5f31_6
+  - python=3.8.20=h4a871b0_2_cpython
+  - python_abi=3.8=5_cp38
+  - pytorch=2.4.1=py3.8_cuda11.8_cudnn9.1.0_0
+  - pytorch-cuda=11.8=h7e8668a_6
+  - pytorch-mutex=1.0=cuda
+  - pyyaml=6.0.2=py38h2019614_0
+  - readline=8.2=h8228510_1
+  - requests=2.32.3=pyhd8ed1ab_0
+  - setuptools=75.3.0=pyhd8ed1ab_0
+  - svt-av1=1.4.1=hcb278e6_0
+  - sympy=1.13.3=pyh2585a3b_104
+  - sysroot_linux-64=2.39=hc4b9eeb_5
+  - tbb=2021.13.0=hceb3a55_1
+  - tk=8.6.13=noxft_h4845f30_101
+  - torchaudio=2.4.1=py38_cu118
+  - torchtriton=3.0.0=py38
+  - torchvision=0.20.0=py38_cu118
+  - typing_extensions=4.12.2=pyha770c72_0
+  - urllib3=2.2.3=pyhd8ed1ab_0
+  - wayland=1.23.1=h3e06ad9_0
+  - wayland-protocols=1.37=hd8ed1ab_0
+  - wheel=0.45.1=pyhd8ed1ab_0
+  - x264=1!164.3095=h166bdaf_2
+  - x265=3.5=h924138e_3
+  - xorg-libice=1.1.2=hb9d3cd8_0
+  - xorg-libsm=1.2.5=he73a12e_0
+  - xorg-libx11=1.8.10=h4f16b4b_1
+  - xorg-libxau=1.0.12=hb9d3cd8_0
+  - xorg-libxdmcp=1.1.5=hb9d3cd8_0
+  - xorg-libxext=1.3.6=hb9d3cd8_0
+  - xorg-libxfixes=6.0.1=hb9d3cd8_0
+  - xorg-libxrender=0.9.12=hb9d3cd8_0
+  - xz=5.6.3=hbcc6ac9_1
+  - xz-gpl-tools=5.6.3=hbcc6ac9_1
+  - xz-tools=5.6.3=hb9d3cd8_1
+  - yaml=0.2.5=h7f98852_2
+  - zlib=1.3.1=hb9d3cd8_2
+  - zstandard=0.23.0=py38h62bed22_0
+  - zstd=1.5.6=ha6fb4c9_0
+  - pip:
+      - absl-py==2.1.0
+      - accelerate==1.0.1
+      - cachetools==5.5.1
+      - click==8.1.8
+      - contourpy==1.1.1
+      - ctcdecode==1.0.3
+      - cycler==0.12.1
+      - diffusers==0.32.2
+      - fastdtw==0.3.4
+      - fonttools==4.55.4
+      - fsspec==2024.12.0
+      - google-auth==2.37.0
+      - google-auth-oauthlib==1.0.0
+      - gputil==1.4.0
+      - graphviz==0.20.3
+      - grpcio==1.69.0
+      - h5py==3.11.0
+      - hiddenlayer==0.3
+      - huggingface-hub==0.27.1
+      - importlib-metadata==8.5.0
+      - importlib-resources==6.4.5
+      - joblib==1.4.2
+      - kiwisolver==1.4.7
+      - markdown==3.7
+      - matplotlib==3.7.5
+      - netron==8.1.3
+      - nltk==3.9.1
+      - oauthlib==3.2.2
+      - opencv-python==4.11.0.86
+      - packaging==24.2
+      - pandas==2.0.3
+      - protobuf==5.29.3
+      - psutil==7.0.0
+      - pyarrow==17.0.0
+      - pyasn1==0.6.1
+      - pyasn1-modules==0.4.1
+      - pyparsing==3.1.4
+      - python-dateutil==2.9.0.post0
+      - pytz==2024.2
+      - regex==2024.11.6
+      - requests-oauthlib==2.0.0
+      - rsa==4.9
+      - safetensors==0.5.2
+      - scikit-learn==1.3.2
+      - scipy==1.10.1
+      - sentencepiece==0.2.0
+      - six==1.17.0
+      - tensorboard==2.14.0
+      - tensorboard-data-server==0.7.2
+      - threadpoolctl==3.5.0
+      - timm==1.0.20
+      - tokenizers==0.20.3
+      - torchinfo==1.8.0
+      - torchview==0.2.6
+      - torchviz==0.0.3
+      - tqdm==4.67.1
+      - transformers==4.46.3
+      - tzdata==2025.1
+      - werkzeug==3.0.6
+      - zipp==3.20.2
+prefix: /research/cbim/vast/sf895/miniforge3/envs/signx-slt

env/slt_tf1.txt

@@ -0,0 +1,39 @@
+absl-py==2.1.0
+astor==0.8.1
+certifi @ file:///croot/certifi_1671487769961/work/certifi
+cycler==0.11.0
+fonttools==4.38.0
+gast==0.2.2
+google-pasta==0.2.0
+grpcio==1.62.3
+h5py==3.8.0
+importlib-metadata==6.7.0
+Keras-Applications==1.0.8
+Keras-Preprocessing==1.1.2
+kiwisolver==1.4.5
+Markdown==3.4.4
+MarkupSafe==2.1.5
+matplotlib==3.5.3
+numpy==1.21.6
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cudnn-cu11==8.5.0.96
+opt-einsum==3.3.0
+packaging==24.0
+Pillow==9.5.0
+protobuf==4.24.4
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+PyYAML==6.0.1
+six==1.17.0
+tensorboard==1.15.0
+tensorflow==1.15.0
+tensorflow-estimator==1.15.1
+termcolor==2.3.0
+tqdm==4.67.1
+typing_extensions==4.7.1
+Werkzeug==2.2.3
+wrapt==1.16.0
+zipp==3.15.0
+

env/slt_tf1.yml

@@ -0,0 +1,80 @@
+name: slt_tf1
+channels:
+  - bioconda
+  - anaconda
+  - nvidia
+  - defaults
+  - pytorch
+  - conda-forge
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - ca-certificates=2025.12.2=h06a4308_0
+  - certifi=2022.12.7=py37h06a4308_0
+  - cudatoolkit=10.0.130=0
+  - cudnn=7.6.5=cuda10.0_0
+  - ld_impl_linux-64=2.44=h153f514_2
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc=15.2.0=h69a1729_7
+  - libgcc-ng=15.2.0=h166f726_7
+  - libgomp=15.2.0=h4751f2c_7
+  - libnsl=2.0.0=h5eee18b_0
+  - libstdcxx=15.2.0=h39759b7_7
+  - libstdcxx-ng=15.2.0=hc03a8fd_7
+  - libxcb=1.17.0=h9b100fa_0
+  - libzlib=1.2.13=h4ab18f5_6
+  - ncurses=6.5=h7934f7d_0
+  - openssl=3.0.19=h1b28b03_0
+  - pip=22.3.1=py37h06a4308_0
+  - pthread-stubs=0.3=h0ce48e5_1
+  - python=3.7.12=hf930737_100_cpython
+  - readline=8.3=hc2a1206_0
+  - setuptools=65.6.3=py37h06a4308_0
+  - sqlite=3.51.0=h2a70700_0
+  - tk=8.6.15=h54e0aa7_0
+  - wheel=0.38.4=py37h06a4308_0
+  - xorg-libx11=1.8.12=h9b100fa_1
+  - xorg-libxau=1.0.12=h9b100fa_0
+  - xorg-libxdmcp=1.1.5=h9b100fa_0
+  - xorg-xorgproto=2024.1=h5eee18b_1
+  - xz=5.6.4=h5eee18b_1
+  - zlib=1.2.13=h4ab18f5_6
+  - pip:
+      - absl-py==2.1.0
+      - astor==0.8.1
+      - cycler==0.11.0
+      - fonttools==4.38.0
+      - gast==0.2.2
+      - google-pasta==0.2.0
+      - grpcio==1.62.3
+      - h5py==3.8.0
+      - importlib-metadata==6.7.0
+      - keras-applications==1.0.8
+      - keras-preprocessing==1.1.2
+      - kiwisolver==1.4.5
+      - markdown==3.4.4
+      - markupsafe==2.1.5
+      - matplotlib==3.5.3
+      - numpy==1.21.6
+      - nvidia-cublas-cu11==11.10.3.66
+      - nvidia-cuda-nvrtc-cu11==11.7.99
+      - nvidia-cuda-runtime-cu11==11.7.99
+      - nvidia-cudnn-cu11==8.5.0.96
+      - opt-einsum==3.3.0
+      - packaging==24.0
+      - pillow==9.5.0
+      - protobuf==4.24.4
+      - pyparsing==3.1.4
+      - python-dateutil==2.9.0.post0
+      - pyyaml==6.0.1
+      - six==1.17.0
+      - tensorboard==1.15.0
+      - tensorflow==1.15.0
+      - tensorflow-estimator==1.15.1
+      - termcolor==2.3.0
+      - tqdm==4.67.1
+      - typing-extensions==4.7.1
+      - werkzeug==2.2.3
+      - wrapt==1.16.0
+      - zipp==3.15.0
+prefix: /research/cbim/vast/sf895/miniforge3/envs/slt_tf1

eval/analyze_video2pose.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Analyze pose ViT features from video2text checkpoint outputs."""
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import cv2
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+from PIL import Image
+from torchvision import transforms
+
+from smkd.pretrained.video2text import (
+    MultimodalPose2TextDiffusion,
+    MultimodalVideo2TextDiffusion,
+)
+
+INPUT_DIMS = {
+    "dwpose": 384,
+    "mediapipe_pose": 258,
+    "primedepth_depth": 576,
+    "sapiens_segmentation": 576,
+    "smplerx": 165,
+}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Pose-dimensional ablation via video2text checkpoint.")
+    parser.add_argument("--video", required=True, help="Path to input video (mp4).")
+    parser.add_argument(
+        "--checkpoint",
+        default="smkd/pretrained/video2text_checkpoint_epoch_14.pth",
+        help="Path to video2text checkpoint.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="pose_vit_feature_analysis",
+        help="Directory to store extracted features/plots.",
+    )
+    parser.add_argument("--num-frames", type=int, default=32, help="Number of frames sampled from video.")
+    parser.add_argument("--device", default="cuda", choices=["cuda", "cpu"], help="Torch device preference.")
+    parser.add_argument("--topk", type=int, default=32, help="Top dimensions to visualize.")
+    return parser.parse_args()
+
+
+def prepare_device(device_pref: str) -> torch.device:
+    if device_pref == "cuda" and torch.cuda.is_available():
+        return torch.device("cuda")
+    return torch.device("cpu")
+
+
+def ensure_dir(path: str) -> Path:
+    path_obj = Path(path)
+    path_obj.mkdir(parents=True, exist_ok=True)
+    return path_obj
+
+
+def load_video_frames(video_path: str, num_frames: int, transform) -> torch.Tensor:
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"Failed to open video: {video_path}")
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total_frames <= 0:
+        raise RuntimeError(f"No frames found in video: {video_path}")
+
+    indices = np.linspace(0, max(total_frames - 1, 0), num=num_frames, dtype=np.int32)
+    frames = []
+
+    for idx in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ok, frame = cap.read()
+        if not ok:
+            continue
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frames.append(transform(Image.fromarray(frame)))
+
+    cap.release()
+
+    if not frames:
+        raise RuntimeError(f"No decodable frames in video: {video_path}")
+
+    while len(frames) < num_frames:
+        frames.append(frames[-1].clone())
+
+    return torch.stack(frames[:num_frames], dim=0)
+
+
+def compute_dimension_stats(pose_2048: torch.Tensor):
+    with torch.no_grad():
+        scores = pose_2048.abs().mean(dim=(0, 1))
+        normalized = scores / (scores.max() + 1e-8)
+    return scores.cpu().numpy(), normalized.cpu().numpy()
+
+
+def plot_top_dims(scores, top_indices, output_path):
+    plt.figure(figsize=(max(8, len(top_indices) * 0.35), 4))
+    plt.bar(range(len(top_indices)), scores[top_indices], color="#1f77b4")
+    plt.xticks(range(len(top_indices)), [str(i) for i in top_indices], rotation=60)
+    plt.ylabel("Mean |value|")
+    plt.xlabel("Dimension")
+    plt.title("Top pose dimensions")
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=240)
+    plt.close()
+
+
+def plot_heatmap(norm_scores, output_path):
+    rows = 32
+    usable = (norm_scores.shape[0] // rows) * rows
+    reshaped = norm_scores[:usable].reshape(rows, -1)
+    plt.figure(figsize=(12, 4))
+    plt.imshow(reshaped, aspect="auto", cmap="magma")
+    plt.colorbar(label="Normalized importance")
+    plt.xlabel("Chunk index")
+    plt.ylabel("Row")
+    plt.title("Pose dimension importance heatmap")
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=240)
+    plt.close()
+
+
+def plot_cumulative(scores, output_path):
+    sorted_scores = np.sort(scores)[::-1]
+    cumsum = np.cumsum(sorted_scores)
+    coverage = cumsum / cumsum[-1]
+    dims = np.arange(1, len(sorted_scores) + 1)
+    plt.figure(figsize=(8, 4))
+    plt.plot(dims, coverage, color="#ff7f0e")
+    plt.xlabel("Top-k dimensions")
+    plt.ylabel("Cumulative coverage")
+    plt.grid(alpha=0.3)
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=240)
+    plt.close()
+    return coverage
+
+
+def save_csv(scores, norm_scores, output_path):
+    with open(output_path, "w", encoding="utf-8") as handle:
+        handle.write("dimension,score,normalized\n")
+        for idx, (score, norm) in enumerate(zip(scores, norm_scores)):
+            handle.write(f"{idx},{score:.8f},{norm:.6f}\n")
+
+
+def write_report(video_path, checkpoint, scores, norm_scores, coverage, top_indices, output_path):
+    levels = [0.25, 0.5, 0.9]
+    with open(output_path, "w", encoding="utf-8") as handle:
+        handle.write("Pose ViT dimensional analysis\n")
+        handle.write("=" * 60 + "\n\n")
+        handle.write(f"Video      : {video_path}\n")
+        handle.write(f"Checkpoint : {checkpoint}\n")
+        handle.write(f"Total dims : {scores.shape[0]}\n\n")
+        handle.write("Top dimensions:\n")
+        for rank, dim_idx in enumerate(top_indices, 1):
+            handle.write(
+                f"{rank:02d}. dim {dim_idx:04d} | score={scores[dim_idx]:.6f} "
+                f"| normalized={norm_scores[dim_idx]:.4f}\n"
+            )
+        handle.write("\nCoverage milestones:\n")
+        for level in levels:
+            required = int(np.argmax(coverage >= level) + 1)
+            handle.write(f"  - Top {required:4d} dims explain {level:.0%} of energy\n")
+        handle.write("\nScores computed as mean absolute activations on pose_2048.\n")
+
+
+def main():
+    args = parse_args()
+    video_path = os.path.abspath(args.video)
+    checkpoint_path = os.path.abspath(args.checkpoint)
+    output_dir = ensure_dir(args.output_dir)
+
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"Video not found: {video_path}")
+    if not os.path.exists(checkpoint_path):
+        raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}")
+
+    device = prepare_device(args.device)
+    print(f"[INFO] Using device: {device}")
+
+    pose2text = MultimodalPose2TextDiffusion(
+        input_dims=INPUT_DIMS,
+        hidden_dim=2048,
+        device=device,
+        codebook=None,
+    )
+    video2text = MultimodalVideo2TextDiffusion(
+        pose2text_model=pose2text,
+        device=device,
+    )
+
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    load_result = video2text.load_state_dict(checkpoint["model_state_dict"], strict=False)
+    if load_result.missing_keys:
+        print(f"[WARN] Missing keys ({len(load_result.missing_keys)}): {load_result.missing_keys[:5]}...")
+    if load_result.unexpected_keys:
+        print(f"[WARN] Unexpected keys ({len(load_result.unexpected_keys)}): {load_result.unexpected_keys[:5]}...")
+    video2text.eval()
+
+    frame_transform = transforms.Compose(
+        [
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+        ]
+    )
+    frames = load_video_frames(video_path, args.num_frames, frame_transform)
+    video_tensor = frames.unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        pose_features = video2text.video2pose(video_tensor)
+        concatenated = pose2text.pose_encoder(pose_features)
+        B, F, D = concatenated.shape
+        flattened = concatenated.reshape(B * F, D)
+        pose_2048 = pose2text.dim_match(flattened).view(B, F, -1)
+        pose_numpy = pose_2048.cpu().numpy()
+
+    np.save(output_dir / "pose_2048.npy", pose_numpy)
+    scores, norm_scores = compute_dimension_stats(pose_2048)
+    save_csv(scores, norm_scores, output_dir / "dimension_scores.csv")
+
+    topk = min(args.topk, scores.shape)

eval/attention_analysis.py

@@ -0,0 +1,946 @@
+#!/usr/bin/env python3
+"""
+Attention weight analysis and visualization helpers for SignX.
+
+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(
+        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 io
+import json
+import shutil
+import subprocess
+import numpy as np
+from pathlib import Path
+from datetime import datetime
+
+
+class AttentionAnalyzer:
+    """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]
+                       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
+        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:
+                self.original_video_total_frames = metadata.get('frames')
+                if metadata.get('fps'):
+                    self.original_video_fps = metadata['fps']
+            elif video_path:
+                print(f"Warning: failed to parse video metadata; gloss-to-frame visualization may be misaligned ({video_path})")
+
+        # 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:
+            self.attn_best = attentions[:, 0, :]  # [time, src_len]
+        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 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]:
+                # Out of range
+                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 for this word
+            peak_frame = int(np.argmax(attn_weights))
+            peak_weight = attn_weights[peak_frame]
+
+            # Frames whose weight >= 90% of the peak
+            threshold = peak_weight * 0.9
+            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)
+
+            # Qualitative confidence bucket
+            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 _compute_frame_attention_strength(self):
+        """Compute average attention per feature frame (normalized 0-1)."""
+        if self.attn_best.size == 0:
+            return np.zeros(self.video_frames, dtype=np.float32)
+
+        if self.attn_best.ndim == 1:
+            frame_strength = self.attn_best.copy()
+        else:
+            frame_strength = self.attn_best.mean(axis=0)
+
+        if frame_strength.shape[0] != self.video_frames:
+            frame_strength = np.resize(frame_strength, self.video_frames)
+
+        max_val = frame_strength.max()
+        if max_val > 0:
+            frame_strength = frame_strength / max_val
+        return frame_strength
+
+    def _map_strength_to_original_frames(self, mapping_list, original_frame_count):
+        """Map latent attention strength to original video frame resolution."""
+        if not mapping_list or original_frame_count <= 0:
+            return None
+
+        orig_strength = np.zeros(original_frame_count, dtype=np.float32)
+        counts = np.zeros(original_frame_count, dtype=np.float32)
+
+        for feat_idx, mapping in enumerate(mapping_list):
+            if feat_idx >= len(self.frame_attention_strength):
+                break
+            start = int(mapping.get('frame_start', 0))
+            end = int(mapping.get('frame_end', start))
+            end = max(end, start + 1)
+            start = max(start, 0)
+            end = min(end, original_frame_count)
+            if start >= end:
+                continue
+            orig_strength[start:end] += self.frame_attention_strength[feat_idx]
+            counts[start:end] += 1
+
+        mask = counts > 0
+        if mask.any():
+            orig_strength[mask] = orig_strength[mask] / counts[mask]
+
+        max_val = orig_strength.max()
+        if max_val > 0:
+            orig_strength = orig_strength / max_val
+        return orig_strength
+
+    def generate_all_visualizations(self, 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"\nGenerating visualization assets in: {output_dir}")
+
+        # 1. Attention heatmap
+        self.plot_attention_heatmap(output_dir / "attention_heatmap.png")
+
+        # 2. Frame alignment
+        self.plot_frame_alignment(output_dir / "frame_alignment.png")
+
+        # 3. JSON metadata
+        self.save_alignment_data(output_dir / "frame_alignment.json")
+
+        # 4. Text report
+        self.save_text_report(output_dir / "analysis_report.txt")
+
+        # 5. Raw numpy dump (for downstream tooling)
+        np.save(output_dir / "attention_weights.npy", self.attentions)
+
+        # 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:
+            f.write(f"video_path = {repr(self.video_path)}\n")
+            f.write(f"video_path type = {type(self.video_path)}\n")
+            f.write(f"video_path is None: {self.video_path is None}\n")
+            f.write(f"bool(video_path): {bool(self.video_path)}\n")
+
+        print(f"[DEBUG] video_path = {self.video_path}")
+        if self.video_path:
+            print(f"[DEBUG] Generating gloss-to-frames visualization with video: {self.video_path}")
+            try:
+                self.generate_gloss_to_frames_visualization(output_dir / "gloss_to_frames.png")
+                print(f"[DEBUG] Successfully generated gloss_to_frames.png")
+            except Exception as e:
+                print(f"[DEBUG] Failed to generate gloss_to_frames.png: {e}")
+                import traceback
+                traceback.print_exc()
+        else:
+            print("[DEBUG] Skipping gloss-to-frames visualization (no video path provided)")
+
+        print(f"✓ Wrote {len(list(output_dir.glob('*')))} file(s)")
+
+    def plot_attention_heatmap(self, output_path):
+        """Render the attention heatmap (image + PDF copy)."""
+        try:
+            import matplotlib
+            matplotlib.use('Agg')
+            import matplotlib.pyplot as plt
+        except ImportError:
+            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)
+
+        plt.tight_layout()
+        plt.savefig(output_path, dpi=150, bbox_inches='tight')
+        # also save PDF copy for high-res usage
+        pdf_path = Path(output_path).with_suffix('.pdf')
+        plt.savefig(str(pdf_path), format='pdf', bbox_inches='tight')
+        plt.close()
+
+        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')
+            import matplotlib.pyplot as plt
+            import matplotlib.patches as patches
+            from matplotlib.gridspec import GridSpec
+        except ImportError:
+            print("  Skipping alignment plot: matplotlib is not available")
+            return
+
+        output_path = Path(output_path)
+
+        # Try to load feature-to-frame mapping
+        feature_mapping = None
+        output_dir = output_path.parent
+        mapping_file = output_dir / "feature_frame_mapping.json"
+        if mapping_file.exists():
+            try:
+                with open(mapping_file, 'r') as f:
+                    feature_mapping = json.load(f)
+            except Exception as e:
+                print(f"  Warning: Failed to load feature mapping: {e}")
+
+        if self.word_frame_ranges:
+            max_feat_end = max(w['end_frame'] for w in self.word_frame_ranges)
+        else:
+            max_feat_end = self.video_frames - 1
+        latent_full_limit = self.video_frames + 2
+        latent_short_limit = max(min(latent_full_limit, max_feat_end + 2), 5)
+
+        original_frame_count = None
+        mapping_list = None
+        orig_full_limit = None
+        orig_short_limit = None
+        pixel_strength_curve = None
+        if feature_mapping:
+            original_frame_count = feature_mapping.get('original_frame_count', self.video_frames)
+            mapping_list = feature_mapping.get('mapping', [])
+            orig_full_limit = original_frame_count + 2
+            if mapping_list:
+                idx = min(max_feat_end, len(mapping_list) - 1)
+                orig_short_limit = mapping_list[idx]['frame_end'] + 2
+            pixel_strength_curve = self._map_strength_to_original_frames(mapping_list, original_frame_count)
+
+        def render_alignment(out_path, latent_xlim_end, orig_xlim_end=None):
+            if feature_mapping:
+                fig = plt.figure(figsize=(18, 9))
+                gs = GridSpec(3, 1, height_ratios=[4, 1, 1], hspace=0.32)
+            else:
+                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)))
+
+            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, latent_xlim_end)
+            ax1.set_ylim(-0.5, len(self.words))
+            ax1.set_xlabel('')
+            ax1.set_ylabel('')
+            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)
+
+            # === 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)
+            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, latent_xlim_end)
+            ax2.set_ylim(-0.4, 0.4)
+            ax2.set_xlabel('')
+            ax2.set_yticks([0])
+            ax2.set_yticklabels(['Latent Space'], fontsize=11, fontweight='bold')
+            ax2.tick_params(axis='y', length=0)
+            ax2.set_title('Latent Feature Timeline', fontsize=13, fontweight='bold')
+            ax2.grid(True, alpha=0.3, axis='x', linestyle='--')
+
+            if self.frame_attention_strength is not None and len(self.frame_attention_strength) >= self.video_frames:
+                latent_curve_x = np.arange(self.video_frames)
+                latent_curve_y = self.frame_attention_strength[:self.video_frames] * 0.6 - 0.3
+                ax2.plot(latent_curve_x, latent_curve_y, color='#E53935', linewidth=1.5, alpha=0.9)
+
+            timeline_axes = [ax2]
+
+            if feature_mapping:
+                ax3 = fig.add_subplot(gs[2])
+                ax3.barh(0, original_frame_count, height=0.6, color='lightgray',
+                        edgecolor='black', linewidth=2)
+
+                for i, word_info in enumerate(self.word_frame_ranges):
+                    feat_start = word_info['start_frame']
+                    feat_end = word_info['end_frame']
+                    confidence = word_info['confidence']
+                    alpha = 0.9 if confidence == 'high' else 0.7 if confidence == 'medium' else 0.5
+                    if mapping_list and feat_start < len(mapping_list) and feat_end < len(mapping_list):
+                        orig_start = mapping_list[feat_start]['frame_start']
+                        orig_end = mapping_list[feat_end]['frame_end']
+                        ax3.barh(0, orig_end - orig_start, left=orig_start, height=0.6,
+                                color=colors[i % 20], alpha=alpha, edgecolor='black', linewidth=0.5)
+
+                ax3_xlim = orig_xlim_end if orig_xlim_end is not None else original_frame_count + 2
+                ax3.set_xlim(-2, ax3_xlim)
+                ax3.set_ylim(-0.4, 0.4)
+                ax3.set_xlabel('')
+                ax3.set_yticks([0])
+                ax3.set_yticklabels(['Pixel Space'], fontsize=11, fontweight='bold')
+                ax3.tick_params(axis='y', length=0)
+                ax3.set_title(f'Original Video Timeline ({original_frame_count} frames, '
+                             f'{feature_mapping["downsampling_ratio"]:.2f}x downsampling)',
+                             fontsize=13, fontweight='bold')
+                ax3.grid(True, alpha=0.3, axis='x', linestyle='--')
+
+                if pixel_strength_curve is not None and len(pixel_strength_curve) >= original_frame_count:
+                    pixel_curve_x = np.arange(original_frame_count)
+                    pixel_curve_y = pixel_strength_curve[:original_frame_count] * 0.6 - 0.3
+                    ax3.plot(pixel_curve_x, pixel_curve_y, color='#E53935', linewidth=1.5, alpha=0.9)
+                timeline_axes.append(ax3)
+
+            plt.tight_layout()
+            fig.canvas.draw()
+
+            ax1_pos = ax1.get_position()
+            renderer = fig.canvas.get_renderer()
+            ytick_extents = [tick.get_window_extent(renderer) for tick in ax1.get_yticklabels() if tick.get_text()]
+            fig_width_px = fig.get_size_inches()[0] * fig.dpi
+            if ytick_extents:
+                min_x_px = min(ext.x0 for ext in ytick_extents)
+            else:
+                min_x_px = ax1_pos.x0 * fig_width_px
+            line_x = max(0.01, (min_x_px / fig_width_px) - 0.01)
+            gw_center = 0.5 * (ax1_pos.y0 + ax1_pos.y1)
+            timeline_bounds = [ax.get_position() for ax in timeline_axes]
+            timeline_center = 0.5 * (min(pos.y0 for pos in timeline_bounds) + max(pos.y1 for pos in timeline_bounds))
+            fig.text(line_x, gw_center, 'Generated Word', rotation='vertical',
+                     ha='right', va='center', fontsize=12, fontweight='bold')
+            fig.text(line_x, timeline_center, 'Timeline', rotation='vertical',
+                     ha='right', va='center', fontsize=12, fontweight='bold')
+
+            png_path = Path(out_path)
+            plt.savefig(str(png_path), dpi=150, bbox_inches='tight')
+            pdf_path = png_path.with_suffix('.pdf')
+            plt.savefig(str(pdf_path), format='pdf', bbox_inches='tight')
+            plt.close()
+
+            print(f"  ✓ {png_path.name} (PDF copy saved)")
+
+        render_alignment(output_path, latent_full_limit, orig_full_limit)
+
+        if latent_short_limit < latent_full_limit - 1e-6:
+            short_path = output_path.with_name("frame_alignment_short.png")
+            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):
+        """Persist frame-alignment metadata to 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):
+        """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 Analysis Report\n")
+            f.write("=" * 80 + "\n\n")
+
+            f.write(f"Generated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+
+            f.write("Translation:\n")
+            f.write("-" * 80 + "\n")
+            f.write(f"{self.translation}\n\n")
+
+            f.write("Video info:\n")
+            f.write("-" * 80 + "\n")
+            f.write(f"Total feature frames: {self.video_frames}\n")
+            f.write(f"Word count: {len(self.words)}\n\n")
+
+            f.write("Attention tensor:\n")
+            f.write("-" * 80 + "\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 size: {self.attentions.shape[1]}\n")
+            if len(self.attentions.shape) >= 4:
+                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("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")
+
+            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")
+
+            # 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'),
+                '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("\nSummary:\n")
+            f.write("-" * 80 + "\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}")
+
+
+    def _map_feature_frame_to_original(self, feature_frame_idx):
+        """
+        Map a SMKD feature frame index back to the original video frame index.
+
+        Args:
+            feature_frame_idx: Zero-based feature frame index
+
+        Returns:
+            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[int] of original frame IDs to load
+
+        Returns:
+            dict mapping frame index to numpy array (BGR).
+        """
+        if not self.video_path:
+            return {}
+
+        cv2 = self._get_cv2_module()
+        if cv2 is not None:
+            return self._extract_frames_with_cv2(cv2, frame_indices)
+
+        return self._extract_frames_with_ffmpeg(frame_indices)
+
+    def _get_cv2_module(self):
+        """Lazy-load cv2 and cache the import outcome."""
+        if self._cv2_checked:
+            return self._cv2_module
+
+        try:
+            import cv2
+            self._cv2_module = cv2
+        except ImportError:
+            self._cv2_module = None
+        finally:
+            self._cv2_checked = True
+
+        if self._cv2_module is None:
+            print("Warning: opencv-python is missing; falling back to ffmpeg grabs")
+        return self._cv2_module
+
+    def _extract_frames_with_cv2(self, cv2, frame_indices):
+        """Extract frames via OpenCV if available."""
+        frames = {}
+        cap = cv2.VideoCapture(self.video_path)
+
+        if not cap.isOpened():
+            print(f"Warning: Cannot open video file: {self.video_path}")
+            return {}
+
+        for frame_idx in sorted(frame_indices):
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+            ret, frame = cap.read()
+            if ret:
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frames[frame_idx] = frame_rgb
+
+        cap.release()
+        return frames
+
+    def _extract_frames_with_ffmpeg(self, frame_indices):
+        """Extract frames via ffmpeg + Pillow (OpenCV fallback)."""
+        if shutil.which("ffmpeg") is None:
+            print("Warning: ffmpeg not found; cannot extract frames")
+            return {}
+
+        try:
+            from PIL import Image
+        except ImportError:
+            print("Warning: Pillow not installed; cannot decode ffmpeg output")
+            return {}
+
+        frames = {}
+        for frame_idx in sorted(frame_indices):
+            cmd = [
+                "ffmpeg",
+                "-v", "error",
+                "-i", str(self.video_path),
+                "-vf", f"select=eq(n\\,{frame_idx})",
+                "-vframes", "1",
+                "-f", "image2pipe",
+                "-vcodec", "png",
+                "-"
+            ]
+            try:
+                result = subprocess.run(
+                    cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+                )
+                if not result.stdout:
+                    continue
+                image = Image.open(io.BytesIO(result.stdout)).convert("RGB")
+                frames[frame_idx] = np.array(image)
+            except subprocess.CalledProcessError as e:
+                print(f"Warning: ffmpeg failed to extract frame {frame_idx}: {e}")
+            except Exception as ex:
+                print(f"Warning: failed to decode frame {frame_idx}: {ex}")
+
+        if frames:
+            print(f"  ✓ Extracted {len(frames)} frame(s) via ffmpeg")
+        else:
+            print("  ⓘ ffmpeg did not return any frames")
+        return frames
+
+    def generate_gloss_to_frames_visualization(self, 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)")
+            return
+
+        try:
+            import matplotlib.pyplot as plt
+            import matplotlib.gridspec as gridspec
+        except ImportError:
+            print("Warning: matplotlib not installed")
+            return
+
+        # Load feature-to-frame mapping if available
+        feature_mapping = None
+        output_dir = Path(output_path).parent
+        mapping_file = output_dir / "feature_frame_mapping.json"
+        if mapping_file.exists():
+            try:
+                with open(mapping_file, 'r') as f:
+                    mapping_data = json.load(f)
+                    feature_mapping = mapping_data['mapping']
+            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']
+
+            # Map the feature range onto original video frames
+            if feature_mapping:
+                # Use the precomputed mapping data
+                for feat_idx in range(start_feat, end_feat + 1):
+                    if feat_idx < len(feature_mapping):
+                        # 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:
+                # 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)
+
+        # 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
+
+        # 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)):
+            # 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')
+
+            # 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']
+
+            feature_text = f"SMKD Feature Index\n"
+            feature_text += f"{'='*20}\n\n"
+            feature_text += f"Range:\n  {feat_start} → {feat_end}\n\n"
+            feature_text += f"Peak:\n  {feat_peak}\n\n"
+            feature_text += f"Count:\n  {feat_end - feat_start + 1} features"
+
+            ax_feature.text(0.5, 0.5, feature_text, fontsize=11, family='monospace',
+                           va='center', ha='center',
+                           bbox=dict(boxstyle='round,pad=0.8', facecolor='lightblue',
+                                   edgecolor='darkblue', linewidth=2, alpha=0.7))
+            ax_feature.axis('off')
+
+            # 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):
+                # 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']
+
+                # 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',
+                                   bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.7))
+            else:
+                ax_peak_frames.text(0.5, 0.5, "No peak frames",
+                                   ha='center', va='center', transform=ax_peak_frames.transAxes)
+
+            ax_peak_frames.axis('off')
+
+            # 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:
+                # 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,
+                                  fontsize=10, weight='bold', color='blue',
+                                  bbox=dict(boxstyle='round,pad=0.3', facecolor='lightblue', alpha=0.7))
+            else:
+                ax_all_frames.text(0.5, 0.5, "No frames available",
+                                  ha='center', va='center', transform=ax_all_frames.transAxes)
+
+            ax_all_frames.axis('off')
+
+        plt.suptitle(f"Three-Layer Alignment: Gloss ↔ Feature Index ↔ Original Frames\nTranslation: {self.translation}",
+                     fontsize=16, weight='bold', y=0.995)
+
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close()
+
+        print(f"  ✓ {Path(output_path).name}")
+
+    def _read_video_metadata(self):
+        """Attempt to read the original video's frame count and FPS."""
+        metadata = self._read_metadata_with_cv2()
+        if metadata:
+            return metadata
+        return self._read_metadata_with_ffprobe()
+
+    def _read_metadata_with_cv2(self):
+        cv2 = self._get_cv2_module()
+        if cv2 is None:
+            return None
+
+        cap = cv2.VideoCapture(self.video_path)
+        if not cap.isOpened():
+            return None
+
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        cap.release()
+
+        if total_frames <= 0:
+            return None
+
+        return {'frames': total_frames, 'fps': fps or self.original_video_fps}
+
+    def _read_metadata_with_ffprobe(self):
+        if shutil.which("ffprobe") is None:
+            return None
+
+        cmd = [
+            "ffprobe",
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "stream=nb_frames,r_frame_rate,avg_frame_rate,duration",
+            "-of", "json",
+            str(self.video_path)
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+            )
+        except subprocess.CalledProcessError:
+            return None
+
+        try:
+            info = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return None
+
+        streams = info.get("streams") or []
+        if not streams:
+            return None
+
+        stream = streams[0]
+        total_frames = stream.get("nb_frames")
+        fps = stream.get("avg_frame_rate") or stream.get("r_frame_rate")
+        duration = stream.get("duration")
+
+        fps_value = self._parse_ffprobe_fps(fps)
+        total_frames_value = None
+
+        if isinstance(total_frames, str) and total_frames.isdigit():
+            total_frames_value = int(total_frames)
+
+        if total_frames_value is None and duration and fps_value:
+            try:
+                total_frames_value = int(round(float(duration) * fps_value))
+            except ValueError:
+                total_frames_value = None
+
+        if total_frames_value is None:
+            return None
+
+        return {'frames': total_frames_value, 'fps': fps_value or self.original_video_fps}
+
+    @staticmethod
+    def _parse_ffprobe_fps(rate_str):
+        """Parse an ffprobe frame-rate string such as '30000/1001'."""
+        if not rate_str or rate_str in ("0/0", "0"):
+            return None
+
+        if "/" in rate_str:
+            num, denom = rate_str.split("/", 1)
+            try:
+                num = float(num)
+                denom = float(denom)
+                if denom == 0:
+                    return None
+                return num / denom
+            except ValueError:
+                return None
+
+        try:
+            return float(rate_str)
+        except ValueError:
+            return None
+
+
+def analyze_from_numpy_file(attention_file, translation, video_frames, output_dir):
+    """
+    Load attention weights from a .npy file and generate visualization assets.
+
+    Args:
+        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)
+    analyzer.generate_all_visualizations(output_dir)
+    return analyzer

eval/benchmark_smkd.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+# 测试 SMKD 视频特征提取的效率 (包含 pose 协助)
+set -e
+
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+echo ""
+echo "======================================================================"
+echo "  SMKD Feature Extraction Benchmark (with Pose Assistance)"
+echo "======================================================================"
+echo ""
+
+# 激活conda
+CONDA_BASE=$(conda info --base 2>/dev/null || echo "")
+source "${CONDA_BASE}/etc/profile.d/conda.sh"
+
+# 切换到 PyTorch 环境
+conda activate signx-slt
+
+if [ $? -ne 0 ]; then
+    echo "错误: 无法激活 signx-slt 环境"
+    exit 1
+fi
+
+# 使用测试集视频进行基准测试
+TEST_VIDEO_DIR="${PROJECT_ROOT}/eval/tiny_test_data/videos"
+
+if [ ! -d "$TEST_VIDEO_DIR" ]; then
+    echo "错误: 测试视频目录不存在: $TEST_VIDEO_DIR"
+    exit 1
+fi
+
+# 获取所有测试视频
+TEST_VIDEOS=($(ls ${TEST_VIDEO_DIR}/*.mp4 2>/dev/null | head -10))
+NUM_VIDEOS=${#TEST_VIDEOS[@]}
+
+if [ $NUM_VIDEOS -eq 0 ]; then
+    echo "错误: 未找到测试视频"
+    exit 1
+fi
+
+echo "找到 $NUM_VIDEOS 个测试视频"
+echo ""
+
+# 创建临时视频列表文件
+TEMP_DIR=$(mktemp -d)
+VIDEO_LIST_FILE="$TEMP_DIR/video_list.txt"
+
+for video in "${TEST_VIDEOS[@]}"; do
+    echo "$video" >> "$VIDEO_LIST_FILE"
+done
+
+FEATURE_OUTPUT="$TEMP_DIR/features.h5"
+
+# 配置文件（使用禁用 pose assistance 的配置）
+SMKD_CONFIG="${PROJECT_ROOT}/smkd/asllrp_baseline_benchmark.yaml"
+SMKD_MODEL="${PROJECT_ROOT}/smkd/work_dir第一次训练的基线/asllrp_smkd/best_model.pt"
+GLOSS_DICT="${PROJECT_ROOT}/smkd/asllrp/gloss_dict.npy"
+
+cd "$PROJECT_ROOT"
+
+echo -e "${BLUE}开始 SMKD 特征提取基准测试...${NC}"
+echo ""
+
+# 记录GPU功耗（后台进程）
+nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits -l 1 > /tmp/power_smkd.log &
+POWER_PID=$!
+
+# 测量特征提取时间
+START=$(date +%s.%N)
+
+python -c "
+import sys
+import os
+sys.path.insert(0, 'smkd')
+
+from smkd.sign_embedder import SignEmbedding
+import h5py
+import numpy as np
+
+print('  加载 SMKD 模型...')
+embedder = SignEmbedding(
+    cfg='$SMKD_CONFIG',
+    gloss_path='$GLOSS_DICT',
+    sign_video_path='$VIDEO_LIST_FILE',
+    model_path='$SMKD_MODEL',
+    gpu_id='0',
+    batch_size=1
+)
+
+print('  提取特征...')
+features = embedder.embed()
+
+print('  保存特征到 h5 文件...')
+with h5py.File('$FEATURE_OUTPUT', 'w') as hf:
+    for key, feature in features.items():
+        hf.create_dataset(key, data=feature)
+
+print('  ✓ 特征提取完成')
+print('  特征数量:', len(features))
+"
+
+END=$(date +%s.%N)
+
+# 停止功耗监控
+kill $POWER_PID 2>/dev/null || true
+
+# 计算结果
+SMKD_TIME=$(echo "$END - $START" | bc)
+SMKD_POWER=$(awk '{ sum += $1; n++ } END { if (n > 0) print sum / n }' /tmp/power_smkd.log)
+SMKD_FPS=$(echo "scale=2; $NUM_VIDEOS / $SMKD_TIME" | bc)
+
+echo ""
+echo -e "${GREEN}✓ SMKD 特征提取完成${NC}"
+echo "  处理视频数: $NUM_VIDEOS"
+echo "  总时间: ${SMKD_TIME}s"
+echo "  平均功耗: ${SMKD_POWER}W"
+echo "  FPS: $SMKD_FPS"
+echo ""
+
+# 清理
+rm -rf "$TEMP_DIR"
+rm -f /tmp/power_smkd.log
+
+echo "======================================================================"
+echo "  SMKD Benchmark Results"
+echo "======================================================================"
+echo ""
+echo "Configuration: SMKD (视频→特征, 包含 Pose 协助)"
+echo "Videos: $NUM_VIDEOS"
+echo "Time: ${SMKD_TIME}s"
+echo "FPS: $SMKD_FPS"
+echo "Power: ${SMKD_POWER}W"
+echo ""
+echo -e "${GREEN}✓ Benchmark complete!${NC}"
+echo ""

eval/extract_attention_keyframes.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Extract peak-feature keyframes and overlay attention heatmaps on the video frames.
+"""
+
+import os
+import sys
+import cv2
+import numpy as np
+import json
+from pathlib import Path
+import matplotlib.pyplot as plt
+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: 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
+
+    # 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))
+
+    # Normalize to [0, 1]
+    gaussian = (gaussian - gaussian.min()) / (gaussian.max() - gaussian.min() + 1e-8)
+
+    # Apply the attention weight
+    heatmap = gaussian * attention_weight
+
+    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
+
+
+def extract_keyframes_with_attention(sample_dir, video_path):
+    """
+    Extract peak-feature keyframes and overlay the attention visualization.
+
+    Args:
+        sample_dir: Sample directory path (e.g., detailed_xxx/sample_0)
+        video_path: Original video path
+    """
+    sample_dir = Path(sample_dir)
+
+    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 not found: {mapping_file}")
+        return
+
+    if not weights_file.exists():
+        print(f"  ⚠ Attention weights missing: {weights_file}")
+        return
+
+    if not os.path.exists(video_path):
+        print(f"  ⚠ Video file not found: {video_path}")
+        return
+
+    # 加载映射和注意力权重
+    with open(mapping_file, 'r') as f:
+        mapping_data = json.load(f)
+
+    attention_weights = np.load(weights_file)
+
+    # Create output directory
+    keyframes_dir = sample_dir / "attention_keyframes"
+    keyframes_dir.mkdir(exist_ok=True)
+
+    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"  ✗ Failed to open video: {video_path}")
+        return
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    print(f"  Total video frames: {total_frames}")
+
+    # 构建特征索引到帧的映射（使用中间帧）
+    feature_to_frame = {}
+    for item in mapping_data['mapping']:
+        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("  ⚠ Invalid attention weight dimensions")
+        cap.release()
+        return
+
+    saved_count = 0
+
+    for gloss_idx in range(num_glosses):
+        gloss_attention = attention_weights[gloss_idx]  # shape: (num_features,)
+
+        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}: 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}: 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
+
+        cv2.imwrite(str(output_path), frame_with_attention)
+        saved_count += 1
+
+    cap.release()
+
+    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("Attention Keyframe Index\n")
+        f.write(f"=" * 60 + "\n\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):
+            gloss_attention = attention_weights[gloss_idx]
+            peak_feature_idx = np.argmax(gloss_attention)
+            peak_attention = gloss_attention[peak_feature_idx]
+
+            if peak_feature_idx in feature_to_frame:
+                frame_idx = feature_to_frame[peak_feature_idx]
+                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 written: {index_file}")
+
+
+def main():
+    if len(sys.argv) < 3:
+        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]
+    video_path = sys.argv[2]
+
+    extract_keyframes_with_attention(sample_dir, video_path)
+
+
+if __name__ == "__main__":
+    main()

eval/generate_feature_mapping.py

@@ -0,0 +1,126 @@
+#!/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>
+
+Example:
+    python generate_feature_mapping.py detailed_prediction_20251226_155113/sample_000 \\
+        eval/tiny_test_data/videos/632051.mp4
+"""
+
+import sys
+import os
+import json
+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"Error: missing attention_weights.npy: {attn_file}")
+        return False
+
+    # Load attention weights to get feature count
+    attn_weights = np.load(attn_file)
+    # Handle both 2D (time, features) and 3D (time, beam, features) shapes
+    if attn_weights.ndim == 2:
+        feature_count = attn_weights.shape[1]  # Shape: (time, features) - inference mode
+    elif attn_weights.ndim == 3:
+        feature_count = attn_weights.shape[2]  # Shape: (time, beam, features) - beam search
+    else:
+        print(f"Error: unexpected attention_weights shape: {attn_weights.shape}")
+        return False
+
+    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"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 frames: {original_frame_count}, FPS: {fps}")
+
+    except ImportError:
+        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]
+    frame_mapping = []
+    for feat_idx in range(feature_count):
+        start_frame = int(feat_idx * original_frame_count / feature_count)
+        end_frame = int((feat_idx + 1) * original_frame_count / feature_count)
+        frame_mapping.append({
+            "feature_index": feat_idx,
+            "frame_start": start_frame,
+            "frame_end": end_frame,
+            "frame_count": end_frame - start_frame
+        })
+
+    # Save mapping
+    mapping_data = {
+        "original_frame_count": original_frame_count,
+        "feature_count": feature_count,
+        "downsampling_ratio": original_frame_count / feature_count,
+        "fps": fps,
+        "mapping": frame_mapping
+    }
+
+    output_file = sample_dir / "feature_frame_mapping.json"
+    with open(output_file, 'w') as f:
+        json.dump(mapping_data, f, indent=2)
+
+    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("\nSample mappings:")
+    for i in range(min(3, len(frame_mapping))):
+        mapping = frame_mapping[i]
+        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"  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("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)
+
+    sample_dir = sys.argv[1]
+    video_path = sys.argv[2]
+
+    if not os.path.exists(sample_dir):
+        print(f"Error: sample directory not found: {sample_dir}")
+        sys.exit(1)
+
+    if not os.path.exists(video_path):
+        print(f"Error: video file not found: {video_path}")
+        sys.exit(1)
+
+    success = generate_feature_mapping(sample_dir, video_path)
+    sys.exit(0 if success else 1)

eval/generate_gloss_frames.py

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

eval/generate_interactive_alignment.py

@@ -0,0 +1,670 @@
+#!/usr/bin/env python3
+"""
+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
+"""
+
+import sys
+import json
+import numpy as np
+from pathlib import Path
+
+def generate_interactive_html(sample_dir, output_path):
+    """Create the interactive alignment HTML for the given sample directory."""
+
+    sample_dir = Path(sample_dir)
+
+    # 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:
+        attn_weights = attention_weights  # [time_steps, src_len] - already 2D
+    elif attention_weights.ndim == 3:
+        attn_weights = attention_weights[:, :, 0]  # [time_steps, src_len] - take beam 0
+    else:
+        raise ValueError(f"Unexpected attention weights shape: {attention_weights.shape}")
+
+    # 2. Load translation output
+    with open(sample_dir / "translation.txt", 'r') as f:
+        lines = f.readlines()
+        gloss_sequence = None
+        for line in lines:
+            if line.startswith('Clean:'):
+                gloss_sequence = line.replace('Clean:', '').strip()
+                break
+
+    if not gloss_sequence:
+        print("Error: translation text not found")
+        return
+
+    glosses = gloss_sequence.split()
+    num_glosses = len(glosses)
+    num_features = attn_weights.shape[1]
+
+    print(f"Gloss sequence: {glosses}")
+    print(f"Feature count: {num_features}")
+    print(f"Attention shape: {attn_weights.shape}")
+
+    # 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()
+        attn_data.append({
+            'word': glosses[word_idx],
+            'word_idx': word_idx,
+            'weights': weights
+        })
+
+    # 4. Build the HTML payload
+    html_content = f"""<!DOCTYPE html>
+<html lang="en">
+<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> {' '.join(glosses)}<br>
+            <strong>Total Words:</strong> {num_glosses} |
+            <strong>Total Features:</strong> {num_features}
+        </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;">
+                    A frame is considered “significant” if its attention ≥ (peak × threshold%)
+                </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;">
+                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>
+
+            <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 = {json.dumps(attn_data, ensure_ascii=False)};
+        const numGlosses = {num_glosses};
+        const numFeatures = {num_features};
+
+        // 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>
+"""
+
+    # 5. Write the HTML file
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+
+    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("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"Error: directory not found: {sample_dir}")
+        sys.exit(1)
+
+    output_path = sample_dir / "interactive_alignment.html"
+    generate_interactive_html(sample_dir, output_path)
+
+    print("\nUsage:")
+    print(f"  Open in a browser: {output_path.absolute()}")
+    print("  Move the sliders to preview different threshold settings in real time.")

eval/good_videos_copy.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# 执行前请确保目标目录可写：SignX/eval/tiny_test_data/good_videos
+set -e
+
+DEST="/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/SignX/eval/tiny_test_data/good_videos"
+SRC_BASE="/research/cbim/vast/sf895/code/Sign-X/output/huggingface_asllrp_repo/ASLLRP_utterances_results"
+
+mkdir -p "$DEST"
+
+cp "$SRC_BASE/7710510/crop_original_video.mp4"   "$DEST/7710510.mp4"
+cp "$SRC_BASE/97999512/crop_original_video.mp4"  "$DEST/97999512.mp4"
+cp "$SRC_BASE/7566726/crop_original_video.mp4"   "$DEST/7566726.mp4"
+cp "$SRC_BASE/629983/crop_original_video.mp4"    "$DEST/629983.mp4"
+cp "$SRC_BASE/619048/crop_original_video.mp4"    "$DEST/619048.mp4"
+cp "$SRC_BASE/171921/crop_original_video.mp4"    "$DEST/171921.mp4"
+cp "$SRC_BASE/6185381/crop_original_video.mp4"   "$DEST/6185381.mp4"
+cp "$SRC_BASE/83940846/crop_original_video.mp4"  "$DEST/83940846.mp4"
+cp "$SRC_BASE/63579/crop_original_video.mp4"     "$DEST/63579.mp4"
+cp "$SRC_BASE/83940254/crop_original_video.mp4"  "$DEST/83940254.mp4"
+cp "$SRC_BASE/6185086/crop_original_video.mp4"   "$DEST/6185086.mp4"
+cp "$SRC_BASE/83941734/crop_original_video.mp4"  "$DEST/83941734.mp4"
+cp "$SRC_BASE/7982378/crop_original_video.mp4"   "$DEST/7982378.mp4"
+cp "$SRC_BASE/31655975/crop_original_video.mp4"  "$DEST/31655975.mp4"
+cp "$SRC_BASE/7454155/crop_original_video.mp4"   "$DEST/7454155.mp4"
+cp "$SRC_BASE/3381121/crop_original_video.mp4"   "$DEST/3381121.mp4"
+cp "$SRC_BASE/23880856/crop_original_video.mp4"  "$DEST/23880856.mp4"
+cp "$SRC_BASE/3378265/crop_original_video.mp4"   "$DEST/3378265.mp4"
+cp "$SRC_BASE/7701925/crop_original_video.mp4"   "$DEST/7701925.mp4"
+cp "$SRC_BASE/4236171/crop_original_video.mp4"   "$DEST/4236171.mp4"
+cp "$SRC_BASE/8394388/crop_original_video.mp4"   "$DEST/8394388.mp4"
+cp "$SRC_BASE/634818/crop_original_video.mp4"    "$DEST/634818.mp4"
+cp "$SRC_BASE/173745/crop_original_video.mp4"    "$DEST/173745.mp4"
+cp "$SRC_BASE/7569669/crop_original_video.mp4"   "$DEST/7569669.mp4"
+cp "$SRC_BASE/50802118/crop_original_video.mp4"  "$DEST/50802118.mp4"
+cp "$SRC_BASE/4235359/crop_original_video.mp4"   "$DEST/4235359.mp4"
+cp "$SRC_BASE/842226/crop_original_video.mp4"    "$DEST/842226.mp4"
+cp "$SRC_BASE/7981884/crop_original_video.mp4"   "$DEST/7981884.mp4"
+cp "$SRC_BASE/31657848/crop_original_video.mp4"  "$DEST/31657848.mp4"
+cp "$SRC_BASE/7983362/crop_original_video.mp4"   "$DEST/7983362.mp4"
+cp "$SRC_BASE/5597316/crop_original_video.mp4"   "$DEST/5597316.mp4"
+cp "$SRC_BASE/173238/crop_original_video.mp4"    "$DEST/173238.mp4"
+cp "$SRC_BASE/843240/crop_original_video.mp4"    "$DEST/843240.mp4"
+cp "$SRC_BASE/23881350/crop_original_video.mp4"  "$DEST/23881350.mp4"
+
+
+
+  - Sample 4 (7710510): NIGHT IX FATHER ARRIVE fs-LATE
+  - Sample 7 (97999512): #NO IX-1p NOT GO-OUT
+  - Sample 11 (7566726): MAYBE POSS CAR HERE
+  - Sample 15 (629983): IX FINISH WORK WHEN IX
+  - Sample 26 (619048): IF STUDENT IX HEAR/LISTEN TEACH+AGENT FUTURE LEARN SOMETHING/ONE
+  - Sample 33 (171921): IX-1p NOT LIKE PINEAPPLE fs-CREAM+CHEESE IX-1p
+  - Sample 38 (6185381): MOTHER SICK HOW part:indef
+  - Sample 40 (83940846, 83940945): DEPART WHO
+  - Sample 43 (63579): IX-1p WORK
+  - Sample 45 (83940254): SWIM fs-BEACH IX WHO IX
+  - Sample 53 (6185086): WHO MUST PAY EVERY-MONTH/RENT
+  - Sample 58 (83941734, 83943314): FRIEND IX DEPART CAMP
+  - Sample 61 (7982378): IX-1p PROCEED TAKE-UP #BBQ GROUP/TOGETHER
+  - Sample 64 (31655975): IX-1p SCL:U-L"person passed out" DRUNK
+    PAST+NIGHT QMwg
+  - Sample 68 (7454155, 8397543): BUY CAR WHO part:indef
+  - Sample 74 (3381121): BOX/ROOM IX NOT-YET ARRIVE IX SHOULD CONTACT
+    ns-fs-FEDEX
+  - Sample 81 (23880856): #IF RAIN IX-1p DEPART part:indef
+  - Sample 86 (3378265): #IF IX NOT BORE IX-1p FUTURE READ IX-1p
+    part:indef
+  - Sample 87 (7701925, 7709712): IX-1p GO-OUT SWIM fs-BEACH
+  - Sample 92 (4236171, 61835108): FRIEND WANT BUY PLAID VOLUNTEER/SHIRT
+  - Sample 94 (8394388): FRIEND GO-OUT TOGETHER/GO-STEADY
+  - Sample 107 (634818): FRIEND IX-pl PARTY GOOD/THANK-YOU
+  - Sample 118 (173745, 173746, 26827222): CAR BREAK-DOWN
+  - Sample 133 (7569669): POSS-1p FRIEND TELL IX BORN ns-CHICAGO
+  - Sample 150 (50802118): IX ns-fs-JOHN HAVE DIFFERENT CAR
+  - Sample 167 (4235359): WHO ASK FOR DIRECT
+  - Sample 172 (842226): FRIEND LOVE SURF-INTERNET REALLY+WORK QMwg
+  - Sample 179 (7981884): IX TEND CHAT WITH IX-pl-2
+  - Sample 184 (31657848): MOTHER SICK QMwg
+  - Sample 187 (7983362): FATHER FINISH MOW GRASS
+  - Sample 192 (5597316): SOMETHING/ONE BUY CAR WHO part:indef
+  - Sample 199 (173238): #NO IX-1p USE CORRECT KEY
+  - Sample 206 (843240): #HS IX GO-OUT WHERE IX
+  - Sample 208 (23881350): HAPPEN RAIN IX-1p STAY HOME
+
+
+echo "复制完成：34 个视频"
+echo "如需额外的同义 key，可将上面命令中的目录替换为 83940945、83943314、7709712、61835108、173746、26827222、8397543 等再运行一次。"

eval/metrics.py

@@ -0,0 +1,320 @@
+# coding: utf-8
+"""
+This module holds various MT evaluation metrics.
+"""
+
+import argparse
+import sacrebleu
+import mscoco_rouge
+import numpy as np
+import phoenix_cleanup as phoenix_utils
+
+WER_COST_DEL = 3
+WER_COST_INS = 3
+WER_COST_SUB = 4
+
+
+def chrf(references, hypotheses):
+    """
+    Character F-score from sacrebleu
+
+    :param hypotheses: list of hypotheses (strings)
+    :param references: list of references (strings)
+    :return:
+    """
+    return (
+        sacrebleu.corpus_chrf(hypotheses=hypotheses, references=references).score * 100
+    )
+
+
+def bleu(references, hypotheses):
+    """
+    Raw corpus BLEU from sacrebleu (without tokenization)
+
+    :param hypotheses: list of hypotheses (strings)
+    :param references: list of references (strings)
+    :return:
+    """
+    bleu_scores = sacrebleu.raw_corpus_bleu(
+        sys_stream=hypotheses, ref_streams=[references]
+    ).scores
+    scores = {}
+    for n in range(len(bleu_scores)):
+        scores["bleu" + str(n + 1)] = bleu_scores[n]
+    return scores
+
+
+def sableu(references, hypotheses, tokenizer):
+    """
+    Sacrebleu (with tokenization)
+
+    :param hypotheses: list of hypotheses (strings)
+    :param references: list of references (strings)
+    :return:
+    """
+    bleu_scores = sacrebleu.corpus_bleu(
+        sys_stream=hypotheses, ref_streams=[references], tokenize=tokenizer,
+    ).scores
+    scores = {}
+    for n in range(len(bleu_scores)):
+        scores["bleu" + str(n + 1)] = bleu_scores[n]
+    return scores
+
+
+def token_accuracy(references, hypotheses, level="word"):
+    """
+    Compute the accuracy of hypothesis tokens: correct tokens / all tokens
+    Tokens are correct if they appear in the same position in the reference.
+
+    :param hypotheses: list of hypotheses (strings)
+    :param references: list of references (strings)
+    :param level: segmentation level, either "word", "bpe", or "char"
+    :return:
+    """
+    correct_tokens = 0
+    all_tokens = 0
+    split_char = " " if level in ["word", "bpe"] else ""
+    assert len(hypotheses) == len(references)
+    for hyp, ref in zip(hypotheses, references):
+        all_tokens += len(hyp)
+        for h_i, r_i in zip(hyp.split(split_char), ref.split(split_char)):
+            # min(len(h), len(r)) tokens considered
+            if h_i == r_i:
+                correct_tokens += 1
+    return (correct_tokens / all_tokens) * 100 if all_tokens > 0 else 0.0
+
+
+def sequence_accuracy(references, hypotheses):
+    """
+    Compute the accuracy of hypothesis tokens: correct tokens / all tokens
+    Tokens are correct if they appear in the same position in the reference.
+
+    :param hypotheses: list of hypotheses (strings)
+    :param references: list of references (strings)
+    :return:
+    """
+    assert len(hypotheses) == len(references)
+    correct_sequences = sum(
+        [1 for (hyp, ref) in zip(hypotheses, references) if hyp == ref]
+    )
+    return (correct_sequences / len(hypotheses)) * 100 if hypotheses else 0.0
+
+
+def rouge(references, hypotheses):
+    rouge_score = 0
+    n_seq = len(hypotheses)
+
+    for h, r in zip(hypotheses, references):
+        rouge_score += mscoco_rouge.calc_score(hypotheses=[h], references=[r]) / n_seq
+
+    return rouge_score * 100
+
+
+def wer_list(references, hypotheses):
+    total_error = total_del = total_ins = total_sub = total_ref_len = 0
+
+    for r, h in zip(references, hypotheses):
+        res = wer_single(r=r, h=h)
+        total_error += res["num_err"]
+        total_del += res["num_del"]
+        total_ins += res["num_ins"]
+        total_sub += res["num_sub"]
+        total_ref_len += res["num_ref"]
+
+    wer = (total_error / total_ref_len) * 100
+    del_rate = (total_del / total_ref_len) * 100
+    ins_rate = (total_ins / total_ref_len) * 100
+    sub_rate = (total_sub / total_ref_len) * 100
+
+    return {
+        "wer": wer,
+        "del_rate": del_rate,
+        "ins_rate": ins_rate,
+        "sub_rate": sub_rate,
+    }
+
+
+def wer_single(r, h):
+    r = r.strip().split()
+    h = h.strip().split()
+    edit_distance_matrix = edit_distance(r=r, h=h)
+    alignment, alignment_out = get_alignment(r=r, h=h, d=edit_distance_matrix)
+
+    num_cor = np.sum([s == "C" for s in alignment])
+    num_del = np.sum([s == "D" for s in alignment])
+    num_ins = np.sum([s == "I" for s in alignment])
+    num_sub = np.sum([s == "S" for s in alignment])
+    num_err = num_del + num_ins + num_sub
+    num_ref = len(r)
+
+    return {
+        "alignment": alignment,
+        "alignment_out": alignment_out,
+        "num_cor": num_cor,
+        "num_del": num_del,
+        "num_ins": num_ins,
+        "num_sub": num_sub,
+        "num_err": num_err,
+        "num_ref": num_ref,
+    }
+
+
+def edit_distance(r, h):
+    """
+    Original Code from https://github.com/zszyellow/WER-in-python/blob/master/wer.py
+    This function is to calculate the edit distance of reference sentence and the hypothesis sentence.
+    Main algorithm used is dynamic programming.
+    Attributes:
+        r -> the list of words produced by splitting reference sentence.
+        h -> the list of words produced by splitting hypothesis sentence.
+    """
+    d = np.zeros((len(r) + 1) * (len(h) + 1), dtype=np.uint8).reshape(
+        (len(r) + 1, len(h) + 1)
+    )
+    for i in range(len(r) + 1):
+        for j in range(len(h) + 1):
+            if i == 0:
+                # d[0][j] = j
+                d[0][j] = j * WER_COST_INS
+            elif j == 0:
+                d[i][0] = i * WER_COST_DEL
+    for i in range(1, len(r) + 1):
+        for j in range(1, len(h) + 1):
+            if r[i - 1] == h[j - 1]:
+                d[i][j] = d[i - 1][j - 1]
+            else:
+                substitute = d[i - 1][j - 1] + WER_COST_SUB
+                insert = d[i][j - 1] + WER_COST_INS
+                delete = d[i - 1][j] + WER_COST_DEL
+                d[i][j] = min(substitute, insert, delete)
+    return d
+
+
+def get_alignment(r, h, d):
+    """
+    Original Code from https://github.com/zszyellow/WER-in-python/blob/master/wer.py
+    This function is to get the list of steps in the process of dynamic programming.
+    Attributes:
+        r -> the list of words produced by splitting reference sentence.
+        h -> the list of words produced by splitting hypothesis sentence.
+        d -> the matrix built when calculating the editing distance of h and r.
+    """
+    x = len(r)
+    y = len(h)
+    max_len = 3 * (x + y)
+
+    alignlist = []
+    align_ref = ""
+    align_hyp = ""
+    alignment = ""
+
+    while True:
+        if (x <= 0 and y <= 0) or (len(alignlist) > max_len):
+            break
+        elif x >= 1 and y >= 1 and d[x][y] == d[x - 1][y - 1] and r[x - 1] == h[y - 1]:
+            align_hyp = " " + h[y - 1] + align_hyp
+            align_ref = " " + r[x - 1] + align_ref
+            alignment = " " * (len(r[x - 1]) + 1) + alignment
+            alignlist.append("C")
+            x = max(x - 1, 0)
+            y = max(y - 1, 0)
+        elif x >= 1 and y >= 1 and d[x][y] == d[x - 1][y - 1] + WER_COST_SUB:
+            ml = max(len(h[y - 1]), len(r[x - 1]))
+            align_hyp = " " + h[y - 1].ljust(ml) + align_hyp
+            align_ref = " " + r[x - 1].ljust(ml) + align_ref
+            alignment = " " + "S" + " " * (ml - 1) + alignment
+            alignlist.append("S")
+            x = max(x - 1, 0)
+            y = max(y - 1, 0)
+        elif y >= 1 and d[x][y] == d[x][y - 1] + WER_COST_INS:
+            align_hyp = " " + h[y - 1] + align_hyp
+            align_ref = " " + "*" * len(h[y - 1]) + align_ref
+            alignment = " " + "I" + " " * (len(h[y - 1]) - 1) + alignment
+            alignlist.append("I")
+            x = max(x, 0)
+            y = max(y - 1, 0)
+        else:
+            align_hyp = " " + "*" * len(r[x - 1]) + align_hyp
+            align_ref = " " + r[x - 1] + align_ref
+            alignment = " " + "D" + " " * (len(r[x - 1]) - 1) + alignment
+            alignlist.append("D")
+            x = max(x - 1, 0)
+            y = max(y, 0)
+
+    align_ref = align_ref[1:]
+    align_hyp = align_hyp[1:]
+    alignment = alignment[1:]
+
+    return (
+        alignlist[::-1],
+        {"align_ref": align_ref, "align_hyp": align_hyp, "alignment": alignment},
+    )
+
+
+if __name__ == "__main__":
+
+    arg_parser = argparse.ArgumentParser(
+        description="SLTUnet Evaluator: quality evaluation for sign language translation",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    arg_parser.add_argument(
+        "--task",
+        "-t",
+        choices=["slt", "slr"],
+        type=str,
+        default=None,
+        required=True,
+        help="the task for evaluation, either sign language translation (slt) or sign langauge recognition (slr)",
+    )
+    arg_parser.add_argument(
+        "--hypothesis",
+        "-hyp",
+        type=str,
+        default=None,
+        required=True,
+        help="Model output or system generation.",
+    )
+ 
+    arg_parser.add_argument(
+        "--reference",
+        "-ref",
+        type=str,
+        default=None,
+        required=True,
+        help="Gold reference",
+    )
+    arg_parser.add_argument(
+        "--tokenize",
+        "-tok",
+        choices=sacrebleu.TOKENIZERS.keys(),
+        default="13a",
+        help="tokenization method to use",
+    )
+    arg_parser.add_argument(
+        "--phoenix",
+        default=False,
+        action="store_true",
+        help="Perform evaluation for Phoenix 2014T (special preprocessing will be applied to glosses)",
+    )
+
+    args = arg_parser.parse_args()
+
+    references = [l.strip() for l in open(args.reference, 'r')]
+    hypotheses = [l.strip() for l in open(args.hypothesis, 'r')]
+
+    if args.task == "slr": # sign language recognition requires WER
+        if args.phoenix:
+            references = [phoenix_utils.clean_phoenix_2014_trans(r) for r in references]
+            hypotheses = [phoenix_utils.clean_phoenix_2014_trans(h) for h in hypotheses]
+
+        print('Wer', wer_list(references, hypotheses))
+    else:
+        if args.tokenize == "none": # default result
+            print('BLEU', bleu(references, hypotheses))
+            print('Rouge', rouge(references, hypotheses))
+        else: # sacrebleu
+            print('Signature: BLEU+case.mixed+numrefs.1+smooth.exp+tok.%s+version.1.4.2' % args.tokenize)
+            print('BLEU', sableu(references, hypotheses, args.tokenize))
+            print('Signature: chrF2+case.mixed+numchars.6+numrefs.1+space.False+version.1.4.2')
+            print('Chrf', chrf(references, hypotheses))
+

eval/mscoco_rouge.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+#
+# File Name : mscoco_rouge.py
+#
+# Description : Computes ROUGE-L metric as described by Lin and Hovey (2004)
+#
+# Creation Date : 2015-01-07 06:03
+# Author : Ramakrishna Vedantam <vrama91@vt.edu>
+
+
+def my_lcs(string, sub):
+    """
+    Calculates longest common subsequence for a pair of tokenized strings
+    :param string : list of str : tokens from a string split using whitespace
+    :param sub : list of str : shorter string, also split using whitespace
+    :returns: length (list of int): length of the longest common subsequence between the two strings
+
+    Note: my_lcs only gives length of the longest common subsequence, not the actual LCS
+    """
+    if len(string) < len(sub):
+        sub, string = string, sub
+
+    lengths = [[0 for i in range(0, len(sub) + 1)] for j in range(0, len(string) + 1)]
+
+    for j in range(1, len(sub) + 1):
+        for i in range(1, len(string) + 1):
+            if string[i - 1] == sub[j - 1]:
+                lengths[i][j] = lengths[i - 1][j - 1] + 1
+            else:
+                lengths[i][j] = max(lengths[i - 1][j], lengths[i][j - 1])
+
+    return lengths[len(string)][len(sub)]
+
+
+def calc_score(hypotheses, references, beta=1.2):
+    """
+    Compute ROUGE-L score given one candidate and references for an image
+    :param hypotheses: str : candidate sentence to be evaluated
+    :param references: list of str : COCO reference sentences for the particular image to be evaluated
+    :returns score: int (ROUGE-L score for the candidate evaluated against references)
+    """
+    assert len(hypotheses) == 1
+    assert len(references) > 0
+    prec = []
+    rec = []
+
+    # split into tokens
+    token_c = hypotheses[0].split(" ")
+
+    for reference in references:
+        # split into tokens
+        token_r = reference.split(" ")
+        # compute the longest common subsequence
+        lcs = my_lcs(token_r, token_c)
+        prec.append(lcs / float(len(token_c)))
+        rec.append(lcs / float(len(token_r)))
+
+    prec_max = max(prec)
+    rec_max = max(rec)
+
+    if prec_max != 0 and rec_max != 0:
+        score = ((1 + beta ** 2) * prec_max * rec_max) / float(
+            rec_max + beta ** 2 * prec_max
+        )
+    else:
+        score = 0.0
+    return score

eval/phoenix_cleanup.py

@@ -0,0 +1,90 @@
+from itertools import groupby
+import re
+
+
+def clean_phoenix_2014(prediction):
+    # TODO (Cihan): Python version of the evaluation script provided
+    #  by the phoenix2014 dataset (not phoenix2014t). This should work
+    #  as intended but further tests are required to make sure it is
+    #  consistent with the bash/sed based clean up script.
+
+    prediction = prediction.strip()
+    prediction = re.sub(r"loc-", "", prediction)
+    prediction = re.sub(r"cl-", "", prediction)
+    prediction = re.sub(r"qu-", "", prediction)
+    prediction = re.sub(r"poss-", "", prediction)
+    prediction = re.sub(r"lh-", "", prediction)
+    prediction = re.sub(r"S0NNE", "SONNE", prediction)
+    prediction = re.sub(r"HABEN2", "HABEN", prediction)
+    prediction = re.sub(r"__EMOTION__", "", prediction)
+    prediction = re.sub(r"__PU__", "", prediction)
+    prediction = re.sub(r"__LEFTHAND__", "", prediction)
+    prediction = re.sub(r"WIE AUSSEHEN", "WIE-AUSSEHEN", prediction)
+    prediction = re.sub(r"ZEIGEN ", "ZEIGEN-BILDSCHIRM ", prediction)
+    prediction = re.sub(r"ZEIGEN$", "ZEIGEN-BILDSCHIRM", prediction)
+    prediction = re.sub(r"^([A-Z]) ([A-Z][+ ])", r"\1+\2", prediction)
+    prediction = re.sub(r"[ +]([A-Z]) ([A-Z]) ", r" \1+\2 ", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +]SCH) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +]NN) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) (NN[ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z])$", r"\1+\2", prediction)
+    prediction = re.sub(r"([A-Z][A-Z])RAUM", r"\1", prediction)
+    prediction = re.sub(r"-PLUSPLUS", "", prediction)
+    prediction = re.sub(r" +", " ", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r" +", " ", prediction)
+
+    assert not re.search("__LEFTHAND__", prediction)
+    assert not re.search("__EPENTHESIS__", prediction)
+    assert not re.search("__EMOTION__", prediction)
+
+    # Remove white spaces and repetitions
+    prediction = " ".join(
+        " ".join(i[0] for i in groupby(prediction.split(" "))).split()
+    )
+    prediction = prediction.strip()
+
+    return prediction
+
+
+def clean_phoenix_2014_trans(prediction):
+
+    prediction = prediction.strip()
+    prediction = re.sub(r"__LEFTHAND__", "", prediction)
+    prediction = re.sub(r"__EPENTHESIS__", "", prediction)
+    prediction = re.sub(r"__EMOTION__", "", prediction)
+    prediction = re.sub(r"\b__[^_ ]*__\b", "", prediction)
+    prediction = re.sub(r"\bloc-([^ ]*)\b", r"\1", prediction)
+    prediction = re.sub(r"\bcl-([^ ]*)\b", r"\1", prediction)
+    prediction = re.sub(r"\b([^ ]*)-PLUSPLUS\b", r"\1", prediction)
+    prediction = re.sub(r"\b([A-Z][A-Z]*)RAUM\b", r"\1", prediction)
+    prediction = re.sub(r"WIE AUSSEHEN", "WIE-AUSSEHEN", prediction)
+    prediction = re.sub(r"^([A-Z]) ([A-Z][+ ])", r"\1+\2", prediction)
+    prediction = re.sub(r"[ +]([A-Z]) ([A-Z]) ", r" \1+\2 ", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +]SCH) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +]NN) ([A-Z][ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) (NN[ +])", r"\1+\2", prediction)
+    prediction = re.sub(r"([ +][A-Z]) ([A-Z])$", r"\1+\2", prediction)
+    prediction = re.sub(r" +", " ", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r"(?<![\w-])(\b[A-Z]+(?![\w-])) \1(?![\w-])", r"\1", prediction)
+    prediction = re.sub(r" +", " ", prediction)
+
+    # Remove white spaces and repetitions
+    prediction = " ".join(
+        " ".join(i[0] for i in groupby(prediction.split(" "))).split()
+    )
+    prediction = prediction.strip()
+
+    return prediction

eval/pose_vit_dim_analysis.py

@@ -0,0 +1,442 @@
+#!/usr/bin/env python3
+"""
+Pose ViT dimensional importance analysis.
+
+This script mimics the pose-assist (video2pose → pad-to-2048) pipeline used in Sign-X:
+  1. Load the ViT-based video2pose encoder and the PadMatch+LayerNorm projection from
+     the video2text checkpoint (e.g., video2text_checkpoint_epoch_14.pth).
+  2. Sample frames from a given video, extract per-frame pose representations,
+     and project them to 2048 dimensions.
+  3. Compute simple importance scores (mean absolute activation per dimension),
+     then export CSV/plots/report summarising the dominant pose dimensions.
+"""
+
+import argparse
+import json
+import os
+import pickle
+import sys
+import types
+from pathlib import Path
+
+import cv2
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import torch  # noqa: E402
+import torch.nn as nn  # noqa: E402
+from PIL import Image  # noqa: E402
+from torchvision import transforms  # noqa: E402
+try:
+    import timm  # noqa: E402
+except ImportError as exc:
+    raise ImportError("timm is required for ViT backbone. Please install timm.") from exc
+
+
+INPUT_DIMS = {
+    "dwpose": 384,
+    "mediapipe_pose": 258,
+    "primedepth_depth": 576,
+    "sapiens_segmentation": 576,
+    "smplerx": 165,
+}
+POSE_TYPE_ORDER = ["dwpose", "mediapipe_pose", "primedepth_depth", "sapiens_segmentation", "smplerx"]
+
+
+class CodeBook:  # noqa: D401 - Dummy placeholder so torch.load can unpickle checkpoints.
+    """Placeholder CodeBook to satisfy torch.load when checkpoints store this object."""
+
+    def __init__(self, *args, **kwargs):
+        self.vocab_size = kwargs.get("vocab_size", 0)
+
+
+class Video2Pose(nn.Module):
+    """Minimal replica of the pose-assist encoder (ViT + temporal attention + per-type projection)."""
+
+    def __init__(self, input_dims):
+        super().__init__()
+        self.backbone = timm.create_model("vit_base_patch16_224", pretrained=True, num_classes=0)
+        self.temporal_attention = nn.MultiheadAttention(768, num_heads=8)
+        self.temporal_norm = nn.LayerNorm(768)
+        self.projections = nn.ModuleDict({pose: nn.Linear(768, dim) for pose, dim in input_dims.items()})
+
+    def forward(self, x):
+        # x: [B, F, 3, H, W]
+        B, F, C, H, W = x.shape
+        features = self.backbone(x.view(B * F, C, H, W))  # [B*F, 768]
+        features = features.view(B, F, -1).transpose(0, 1)  # [F, B, 768]
+        attended, _ = self.temporal_attention(features, features, features)
+        attended = self.temporal_norm(attended).transpose(0, 1)  # [B, F, 768]
+        return {pose: proj(attended) for pose, proj in self.projections.items()}
+
+
+class PadMatch(nn.Module):
+    """Pad features to hidden_dim and apply LayerNorm (weights loaded from checkpoint)."""
+
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.input_dim = input_dim
+        self.hidden_dim = hidden_dim
+        self.pad = hidden_dim - input_dim
+        if self.pad < 0:
+            raise ValueError(f"hidden_dim {hidden_dim} must be >= input_dim {input_dim}")
+        self.layer_norm = nn.LayerNorm(hidden_dim)
+
+    def forward(self, x):
+        if self.pad > 0:
+            x = nn.functional.pad(x, (0, self.pad), "constant", 0.0)
+        return self.layer_norm(x)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Pose ViT dimensional analysis (video2pose → 2048D).")
+    parser.add_argument("--video", required=True, help="Path to input video (.mp4).")
+    parser.add_argument(
+        "--checkpoint",
+        default="smkd/pretrained/video2text_checkpoint_epoch_14.pth",
+        help="Path to video2text checkpoint containing video2pose weights.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="pose_vit_feature_analysis",
+        help="Directory to store feature dumps, plots, and summary.",
+    )
+    parser.add_argument("--num-frames", type=int, default=32, help="Frames sampled uniformly from the video.")
+    parser.add_argument("--device", choices=["cuda", "cpu"], default="cuda", help="Torch device preference.")
+    parser.add_argument("--topk", type=int, default=32, help="Number of top dimensions to visualise.")
+    return parser.parse_args()
+
+
+def prepare_device(pref: str) -> torch.device:
+    if pref == "cuda" and torch.cuda.is_available():
+        return torch.device("cuda")
+    return torch.device("cpu")
+
+
+def ensure_dir(path: str) -> Path:
+    dst = Path(path)
+    dst.mkdir(parents=True, exist_ok=True)
+    return dst
+
+
+def load_checkpoint(checkpoint_path: str, device: torch.device):
+    """Load checkpoint with safe unpickling fallback."""
+    try:
+        ckpt = torch.load(checkpoint_path, map_location=device, weights_only=True)
+    except (TypeError, AttributeError, pickle.UnpicklingError):
+        torch.serialization.add_safe_globals([CodeBook])
+        ckpt = torch.load(checkpoint_path, map_location=device, weights_only=False)
+
+    if isinstance(ckpt, dict) and "model_state_dict" in ckpt:
+        return ckpt["model_state_dict"]
+    return ckpt
+
+
+def load_video2pose_weights(model: Video2Pose, state_dict):
+    sub_state = {k.replace("video2pose.", "", 1): v for k, v in state_dict.items() if k.startswith("video2pose.")}
+    missing, unexpected = model.load_state_dict(sub_state, strict=False)
+    if missing:
+        print(f"[WARN] Missing video2pose keys ({len(missing)}): {missing[:5]}...")
+    if unexpected:
+        print(f"[WARN] Unexpected video2pose keys ({len(unexpected)}): {unexpected[:5]}...")
+
+
+def load_padmatch_weights(projector: PadMatch, state_dict):
+    sub_state = {
+        k.replace("pose2text.dim_match.", "", 1): v
+        for k, v in state_dict.items()
+        if k.startswith("pose2text.dim_match.")
+    }
+    ln_state = {}
+    if "1.weight" in sub_state:
+        ln_state["weight"] = sub_state["1.weight"]
+    if "1.bias" in sub_state:
+        ln_state["bias"] = sub_state["1.bias"]
+    if ln_state:
+        projector.layer_norm.load_state_dict(ln_state, strict=False)
+    if "1.weight" not in sub_state or "1.bias" not in sub_state:
+        print("[WARN] LayerNorm weights not found in checkpoint; using default initialisation.")
+
+
+def load_and_process_video(video_path: str, num_frames: int):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"Unable to open video {video_path}")
+
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total <= 0:
+        raise RuntimeError(f"No frames found in video {video_path}")
+
+    indices = np.linspace(0, max(total - 1, 0), num=num_frames, dtype=np.int32)
+    transform = transforms.Compose(
+        [
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+        ]
+    )
+
+    frames = []
+    for idx in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ok, frame = cap.read()
+        if not ok:
+            continue
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frames.append(transform(Image.fromarray(frame)))
+
+    cap.release()
+
+    if not frames:
+        raise RuntimeError(f"Failed to decode frames from {video_path}")
+
+    while len(frames) < num_frames:
+        frames.append(frames[-1].clone())
+
+    return torch.stack(frames[:num_frames], dim=0)  # [F, 3, 224, 224]
+
+
+def compute_importance(pose_2048: torch.Tensor):
+    with torch.no_grad():
+        scores = pose_2048.abs().mean(dim=(0, 1)).cpu().numpy()
+    normalized = scores / (scores.max() + 1e-8)
+    return scores, normalized
+
+
+def plot_top_dimensions(scores, top_indices, output_path):
+    plt.figure(figsize=(max(8, len(top_indices) * 0.35), 4))
+    plt.bar(range(len(top_indices)), scores[top_indices], color="#1f77b4")
+    plt.xticks(range(len(top_indices)), [str(i) for i in top_indices], rotation=60)
+    plt.ylabel("Mean |activation|")
+    plt.xlabel("Dimension")
+    plt.title("Top pose dimensions")
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=240)
+    plt.close()
+
+
+def plot_heatmap(normalized_scores, output_path):
+    # Only use the actual pose dimensions (excluding padding)
+    total_pose_dims = sum(INPUT_DIMS.values())  # 1959
+    rows = 32
+    cols = int(np.ceil(total_pose_dims / rows))  # 62 columns needed
+
+    # Only use real pose features, not padding
+    heat_data = normalized_scores[:total_pose_dims]
+    # Pad to fill the rectangle if needed
+    needed = rows * cols
+    if len(heat_data) < needed:
+        heat_data = np.pad(heat_data, (0, needed - len(heat_data)), constant_values=0)
+    heat = heat_data.reshape(rows, cols)
+
+    # Calculate pose type boundaries
+    boundaries = []
+    cumsum = 0
+    for pose_type in POSE_TYPE_ORDER:
+        cumsum += INPUT_DIMS[pose_type]
+        boundaries.append(cumsum)
+    # boundaries = [384, 642, 1218, 1794, 1959]
+
+    # Adjust figure size to reduce right-side whitespace
+    fig, ax = plt.subplots(figsize=(12, 6))
+    im = ax.imshow(heat, aspect="auto", cmap="magma", extent=[0, cols, rows, 0])
+
+    # Set limits to avoid extra space
+    ax.set_xlim(0, cols)
+    ax.set_ylim(rows, 0)  # Invert y-axis
+
+    # Draw red lines to separate pose types
+    # Convert dimension index to (row, col) in the heatmap
+    for boundary_dim in boundaries:
+        row = boundary_dim // cols
+        col = boundary_dim % cols
+
+        if col == 0:
+            # Boundary is at the start of a row, draw horizontal line
+            ax.axhline(y=row, color='red', linewidth=1.2, linestyle='-', alpha=0.9)
+        else:
+            # Boundary is in the middle of a row, draw an L-shaped line
+            # Vertical line from current position to end of row
+            ax.plot([col, col], [row, row + 1],
+                   color='red', linewidth=1.2, linestyle='-', alpha=0.9)
+            # Horizontal line at the bottom of current row
+            ax.plot([0, col], [row + 1, row + 1],
+                   color='red', linewidth=1.2, linestyle='-', alpha=0.9)
+            # Horizontal line at the top of next row (if boundary continues)
+            if row < rows - 1:
+                ax.plot([col, cols], [row + 1, row + 1],
+                       color='red', linewidth=1.2, linestyle='-', alpha=0.9)
+
+    # Add text labels for pose types at region centers (1.5x size)
+    pose_labels = POSE_TYPE_ORDER
+    pose_boundaries = [0] + boundaries
+    for i, pose_name in enumerate(pose_labels):
+        start_dim = pose_boundaries[i]
+        end_dim = pose_boundaries[i + 1] - 1  # Last dimension in region
+
+        # Calculate geometric center for regions spanning multiple rows
+        start_row = start_dim // cols
+        start_col = start_dim % cols
+        end_row = end_dim // cols
+        end_col = end_dim % cols
+
+        region_size = pose_boundaries[i + 1] - start_dim
+
+        # Calculate center row
+        center_row = (start_row + end_row) / 2.0
+
+        # Calculate center col based on region shape
+        if start_row == end_row:
+            # Single row: simple average
+            center_col = (start_col + end_col) / 2.0
+        else:
+            # Multi-row: calculate weighted average col
+            total_cells = 0
+            weighted_col = 0
+
+            # First partial row
+            first_row_cells = cols - start_col
+            weighted_col += (start_col + cols - 1) / 2.0 * first_row_cells
+            total_cells += first_row_cells
+
+            # Full middle rows
+            middle_rows = end_row - start_row - 1
+            if middle_rows > 0:
+                weighted_col += (cols / 2.0) * cols * middle_rows
+                total_cells += cols * middle_rows
+
+            # Last partial row
+            last_row_cells = end_col + 1
+            weighted_col += (end_col / 2.0) * last_row_cells
+            total_cells += last_row_cells
+
+            center_col = weighted_col / total_cells
+
+        # Add label if there's enough space
+        if region_size >= 50:
+            ax.text(center_col, center_row, pose_name,
+                   fontsize=14, ha='center', va='center',
+                   color='white', weight='bold',
+                   bbox=dict(boxstyle='round,pad=0.3', facecolor='black', alpha=0.5))
+
+    # Set labels and title with 2x font size
+    ax.set_xlabel("Chunk index", fontsize=20)
+    ax.set_ylabel("Row", fontsize=20)
+    ax.set_title("Pose dimension importance heatmap", fontsize=24)
+
+    # Set tick label size to 2x
+    ax.tick_params(axis='both', which='major', labelsize=20)
+
+    # Add colorbar with larger font, shrink to reduce width
+    cbar = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+    cbar.ax.tick_params(labelsize=20)
+    cbar.set_label("Normalized importance", fontsize=20)
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=240, bbox_inches='tight')
+    # Also save as PDF
+    pdf_path = output_path.parent / (output_path.stem + ".pdf")
+    plt.savefig(pdf_path, bbox_inches='tight')
+    plt.close()
+
+
+def plot_cumulative(scores, output_path):
+    sorted_scores = np.sort(scores)[::-1]
+    coverage = np.cumsum(sorted_scores) / sorted_scores.sum()
+    plt.figure(figsize=(8, 4))
+    plt.plot(np.arange(1, len(sorted_scores) + 1), coverage, color="#ff7f0e")
+    plt.xlabel("Top-k dimensions")
+    plt.ylabel("Cumulative coverage")
+    plt.grid(alpha=0.3)
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=240)
+    plt.close()
+    return coverage
+
+
+def save_csv(scores, normalized, output_path):
+    with open(output_path, "w", encoding="utf-8") as handle:
+        handle.write("dimension,score,normalized\n")
+        for idx, (score, norm) in enumerate(zip(scores, normalized)):
+            handle.write(f"{idx},{score:.8f},{norm:.6f}\n")
+
+
+def write_report(video, checkpoint, scores, normalized, coverage, top_indices, output_path):
+    with open(output_path, "w", encoding="utf-8") as handle:
+        handle.write("Pose ViT dimensional analysis\n")
+        handle.write("=" * 60 + "\n\n")
+        handle.write(f"Video      : {video}\n")
+        handle.write(f"Checkpoint : {checkpoint}\n")
+        handle.write(f"Total dims : {scores.shape[0]}\n\n")
+        handle.write("Top dimensions:\n")
+        for rank, dim_idx in enumerate(top_indices, 1):
+            handle.write(
+                f"{rank:02d}. dim {dim_idx:04d} | score={scores[dim_idx]:.6f} "
+                f"| normalized={normalized[dim_idx]:.4f}\n"
+            )
+
+        handle.write("\nCoverage milestones:\n")
+        for pct in (0.25, 0.5, 0.9):
+            required = np.argmax(coverage >= pct) + 1
+            handle.write(f"  - Top {required:4d} dims explain {pct:.0%} of energy\n")
+
+        handle.write("\nScores = mean absolute activation over frames/batch.\n")
+
+
+def main():
+    args = parse_args()
+    video_abs = os.path.abspath(args.video)
+    ckpt_abs = os.path.abspath(args.checkpoint)
+    out_dir = ensure_dir(args.output_dir)
+
+    if not os.path.exists(video_abs):
+        raise FileNotFoundError(f"Video not found: {video_abs}")
+    if not os.path.exists(ckpt_abs):
+        raise FileNotFoundError(f"Checkpoint not found: {ckpt_abs}")
+
+    device = prepare_device(args.device)
+    print(f"[INFO] Using device: {device}")
+
+    state_dict = load_checkpoint(ckpt_abs, device)
+    video2pose = Video2Pose(INPUT_DIMS).to(device)
+    load_video2pose_weights(video2pose, state_dict)
+    projector = PadMatch(sum(INPUT_DIMS.values()), 2048).to(device)
+    load_padmatch_weights(projector, state_dict)
+
+    frames = load_and_process_video(video_abs, args.num_frames).unsqueeze(0).to(device)  # [1, F, 3, 224, 224]
+
+    with torch.no_grad():
+        pose_dict = video2pose(frames)
+        pose_concat = torch.cat([pose_dict[ptype] for ptype in POSE_TYPE_ORDER if ptype in pose_dict], dim=-1)
+        B, F, D = pose_concat.shape
+        pose_flat = pose_concat.reshape(B * F, D)
+        pose_2048 = projector(pose_flat).view(B, F, -1)
+        np.save(out_dir / "pose_2048.npy", pose_2048.cpu().numpy())
+
+    scores, normalized = compute_importance(pose_2048)
+    save_csv(scores, normalized, out_dir / "dimension_scores.csv")
+
+    topk = min(args.topk, scores.shape[0])
+    top_indices = np.argsort(scores)[::-1][:topk]
+    plot_top_dimensions(scores, top_indices, out_dir / "top_dimensions.png")
+    plot_heatmap(normalized, out_dir / "dimension_heatmap.png")
+    coverage = plot_cumulative(scores, out_dir / "cumulative_importance.png")
+    write_report(video_abs, ckpt_abs, scores, normalized, coverage, top_indices, out_dir / "analysis_report.txt")
+
+    meta = {
+        "video": video_abs,
+        "checkpoint": ckpt_abs,
+        "num_frames": args.num_frames,
+        "device": str(device),
+        "top_dimensions": top_indices.tolist(),
+    }
+    with open(out_dir / "metadata.json", "w", encoding="utf-8") as handle:
+        json.dump(meta, handle, indent=2)
+
+    print(f"[INFO] Analysis complete. Artifacts saved to: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

eval/regenerate_visualizations.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+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
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# 添加项目根目录到path
+SCRIPT_DIR = Path(__file__).parent.parent
+sys.path.insert(0, str(SCRIPT_DIR))
+
+from eval.attention_analysis import AttentionAnalyzer
+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"Error: sample directory not found: {sample_dir}")
+        return False
+
+    # 加载数据
+    attn_file = sample_dir / "attention_weights.npy"
+    trans_file = sample_dir / "translation.txt"
+
+    if not attn_file.exists() or not trans_file.exists():
+        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()
+        # 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()  # fallback
+
+    # Determine feature count (video_frames)
+    if len(attention_weights.shape) == 4:
+        video_frames = attention_weights.shape[3]
+    elif len(attention_weights.shape) == 3:
+        video_frames = attention_weights.shape[2]
+    else:
+        video_frames = attention_weights.shape[1]
+
+    print(f"  Sample: {sample_dir.name}")
+    print(f"    Attention shape: {attention_weights.shape}")
+    print(f"    Translation: {translation}")
+    print(f"    Features: {video_frames}")
+
+    # 创建分析器
+    analyzer = AttentionAnalyzer(
+        attentions=attention_weights,
+        translation=translation,
+        video_frames=video_frames,
+        video_path=str(video_path) if video_path else None
+    )
+
+    # Regenerate frame_alignment.png (with original-frame layer)
+    print("    Regenerating frame_alignment.png...")
+    analyzer.plot_frame_alignment(sample_dir / "frame_alignment.png")
+
+    # Regenerate gloss_to_frames.png (feature index overlay)
+    if video_path and Path(video_path).exists():
+        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"      Warning: failed to create gloss_to_frames.png: {e}")
+
+    return True
+
+
+def main():
+    if len(sys.argv) < 2:
+        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)
+
+    pred_dir = Path(sys.argv[1])
+    video_path = Path(sys.argv[2]) if len(sys.argv) > 2 else None
+
+    if not pred_dir.exists():
+        print(f"Error: detailed prediction directory not found: {pred_dir}")
+        sys.exit(1)
+
+    if video_path and not video_path.exists():
+        print(f"Warning: video file not found, disabling video overlays: {video_path}")
+        video_path = None
+
+    print("Regenerating visualizations:")
+    print(f"  Detailed prediction dir: {pred_dir}")
+    print(f"  Video path: {video_path if video_path else 'N/A'}")
+    print()
+
+    # 处理所有样本
+    success_count = 0
+    for sample_dir in sorted([d for d in pred_dir.iterdir() if d.is_dir()]):
+        if regenerate_sample_visualizations(sample_dir, video_path):
+            success_count += 1
+
+    print(f"\n✓ Done! Successfully processed {success_count} sample(s)")
+
+
+if __name__ == "__main__":
+    main()

eval/simple_benchmark.sh

@@ -0,0 +1,188 @@
+#!/bin/bash
+# 简单的效率基准测试 - 测量真实的推理时间和功耗
+set -e
+
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+OUTPUT_DIR="${PROJECT_ROOT}/benchmark_results"
+mkdir -p "$OUTPUT_DIR"
+
+echo ""
+echo "======================================================================"
+echo "  SignX Efficiency Benchmark (Simple Version)"
+echo "======================================================================"
+echo ""
+
+# 激活conda
+CONDA_BASE=$(conda info --base 2>/dev/null || echo "")
+source "${CONDA_BASE}/etc/profile.d/conda.sh"
+
+# ============================================================
+# 1. Latent-only: 只测量 SLTUNET 推理时间
+# ============================================================
+echo -e "${BLUE}[1/2] Benchmarking Latent-only (SLTUNET only)${NC}"
+echo ""
+
+conda activate slt_tf1
+export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
+
+# 创建配置文件（使用benchmark专用配置，禁用pose assistance和详细输出）
+cat > /tmp/latent_only_config.py <<'EOF'
+{
+    'sign_cfg': 'smkd/asllrp_baseline_benchmark.yaml',
+    'gloss_path': 'smkd/asllrp/gloss_dict.npy',
+    'smkd_model_path': 'smkd/work_dir第一次训练的基线/asllrp_smkd/best_model.pt',
+    'img_test_file': 'smkd/work_dir第一次训练的基线/asllrp_smkd/test.h5',
+    'src_test_file': 'preprocessed-asllrp/test.bpe.gloss',
+    'tgt_test_file': 'preprocessed-asllrp/test.bpe.gloss',
+    'src_vocab_file': 'preprocessed-asllrp/vocab.asllrp',
+    'tgt_vocab_file': 'preprocessed-asllrp/vocab.asllrp',
+    'src_codes': 'preprocessed-asllrp/asllrp.bpe',
+    'tgt_codes': 'preprocessed-asllrp/asllrp.bpe',
+    'output_dir': 'checkpoints_asllrp第一次训练的基线',
+    'test_output': '/tmp/latent_only_output.txt',
+    'eval_batch_size': 10,
+    'gpus': [0],
+    'remove_bpe': True,
+    'collect_attention_weights': False,  # 禁用attention收集以加速基准测试
+}
+EOF
+
+echo "Running latent-only inference..."
+
+# 记录GPU功耗（后台进程）
+nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits -l 1 > /tmp/power_latent.log &
+POWER_PID=$!
+
+# 测量推理时间
+START=$(date +%s.%N)
+cd "$PROJECT_ROOT"
+python run.py --mode test --config /tmp/latent_only_config.py 2>&1 | grep -E "(BLEU|Evaluating)" || true
+END=$(date +%s.%N)
+
+# 停止功耗监控
+kill $POWER_PID 2>/dev/null || true
+
+# 计算结果
+LATENT_TIME=$(echo "$END - $START" | bc)
+LATENT_POWER=$(awk '{ sum += $1; n++ } END { if (n > 0) print sum / n }' /tmp/power_latent.log)
+
+# 计算FPS（使用test集的样本数）
+NUM_SAMPLES=$(wc -l < "$PROJECT_ROOT/preprocessed-asllrp/test.bpe.gloss")
+LATENT_FPS=$(echo "scale=2; $NUM_SAMPLES / $LATENT_TIME" | bc)
+
+echo -e "${GREEN}✓ Latent-only完成${NC}"
+echo "  推理时间: ${LATENT_TIME}s"
+echo "  平均功耗: ${LATENT_POWER}W"
+echo "  FPS: $LATENT_FPS"
+echo ""
+
+# ============================================================
+# 2. SMKD Feature Extraction: 测量视频特征提取时间
+# ============================================================
+echo -e "${BLUE}[2/3] Benchmarking SMKD Feature Extraction${NC}"
+echo ""
+
+# 运行 SMKD 基准测试脚本
+if [ -f "$SCRIPT_DIR/benchmark_smkd.sh" ]; then
+    bash "$SCRIPT_DIR/benchmark_smkd.sh" 2>&1 | grep -E "(FPS|Power|Time)" | tail -3 > /tmp/smkd_results.txt
+
+    # 提取结果
+    SMKD_FPS=$(grep "FPS:" /tmp/smkd_results.txt | awk '{print $2}')
+    SMKD_POWER=$(grep "Power:" /tmp/smkd_results.txt | awk '{print $2}' | sed 's/W//')
+
+    echo -e "${GREEN}✓ SMKD Feature Extraction完成${NC}"
+    echo "  FPS: $SMKD_FPS"
+    echo "  功耗: ${SMKD_POWER}W"
+    echo ""
+else
+    echo "Warning: benchmark_smkd.sh not found, skipping SMKD test"
+    SMKD_FPS="N/A"
+    SMKD_POWER="N/A"
+fi
+
+# ============================================================
+# 3. Full Pipeline: 测量 inference.sh 的总时间
+# ============================================================
+echo -e "${BLUE}[3/3] Benchmarking Full Pipeline (SMKD + SLTUNET)${NC}"
+echo ""
+
+TEST_VIDEO="${PROJECT_ROOT}/eval/tiny_test_data/videos/666.mp4"
+
+if [ ! -f "$TEST_VIDEO" ]; then
+    echo "Warning: Test video not found, skipping full pipeline test"
+else
+    echo "Running full pipeline inference..."
+
+    # 记录GPU功耗
+    nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits -l 1 > /tmp/power_full.log &
+    POWER_PID=$!
+
+    # 测量推理时间
+    START=$(date +%s.%N)
+    cd "$PROJECT_ROOT"
+    bash inference.sh "$TEST_VIDEO" /tmp/full_pipeline_output.txt 2>&1 | grep -E "(完成|BLEU)" || true
+    END=$(date +%s.%N)
+
+    # 停止功耗监控
+    kill $POWER_PID 2>/dev/null || true
+
+    # 计算结果
+    FULL_TIME=$(echo "$END - $START" | bc)
+    FULL_POWER=$(awk '{ sum += $1; n++ } END { if (n > 0) print sum / n }' /tmp/power_full.log)
+    FULL_FPS=$(echo "scale=2; 1 / $FULL_TIME" | bc)  # 单个视频
+
+    echo -e "${GREEN}�� Full Pipeline完成${NC}"
+    echo "  推理时间: ${FULL_TIME}s"
+    echo "  平均功耗: ${FULL_POWER}W"
+    echo "  FPS: $FULL_FPS"
+    echo ""
+fi
+
+# ============================================================
+# 4. 生成LaTeX表格
+# ============================================================
+echo -e "${BLUE}[4/4] Generating LaTeX Table${NC}"
+echo ""
+
+cat > "${OUTPUT_DIR}/efficiency_comparison_table.tex" <<EOF
+\begin{table}[t]
+\centering
+\caption{\textbf{Inference Efficiency on ASLLRP:} SignX achieves real-time performance by operating in latent space.}
+\label{tab:efficiency}
+\begin{tabular}{lcc}
+\toprule
+Method & FPS \$\\uparrow\$ & Power (W) \$\\downarrow\$ \\\\
+\midrule
+SignX (Full Pipeline) & ${FULL_FPS:-N/A} & ${FULL_POWER:-N/A} \\\\
+SignX (SMKD Feature Extraction) & ${SMKD_FPS:-N/A} & ${SMKD_POWER:-N/A} \\\\
+SignX (Latent-only) & $LATENT_FPS & $LATENT_POWER \\\\
+\bottomrule
+\end{tabular}
+\end{table}
+EOF
+
+echo "======================================================================"
+echo "  Benchmark Results"
+echo "======================================================================"
+echo ""
+echo "Configuration                      | FPS      | Power (W)"
+echo "-----------------------------------|----------|----------"
+echo "Full Pipeline                      | ${FULL_FPS:-N/A}      | ${FULL_POWER:-N/A}"
+echo "SMKD Feature Extraction (视频→特征) | ${SMKD_FPS:-N/A}      | ${SMKD_POWER:-N/A}"
+echo "Latent-only (特征→gloss)           | $LATENT_FPS      | $LATENT_POWER"
+echo ""
+echo -e "${GREEN}✓ LaTeX table saved to: ${OUTPUT_DIR}/efficiency_comparison_table.tex${NC}"
+echo ""
+
+# 清理
+rm -f /tmp/latent_only_config.py /tmp/power_*.log /tmp/latent_only_output.txt /tmp/full_pipeline_output.txt /tmp/smkd_results.txt
+rm -rf /tmp/detailed_*  # 删除任何详细输出目录
+
+echo -e "${GREEN}✓ Benchmark complete!${NC}"
+echo ""

eval/tiny_test_data_for_ASLLRP/README.md

@@ -0,0 +1,86 @@
+# Tiny Test Dataset
+
+这是一个包含10个ASLLRP测试样本的小型数据集，用于快速测试推理脚本。
+
+## 内容
+
+- **videos/**: 10个测试视频（MP4格式）
+- **ground_truth.txt**: Ground truth gloss标注
+- **video_list.txt**: 视频文件名列表
+
+## 统计信息
+
+- 样本数量: 10
+- 数据来源: ASLLRP测试集（前10个样本）
+
+## Ground Truth 格式
+
+```
+<video_id>\t<gloss_sequence>
+```
+
+## 使用方法
+
+### 测试单个视频
+
+```bash
+# 使用快速推理
+cd ../../../
+python inference.py --video eval/tiny_test_data/videos/60484391.mp4
+
+# 使用完整pipeline
+./inference.sh eval/tiny_test_data/videos/60484391.mp4
+```
+
+### 批量测试
+
+```bash
+# 测试所有10个视频
+for video in eval/tiny_test_data/videos/*.mp4; do
+    echo "Testing: $video"
+    python inference.py --video "$video" --output "results/$(basename $video .mp4).txt"
+done
+```
+
+### 计算WER
+
+```bash
+# 使用eval/metrics.py计算WER
+python eval/metrics.py \
+    --task slr \
+    --hypothesis predictions.txt \
+    --reference eval/tiny_test_data/ground_truth.txt
+```
+
+## 样本列表
+
+1. **60484391.mp4**
+   - Gloss: `fs-GRUNT ACCEPT IN AREA TALK HEAR/LISTEN CULTURE THROUGH SO-SO NOT EXACT`
+
+2. **666.mp4**
+   - Gloss: `NEW STUDENT UP-TO-NOW NONE/NOTHING MEET NONE/NOTHING`
+
+3. **47609690.mp4**
+   - Gloss: `HAVE CULTURE VOICE-RANGE fs-RANGE CANNOT ENTER DCL:5"emit waste" FUTURE 5"surpri...`
+
+4. **11945625.mp4**
+   - Gloss: `IX-1p BABY BORN IX-1p WANT GIFT ns-IRELAND NAME BUT IX IX-1p FATHER IX WANT GIFT...`
+
+5. **26826234.mp4**
+   - Gloss: `IX ns-fs-JOHN GO-OUT WITH ns-fs-MARY NOT DRIVE 5"wave no" SCL:U-L"person walking...`
+
+6. **51694177.mp4**
+   - Gloss: `GO-OUT DATE/DESSERT PROGRESS POSS HOME ENTER TOILET fs-CODA WOMAN LOOK OUT POSS ...`
+
+7. **97998032.mp4**
+   - Gloss: `BOX/ROOM BIG`
+
+8. **632051.mp4**
+   - Gloss: `#IF FRIEND GROUP/TOGETHER GO-OUT PARTY IX-1p JOIN IX-1p`
+
+9. **63826969.mp4**
+   - Gloss: `SHOW ns-fs-BAUMAN BETWEEN/SHARE POSS EXPERIENCE IN IX fs-LOCKER+BOX/ROOM`
+
+10. **46272693.mp4**
+   - Gloss: `IDEA fs-OF VOICE VOICE-RANGE fs-RANGE PLACE PERMIT BUT STILL MUST VOICE-RANGE fs...`
+

eval/tiny_test_data_for_ASLLRP/good_videos/171921.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/173238.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/173745.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/23880856.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/23881350.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/31655975.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/31657848.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/3378265.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/3381121.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/4235359.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/4236171.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/50802118.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/5597316.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/6185086.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/6185381.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/619048.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/629983.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/634818.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/63579.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7454155.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7566726.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7569669.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7701925.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7710510.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7981884.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7982378.mp4

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

eval/tiny_test_data_for_ASLLRP/good_videos/7983362.mp4

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